diff --git a/lightning/src/ln/async_signer_tests.rs b/lightning/src/ln/async_signer_tests.rs index 3616030be7a..2e411b42f09 100644 --- a/lightning/src/ln/async_signer_tests.rs +++ b/lightning/src/ln/async_signer_tests.rs @@ -1,5 +1,3 @@ -#![cfg_attr(rustfmt, rustfmt_skip)] - // This file is Copyright its original authors, visible in version control // history. // @@ -13,10 +11,10 @@ //! properly with a signer implementation that asynchronously derives signatures. use crate::prelude::*; -use bitcoin::secp256k1::Secp256k1; -use bitcoin::{Transaction, TxOut, TxIn, Amount}; use bitcoin::locktime::absolute::LockTime; +use bitcoin::secp256k1::Secp256k1; use bitcoin::transaction::Version; +use bitcoin::{Amount, Transaction, TxIn, TxOut}; use crate::chain::channelmonitor::LATENCY_GRACE_PERIOD_BLOCKS; use crate::chain::ChannelMonitorUpdateStatus; @@ -30,8 +28,8 @@ use crate::ln::msgs::{BaseMessageHandler, ChannelMessageHandler, MessageSendEven use crate::ln::{functional_test_utils::*, msgs}; use crate::sign::ecdsa::EcdsaChannelSigner; use crate::sign::SignerProvider; -use crate::util::test_channel_signer::SignerOp; use crate::util::logger::Logger; +use crate::util::test_channel_signer::SignerOp; #[test] fn test_open_channel() { @@ -48,38 +46,49 @@ fn do_test_open_channel(zero_conf: bool) { let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, Some(manually_accept_config)]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); // Open an outbound channel simulating an async signer. let channel_value_satoshis = 100000; let user_channel_id = 42; nodes[0].disable_next_channel_signer_op(SignerOp::GetPerCommitmentPoint); - let channel_id_0 = nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), channel_value_satoshis, 10001, user_channel_id, None, None).unwrap(); + let channel_id_0 = nodes[0] + .node + .create_channel(node_b_id, channel_value_satoshis, 10001, user_channel_id, None, None) + .unwrap(); { let msgs = nodes[0].node.get_and_clear_pending_msg_events(); assert!(msgs.is_empty(), "Expected no message events; got {:?}", msgs); } - nodes[0].enable_channel_signer_op(&nodes[1].node.get_our_node_id(), &channel_id_0, SignerOp::GetPerCommitmentPoint); + nodes[0].enable_channel_signer_op(&node_b_id, &channel_id_0, SignerOp::GetPerCommitmentPoint); nodes[0].node.signer_unblocked(None); // nodes[0] --- open_channel --> nodes[1] - let mut open_chan_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); + let mut open_chan_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, node_b_id); // Handle an inbound channel simulating an async signer. nodes[1].disable_next_channel_signer_op(SignerOp::GetPerCommitmentPoint); - nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_chan_msg); + nodes[1].node.handle_open_channel(node_a_id, &open_chan_msg); if zero_conf { let events = nodes[1].node.get_and_clear_pending_events(); assert_eq!(events.len(), 1, "Expected one event, got {}", events.len()); match &events[0] { Event::OpenChannelRequest { temporary_channel_id, .. } => { - nodes[1].node.accept_inbound_channel_from_trusted_peer_0conf( - temporary_channel_id, &nodes[0].node.get_our_node_id(), 0, None) + nodes[1] + .node + .accept_inbound_channel_from_trusted_peer_0conf( + temporary_channel_id, + &node_a_id, + 0, + None, + ) .expect("Unable to accept inbound zero-conf channel"); }, - ev => panic!("Expected OpenChannelRequest, not {:?}", ev) + ev => panic!("Expected OpenChannelRequest, not {:?}", ev), } } else { let msgs = nodes[1].node.get_and_clear_pending_msg_events(); @@ -92,17 +101,23 @@ fn do_test_open_channel(zero_conf: bool) { channels[0].channel_id }; - nodes[1].enable_channel_signer_op(&nodes[0].node.get_our_node_id(), &channel_id_1, SignerOp::GetPerCommitmentPoint); + nodes[1].enable_channel_signer_op(&node_a_id, &channel_id_1, SignerOp::GetPerCommitmentPoint); nodes[1].node.signer_unblocked(None); // nodes[0] <-- accept_channel --- nodes[1] - get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id()); + get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, node_a_id); } #[test] fn test_funding_created() { - do_test_funding_created(vec![SignerOp::SignCounterpartyCommitment, SignerOp::GetPerCommitmentPoint]); - do_test_funding_created(vec![SignerOp::GetPerCommitmentPoint, SignerOp::SignCounterpartyCommitment]); + do_test_funding_created(vec![ + SignerOp::SignCounterpartyCommitment, + SignerOp::GetPerCommitmentPoint, + ]); + do_test_funding_created(vec![ + SignerOp::GetPerCommitmentPoint, + SignerOp::SignCounterpartyCommitment, + ]); } fn do_test_funding_created(signer_ops: Vec) { @@ -111,25 +126,34 @@ fn do_test_funding_created(signer_ops: Vec) { let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); - nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None, None).unwrap(); + nodes[0].node.create_channel(node_b_id, 100000, 10001, 42, None, None).unwrap(); // nodes[0] --- open_channel --> nodes[1] - let mut open_chan_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_chan_msg); + let mut open_chan_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, node_b_id); + nodes[1].node.handle_open_channel(node_a_id, &open_chan_msg); // nodes[0] <-- accept_channel --- nodes[1] - nodes[0].node.handle_accept_channel(nodes[1].node.get_our_node_id(), &get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id())); + nodes[0].node.handle_accept_channel( + node_b_id, + &get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, node_a_id), + ); // nodes[0] --- funding_created --> nodes[1] // // But! Let's make node[0]'s signer be unavailable: we should *not* broadcast a funding_created // message... - let (temporary_channel_id, tx, _) = create_funding_transaction(&nodes[0], &nodes[1].node.get_our_node_id(), 100000, 42); + let (temporary_channel_id, tx, _) = + create_funding_transaction(&nodes[0], &node_b_id, 100000, 42); for op in signer_ops.iter() { - nodes[0].disable_channel_signer_op(&nodes[1].node.get_our_node_id(), &temporary_channel_id, *op); + nodes[0].disable_channel_signer_op(&node_b_id, &temporary_channel_id, *op); } - nodes[0].node.funding_transaction_generated(temporary_channel_id, nodes[1].node.get_our_node_id(), tx.clone()).unwrap(); + nodes[0] + .node + .funding_transaction_generated(temporary_channel_id, node_b_id, tx.clone()) + .unwrap(); check_added_monitors(&nodes[0], 0); assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); @@ -143,26 +167,34 @@ fn do_test_funding_created(signer_ops: Vec) { }; for op in signer_ops.iter() { - nodes[0].enable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, *op); - nodes[0].node.signer_unblocked(Some((nodes[1].node.get_our_node_id(), chan_id))); + nodes[0].enable_channel_signer_op(&node_b_id, &chan_id, *op); + nodes[0].node.signer_unblocked(Some((node_b_id, chan_id))); } - let mut funding_created_msg = get_event_msg!(nodes[0], MessageSendEvent::SendFundingCreated, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_funding_created(nodes[0].node.get_our_node_id(), &funding_created_msg); + let mut funding_created_msg = + get_event_msg!(nodes[0], MessageSendEvent::SendFundingCreated, node_b_id); + nodes[1].node.handle_funding_created(node_a_id, &funding_created_msg); check_added_monitors(&nodes[1], 1); - expect_channel_pending_event(&nodes[1], &nodes[0].node.get_our_node_id()); + expect_channel_pending_event(&nodes[1], &node_a_id); // nodes[0] <-- funding_signed --- nodes[1] - let funding_signed_msg = get_event_msg!(nodes[1], MessageSendEvent::SendFundingSigned, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_funding_signed(nodes[1].node.get_our_node_id(), &funding_signed_msg); + let funding_signed_msg = + get_event_msg!(nodes[1], MessageSendEvent::SendFundingSigned, node_a_id); + nodes[0].node.handle_funding_signed(node_b_id, &funding_signed_msg); check_added_monitors(&nodes[0], 1); - expect_channel_pending_event(&nodes[0], &nodes[1].node.get_our_node_id()); + expect_channel_pending_event(&nodes[0], &node_b_id); } #[test] fn test_funding_signed() { - do_test_funding_signed(vec![SignerOp::SignCounterpartyCommitment, SignerOp::GetPerCommitmentPoint]); - do_test_funding_signed(vec![SignerOp::GetPerCommitmentPoint, SignerOp::SignCounterpartyCommitment]); + do_test_funding_signed(vec![ + SignerOp::SignCounterpartyCommitment, + SignerOp::GetPerCommitmentPoint, + ]); + do_test_funding_signed(vec![ + SignerOp::GetPerCommitmentPoint, + SignerOp::SignCounterpartyCommitment, + ]); } fn do_test_funding_signed(signer_ops: Vec) { @@ -171,29 +203,39 @@ fn do_test_funding_signed(signer_ops: Vec) { let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); - nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None, None).unwrap(); + nodes[0].node.create_channel(node_b_id, 100000, 10001, 42, None, None).unwrap(); // nodes[0] --- open_channel --> nodes[1] - let mut open_chan_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_chan_msg); + let mut open_chan_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, node_b_id); + nodes[1].node.handle_open_channel(node_a_id, &open_chan_msg); // nodes[0] <-- accept_channel --- nodes[1] - nodes[0].node.handle_accept_channel(nodes[1].node.get_our_node_id(), &get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id())); + nodes[0].node.handle_accept_channel( + node_b_id, + &get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, node_a_id), + ); // nodes[0] --- funding_created --> nodes[1] - let (temporary_channel_id, tx, _) = create_funding_transaction(&nodes[0], &nodes[1].node.get_our_node_id(), 100000, 42); - nodes[0].node.funding_transaction_generated(temporary_channel_id, nodes[1].node.get_our_node_id(), tx.clone()).unwrap(); + let (temporary_channel_id, tx, _) = + create_funding_transaction(&nodes[0], &node_b_id, 100000, 42); + nodes[0] + .node + .funding_transaction_generated(temporary_channel_id, node_b_id, tx.clone()) + .unwrap(); check_added_monitors(&nodes[0], 0); - let mut funding_created_msg = get_event_msg!(nodes[0], MessageSendEvent::SendFundingCreated, nodes[1].node.get_our_node_id()); + let mut funding_created_msg = + get_event_msg!(nodes[0], MessageSendEvent::SendFundingCreated, node_b_id); // Now let's make node[1]'s signer be unavailable while handling the `funding_created`. It should // *not* broadcast a `funding_signed`... for op in signer_ops.iter() { - nodes[1].disable_channel_signer_op(&nodes[0].node.get_our_node_id(), &temporary_channel_id, *op); + nodes[1].disable_channel_signer_op(&node_a_id, &temporary_channel_id, *op); } - nodes[1].node.handle_funding_created(nodes[0].node.get_our_node_id(), &funding_created_msg); + nodes[1].node.handle_funding_created(node_a_id, &funding_created_msg); check_added_monitors(&nodes[1], 1); assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); @@ -206,16 +248,17 @@ fn do_test_funding_signed(signer_ops: Vec) { channels[0].channel_id }; for op in signer_ops.iter() { - nodes[1].enable_channel_signer_op(&nodes[0].node.get_our_node_id(), &chan_id, *op); - nodes[1].node.signer_unblocked(Some((nodes[0].node.get_our_node_id(), chan_id))); + nodes[1].enable_channel_signer_op(&node_a_id, &chan_id, *op); + nodes[1].node.signer_unblocked(Some((node_a_id, chan_id))); if *op == SignerOp::SignCounterpartyCommitment { - expect_channel_pending_event(&nodes[1], &nodes[0].node.get_our_node_id()); + expect_channel_pending_event(&nodes[1], &node_a_id); // nodes[0] <-- funding_signed --- nodes[1] - let funding_signed_msg = get_event_msg!(nodes[1], MessageSendEvent::SendFundingSigned, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_funding_signed(nodes[1].node.get_our_node_id(), &funding_signed_msg); + let funding_signed_msg = + get_event_msg!(nodes[1], MessageSendEvent::SendFundingSigned, node_a_id); + nodes[0].node.handle_funding_signed(node_b_id, &funding_signed_msg); check_added_monitors(&nodes[0], 1); - expect_channel_pending_event(&nodes[0], &nodes[1].node.get_our_node_id()); + expect_channel_pending_event(&nodes[0], &node_b_id); } else { assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); } @@ -229,12 +272,19 @@ fn test_async_commitment_signature_for_commitment_signed() { SignerOp::GetPerCommitmentPoint, SignerOp::ReleaseCommitmentSecret, SignerOp::SignCounterpartyCommitment, - ].into_iter().filter(|&op| i & (1 << op as u8) != 0).collect(); - do_test_async_commitment_signature_for_commitment_signed_revoke_and_ack(enable_signer_op_order); + ] + .into_iter() + .filter(|&op| i & (1 << op as u8) != 0) + .collect(); + do_test_async_commitment_signature_for_commitment_signed_revoke_and_ack( + enable_signer_op_order, + ); } } -fn do_test_async_commitment_signature_for_commitment_signed_revoke_and_ack(enable_signer_op_order: Vec) { +fn do_test_async_commitment_signature_for_commitment_signed_revoke_and_ack( + enable_signer_op_order: Vec, +) { let chanmon_cfgs = create_chanmon_cfgs(2); let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); @@ -244,9 +294,13 @@ fn do_test_async_commitment_signature_for_commitment_signed_revoke_and_ack(enabl // Send a payment. let src = &nodes[0]; let dst = &nodes[1]; - let (route, our_payment_hash, _our_payment_preimage, our_payment_secret) = get_route_and_payment_hash!(src, dst, 8000000); - src.node.send_payment_with_route(route, our_payment_hash, - RecipientOnionFields::secret_only(our_payment_secret), PaymentId(our_payment_hash.0)).unwrap(); + let (route, our_payment_hash, _our_payment_preimage, our_payment_secret) = + get_route_and_payment_hash!(src, dst, 8000000); + let recipient_fields = RecipientOnionFields::secret_only(our_payment_secret); + let payment_id = PaymentId(our_payment_hash.0); + src.node + .send_payment_with_route(route, our_payment_hash, recipient_fields, payment_id) + .unwrap(); check_added_monitors!(src, 1); // Pass the payment along the route. @@ -262,10 +316,25 @@ fn do_test_async_commitment_signature_for_commitment_signed_revoke_and_ack(enabl // Mark dst's signer as unavailable and handle src's commitment_signed: while dst won't yet have a // `commitment_signed` of its own to offer, it should publish a `revoke_and_ack`. - dst.disable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, SignerOp::GetPerCommitmentPoint); - dst.disable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, SignerOp::ReleaseCommitmentSecret); - dst.disable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, SignerOp::SignCounterpartyCommitment); - dst.node.handle_commitment_signed_batch_test(src.node.get_our_node_id(), &payment_event.commitment_msg); + dst.disable_channel_signer_op( + &src.node.get_our_node_id(), + &chan_id, + SignerOp::GetPerCommitmentPoint, + ); + dst.disable_channel_signer_op( + &src.node.get_our_node_id(), + &chan_id, + SignerOp::ReleaseCommitmentSecret, + ); + dst.disable_channel_signer_op( + &src.node.get_our_node_id(), + &chan_id, + SignerOp::SignCounterpartyCommitment, + ); + dst.node.handle_commitment_signed_batch_test( + src.node.get_our_node_id(), + &payment_event.commitment_msg, + ); check_added_monitors(dst, 1); let mut enabled_signer_ops = new_hash_set(); @@ -275,7 +344,9 @@ fn do_test_async_commitment_signature_for_commitment_signed_revoke_and_ack(enabl dst.enable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, op); dst.node.signer_unblocked(Some((src.node.get_our_node_id(), chan_id))); - if enabled_signer_ops.contains(&SignerOp::GetPerCommitmentPoint) && enabled_signer_ops.contains(&SignerOp::ReleaseCommitmentSecret) { + if enabled_signer_ops.contains(&SignerOp::GetPerCommitmentPoint) + && enabled_signer_ops.contains(&SignerOp::ReleaseCommitmentSecret) + { // We are just able to send revoke_and_ack if op == SignerOp::GetPerCommitmentPoint || op == SignerOp::ReleaseCommitmentSecret { get_event_msg!(dst, MessageSendEvent::SendRevokeAndACK, src.node.get_our_node_id()); @@ -295,8 +366,14 @@ fn do_test_async_commitment_signature_for_commitment_signed_revoke_and_ack(enabl #[test] fn test_funding_signed_0conf() { - do_test_funding_signed_0conf(vec![SignerOp::GetPerCommitmentPoint, SignerOp::SignCounterpartyCommitment]); - do_test_funding_signed_0conf(vec![SignerOp::SignCounterpartyCommitment, SignerOp::GetPerCommitmentPoint]); + do_test_funding_signed_0conf(vec![ + SignerOp::GetPerCommitmentPoint, + SignerOp::SignCounterpartyCommitment, + ]); + do_test_funding_signed_0conf(vec![ + SignerOp::SignCounterpartyCommitment, + SignerOp::GetPerCommitmentPoint, + ]); } fn do_test_funding_signed_0conf(signer_ops: Vec) { @@ -308,44 +385,57 @@ fn do_test_funding_signed_0conf(signer_ops: Vec) { let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, Some(manually_accept_config)]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); // nodes[0] --- open_channel --> nodes[1] - nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None, None).unwrap(); - let open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); + nodes[0].node.create_channel(node_b_id, 100000, 10001, 42, None, None).unwrap(); + let open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, node_b_id); - nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel); + nodes[1].node.handle_open_channel(node_a_id, &open_channel); { let events = nodes[1].node.get_and_clear_pending_events(); assert_eq!(events.len(), 1, "Expected one event, got {}", events.len()); match &events[0] { Event::OpenChannelRequest { temporary_channel_id, .. } => { - nodes[1].node.accept_inbound_channel_from_trusted_peer_0conf( - temporary_channel_id, &nodes[0].node.get_our_node_id(), 0, None) + nodes[1] + .node + .accept_inbound_channel_from_trusted_peer_0conf( + temporary_channel_id, + &node_a_id, + 0, + None, + ) .expect("Unable to accept inbound zero-conf channel"); }, - ev => panic!("Expected OpenChannelRequest, not {:?}", ev) + ev => panic!("Expected OpenChannelRequest, not {:?}", ev), } } // nodes[0] <-- accept_channel --- nodes[1] - let accept_channel = get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id()); + let accept_channel = get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, node_a_id); assert_eq!(accept_channel.common_fields.minimum_depth, 0, "Expected minimum depth of 0"); - nodes[0].node.handle_accept_channel(nodes[1].node.get_our_node_id(), &accept_channel); + nodes[0].node.handle_accept_channel(node_b_id, &accept_channel); // nodes[0] --- funding_created --> nodes[1] - let (temporary_channel_id, tx, _) = create_funding_transaction(&nodes[0], &nodes[1].node.get_our_node_id(), 100000, 42); - nodes[0].node.funding_transaction_generated(temporary_channel_id, nodes[1].node.get_our_node_id(), tx.clone()).unwrap(); + let (temporary_channel_id, tx, _) = + create_funding_transaction(&nodes[0], &node_b_id, 100000, 42); + nodes[0] + .node + .funding_transaction_generated(temporary_channel_id, node_b_id, tx.clone()) + .unwrap(); check_added_monitors(&nodes[0], 0); - let mut funding_created_msg = get_event_msg!(nodes[0], MessageSendEvent::SendFundingCreated, nodes[1].node.get_our_node_id()); + let mut funding_created_msg = + get_event_msg!(nodes[0], MessageSendEvent::SendFundingCreated, node_b_id); // Now let's make node[1]'s signer be unavailable while handling the `funding_created`. It should // *not* broadcast a `funding_signed`... for op in signer_ops.iter() { - nodes[1].disable_channel_signer_op(&nodes[0].node.get_our_node_id(), &temporary_channel_id, *op); + nodes[1].disable_channel_signer_op(&node_a_id, &temporary_channel_id, *op); } - nodes[1].node.handle_funding_created(nodes[0].node.get_our_node_id(), &funding_created_msg); + nodes[1].node.handle_funding_created(node_a_id, &funding_created_msg); check_added_monitors(&nodes[1], 1); assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); @@ -360,8 +450,8 @@ fn do_test_funding_signed_0conf(signer_ops: Vec) { // At this point, we basically expect the channel to open like a normal zero-conf channel. for op in signer_ops.iter() { - nodes[1].enable_channel_signer_op(&nodes[0].node.get_our_node_id(), &chan_id, *op); - nodes[1].node.signer_unblocked(Some((nodes[0].node.get_our_node_id(), chan_id))); + nodes[1].enable_channel_signer_op(&node_a_id, &chan_id, *op); + nodes[1].node.signer_unblocked(Some((node_a_id, chan_id))); } let (funding_signed, channel_ready_1) = { @@ -369,33 +459,33 @@ fn do_test_funding_signed_0conf(signer_ops: Vec) { assert_eq!(events.len(), 2); let funding_signed = match &events[0] { MessageSendEvent::SendFundingSigned { msg, .. } => msg.clone(), - ev => panic!("Expected SendFundingSigned, not {:?}", ev) + ev => panic!("Expected SendFundingSigned, not {:?}", ev), }; let channel_ready = match &events[1] { MessageSendEvent::SendChannelReady { msg, .. } => msg.clone(), - ev => panic!("Expected SendChannelReady, not {:?}", ev) + ev => panic!("Expected SendChannelReady, not {:?}", ev), }; (funding_signed, channel_ready) }; - nodes[0].node.handle_funding_signed(nodes[1].node.get_our_node_id(), &funding_signed); - expect_channel_pending_event(&nodes[0], &nodes[1].node.get_our_node_id()); - expect_channel_pending_event(&nodes[1], &nodes[0].node.get_our_node_id()); + nodes[0].node.handle_funding_signed(node_b_id, &funding_signed); + expect_channel_pending_event(&nodes[0], &node_b_id); + expect_channel_pending_event(&nodes[1], &node_a_id); check_added_monitors(&nodes[0], 1); - let channel_ready_0 = get_event_msg!(nodes[0], MessageSendEvent::SendChannelReady, nodes[1].node.get_our_node_id()); + let channel_ready_0 = get_event_msg!(nodes[0], MessageSendEvent::SendChannelReady, node_b_id); - nodes[0].node.handle_channel_ready(nodes[1].node.get_our_node_id(), &channel_ready_1); - expect_channel_ready_event(&nodes[0], &nodes[1].node.get_our_node_id()); + nodes[0].node.handle_channel_ready(node_b_id, &channel_ready_1); + expect_channel_ready_event(&nodes[0], &node_b_id); - nodes[1].node.handle_channel_ready(nodes[0].node.get_our_node_id(), &channel_ready_0); - expect_channel_ready_event(&nodes[1], &nodes[0].node.get_our_node_id()); + nodes[1].node.handle_channel_ready(node_a_id, &channel_ready_0); + expect_channel_ready_event(&nodes[1], &node_a_id); - let channel_update_0 = get_event_msg!(nodes[0], MessageSendEvent::SendChannelUpdate, nodes[1].node.get_our_node_id()); - let channel_update_1 = get_event_msg!(nodes[1], MessageSendEvent::SendChannelUpdate, nodes[0].node.get_our_node_id()); + let channel_update_0 = get_event_msg!(nodes[0], MessageSendEvent::SendChannelUpdate, node_b_id); + let channel_update_1 = get_event_msg!(nodes[1], MessageSendEvent::SendChannelUpdate, node_a_id); - nodes[0].node.handle_channel_update(nodes[1].node.get_our_node_id(), &channel_update_1); - nodes[1].node.handle_channel_update(nodes[0].node.get_our_node_id(), &channel_update_0); + nodes[0].node.handle_channel_update(node_b_id, &channel_update_1); + nodes[1].node.handle_channel_update(node_a_id, &channel_update_0); assert_eq!(nodes[0].node.list_usable_channels().len(), 1); assert_eq!(nodes[1].node.list_usable_channels().len(), 1); @@ -412,13 +502,21 @@ enum UnblockSignerAcrossDisconnectCase { fn test_async_raa_peer_disconnect() { do_test_async_raa_peer_disconnect(UnblockSignerAcrossDisconnectCase::AtEnd, true); do_test_async_raa_peer_disconnect(UnblockSignerAcrossDisconnectCase::AtEnd, false); - do_test_async_raa_peer_disconnect(UnblockSignerAcrossDisconnectCase::BeforeMonitorRestored, true); - do_test_async_raa_peer_disconnect(UnblockSignerAcrossDisconnectCase::BeforeMonitorRestored, false); + do_test_async_raa_peer_disconnect( + UnblockSignerAcrossDisconnectCase::BeforeMonitorRestored, + true, + ); + do_test_async_raa_peer_disconnect( + UnblockSignerAcrossDisconnectCase::BeforeMonitorRestored, + false, + ); do_test_async_raa_peer_disconnect(UnblockSignerAcrossDisconnectCase::BeforeReestablish, true); do_test_async_raa_peer_disconnect(UnblockSignerAcrossDisconnectCase::BeforeReestablish, false); } -fn do_test_async_raa_peer_disconnect(test_case: UnblockSignerAcrossDisconnectCase, raa_blocked_by_commit_point: bool) { +fn do_test_async_raa_peer_disconnect( + test_case: UnblockSignerAcrossDisconnectCase, raa_blocked_by_commit_point: bool, +) { // `raa_blocked_by_commit_point` determines whether we block the RAA by blocking the // signer on `GetPerCommitmentPoint` or `ReleaseCommitmentSecret`. let block_raa_signer_op = if raa_blocked_by_commit_point { @@ -435,9 +533,13 @@ fn do_test_async_raa_peer_disconnect(test_case: UnblockSignerAcrossDisconnectCas // Send a payment. let src = &nodes[0]; let dst = &nodes[1]; - let (route, our_payment_hash, _our_payment_preimage, our_payment_secret) = get_route_and_payment_hash!(src, dst, 8000000); - src.node.send_payment_with_route(route, our_payment_hash, - RecipientOnionFields::secret_only(our_payment_secret), PaymentId(our_payment_hash.0)).unwrap(); + let (route, our_payment_hash, _our_payment_preimage, our_payment_secret) = + get_route_and_payment_hash!(src, dst, 8000000); + let recipient_fields = RecipientOnionFields::secret_only(our_payment_secret); + let payment_id = PaymentId(our_payment_hash.0); + src.node + .send_payment_with_route(route, our_payment_hash, recipient_fields, payment_id) + .unwrap(); check_added_monitors!(src, 1); // Pass the payment along the route. @@ -459,7 +561,10 @@ fn do_test_async_raa_peer_disconnect(test_case: UnblockSignerAcrossDisconnectCas // Mark dst's signer as unavailable and handle src's commitment_signed: while dst won't yet have a // `commitment_signed` of its own to offer, it should publish a `revoke_and_ack`. dst.disable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, block_raa_signer_op); - dst.node.handle_commitment_signed_batch_test(src.node.get_our_node_id(), &payment_event.commitment_msg); + dst.node.handle_commitment_signed_batch_test( + src.node.get_our_node_id(), + &payment_event.commitment_msg, + ); check_added_monitors(dst, 1); let events = dst.node.get_and_clear_pending_msg_events(); @@ -470,14 +575,20 @@ fn do_test_async_raa_peer_disconnect(test_case: UnblockSignerAcrossDisconnectCas dst.node.peer_disconnected(src.node.get_our_node_id()); // do reestablish stuff - src.node.peer_connected(dst.node.get_our_node_id(), &msgs::Init { - features: dst.node.init_features(), networks: None, remote_network_address: None - }, true).unwrap(); + let init_msg = &msgs::Init { + features: dst.node.init_features(), + networks: None, + remote_network_address: None, + }; + src.node.peer_connected(dst.node.get_our_node_id(), init_msg, true).unwrap(); let reestablish_1 = get_chan_reestablish_msgs!(src, dst); assert_eq!(reestablish_1.len(), 1); - dst.node.peer_connected(src.node.get_our_node_id(), &msgs::Init { - features: src.node.init_features(), networks: None, remote_network_address: None - }, false).unwrap(); + let init_msg = &msgs::Init { + features: src.node.init_features(), + networks: None, + remote_network_address: None, + }; + dst.node.peer_connected(src.node.get_our_node_id(), init_msg, false).unwrap(); let reestablish_2 = get_chan_reestablish_msgs!(dst, src); assert_eq!(reestablish_2.len(), 1); @@ -491,13 +602,18 @@ fn do_test_async_raa_peer_disconnect(test_case: UnblockSignerAcrossDisconnectCas if test_case == UnblockSignerAcrossDisconnectCase::BeforeMonitorRestored { dst.enable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, block_raa_signer_op); chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); - let (latest_update, _) = dst.chain_monitor.latest_monitor_update_id.lock().unwrap().get(&chan_id).unwrap().clone(); + let latest_update; + { + let channel_map = dst.chain_monitor.latest_monitor_update_id.lock().unwrap(); + (latest_update, _) = channel_map.get(&chan_id).unwrap().clone(); + } dst.chain_monitor.chain_monitor.force_channel_monitor_updated(chan_id, latest_update); check_added_monitors!(dst, 0); } // Expect the RAA - let (_, revoke_and_ack, commitment_signed, resend_order) = handle_chan_reestablish_msgs!(dst, src); + let (_, revoke_and_ack, commitment_signed, resend_order) = + handle_chan_reestablish_msgs!(dst, src); if test_case == UnblockSignerAcrossDisconnectCase::AtEnd { assert!(revoke_and_ack.is_none()); assert!(commitment_signed.is_none()); @@ -512,7 +628,8 @@ fn do_test_async_raa_peer_disconnect(test_case: UnblockSignerAcrossDisconnectCas dst.node.signer_unblocked(Some((src.node.get_our_node_id(), chan_id))); if test_case == UnblockSignerAcrossDisconnectCase::AtEnd { - let (_, revoke_and_ack, commitment_signed, resend_order) = handle_chan_reestablish_msgs!(dst, src); + let (_, revoke_and_ack, commitment_signed, resend_order) = + handle_chan_reestablish_msgs!(dst, src); assert!(revoke_and_ack.is_some()); assert!(commitment_signed.is_some()); assert!(resend_order == RAACommitmentOrder::RevokeAndACKFirst); @@ -524,7 +641,6 @@ fn do_test_async_raa_peer_disconnect(test_case: UnblockSignerAcrossDisconnectCas } } - #[test] fn test_async_commitment_signature_peer_disconnect() { // This tests that if our signer is blocked and gets unblocked @@ -538,7 +654,9 @@ fn test_async_commitment_signature_peer_disconnect_signer_restored_before_monito // and needed to send a CS, that if our signer becomes available before the monitor // update completes, then we don't send duplicate messages upon calling `signer_unblocked` // after the monitor update completes. - do_test_async_commitment_signature_peer_disconnect(UnblockSignerAcrossDisconnectCase::BeforeMonitorRestored); + do_test_async_commitment_signature_peer_disconnect( + UnblockSignerAcrossDisconnectCase::BeforeMonitorRestored, + ); } #[test] @@ -546,10 +664,14 @@ fn test_async_commitment_signature_peer_disconnect_signer_restored_before_reesta // This tests that if we tried to send a commitment_signed, but our signer was blocked, // if we disconnect, reconnect, the signer becomes available, then handle channel_reestablish, // that we don't send duplicate messages upon calling `signer_unblocked`. - do_test_async_commitment_signature_peer_disconnect(UnblockSignerAcrossDisconnectCase::BeforeReestablish); + do_test_async_commitment_signature_peer_disconnect( + UnblockSignerAcrossDisconnectCase::BeforeReestablish, + ); } -fn do_test_async_commitment_signature_peer_disconnect(test_case: UnblockSignerAcrossDisconnectCase) { +fn do_test_async_commitment_signature_peer_disconnect( + test_case: UnblockSignerAcrossDisconnectCase, +) { let chanmon_cfgs = create_chanmon_cfgs(2); let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); @@ -559,9 +681,13 @@ fn do_test_async_commitment_signature_peer_disconnect(test_case: UnblockSignerAc // Send a payment. let src = &nodes[0]; let dst = &nodes[1]; - let (route, our_payment_hash, _our_payment_preimage, our_payment_secret) = get_route_and_payment_hash!(src, dst, 8000000); - src.node.send_payment_with_route(route, our_payment_hash, - RecipientOnionFields::secret_only(our_payment_secret), PaymentId(our_payment_hash.0)).unwrap(); + let (route, our_payment_hash, _our_payment_preimage, our_payment_secret) = + get_route_and_payment_hash!(src, dst, 8000000); + let recipient_fields = RecipientOnionFields::secret_only(our_payment_secret); + let payment_id = PaymentId(our_payment_hash.0); + src.node + .send_payment_with_route(route, our_payment_hash, recipient_fields, payment_id) + .unwrap(); check_added_monitors!(src, 1); // Pass the payment along the route. @@ -582,8 +708,15 @@ fn do_test_async_commitment_signature_peer_disconnect(test_case: UnblockSignerAc // Mark dst's signer as unavailable and handle src's commitment_signed: while dst won't yet have a // `commitment_signed` of its own to offer, it should publish a `revoke_and_ack`. - dst.disable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, SignerOp::SignCounterpartyCommitment); - dst.node.handle_commitment_signed_batch_test(src.node.get_our_node_id(), &payment_event.commitment_msg); + dst.disable_channel_signer_op( + &src.node.get_our_node_id(), + &chan_id, + SignerOp::SignCounterpartyCommitment, + ); + dst.node.handle_commitment_signed_batch_test( + src.node.get_our_node_id(), + &payment_event.commitment_msg, + ); check_added_monitors(dst, 1); if test_case != UnblockSignerAcrossDisconnectCase::BeforeMonitorRestored { @@ -595,28 +728,46 @@ fn do_test_async_commitment_signature_peer_disconnect(test_case: UnblockSignerAc dst.node.peer_disconnected(src.node.get_our_node_id()); // do reestablish stuff - src.node.peer_connected(dst.node.get_our_node_id(), &msgs::Init { - features: dst.node.init_features(), networks: None, remote_network_address: None - }, true).unwrap(); + let init_msg = &msgs::Init { + features: dst.node.init_features(), + networks: None, + remote_network_address: None, + }; + src.node.peer_connected(dst.node.get_our_node_id(), init_msg, true).unwrap(); let reestablish_1 = get_chan_reestablish_msgs!(src, dst); assert_eq!(reestablish_1.len(), 1); - dst.node.peer_connected(src.node.get_our_node_id(), &msgs::Init { - features: src.node.init_features(), networks: None, remote_network_address: None - }, false).unwrap(); + let init_msg = &msgs::Init { + features: src.node.init_features(), + networks: None, + remote_network_address: None, + }; + dst.node.peer_connected(src.node.get_our_node_id(), init_msg, false).unwrap(); let reestablish_2 = get_chan_reestablish_msgs!(dst, src); assert_eq!(reestablish_2.len(), 1); if test_case == UnblockSignerAcrossDisconnectCase::BeforeReestablish { // Reenable the signer before the reestablish. - dst.enable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, SignerOp::SignCounterpartyCommitment); + dst.enable_channel_signer_op( + &src.node.get_our_node_id(), + &chan_id, + SignerOp::SignCounterpartyCommitment, + ); } dst.node.handle_channel_reestablish(src.node.get_our_node_id(), &reestablish_1[0]); if test_case == UnblockSignerAcrossDisconnectCase::BeforeMonitorRestored { - dst.enable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, SignerOp::SignCounterpartyCommitment); + dst.enable_channel_signer_op( + &src.node.get_our_node_id(), + &chan_id, + SignerOp::SignCounterpartyCommitment, + ); chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); - let (latest_update, _) = dst.chain_monitor.latest_monitor_update_id.lock().unwrap().get(&chan_id).unwrap().clone(); + let latest_update; + { + let channel_map = dst.chain_monitor.latest_monitor_update_id.lock().unwrap(); + (latest_update, _) = channel_map.get(&chan_id).unwrap().clone(); + } dst.chain_monitor.chain_monitor.force_channel_monitor_updated(chan_id, latest_update); check_added_monitors!(dst, 0); } @@ -631,7 +782,11 @@ fn do_test_async_commitment_signature_peer_disconnect(test_case: UnblockSignerAc } // Mark dst's signer as available and retry: we now expect to see dst's `commitment_signed`. - dst.enable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, SignerOp::SignCounterpartyCommitment); + dst.enable_channel_signer_op( + &src.node.get_our_node_id(), + &chan_id, + SignerOp::SignCounterpartyCommitment, + ); dst.node.signer_unblocked(Some((src.node.get_our_node_id(), chan_id))); if test_case == UnblockSignerAcrossDisconnectCase::AtEnd { @@ -670,18 +825,26 @@ fn do_test_async_commitment_signature_ordering(monitor_update_failure: bool) { let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); let (_, _, chan_id, _) = create_announced_chan_between_nodes(&nodes, 0, 1); - let (payment_preimage_1, payment_hash_1, ..) = route_payment(&nodes[0], &[&nodes[1]], 1_000_000); + let (payment_preimage_1, payment_hash_1, ..) = + route_payment(&nodes[0], &[&nodes[1]], 1_000_000); // Start to send the second update_add_htlc + commitment_signed, but don't actually make it // to the peer. - let (route, payment_hash_2, payment_preimage_2, payment_secret_2) = get_route_and_payment_hash!(nodes[0], nodes[1], 1000000); - nodes[0].node.send_payment_with_route(route, payment_hash_2, - RecipientOnionFields::secret_only(payment_secret_2), PaymentId(payment_hash_2.0)).unwrap(); + let (route, payment_hash_2, payment_preimage_2, payment_secret_2) = + get_route_and_payment_hash!(nodes[0], nodes[1], 1000000); + let recipient_fields = RecipientOnionFields::secret_only(payment_secret_2); + let payment_id = PaymentId(payment_hash_2.0); + nodes[0] + .node + .send_payment_with_route(route, payment_hash_2, recipient_fields, payment_id) + .unwrap(); check_added_monitors!(nodes[0], 1); - get_htlc_update_msgs(&nodes[0], &nodes[1].node.get_our_node_id()); + get_htlc_update_msgs(&nodes[0], &node_b_id); // Send back update_fulfill_htlc + commitment_signed for the first payment. nodes[1].node.claim_funds(payment_preimage_1); @@ -693,17 +856,21 @@ fn do_test_async_commitment_signature_ordering(monitor_update_failure: bool) { let events_2 = nodes[1].node.get_and_clear_pending_msg_events(); assert_eq!(events_2.len(), 1); match events_2[0] { - MessageSendEvent::UpdateHTLCs { node_id: _, channel_id: _, updates: msgs::CommitmentUpdate { ref update_fulfill_htlcs, ref commitment_signed, .. } } => { - nodes[0].node.handle_update_fulfill_htlc(nodes[1].node.get_our_node_id(), &update_fulfill_htlcs[0]); + MessageSendEvent::UpdateHTLCs { + node_id: _, + channel_id: _, + updates: msgs::CommitmentUpdate { ref update_fulfill_htlcs, ref commitment_signed, .. }, + } => { + nodes[0].node.handle_update_fulfill_htlc(node_b_id, &update_fulfill_htlcs[0]); expect_payment_sent(&nodes[0], payment_preimage_1, None, false, false); if monitor_update_failure { chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); } - nodes[0].node.handle_commitment_signed_batch_test(nodes[1].node.get_our_node_id(), commitment_signed); + nodes[0].node.handle_commitment_signed_batch_test(node_b_id, commitment_signed); if monitor_update_failure { assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); } else { - let _ = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id()); + let _ = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); } // No commitment_signed so get_event_msg's assert(len == 1) passes check_added_monitors!(nodes[0], 1); @@ -713,25 +880,31 @@ fn do_test_async_commitment_signature_ordering(monitor_update_failure: bool) { // Disconnect and reconnect the peers so that nodes[0] will // need to re-send the commitment update *and then* revoke_and_ack. - nodes[0].node.peer_disconnected(nodes[1].node.get_our_node_id()); - nodes[1].node.peer_disconnected(nodes[0].node.get_our_node_id()); + nodes[0].node.peer_disconnected(node_b_id); + nodes[1].node.peer_disconnected(node_a_id); - nodes[0].node.peer_connected(nodes[1].node.get_our_node_id(), &msgs::Init { - features: nodes[1].node.init_features(), networks: None, remote_network_address: None - }, true).unwrap(); + let init_msg = &msgs::Init { + features: nodes[1].node.init_features(), + networks: None, + remote_network_address: None, + }; + nodes[0].node.peer_connected(node_b_id, init_msg, true).unwrap(); let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]); assert_eq!(reestablish_1.len(), 1); - nodes[1].node.peer_connected(nodes[0].node.get_our_node_id(), &msgs::Init { - features: nodes[0].node.init_features(), networks: None, remote_network_address: None - }, false).unwrap(); + let init_msg = &msgs::Init { + features: nodes[0].node.init_features(), + networks: None, + remote_network_address: None, + }; + nodes[1].node.peer_connected(node_a_id, init_msg, false).unwrap(); let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]); assert_eq!(reestablish_2.len(), 1); // With a fully working signer, here we would send a commitment_signed, // and then revoke_and_ack. With commitment_signed disabled, since // our ordering is CS then RAA, we should make sure we don't send the RAA. - nodes[0].disable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignCounterpartyCommitment); - nodes[0].node.handle_channel_reestablish(nodes[1].node.get_our_node_id(), &reestablish_2[0]); + nodes[0].disable_channel_signer_op(&node_b_id, &chan_id, SignerOp::SignCounterpartyCommitment); + nodes[0].node.handle_channel_reestablish(node_b_id, &reestablish_2[0]); let as_resp = handle_chan_reestablish_msgs!(nodes[0], nodes[1]); assert!(as_resp.0.is_none()); assert!(as_resp.1.is_none()); @@ -739,24 +912,28 @@ fn do_test_async_commitment_signature_ordering(monitor_update_failure: bool) { if monitor_update_failure { chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); - let (latest_update, _) = nodes[0].chain_monitor.latest_monitor_update_id.lock().unwrap().get(&chan_id).unwrap().clone(); + let latest_update; + { + let channel_map = nodes[0].chain_monitor.latest_monitor_update_id.lock().unwrap(); + (latest_update, _) = channel_map.get(&chan_id).unwrap().clone(); + } nodes[0].chain_monitor.chain_monitor.force_channel_monitor_updated(chan_id, latest_update); check_added_monitors!(nodes[0], 0); } // Make sure that on signer_unblocked we have the same behavior (even though RAA is ready, // we don't send CS yet). - nodes[0].node.signer_unblocked(Some((nodes[1].node.get_our_node_id(), chan_id))); + nodes[0].node.signer_unblocked(Some((node_b_id, chan_id))); let as_resp = handle_chan_reestablish_msgs!(nodes[0], nodes[1]); assert!(as_resp.0.is_none()); assert!(as_resp.1.is_none()); assert!(as_resp.2.is_none()); - nodes[0].enable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignCounterpartyCommitment); - nodes[0].node.signer_unblocked(Some((nodes[1].node.get_our_node_id(), chan_id))); + nodes[0].enable_channel_signer_op(&node_b_id, &chan_id, SignerOp::SignCounterpartyCommitment); + nodes[0].node.signer_unblocked(Some((node_b_id, chan_id))); let as_resp = handle_chan_reestablish_msgs!(nodes[0], nodes[1]); - nodes[1].node.handle_channel_reestablish(nodes[0].node.get_our_node_id(), &reestablish_1[0]); + nodes[1].node.handle_channel_reestablish(node_a_id, &reestablish_1[0]); let bs_resp = handle_chan_reestablish_msgs!(nodes[1], nodes[0]); assert!(as_resp.0.is_none()); @@ -768,40 +945,56 @@ fn do_test_async_commitment_signature_ordering(monitor_update_failure: bool) { assert!(as_resp.3 == RAACommitmentOrder::CommitmentFirst); // Now that everything is restored, get the CS + RAA and handle them. - nodes[1].node.handle_update_add_htlc(nodes[0].node.get_our_node_id(), &as_resp.2.as_ref().unwrap().update_add_htlcs[0]); - nodes[1].node.handle_commitment_signed_batch_test(nodes[0].node.get_our_node_id(), &as_resp.2.as_ref().unwrap().commitment_signed); - nodes[1].node.handle_revoke_and_ack(nodes[0].node.get_our_node_id(), as_resp.1.as_ref().unwrap()); - let (bs_revoke_and_ack, bs_second_commitment_signed) = get_revoke_commit_msgs(&nodes[1], &nodes[0].node.get_our_node_id()); + nodes[1] + .node + .handle_update_add_htlc(node_a_id, &as_resp.2.as_ref().unwrap().update_add_htlcs[0]); + nodes[1].node.handle_commitment_signed_batch_test( + node_a_id, + &as_resp.2.as_ref().unwrap().commitment_signed, + ); + nodes[1].node.handle_revoke_and_ack(node_a_id, as_resp.1.as_ref().unwrap()); + let (bs_revoke_and_ack, bs_second_commitment_signed) = + get_revoke_commit_msgs(&nodes[1], &node_a_id); check_added_monitors!(nodes[1], 2); // The rest of this is boilerplate for resolving the previous state. - nodes[0].node.handle_revoke_and_ack(nodes[1].node.get_our_node_id(), &bs_revoke_and_ack); - let as_commitment_signed = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id()); + nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_revoke_and_ack); + let as_commitment_signed = get_htlc_update_msgs!(nodes[0], node_b_id); check_added_monitors!(nodes[0], 1); - nodes[0].node.handle_commitment_signed_batch_test(nodes[1].node.get_our_node_id(), &bs_second_commitment_signed); - let as_revoke_and_ack = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id()); + nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &bs_second_commitment_signed); + let as_revoke_and_ack = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); // No commitment_signed so get_event_msg's assert(len == 1) passes check_added_monitors!(nodes[0], 1); - nodes[1].node.handle_commitment_signed_batch_test(nodes[0].node.get_our_node_id(), &as_commitment_signed.commitment_signed); - let bs_second_revoke_and_ack = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id()); + nodes[1] + .node + .handle_commitment_signed_batch_test(node_a_id, &as_commitment_signed.commitment_signed); + let bs_second_revoke_and_ack = + get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, node_a_id); // No commitment_signed so get_event_msg's assert(len == 1) passes check_added_monitors!(nodes[1], 1); - nodes[1].node.handle_revoke_and_ack(nodes[0].node.get_our_node_id(), &as_revoke_and_ack); + nodes[1].node.handle_revoke_and_ack(node_a_id, &as_revoke_and_ack); assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); check_added_monitors!(nodes[1], 1); - nodes[0].node.handle_revoke_and_ack(nodes[1].node.get_our_node_id(), &bs_second_revoke_and_ack); + nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_second_revoke_and_ack); assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); check_added_monitors!(nodes[0], 1); expect_pending_htlcs_forwardable!(nodes[1]); let events_5 = nodes[1].node.get_and_clear_pending_events(); - check_payment_claimable(&events_5[0], payment_hash_2, payment_secret_2, 1_000_000, None, nodes[1].node.get_our_node_id()); + check_payment_claimable( + &events_5[0], + payment_hash_2, + payment_secret_2, + 1_000_000, + None, + node_b_id, + ); expect_payment_path_successful!(nodes[0]); claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2); @@ -821,23 +1014,26 @@ fn do_test_async_holder_signatures(anchors: bool, remote_commitment: bool) { let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[Some(config.clone()), Some(config)]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); let closing_node = if remote_commitment { &nodes[1] } else { &nodes[0] }; let coinbase_tx = Transaction { version: Version::TWO, lock_time: LockTime::ZERO, input: vec![TxIn { ..Default::default() }], - output: vec![ - TxOut { - value: Amount::ONE_BTC, - script_pubkey: closing_node.wallet_source.get_change_script().unwrap(), - }, - ], + output: vec![TxOut { + value: Amount::ONE_BTC, + script_pubkey: closing_node.wallet_source.get_change_script().unwrap(), + }], }; if anchors { *nodes[0].fee_estimator.sat_per_kw.lock().unwrap() *= 2; *nodes[1].fee_estimator.sat_per_kw.lock().unwrap() *= 2; - closing_node.wallet_source.add_utxo(bitcoin::OutPoint { txid: coinbase_tx.compute_txid(), vout: 0 }, coinbase_tx.output[0].value); + closing_node.wallet_source.add_utxo( + bitcoin::OutPoint { txid: coinbase_tx.compute_txid(), vout: 0 }, + coinbase_tx.output[0].value, + ); } // Route an HTLC and set the signer as unavailable. @@ -845,16 +1041,23 @@ fn do_test_async_holder_signatures(anchors: bool, remote_commitment: bool) { route_payment(&nodes[0], &[&nodes[1]], 1_000_000); let error_message = "Channel force-closed"; - if remote_commitment { // Make the counterparty broadcast its latest commitment. - nodes[1].node.force_close_broadcasting_latest_txn(&chan_id, &nodes[0].node.get_our_node_id(), error_message.to_string()).unwrap(); + nodes[1] + .node + .force_close_broadcasting_latest_txn(&chan_id, &node_a_id, error_message.to_string()) + .unwrap(); check_added_monitors(&nodes[1], 1); check_closed_broadcast(&nodes[1], 1, true); - check_closed_event(&nodes[1], 1, ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }, false, &[nodes[0].node.get_our_node_id()], 100_000); + let reason = ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }; + check_closed_event(&nodes[1], 1, reason, false, &[node_a_id], 100_000); } else { - nodes[0].disable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignHolderCommitment); - nodes[0].disable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignHolderHtlcTransaction); + nodes[0].disable_channel_signer_op(&node_b_id, &chan_id, SignerOp::SignHolderCommitment); + nodes[0].disable_channel_signer_op( + &node_b_id, + &chan_id, + SignerOp::SignHolderHtlcTransaction, + ); // We'll connect blocks until the sender has to go onchain to time out the HTLC. connect_blocks(&nodes[0], TEST_FINAL_CLTV + LATENCY_GRACE_PERIOD_BLOCKS + 1); @@ -863,9 +1066,17 @@ fn do_test_async_holder_signatures(anchors: bool, remote_commitment: bool) { assert!(nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty()); // Mark it as available now, we should see the signed commitment transaction. - nodes[0].enable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignHolderCommitment); - nodes[0].enable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignHolderHtlcTransaction); - get_monitor!(nodes[0], chan_id).signer_unblocked(nodes[0].tx_broadcaster, nodes[0].fee_estimator, &nodes[0].logger); + nodes[0].enable_channel_signer_op(&node_b_id, &chan_id, SignerOp::SignHolderCommitment); + nodes[0].enable_channel_signer_op( + &node_b_id, + &chan_id, + SignerOp::SignHolderHtlcTransaction, + ); + get_monitor!(nodes[0], chan_id).signer_unblocked( + nodes[0].tx_broadcaster, + nodes[0].fee_estimator, + &nodes[0].logger, + ); } let commitment_tx = { @@ -895,13 +1106,20 @@ fn do_test_async_holder_signatures(anchors: bool, remote_commitment: bool) { } else { SignerOp::SignHolderHtlcTransaction }; - nodes[0].disable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignHolderCommitment); - nodes[0].disable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, sign_htlc_op); + nodes[0].disable_channel_signer_op(&node_b_id, &chan_id, SignerOp::SignHolderCommitment); + nodes[0].disable_channel_signer_op(&node_b_id, &chan_id, sign_htlc_op); mine_transaction(&nodes[0], &commitment_tx); check_added_monitors(&nodes[0], 1); check_closed_broadcast(&nodes[0], 1, true); - check_closed_event(&nodes[0], 1, ClosureReason::CommitmentTxConfirmed, false, &[nodes[1].node.get_our_node_id()], 100_000); + check_closed_event( + &nodes[0], + 1, + ClosureReason::CommitmentTxConfirmed, + false, + &[node_b_id], + 100_000, + ); // If the counterparty broadcast its latest commitment, we need to mine enough blocks for the // HTLC timeout. @@ -917,9 +1135,13 @@ fn do_test_async_holder_signatures(anchors: bool, remote_commitment: bool) { assert!(txn.is_empty(), "expected no transaction to be broadcast, got {:?}", txn); // Mark it as available now, we should see the signed HTLC transaction. - nodes[0].enable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignHolderCommitment); - nodes[0].enable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, sign_htlc_op); - get_monitor!(nodes[0], chan_id).signer_unblocked(nodes[0].tx_broadcaster, nodes[0].fee_estimator, &nodes[0].logger); + nodes[0].enable_channel_signer_op(&node_b_id, &chan_id, SignerOp::SignHolderCommitment); + nodes[0].enable_channel_signer_op(&node_b_id, &chan_id, sign_htlc_op); + get_monitor!(nodes[0], chan_id).signer_unblocked( + nodes[0].tx_broadcaster, + nodes[0].fee_estimator, + &nodes[0].logger, + ); if anchors && !remote_commitment { handle_bump_htlc_event(&nodes[0], 1); @@ -966,6 +1188,8 @@ fn do_test_closing_signed(extra_closing_signed: bool, reconnect: bool) { let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); let (_, _, chan_id, funding_tx) = create_announced_chan_between_nodes(&nodes, 0, 1); // Avoid extra channel ready message upon reestablish later @@ -973,45 +1197,47 @@ fn do_test_closing_signed(extra_closing_signed: bool, reconnect: bool) { expect_channel_shutdown_state!(nodes[0], chan_id, ChannelShutdownState::NotShuttingDown); - nodes[0].node.close_channel(&chan_id, &nodes[1].node.get_our_node_id()).unwrap(); + nodes[0].node.close_channel(&chan_id, &node_b_id).unwrap(); expect_channel_shutdown_state!(nodes[0], chan_id, ChannelShutdownState::ShutdownInitiated); expect_channel_shutdown_state!(nodes[1], chan_id, ChannelShutdownState::NotShuttingDown); - let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); + let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, node_b_id); + nodes[1].node.handle_shutdown(node_a_id, &node_0_shutdown); expect_channel_shutdown_state!(nodes[0], chan_id, ChannelShutdownState::ShutdownInitiated); expect_channel_shutdown_state!(nodes[1], chan_id, ChannelShutdownState::NegotiatingClosingFee); - let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - nodes[0].disable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignClosingTransaction); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_shutdown); + let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, node_a_id); + nodes[0].disable_channel_signer_op(&node_b_id, &chan_id, SignerOp::SignClosingTransaction); + nodes[0].node.handle_shutdown(node_b_id, &node_1_shutdown); expect_channel_shutdown_state!(nodes[0], chan_id, ChannelShutdownState::NegotiatingClosingFee); expect_channel_shutdown_state!(nodes[1], chan_id, ChannelShutdownState::NegotiatingClosingFee); let events = nodes[0].node.get_and_clear_pending_msg_events(); assert!(events.is_empty(), "Expected no events, got {:?}", events); - nodes[0].enable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignClosingTransaction); + nodes[0].enable_channel_signer_op(&node_b_id, &chan_id, SignerOp::SignClosingTransaction); nodes[0].node.signer_unblocked(None); - let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id()); - nodes[1].disable_channel_signer_op(&nodes[0].node.get_our_node_id(), &chan_id, SignerOp::SignClosingTransaction); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); + let node_0_closing_signed = + get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, node_b_id); + nodes[1].disable_channel_signer_op(&node_a_id, &chan_id, SignerOp::SignClosingTransaction); + nodes[1].node.handle_closing_signed(node_a_id, &node_0_closing_signed); let events = nodes[1].node.get_and_clear_pending_msg_events(); assert!(events.is_empty(), "Expected no events, got {:?}", events); - nodes[1].enable_channel_signer_op(&nodes[0].node.get_our_node_id(), &chan_id, SignerOp::SignClosingTransaction); + nodes[1].enable_channel_signer_op(&node_a_id, &chan_id, SignerOp::SignClosingTransaction); nodes[1].node.signer_unblocked(None); - let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); + let node_1_closing_signed = + get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, node_a_id); - nodes[0].disable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignClosingTransaction); - nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); + nodes[0].disable_channel_signer_op(&node_b_id, &chan_id, SignerOp::SignClosingTransaction); + nodes[0].node.handle_closing_signed(node_b_id, &node_1_closing_signed); let events = nodes[0].node.get_and_clear_pending_msg_events(); assert!(events.is_empty(), "Expected no events, got {:?}", events); - nodes[0].enable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignClosingTransaction); + nodes[0].enable_channel_signer_op(&node_b_id, &chan_id, SignerOp::SignClosingTransaction); if extra_closing_signed { let node_1_closing_signed_2_bad = { @@ -1019,36 +1245,48 @@ fn do_test_closing_signed(extra_closing_signed: bool, reconnect: bool) { let holder_script = nodes[0].keys_manager.get_shutdown_scriptpubkey().unwrap(); let counterparty_script = nodes[1].keys_manager.get_shutdown_scriptpubkey().unwrap(); let funding_outpoint = bitcoin::OutPoint { txid: funding_tx.compute_txid(), vout: 0 }; - let closing_tx_2 = ClosingTransaction::new(50000, 0, holder_script.into(), - counterparty_script.into(), funding_outpoint); + let closing_tx_2 = ClosingTransaction::new( + 50000, + 0, + holder_script.into(), + counterparty_script.into(), + funding_outpoint, + ); let per_peer_state = nodes[1].node.per_peer_state.read().unwrap(); - let mut chan_lock = per_peer_state.get(&nodes[0].node.get_our_node_id()).unwrap().lock().unwrap(); + let mut chan_lock = per_peer_state.get(&node_a_id).unwrap().lock().unwrap(); let channel = chan_lock.channel_by_id.get_mut(&chan_id).unwrap(); let (funding, context) = channel.funding_and_context_mut(); let signer = context.get_mut_signer().as_mut_ecdsa().unwrap(); - let signature = signer.sign_closing_transaction(&funding.channel_transaction_parameters, &closing_tx_2, &Secp256k1::new()).unwrap(); + let signature = signer + .sign_closing_transaction( + &funding.channel_transaction_parameters, + &closing_tx_2, + &Secp256k1::new(), + ) + .unwrap(); node_1_closing_signed_2.signature = signature; node_1_closing_signed_2 }; - nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed_2_bad); + nodes[0].node.handle_closing_signed(node_b_id, &node_1_closing_signed_2_bad); let events = nodes[0].node.get_and_clear_pending_msg_events(); assert_eq!(events.len(), 1); match events[0] { MessageSendEvent::HandleError { - action: msgs::ErrorAction::SendWarningMessage { .. }, ref node_id + action: msgs::ErrorAction::SendWarningMessage { .. }, + ref node_id, } => { - assert_eq!(node_id, &nodes[1].node.get_our_node_id()); + assert_eq!(node_id, &node_b_id); }, _ => panic!("Unexpected event: {:?}", events[0]), }; } if reconnect { - nodes[0].node.peer_disconnected(nodes[1].node.get_our_node_id()); - nodes[1].node.peer_disconnected(nodes[0].node.get_our_node_id()); + nodes[0].node.peer_disconnected(node_b_id); + nodes[1].node.peer_disconnected(node_a_id); *nodes[0].fee_estimator.sat_per_kw.lock().unwrap() *= 8; *nodes[1].fee_estimator.sat_per_kw.lock().unwrap() *= 8; @@ -1056,43 +1294,53 @@ fn do_test_closing_signed(extra_closing_signed: bool, reconnect: bool) { connect_nodes(&nodes[0], &nodes[1]); let node_0_reestablish = get_chan_reestablish_msgs!(nodes[0], nodes[1]).pop().unwrap(); let node_1_reestablish = get_chan_reestablish_msgs!(nodes[1], nodes[0]).pop().unwrap(); - nodes[1].node.handle_channel_reestablish(nodes[0].node.get_our_node_id(), &node_0_reestablish); - nodes[0].node.handle_channel_reestablish(nodes[1].node.get_our_node_id(), &node_1_reestablish); + nodes[1].node.handle_channel_reestablish(node_a_id, &node_0_reestablish); + nodes[0].node.handle_channel_reestablish(node_b_id, &node_1_reestablish); let node_0_msgs = nodes[0].node.get_and_clear_pending_msg_events(); assert_eq!(node_0_msgs.len(), 2); let node_0_2nd_shutdown = match node_0_msgs[0] { - MessageSendEvent::SendShutdown { ref msg, .. } => { - msg.clone() - }, + MessageSendEvent::SendShutdown { ref msg, .. } => msg.clone(), _ => panic!(), }; let node_0_2nd_closing_signed = match node_0_msgs[1] { - MessageSendEvent::SendClosingSigned { ref msg, .. } => { - msg.clone() - }, + MessageSendEvent::SendClosingSigned { ref msg, .. } => msg.clone(), _ => panic!(), }; - let node_1_2nd_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); + let node_1_2nd_shutdown = + get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, node_a_id); - nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_2nd_shutdown); + nodes[1].node.handle_shutdown(node_a_id, &node_0_2nd_shutdown); assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_2nd_shutdown); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed); - let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); + nodes[0].node.handle_shutdown(node_b_id, &node_1_2nd_shutdown); + nodes[1].node.handle_closing_signed(node_a_id, &node_0_2nd_closing_signed); + let node_1_closing_signed = + get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, node_a_id); + nodes[0].node.handle_closing_signed(node_b_id, &node_1_closing_signed); } nodes[0].node.signer_unblocked(None); - let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap()); - let (_, node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); + let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, node_b_id); + nodes[1].node.handle_closing_signed(node_a_id, &node_0_2nd_closing_signed.unwrap()); + let (_, node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, node_a_id); assert!(node_1_closing_signed.is_none()); assert!(nodes[0].node.list_channels().is_empty()); assert!(nodes[1].node.list_channels().is_empty()); - check_closed_event!(nodes[0], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); - check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 100000); + check_closed_event!( + nodes[0], + 1, + ClosureReason::LocallyInitiatedCooperativeClosure, + [node_b_id], + 100000 + ); + check_closed_event!( + nodes[1], + 1, + ClosureReason::CounterpartyInitiatedCooperativeClosure, + [node_a_id], + 100000 + ); } #[test] @@ -1105,15 +1353,14 @@ fn test_no_disconnect_while_async_revoke_and_ack_expecting_remote_commitment_sig let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; - let node_id_0 = nodes[0].node.get_our_node_id(); - let node_id_1 = nodes[1].node.get_our_node_id(); - let payment_amount = 1_000_000; send_payment(&nodes[0], &[&nodes[1]], payment_amount * 4); - nodes[1].disable_channel_signer_op(&node_id_0, &chan_id, SignerOp::ReleaseCommitmentSecret); + nodes[1].disable_channel_signer_op(&node_a_id, &chan_id, SignerOp::ReleaseCommitmentSecret); // We'll send a payment from both nodes to each other. let (route1, payment_hash1, _, payment_secret1) = @@ -1130,20 +1377,20 @@ fn test_no_disconnect_while_async_revoke_and_ack_expecting_remote_commitment_sig nodes[1].node.send_payment_with_route(route2, payment_hash2, onion2, payment_id2).unwrap(); check_added_monitors(&nodes[1], 1); - let update = get_htlc_update_msgs!(&nodes[0], node_id_1); - nodes[1].node.handle_update_add_htlc(node_id_0, &update.update_add_htlcs[0]); - nodes[1].node.handle_commitment_signed_batch_test(node_id_0, &update.commitment_signed); + let update = get_htlc_update_msgs!(&nodes[0], node_b_id); + nodes[1].node.handle_update_add_htlc(node_a_id, &update.update_add_htlcs[0]); + nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &update.commitment_signed); check_added_monitors(&nodes[1], 1); - let update = get_htlc_update_msgs!(&nodes[1], node_id_0); - nodes[0].node.handle_update_add_htlc(node_id_1, &update.update_add_htlcs[0]); - nodes[0].node.handle_commitment_signed_batch_test(node_id_1, &update.commitment_signed); + let update = get_htlc_update_msgs!(&nodes[1], node_a_id); + nodes[0].node.handle_update_add_htlc(node_b_id, &update.update_add_htlcs[0]); + nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &update.commitment_signed); check_added_monitors(&nodes[0], 1); // nodes[0] can only respond with a `revoke_and_ack`. The `commitment_signed` that would follow // is blocked on receiving a counterparty `revoke_and_ack`, which nodes[1] is still pending on. - let revoke_and_ack = get_event_msg!(&nodes[0], MessageSendEvent::SendRevokeAndACK, node_id_1); - nodes[1].node.handle_revoke_and_ack(node_id_0, &revoke_and_ack); + let revoke_and_ack = get_event_msg!(&nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); + nodes[1].node.handle_revoke_and_ack(node_a_id, &revoke_and_ack); check_added_monitors(&nodes[1], 1); assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); @@ -1176,11 +1423,10 @@ fn test_no_disconnect_while_async_commitment_signed_expecting_remote_revoke_and_ let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; - let node_id_0 = nodes[0].node.get_our_node_id(); - let node_id_1 = nodes[1].node.get_our_node_id(); - // Route a payment and attempt to claim it. let payment_amount = 1_000_000; let (preimage, payment_hash, ..) = route_payment(&nodes[0], &[&nodes[1]], payment_amount); @@ -1188,17 +1434,17 @@ fn test_no_disconnect_while_async_commitment_signed_expecting_remote_revoke_and_ check_added_monitors(&nodes[1], 1); // We'll disable signing counterparty commitments on the payment sender. - nodes[0].disable_channel_signer_op(&node_id_1, &chan_id, SignerOp::SignCounterpartyCommitment); + nodes[0].disable_channel_signer_op(&node_b_id, &chan_id, SignerOp::SignCounterpartyCommitment); // After processing the `update_fulfill`, they'll only be able to send `revoke_and_ack` until // the `commitment_signed` is no longer pending. - let update = get_htlc_update_msgs!(&nodes[1], node_id_0); - nodes[0].node.handle_update_fulfill_htlc(node_id_1, &update.update_fulfill_htlcs[0]); - nodes[0].node.handle_commitment_signed_batch_test(node_id_1, &update.commitment_signed); + let update = get_htlc_update_msgs!(&nodes[1], node_a_id); + nodes[0].node.handle_update_fulfill_htlc(node_b_id, &update.update_fulfill_htlcs[0]); + nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &update.commitment_signed); check_added_monitors(&nodes[0], 1); - let revoke_and_ack = get_event_msg!(&nodes[0], MessageSendEvent::SendRevokeAndACK, node_id_1); - nodes[1].node.handle_revoke_and_ack(node_id_0, &revoke_and_ack); + let revoke_and_ack = get_event_msg!(&nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); + nodes[1].node.handle_revoke_and_ack(node_a_id, &revoke_and_ack); check_added_monitors(&nodes[1], 1); // The payment sender shouldn't disconnect the counterparty due to a missing `revoke_and_ack` diff --git a/lightning/src/ln/functional_test_utils.rs b/lightning/src/ln/functional_test_utils.rs index c680dc94486..05967fa6d23 100644 --- a/lightning/src/ln/functional_test_utils.rs +++ b/lightning/src/ln/functional_test_utils.rs @@ -1,5 +1,3 @@ -#![cfg_attr(rustfmt, rustfmt_skip)] - // This file is Copyright its original authors, visible in version control // history. // @@ -12,60 +10,70 @@ //! A bunch of useful utilities for building networks of nodes and exchanging messages between //! nodes for functional tests. -use crate::chain::{BestBlock, ChannelMonitorUpdateStatus, Confirm, Listen, Watch}; use crate::chain::channelmonitor::ChannelMonitor; use crate::chain::transaction::OutPoint; -use crate::events::{ClaimedHTLC, ClosureReason, Event, HTLCHandlingFailureType, PaidBolt12Invoice, PathFailure, PaymentFailureReason, PaymentPurpose}; -use crate::events::bump_transaction::{BumpTransactionEvent}; -use crate::events::bump_transaction::sync::{BumpTransactionEventHandlerSync, WalletSourceSync, WalletSync}; -use crate::ln::types::ChannelId; -use crate::types::features::ChannelTypeFeatures; -use crate::types::payment::{PaymentPreimage, PaymentHash, PaymentSecret}; +use crate::chain::{BestBlock, ChannelMonitorUpdateStatus, Confirm, Listen, Watch}; +use crate::events::bump_transaction::sync::{ + BumpTransactionEventHandlerSync, WalletSourceSync, WalletSync, +}; +use crate::events::bump_transaction::BumpTransactionEvent; +use crate::events::{ + ClaimedHTLC, ClosureReason, Event, HTLCHandlingFailureType, PaidBolt12Invoice, PathFailure, + PaymentFailureReason, PaymentPurpose, +}; use crate::ln::chan_utils::{commitment_tx_base_weight, COMMITMENT_TX_WEIGHT_PER_HTLC}; -use crate::ln::channelmanager::{AChannelManager, ChainParameters, ChannelManager, ChannelManagerReadArgs, RAACommitmentOrder, RecipientOnionFields, PaymentId, MIN_CLTV_EXPIRY_DELTA}; -use crate::types::features::InitFeatures; +use crate::ln::channelmanager::{ + AChannelManager, ChainParameters, ChannelManager, ChannelManagerReadArgs, PaymentId, + RAACommitmentOrder, RecipientOnionFields, MIN_CLTV_EXPIRY_DELTA, +}; use crate::ln::msgs; -use crate::ln::msgs::{BaseMessageHandler, ChannelMessageHandler, MessageSendEvent, RoutingMessageHandler}; +use crate::ln::msgs::{ + BaseMessageHandler, ChannelMessageHandler, MessageSendEvent, RoutingMessageHandler, +}; +use crate::ln::onion_utils::LocalHTLCFailureReason; use crate::ln::outbound_payment::Retry; use crate::ln::peer_handler::IgnoringMessageHandler; +use crate::ln::types::ChannelId; use crate::onion_message::messenger::OnionMessenger; -use crate::ln::onion_utils::LocalHTLCFailureReason; -use crate::routing::gossip::{P2PGossipSync, NetworkGraph, NetworkUpdate}; +use crate::routing::gossip::{NetworkGraph, NetworkUpdate, P2PGossipSync}; use crate::routing::router::{self, PaymentParameters, Route, RouteParameters}; use crate::sign::{EntropySource, RandomBytes}; +use crate::types::features::ChannelTypeFeatures; +use crate::types::features::InitFeatures; +use crate::types::payment::{PaymentHash, PaymentPreimage, PaymentSecret}; use crate::util::config::{MaxDustHTLCExposure, UserConfig}; use crate::util::logger::Logger; use crate::util::scid_utils; -use crate::util::test_channel_signer::TestChannelSigner; +use crate::util::ser::{ReadableArgs, Writeable}; use crate::util::test_channel_signer::SignerOp; +use crate::util::test_channel_signer::TestChannelSigner; use crate::util::test_utils; -use crate::util::test_utils::{TestChainMonitor, TestScorer, TestKeysInterface}; -use crate::util::ser::{ReadableArgs, Writeable}; +use crate::util::test_utils::{TestChainMonitor, TestKeysInterface, TestScorer}; -use bitcoin::{Weight, WPubkeyHash}; use bitcoin::amount::Amount; use bitcoin::block::{Block, Header, Version as BlockVersion}; -use bitcoin::locktime::absolute::{LockTime, LOCK_TIME_THRESHOLD}; -use bitcoin::transaction::{Sequence, Transaction, TxIn, TxOut}; use bitcoin::hash_types::{BlockHash, TxMerkleNode}; use bitcoin::hashes::sha256::Hash as Sha256; use bitcoin::hashes::Hash as _; +use bitcoin::locktime::absolute::{LockTime, LOCK_TIME_THRESHOLD}; use bitcoin::network::Network; use bitcoin::pow::CompactTarget; use bitcoin::script::ScriptBuf; use bitcoin::secp256k1::{PublicKey, SecretKey}; use bitcoin::transaction::{self, Version as TxVersion}; +use bitcoin::transaction::{Sequence, Transaction, TxIn, TxOut}; use bitcoin::witness::Witness; +use bitcoin::{WPubkeyHash, Weight}; +use crate::io; +use crate::prelude::*; +use crate::sign::P2WPKH_WITNESS_WEIGHT; +use crate::sync::{Arc, LockTestExt, Mutex, RwLock}; use alloc::rc::Rc; use core::cell::RefCell; use core::iter::repeat; use core::mem; use core::ops::Deref; -use crate::io; -use crate::prelude::*; -use crate::sign::P2WPKH_WITNESS_WEIGHT; -use crate::sync::{Arc, Mutex, LockTestExt, RwLock}; pub const CHAN_CONFIRM_DEPTH: u32 = 10; @@ -94,7 +102,9 @@ pub fn mine_transactions<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, txn: &[&Tra } /// Mine a single block containing the given transaction without extra consistency checks which may /// impact ChannelManager state. -pub fn mine_transaction_without_consistency_checks<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, tx: &Transaction) { +pub fn mine_transaction_without_consistency_checks<'a, 'b, 'c, 'd>( + node: &'a Node<'b, 'c, 'd>, tx: &Transaction, +) { let height = node.best_block_info().1 + 1; let mut block = Block { header: Header { @@ -107,8 +117,14 @@ pub fn mine_transaction_without_consistency_checks<'a, 'b, 'c, 'd>(node: &'a Nod }, txdata: Vec::new(), }; - for _ in 0..*node.network_chan_count.borrow() { // Make sure we don't end up with channels at the same short id by offsetting by chan_count - block.txdata.push(Transaction { version: transaction::Version(0), lock_time: LockTime::ZERO, input: Vec::new(), output: Vec::new() }); + for _ in 0..*node.network_chan_count.borrow() { + // Make sure we don't end up with channels at the same short id by offsetting by chan_count + block.txdata.push(Transaction { + version: transaction::Version(0), + lock_time: LockTime::ZERO, + input: Vec::new(), + output: Vec::new(), + }); } block.txdata.push((*tx).clone()); do_connect_block_without_consistency_checks(node, block, false); @@ -118,15 +134,23 @@ pub fn mine_transaction_without_consistency_checks<'a, 'b, 'c, 'd>(node: &'a Nod /// /// Returns the SCID a channel confirmed in the given transaction will have, assuming the funding /// output is the 1st output in the transaction. -pub fn confirm_transactions_at<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, txn: &[&Transaction], conf_height: u32) -> u64 { +pub fn confirm_transactions_at<'a, 'b, 'c, 'd>( + node: &'a Node<'b, 'c, 'd>, txn: &[&Transaction], conf_height: u32, +) -> u64 { let first_connect_height = node.best_block_info().1 + 1; assert!(first_connect_height <= conf_height); if conf_height > first_connect_height { connect_blocks(node, conf_height - first_connect_height); } let mut txdata = Vec::new(); - for _ in 0..*node.network_chan_count.borrow() { // Make sure we don't end up with channels at the same short id by offsetting by chan_count - txdata.push(Transaction { version: transaction::Version(0), lock_time: LockTime::ZERO, input: Vec::new(), output: Vec::new() }); + for _ in 0..*node.network_chan_count.borrow() { + // Make sure we don't end up with channels at the same short id by offsetting by chan_count + txdata.push(Transaction { + version: transaction::Version(0), + lock_time: LockTime::ZERO, + input: Vec::new(), + output: Vec::new(), + }); } for tx in txn { txdata.push((*tx).clone()); @@ -135,7 +159,9 @@ pub fn confirm_transactions_at<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, txn: connect_block(node, &block); scid_utils::scid_from_parts(conf_height as u64, block.txdata.len() as u64 - 1, 0).unwrap() } -pub fn confirm_transaction_at<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, tx: &Transaction, conf_height: u32) -> u64 { +pub fn confirm_transaction_at<'a, 'b, 'c, 'd>( + node: &'a Node<'b, 'c, 'd>, tx: &Transaction, conf_height: u32, +) -> u64 { confirm_transactions_at(node, &[tx], conf_height) } @@ -265,14 +291,18 @@ fn call_claimable_balances<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>) { } } -fn do_connect_block_with_consistency_checks<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, block: Block, skip_intermediaries: bool) { +fn do_connect_block_with_consistency_checks<'a, 'b, 'c, 'd>( + node: &'a Node<'b, 'c, 'd>, block: Block, skip_intermediaries: bool, +) { call_claimable_balances(node); do_connect_block_without_consistency_checks(node, block, skip_intermediaries); call_claimable_balances(node); node.node.test_process_background_events(); } -fn do_connect_block_without_consistency_checks<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, block: Block, skip_intermediaries: bool) { +fn do_connect_block_without_consistency_checks<'a, 'b, 'c, 'd>( + node: &'a Node<'b, 'c, 'd>, block: Block, skip_intermediaries: bool, +) { let height = node.best_block_info().1 + 1; eprintln!("Connecting block using Block Connection Style: {:?}", *node.connect_style.borrow()); // Update the block internally before handing it over to LDK, to ensure our assertions regarding @@ -281,17 +311,27 @@ fn do_connect_block_without_consistency_checks<'a, 'b, 'c, 'd>(node: &'a Node<'b if !skip_intermediaries { let txdata: Vec<_> = block.txdata.iter().enumerate().collect(); match *node.connect_style.borrow() { - ConnectStyle::BestBlockFirst|ConnectStyle::BestBlockFirstSkippingBlocks|ConnectStyle::BestBlockFirstReorgsOnlyTip => { + ConnectStyle::BestBlockFirst + | ConnectStyle::BestBlockFirstSkippingBlocks + | ConnectStyle::BestBlockFirstReorgsOnlyTip => { node.chain_monitor.chain_monitor.best_block_updated(&block.header, height); call_claimable_balances(node); - node.chain_monitor.chain_monitor.transactions_confirmed(&block.header, &txdata, height); + node.chain_monitor.chain_monitor.transactions_confirmed( + &block.header, + &txdata, + height, + ); node.node.best_block_updated(&block.header, height); node.node.transactions_confirmed(&block.header, &txdata, height); }, - ConnectStyle::TransactionsFirst|ConnectStyle::TransactionsFirstSkippingBlocks| - ConnectStyle::TransactionsDuplicativelyFirstSkippingBlocks|ConnectStyle::HighlyRedundantTransactionsFirstSkippingBlocks| - ConnectStyle::TransactionsFirstReorgsOnlyTip => { - if *node.connect_style.borrow() == ConnectStyle::HighlyRedundantTransactionsFirstSkippingBlocks { + ConnectStyle::TransactionsFirst + | ConnectStyle::TransactionsFirstSkippingBlocks + | ConnectStyle::TransactionsDuplicativelyFirstSkippingBlocks + | ConnectStyle::HighlyRedundantTransactionsFirstSkippingBlocks + | ConnectStyle::TransactionsFirstReorgsOnlyTip => { + if *node.connect_style.borrow() + == ConnectStyle::HighlyRedundantTransactionsFirstSkippingBlocks + { let mut connections = Vec::new(); for (block, height) in node.blocks.lock().unwrap().iter() { if !block.txdata.is_empty() { @@ -306,13 +346,26 @@ fn do_connect_block_without_consistency_checks<'a, 'b, 'c, 'd>(node: &'a Node<'b } } for (old_block, height) in connections { - node.chain_monitor.chain_monitor.transactions_confirmed(&old_block.header, - &old_block.txdata.iter().enumerate().collect::>(), height); + node.chain_monitor.chain_monitor.transactions_confirmed( + &old_block.header, + &old_block.txdata.iter().enumerate().collect::>(), + height, + ); } } - node.chain_monitor.chain_monitor.transactions_confirmed(&block.header, &txdata, height); - if *node.connect_style.borrow() == ConnectStyle::TransactionsDuplicativelyFirstSkippingBlocks { - node.chain_monitor.chain_monitor.transactions_confirmed(&block.header, &txdata, height); + node.chain_monitor.chain_monitor.transactions_confirmed( + &block.header, + &txdata, + height, + ); + if *node.connect_style.borrow() + == ConnectStyle::TransactionsDuplicativelyFirstSkippingBlocks + { + node.chain_monitor.chain_monitor.transactions_confirmed( + &block.header, + &txdata, + height, + ); } call_claimable_balances(node); node.chain_monitor.chain_monitor.best_block_updated(&block.header, height); @@ -322,7 +375,7 @@ fn do_connect_block_without_consistency_checks<'a, 'b, 'c, 'd>(node: &'a Node<'b ConnectStyle::FullBlockViaListen => { node.chain_monitor.chain_monitor.block_connected(&block, height); node.node.block_connected(&block, height); - } + }, } } @@ -342,7 +395,11 @@ fn do_connect_block_without_consistency_checks<'a, 'b, 'c, 'd>(node: &'a Node<'b pub fn disconnect_blocks<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, count: u32) { call_claimable_balances(node); - eprintln!("Disconnecting {} blocks using Block Connection Style: {:?}", count, *node.connect_style.borrow()); + eprintln!( + "Disconnecting {} blocks using Block Connection Style: {:?}", + count, + *node.connect_style.borrow() + ); for i in 0..count { let orig = node.blocks.lock().unwrap().pop().unwrap(); assert!(orig.1 > 0); // Cannot disconnect genesis @@ -353,14 +410,17 @@ pub fn disconnect_blocks<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, count: u32) node.chain_monitor.chain_monitor.block_disconnected(&orig.0.header, orig.1); Listen::block_disconnected(node.node, &orig.0.header, orig.1); }, - ConnectStyle::BestBlockFirstSkippingBlocks|ConnectStyle::TransactionsFirstSkippingBlocks| - ConnectStyle::HighlyRedundantTransactionsFirstSkippingBlocks|ConnectStyle::TransactionsDuplicativelyFirstSkippingBlocks => { + ConnectStyle::BestBlockFirstSkippingBlocks + | ConnectStyle::TransactionsFirstSkippingBlocks + | ConnectStyle::HighlyRedundantTransactionsFirstSkippingBlocks + | ConnectStyle::TransactionsDuplicativelyFirstSkippingBlocks => { if i == count - 1 { node.chain_monitor.chain_monitor.best_block_updated(&prev.0.header, prev.1); node.node.best_block_updated(&prev.0.header, prev.1); } }, - ConnectStyle::BestBlockFirstReorgsOnlyTip|ConnectStyle::TransactionsFirstReorgsOnlyTip => { + ConnectStyle::BestBlockFirstReorgsOnlyTip + | ConnectStyle::TransactionsFirstReorgsOnlyTip => { for tx in orig.0.txdata { node.chain_monitor.chain_monitor.transaction_unconfirmed(&tx.compute_txid()); node.node.transaction_unconfirmed(&tx.compute_txid()); @@ -450,7 +510,9 @@ pub struct DedicatedEntropy(RandomBytes); impl Deref for DedicatedEntropy { type Target = RandomBytes; - fn deref(&self) -> &Self::Target { &self.0 } + fn deref(&self) -> &Self::Target { + &self.0 + } } pub struct Node<'chan_man, 'node_cfg: 'chan_man, 'chan_mon_cfg: 'node_cfg> { @@ -464,7 +526,11 @@ pub struct Node<'chan_man, 'node_cfg: 'chan_man, 'chan_mon_cfg: 'node_cfg> { pub node: &'chan_man TestChannelManager<'node_cfg, 'chan_mon_cfg>, pub onion_messenger: TestOnionMessenger<'chan_man, 'node_cfg, 'chan_mon_cfg>, pub network_graph: &'node_cfg NetworkGraph<&'chan_mon_cfg test_utils::TestLogger>, - pub gossip_sync: P2PGossipSync<&'node_cfg NetworkGraph<&'chan_mon_cfg test_utils::TestLogger>, &'chan_mon_cfg test_utils::TestChainSource, &'chan_mon_cfg test_utils::TestLogger>, + pub gossip_sync: P2PGossipSync< + &'node_cfg NetworkGraph<&'chan_mon_cfg test_utils::TestLogger>, + &'chan_mon_cfg test_utils::TestChainSource, + &'chan_mon_cfg test_utils::TestLogger, + >, pub node_seed: [u8; 32], pub network_payment_count: Rc>, pub network_chan_count: Rc>, @@ -483,8 +549,9 @@ pub struct Node<'chan_man, 'node_cfg: 'chan_man, 'chan_mon_cfg: 'node_cfg> { impl<'a, 'b, 'c> Node<'a, 'b, 'c> { pub fn init_features(&self, peer_node_id: PublicKey) -> InitFeatures { - self.override_init_features.borrow().clone() - .unwrap_or_else(|| self.node.init_features() | self.onion_messenger.provided_init_features(peer_node_id)) + self.override_init_features.borrow().clone().unwrap_or_else(|| { + self.node.init_features() | self.onion_messenger.provided_init_features(peer_node_id) + }) } } @@ -520,7 +587,9 @@ impl<'a, 'b, 'c> Node<'a, 'b, 'c> { /// Toggles this node's signer to be available for the given signer operation. /// This is useful for testing behavior for restoring an async signer that previously /// could not return a signature immediately. - pub fn enable_channel_signer_op(&self, peer_id: &PublicKey, chan_id: &ChannelId, signer_op: SignerOp) { + pub fn enable_channel_signer_op( + &self, peer_id: &PublicKey, chan_id: &ChannelId, signer_op: SignerOp, + ) { self.set_channel_signer_ops(peer_id, chan_id, signer_op, true); } @@ -528,7 +597,9 @@ impl<'a, 'b, 'c> Node<'a, 'b, 'c> { /// This is useful for testing behavior for an async signer that cannot return a signature /// immediately. #[cfg(test)] - pub fn disable_channel_signer_op(&self, peer_id: &PublicKey, chan_id: &ChannelId, signer_op: SignerOp) { + pub fn disable_channel_signer_op( + &self, peer_id: &PublicKey, chan_id: &ChannelId, signer_op: SignerOp, + ) { self.set_channel_signer_ops(peer_id, chan_id, signer_op, false); } @@ -539,15 +610,24 @@ impl<'a, 'b, 'c> Node<'a, 'b, 'c> { /// will behave normally, returning `Ok`. When set to `false`, and the channel signer will /// act like an off-line remote signer, returning `Err`. This applies to the signer in all /// relevant places, i.e. the channel manager, chain monitor, and the keys manager. - fn set_channel_signer_ops(&self, peer_id: &PublicKey, chan_id: &ChannelId, signer_op: SignerOp, available: bool) { + fn set_channel_signer_ops( + &self, peer_id: &PublicKey, chan_id: &ChannelId, signer_op: SignerOp, available: bool, + ) { use crate::sign::ChannelSigner; - log_debug!(self.logger, "Setting channel signer for {} as available={}", chan_id, available); + log_debug!( + self.logger, + "Setting channel signer for {} as available={}", + chan_id, + available + ); let per_peer_state = self.node.per_peer_state.read().unwrap(); let mut chan_lock = per_peer_state.get(peer_id).unwrap().lock().unwrap(); let mut channel_keys_id = None; - if let Some(context) = chan_lock.channel_by_id.get_mut(chan_id).map(|chan| chan.context_mut()) { + if let Some(context) = + chan_lock.channel_by_id.get_mut(chan_id).map(|chan| chan.context_mut()) + { let signer = context.get_mut_signer().as_mut_ecdsa().unwrap(); if available { signer.enable_op(signer_op); @@ -601,10 +681,11 @@ impl NodePtr { unsafe impl Send for NodePtr {} unsafe impl Sync for NodePtr {} - pub trait NodeHolder { type CM: AChannelManager; - fn node(&self) -> &ChannelManager< + fn node( + &self, + ) -> &ChannelManager< ::M, ::T, ::ES, @@ -613,12 +694,15 @@ pub trait NodeHolder { ::F, ::R, ::MR, - ::L>; + ::L, + >; fn chain_monitor(&self) -> Option<&test_utils::TestChainMonitor>; } impl NodeHolder for &H { type CM = H::CM; - fn node(&self) -> &ChannelManager< + fn node( + &self, + ) -> &ChannelManager< ::M, ::T, ::ES, @@ -627,13 +711,22 @@ impl NodeHolder for &H { ::F, ::R, ::MR, - ::L> { (*self).node() } - fn chain_monitor(&self) -> Option<&test_utils::TestChainMonitor> { (*self).chain_monitor() } + ::L, + > { + (*self).node() + } + fn chain_monitor(&self) -> Option<&test_utils::TestChainMonitor> { + (*self).chain_monitor() + } } impl<'a, 'b: 'a, 'c: 'b> NodeHolder for Node<'a, 'b, 'c> { type CM = TestChannelManager<'b, 'c>; - fn node(&self) -> &TestChannelManager<'b, 'c> { &self.node } - fn chain_monitor(&self) -> Option<&test_utils::TestChainMonitor> { Some(self.chain_monitor) } + fn node(&self) -> &TestChannelManager<'b, 'c> { + &self.node + } + fn chain_monitor(&self) -> Option<&test_utils::TestChainMonitor> { + Some(self.chain_monitor) + } } impl<'a, 'b, 'c> Drop for Node<'a, 'b, 'c> { @@ -650,27 +743,33 @@ impl<'a, 'b, 'c> Drop for Node<'a, 'b, 'c> { } let added_monitors = self.chain_monitor.added_monitors.lock().unwrap().split_off(0); if !added_monitors.is_empty() { - panic!("Had {} excess added monitors on node {}", added_monitors.len(), self.logger.id); + panic!( + "Had {} excess added monitors on node {}", + added_monitors.len(), + self.logger.id + ); } let raa_blockers = self.node.get_and_clear_pending_raa_blockers(); if !raa_blockers.is_empty() { - panic!( "Had excess RAA blockers on node {}: {:?}", self.logger.id, raa_blockers); + panic!("Had excess RAA blockers on node {}: {:?}", self.logger.id, raa_blockers); } // Check that if we serialize the network graph, we can deserialize it again. let network_graph = { let mut w = test_utils::TestVecWriter(Vec::new()); self.network_graph.write(&mut w).unwrap(); - let network_graph_deser = >::read(&mut io::Cursor::new(&w.0), self.logger).unwrap(); + let network_graph_deser = + >::read(&mut io::Cursor::new(&w.0), self.logger).unwrap(); assert!(network_graph_deser == *self.network_graph); - let gossip_sync = P2PGossipSync::new( - &network_graph_deser, Some(self.chain_source), self.logger - ); + let gossip_sync = + P2PGossipSync::new(&network_graph_deser, Some(self.chain_source), self.logger); let mut chan_progress = 0; loop { - let orig_announcements = self.gossip_sync.get_next_channel_announcement(chan_progress); - let deserialized_announcements = gossip_sync.get_next_channel_announcement(chan_progress); + let orig_announcements = + self.gossip_sync.get_next_channel_announcement(chan_progress); + let deserialized_announcements = + gossip_sync.get_next_channel_announcement(chan_progress); assert!(orig_announcements == deserialized_announcements); chan_progress = match orig_announcements { Some(announcement) => announcement.0.contents.short_channel_id + 1, @@ -679,8 +778,10 @@ impl<'a, 'b, 'c> Drop for Node<'a, 'b, 'c> { } let mut node_progress = None; loop { - let orig_announcements = self.gossip_sync.get_next_node_announcement(node_progress.as_ref()); - let deserialized_announcements = gossip_sync.get_next_node_announcement(node_progress.as_ref()); + let orig_announcements = + self.gossip_sync.get_next_node_announcement(node_progress.as_ref()); + let deserialized_announcements = + gossip_sync.get_next_node_announcement(node_progress.as_ref()); assert!(orig_announcements == deserialized_announcements); node_progress = match orig_announcements { Some(announcement) => Some(announcement.contents.node_id), @@ -698,15 +799,26 @@ impl<'a, 'b, 'c> Drop for Node<'a, 'b, 'c> { { for channel_id in self.chain_monitor.chain_monitor.list_monitors() { let mut w = test_utils::TestVecWriter(Vec::new()); - self.chain_monitor.chain_monitor.get_monitor(channel_id).unwrap().write(&mut w).unwrap(); - let (_, deserialized_monitor) = <(BlockHash, ChannelMonitor)>::read( - &mut io::Cursor::new(&w.0), (self.keys_manager, self.keys_manager)).unwrap(); + self.chain_monitor + .chain_monitor + .get_monitor(channel_id) + .unwrap() + .write(&mut w) + .unwrap(); + let (_, deserialized_monitor) = + <(BlockHash, ChannelMonitor)>::read( + &mut io::Cursor::new(&w.0), + (self.keys_manager, self.keys_manager), + ) + .unwrap(); deserialized_monitors.push(deserialized_monitor); } } let broadcaster = test_utils::TestBroadcaster { - txn_broadcasted: Mutex::new(self.tx_broadcaster.txn_broadcasted.lock().unwrap().clone()), + txn_broadcasted: Mutex::new( + self.tx_broadcaster.txn_broadcasted.lock().unwrap().clone(), + ), blocks: Arc::new(Mutex::new(self.tx_broadcaster.blocks.lock().unwrap().clone())), }; @@ -721,89 +833,144 @@ impl<'a, 'b, 'c> Drop for Node<'a, 'b, 'c> { let scorer = RwLock::new(test_utils::TestScorer::new()); let mut w = test_utils::TestVecWriter(Vec::new()); self.node.write(&mut w).unwrap(); - <(BlockHash, ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestKeysInterface, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestRouter, &test_utils::TestMessageRouter, &test_utils::TestLogger>)>::read(&mut io::Cursor::new(w.0), ChannelManagerReadArgs { - default_config: self.node.get_current_default_configuration().clone(), - entropy_source: self.keys_manager, - node_signer: self.keys_manager, - signer_provider: self.keys_manager, - fee_estimator: &test_utils::TestFeeEstimator::new(253), - router: &test_utils::TestRouter::new(Arc::clone(&network_graph), &self.logger, &scorer), - message_router: &test_utils::TestMessageRouter::new(network_graph, self.keys_manager), - chain_monitor: self.chain_monitor, - tx_broadcaster: &broadcaster, - logger: &self.logger, - channel_monitors, - }).unwrap(); + <( + BlockHash, + ChannelManager< + &test_utils::TestChainMonitor, + &test_utils::TestBroadcaster, + &test_utils::TestKeysInterface, + &test_utils::TestKeysInterface, + &test_utils::TestKeysInterface, + &test_utils::TestFeeEstimator, + &test_utils::TestRouter, + &test_utils::TestMessageRouter, + &test_utils::TestLogger, + >, + )>::read( + &mut io::Cursor::new(w.0), + ChannelManagerReadArgs { + default_config: self.node.get_current_default_configuration().clone(), + entropy_source: self.keys_manager, + node_signer: self.keys_manager, + signer_provider: self.keys_manager, + fee_estimator: &test_utils::TestFeeEstimator::new(253), + router: &test_utils::TestRouter::new( + Arc::clone(&network_graph), + &self.logger, + &scorer, + ), + message_router: &test_utils::TestMessageRouter::new( + network_graph, + self.keys_manager, + ), + chain_monitor: self.chain_monitor, + tx_broadcaster: &broadcaster, + logger: &self.logger, + channel_monitors, + }, + ) + .unwrap(); } let persister = test_utils::TestPersister::new(); let chain_source = test_utils::TestChainSource::new(Network::Testnet); - let chain_monitor = test_utils::TestChainMonitor::new(Some(&chain_source), &broadcaster, &self.logger, &feeest, &persister, &self.keys_manager); + let chain_monitor = test_utils::TestChainMonitor::new( + Some(&chain_source), + &broadcaster, + &self.logger, + &feeest, + &persister, + &self.keys_manager, + ); for deserialized_monitor in deserialized_monitors.drain(..) { let channel_id = deserialized_monitor.channel_id(); - if chain_monitor.watch_channel(channel_id, deserialized_monitor) != Ok(ChannelMonitorUpdateStatus::Completed) { + if chain_monitor.watch_channel(channel_id, deserialized_monitor) + != Ok(ChannelMonitorUpdateStatus::Completed) + { panic!(); } } - assert_eq!(*chain_source.watched_txn.unsafe_well_ordered_double_lock_self(), *self.chain_source.watched_txn.unsafe_well_ordered_double_lock_self()); - assert_eq!(*chain_source.watched_outputs.unsafe_well_ordered_double_lock_self(), *self.chain_source.watched_outputs.unsafe_well_ordered_double_lock_self()); + assert_eq!( + *chain_source.watched_txn.unsafe_well_ordered_double_lock_self(), + *self.chain_source.watched_txn.unsafe_well_ordered_double_lock_self() + ); + assert_eq!( + *chain_source.watched_outputs.unsafe_well_ordered_double_lock_self(), + *self.chain_source.watched_outputs.unsafe_well_ordered_double_lock_self() + ); } } } -pub fn create_chan_between_nodes<'a, 'b, 'c: 'd, 'd>(node_a: &'a Node<'b, 'c, 'd>, node_b: &'a Node<'b, 'c, 'd>) -> (msgs::ChannelAnnouncement, msgs::ChannelUpdate, msgs::ChannelUpdate, ChannelId, Transaction) { +pub fn create_chan_between_nodes<'a, 'b, 'c: 'd, 'd>( + node_a: &'a Node<'b, 'c, 'd>, node_b: &'a Node<'b, 'c, 'd>, +) -> (msgs::ChannelAnnouncement, msgs::ChannelUpdate, msgs::ChannelUpdate, ChannelId, Transaction) { create_chan_between_nodes_with_value(node_a, node_b, 100000, 10001) } -pub fn create_chan_between_nodes_with_value<'a, 'b, 'c: 'd, 'd>(node_a: &'a Node<'b, 'c, 'd>, node_b: &'a Node<'b, 'c, 'd>, channel_value: u64, push_msat: u64) -> (msgs::ChannelAnnouncement, msgs::ChannelUpdate, msgs::ChannelUpdate, ChannelId, Transaction) { - let (channel_ready, channel_id, tx) = create_chan_between_nodes_with_value_a(node_a, node_b, channel_value, push_msat); - let (announcement, as_update, bs_update) = create_chan_between_nodes_with_value_b(node_a, node_b, &channel_ready); +pub fn create_chan_between_nodes_with_value<'a, 'b, 'c: 'd, 'd>( + node_a: &'a Node<'b, 'c, 'd>, node_b: &'a Node<'b, 'c, 'd>, channel_value: u64, push_msat: u64, +) -> (msgs::ChannelAnnouncement, msgs::ChannelUpdate, msgs::ChannelUpdate, ChannelId, Transaction) { + let (channel_ready, channel_id, tx) = + create_chan_between_nodes_with_value_a(node_a, node_b, channel_value, push_msat); + let (announcement, as_update, bs_update) = + create_chan_between_nodes_with_value_b(node_a, node_b, &channel_ready); (announcement, as_update, bs_update, channel_id, tx) } /// Gets an RAA and CS which were sent in response to a commitment update -pub fn get_revoke_commit_msgs>(node: &H, recipient: &PublicKey) -> (msgs::RevokeAndACK, Vec) { +pub fn get_revoke_commit_msgs>( + node: &H, recipient: &PublicKey, +) -> (msgs::RevokeAndACK, Vec) { let events = node.node().get_and_clear_pending_msg_events(); assert_eq!(events.len(), 2); - (match events[0] { - MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => { - assert_eq!(node_id, recipient); - (*msg).clone() + ( + match events[0] { + MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => { + assert_eq!(node_id, recipient); + (*msg).clone() + }, + _ => panic!("Unexpected event"), }, - _ => panic!("Unexpected event"), - }, match events[1] { - MessageSendEvent::UpdateHTLCs { ref node_id, ref channel_id, ref updates } => { - assert_eq!(node_id, recipient); - assert!(updates.update_add_htlcs.is_empty()); - assert!(updates.update_fulfill_htlcs.is_empty()); - assert!(updates.update_fail_htlcs.is_empty()); - assert!(updates.update_fail_malformed_htlcs.is_empty()); - assert!(updates.update_fee.is_none()); - assert!(updates.commitment_signed.iter().all(|cs| cs.channel_id == *channel_id)); - updates.commitment_signed.clone() + match events[1] { + MessageSendEvent::UpdateHTLCs { ref node_id, ref channel_id, ref updates } => { + assert_eq!(node_id, recipient); + assert!(updates.update_add_htlcs.is_empty()); + assert!(updates.update_fulfill_htlcs.is_empty()); + assert!(updates.update_fail_htlcs.is_empty()); + assert!(updates.update_fail_malformed_htlcs.is_empty()); + assert!(updates.update_fee.is_none()); + assert!(updates.commitment_signed.iter().all(|cs| cs.channel_id == *channel_id)); + updates.commitment_signed.clone() + }, + _ => panic!("Unexpected event"), }, - _ => panic!("Unexpected event"), - }) + ) } /// Gets a `UpdateHTLCs` and `revoke_and_ack` (i.e. after we get a responding `commitment_signed` /// while we have updates in the holding cell). -pub fn get_updates_and_revoke>(node: &H, recipient: &PublicKey) -> (msgs::CommitmentUpdate, msgs::RevokeAndACK) { +pub fn get_updates_and_revoke>( + node: &H, recipient: &PublicKey, +) -> (msgs::CommitmentUpdate, msgs::RevokeAndACK) { let events = node.node().get_and_clear_pending_msg_events(); assert_eq!(events.len(), 2); - (match events[0] { - MessageSendEvent::UpdateHTLCs { ref node_id, channel_id: _, ref updates } => { - assert_eq!(node_id, recipient); - (*updates).clone() + ( + match events[0] { + MessageSendEvent::UpdateHTLCs { ref node_id, channel_id: _, ref updates } => { + assert_eq!(node_id, recipient); + (*updates).clone() + }, + _ => panic!("Unexpected event"), }, - _ => panic!("Unexpected event"), - }, match events[1] { - MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => { - assert_eq!(node_id, recipient); - (*msg).clone() + match events[1] { + MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => { + assert_eq!(node_id, recipient); + (*msg).clone() + }, + _ => panic!("Unexpected event"), }, - _ => panic!("Unexpected event"), - }) + ) } #[macro_export] @@ -813,25 +980,23 @@ pub fn get_updates_and_revoke>(node: & macro_rules! get_revoke_commit_msgs { ($node: expr, $node_id: expr) => { $crate::ln::functional_test_utils::get_revoke_commit_msgs(&$node, &$node_id) - } + }; } /// Get an specific event message from the pending events queue. #[macro_export] macro_rules! get_event_msg { - ($node: expr, $event_type: path, $node_id: expr) => { - { - let events = $node.node.get_and_clear_pending_msg_events(); - assert_eq!(events.len(), 1); - match events[0] { - $event_type { ref node_id, ref msg } => { - assert_eq!(*node_id, $node_id); - (*msg).clone() - }, - _ => panic!("Unexpected event {:?}", events[0]), - } + ($node: expr, $event_type: path, $node_id: expr) => {{ + let events = $node.node.get_and_clear_pending_msg_events(); + assert_eq!(events.len(), 1); + match events[0] { + $event_type { ref node_id, ref msg } => { + assert_eq!(*node_id, $node_id); + (*msg).clone() + }, + _ => panic!("Unexpected event {:?}", events[0]), } - } + }}; } /// Get an error message from the pending events queue. @@ -840,13 +1005,15 @@ pub fn get_err_msg(node: &Node, recipient: &PublicKey) -> msgs::ErrorMessage { assert_eq!(events.len(), 1); match events[0] { MessageSendEvent::HandleError { - action: msgs::ErrorAction::SendErrorMessage { ref msg }, ref node_id + action: msgs::ErrorAction::SendErrorMessage { ref msg }, + ref node_id, } => { assert_eq!(node_id, recipient); (*msg).clone() }, MessageSendEvent::HandleError { - action: msgs::ErrorAction::DisconnectPeer { ref msg }, ref node_id + action: msgs::ErrorAction::DisconnectPeer { ref msg }, + ref node_id, } => { assert_eq!(node_id, recipient); msg.as_ref().unwrap().clone() @@ -858,19 +1025,15 @@ pub fn get_err_msg(node: &Node, recipient: &PublicKey) -> msgs::ErrorMessage { /// Get a specific event from the pending events queue. #[macro_export] macro_rules! get_event { - ($node: expr, $event_type: path) => { - { - let mut events = $node.node.get_and_clear_pending_events(); - assert_eq!(events.len(), 1); - let ev = events.pop().unwrap(); - match ev { - $event_type { .. } => { - ev - }, - _ => panic!("Unexpected event"), - } + ($node: expr, $event_type: path) => {{ + let mut events = $node.node.get_and_clear_pending_events(); + assert_eq!(events.len(), 1); + let ev = events.pop().unwrap(); + match ev { + $event_type { .. } => ev, + _ => panic!("Unexpected event"), } - } + }}; } /// Gets an UpdateHTLCs MessageSendEvent @@ -893,7 +1056,7 @@ pub fn get_htlc_update_msgs(node: &Node, recipient: &PublicKey) -> msgs::Commitm macro_rules! get_htlc_update_msgs { ($node: expr, $node_id: expr) => { $crate::ln::functional_test_utils::get_htlc_update_msgs(&$node, &$node_id) - } + }; } /// Fetches the first `msg_event` to the passed `node_id` in the passed `msg_events` vec. @@ -902,129 +1065,51 @@ macro_rules! get_htlc_update_msgs { /// Note that even though `BroadcastChannelAnnouncement` and `BroadcastChannelUpdate` /// `msg_events` are stored under specific peers, this function does not fetch such `msg_events` as /// such messages are intended to all peers. -pub fn remove_first_msg_event_to_node(msg_node_id: &PublicKey, msg_events: &mut Vec) -> MessageSendEvent { - let ev_index = msg_events.iter().position(|e| { match e { - MessageSendEvent::SendPeerStorage { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::SendPeerStorageRetrieval { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::SendAcceptChannel { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::SendOpenChannel { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::SendFundingCreated { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::SendFundingSigned { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::SendChannelReady { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::SendAnnouncementSignatures { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::UpdateHTLCs { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::SendRevokeAndACK { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::SendClosingSigned { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::SendClosingComplete { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::SendClosingSig { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::SendShutdown { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::SendChannelReestablish { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::SendChannelAnnouncement { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::BroadcastChannelAnnouncement { .. } => { - false - }, - MessageSendEvent::BroadcastChannelUpdate { .. } => { - false - }, - MessageSendEvent::BroadcastNodeAnnouncement { .. } => { - false - }, - MessageSendEvent::SendChannelUpdate { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::HandleError { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::SendChannelRangeQuery { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::SendShortIdsQuery { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::SendReplyChannelRange { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::SendGossipTimestampFilter { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::SendAcceptChannelV2 { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::SendOpenChannelV2 { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::SendStfu { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::SendSpliceInit { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::SendSpliceAck { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::SendSpliceLocked { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::SendTxAddInput { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::SendTxAddOutput { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::SendTxRemoveInput { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::SendTxRemoveOutput { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::SendTxComplete { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::SendTxSignatures { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::SendTxInitRbf { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::SendTxAckRbf { node_id, .. } => { - node_id == msg_node_id - }, - MessageSendEvent::SendTxAbort { node_id, .. } => { - node_id == msg_node_id - }, - }}); +pub fn remove_first_msg_event_to_node( + msg_node_id: &PublicKey, msg_events: &mut Vec, +) -> MessageSendEvent { + let ev_index = msg_events.iter().position(|e| match e { + MessageSendEvent::SendPeerStorage { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::SendPeerStorageRetrieval { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::SendAcceptChannel { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::SendOpenChannel { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::SendFundingCreated { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::SendFundingSigned { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::SendChannelReady { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::SendAnnouncementSignatures { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::UpdateHTLCs { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::SendRevokeAndACK { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::SendClosingSigned { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::SendClosingComplete { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::SendClosingSig { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::SendShutdown { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::SendChannelReestablish { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::SendChannelAnnouncement { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::BroadcastChannelAnnouncement { .. } => false, + MessageSendEvent::BroadcastChannelUpdate { .. } => false, + MessageSendEvent::BroadcastNodeAnnouncement { .. } => false, + MessageSendEvent::SendChannelUpdate { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::HandleError { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::SendChannelRangeQuery { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::SendShortIdsQuery { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::SendReplyChannelRange { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::SendGossipTimestampFilter { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::SendAcceptChannelV2 { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::SendOpenChannelV2 { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::SendStfu { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::SendSpliceInit { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::SendSpliceAck { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::SendSpliceLocked { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::SendTxAddInput { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::SendTxAddOutput { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::SendTxRemoveInput { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::SendTxRemoveOutput { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::SendTxComplete { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::SendTxSignatures { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::SendTxInitRbf { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::SendTxAckRbf { node_id, .. } => node_id == msg_node_id, + MessageSendEvent::SendTxAbort { node_id, .. } => node_id == msg_node_id, + }); if ev_index.is_some() { msg_events.remove(ev_index.unwrap()) } else { @@ -1034,57 +1119,64 @@ pub fn remove_first_msg_event_to_node(msg_node_id: &PublicKey, msg_events: &mut #[cfg(any(test, feature = "_externalize_tests"))] macro_rules! get_channel_ref { - ($node: expr, $counterparty_node: expr, $per_peer_state_lock: ident, $peer_state_lock: ident, $channel_id: expr) => { - { - $per_peer_state_lock = $node.node.per_peer_state.read().unwrap(); - $peer_state_lock = $per_peer_state_lock.get(&$counterparty_node.node.get_our_node_id()).unwrap().lock().unwrap(); - $peer_state_lock.channel_by_id.get_mut(&$channel_id).unwrap() - } - } + ($node: expr, $counterparty_node: expr, $per_peer_state_lock: ident, $peer_state_lock: ident, $channel_id: expr) => {{ + $per_peer_state_lock = $node.node.per_peer_state.read().unwrap(); + $peer_state_lock = $per_peer_state_lock + .get(&$counterparty_node.node.get_our_node_id()) + .unwrap() + .lock() + .unwrap(); + $peer_state_lock.channel_by_id.get_mut(&$channel_id).unwrap() + }}; } #[cfg(any(test, feature = "_externalize_tests"))] macro_rules! get_feerate { - ($node: expr, $counterparty_node: expr, $channel_id: expr) => { - { - let mut per_peer_state_lock; - let mut peer_state_lock; - let chan = get_channel_ref!($node, $counterparty_node, per_peer_state_lock, peer_state_lock, $channel_id); - chan.context().get_feerate_sat_per_1000_weight() - } - } + ($node: expr, $counterparty_node: expr, $channel_id: expr) => {{ + let mut per_peer_state_lock; + let mut peer_state_lock; + let chan = get_channel_ref!( + $node, + $counterparty_node, + per_peer_state_lock, + peer_state_lock, + $channel_id + ); + chan.context().get_feerate_sat_per_1000_weight() + }}; } #[cfg(any(test, feature = "_externalize_tests"))] macro_rules! get_channel_type_features { - ($node: expr, $counterparty_node: expr, $channel_id: expr) => { - { - let mut per_peer_state_lock; - let mut peer_state_lock; - let chan = get_channel_ref!($node, $counterparty_node, per_peer_state_lock, peer_state_lock, $channel_id); - chan.funding().get_channel_type().clone() - } - } + ($node: expr, $counterparty_node: expr, $channel_id: expr) => {{ + let mut per_peer_state_lock; + let mut peer_state_lock; + let chan = get_channel_ref!( + $node, + $counterparty_node, + per_peer_state_lock, + peer_state_lock, + $channel_id + ); + chan.funding().get_channel_type().clone() + }}; } /// Returns a channel monitor given a channel id, making some naive assumptions #[macro_export] macro_rules! get_monitor { - ($node: expr, $channel_id: expr) => { - { - $node.chain_monitor.chain_monitor.get_monitor($channel_id).unwrap() - } - } + ($node: expr, $channel_id: expr) => {{ + $node.chain_monitor.chain_monitor.get_monitor($channel_id).unwrap() + }}; } /// Returns any local commitment transactions for the channel. #[macro_export] macro_rules! get_local_commitment_txn { - ($node: expr, $channel_id: expr) => { - { - $crate::get_monitor!($node, $channel_id).unsafe_get_latest_holder_commitment_txn(&$node.logger) - } - } + ($node: expr, $channel_id: expr) => {{ + $crate::get_monitor!($node, $channel_id) + .unsafe_get_latest_holder_commitment_txn(&$node.logger) + }}; } /// Check the error from attempting a payment. @@ -1095,32 +1187,32 @@ macro_rules! unwrap_send_err { let events = $node.node.get_and_clear_pending_events(); assert!(events.len() == 2); match &events[0] { - $crate::events::Event::PaymentPathFailed { failure, .. } => { - match failure { - $crate::events::PathFailure::InitialSend { err } => { - match err { - $type => { $check }, - _ => panic!() - } - }, - _ => panic!() - } + $crate::events::Event::PaymentPathFailed { failure, .. } => match failure { + $crate::events::PathFailure::InitialSend { err } => match err { + $type => $check, + _ => panic!(), + }, + _ => panic!(), }, - _ => panic!() + _ => panic!(), } match &events[1] { $crate::events::Event::PaymentFailed { .. } => {}, - _ => panic!() + _ => panic!(), } - } + }; } -pub fn commit_tx_fee_msat(feerate: u32, num_htlcs: u64, channel_type_features: &ChannelTypeFeatures) -> u64 { - (commitment_tx_base_weight(channel_type_features) + num_htlcs * COMMITMENT_TX_WEIGHT_PER_HTLC) * feerate as u64 / 1000 * 1000 +pub fn commit_tx_fee_msat( + feerate: u32, num_htlcs: u64, channel_type_features: &ChannelTypeFeatures, +) -> u64 { + (commitment_tx_base_weight(channel_type_features) + num_htlcs * COMMITMENT_TX_WEIGHT_PER_HTLC) + * feerate as u64 + / 1000 * 1000 } /// Check whether N channel monitor(s) have been added. -pub fn check_added_monitors>(node: &H, count: usize) { +pub fn check_added_monitors>(node: &H, count: usize) { if let Some(chain_monitor) = node.chain_monitor() { let mut added_monitors = chain_monitor.added_monitors.lock().unwrap(); let n = added_monitors.len(); @@ -1136,21 +1228,26 @@ pub fn check_added_monitors>(node: &H, macro_rules! check_added_monitors { ($node: expr, $count: expr) => { $crate::ln::functional_test_utils::check_added_monitors(&$node, $count); - } + }; } -fn claimed_htlc_matches_path<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, path: &[&Node<'a, 'b, 'c>], htlc: &ClaimedHTLC) -> bool { +fn claimed_htlc_matches_path<'a, 'b, 'c>( + origin_node: &Node<'a, 'b, 'c>, path: &[&Node<'a, 'b, 'c>], htlc: &ClaimedHTLC, +) -> bool { let mut nodes = path.iter().rev(); let dest = nodes.next().expect("path should have a destination").node; let prev = nodes.next().unwrap_or(&origin_node).node; let dest_channels = dest.list_channels(); - let ch = dest_channels.iter().find(|ch| ch.channel_id == htlc.channel_id) + let ch = dest_channels + .iter() + .find(|ch| ch.channel_id == htlc.channel_id) .expect("HTLC's channel should be one of destination node's channels"); - htlc.user_channel_id == ch.user_channel_id && - ch.counterparty.node_id == prev.get_our_node_id() + htlc.user_channel_id == ch.user_channel_id && ch.counterparty.node_id == prev.get_our_node_id() } -fn check_claimed_htlcs_match_route<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, route: &[&[&Node<'a, 'b, 'c>]], htlcs: &[ClaimedHTLC]) { +fn check_claimed_htlcs_match_route<'a, 'b, 'c>( + origin_node: &Node<'a, 'b, 'c>, route: &[&[&Node<'a, 'b, 'c>]], htlcs: &[ClaimedHTLC], +) { assert_eq!(route.len(), htlcs.len()); for path in route { let mut found_matching_htlc = false; @@ -1164,12 +1261,18 @@ fn check_claimed_htlcs_match_route<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, r } } -pub fn _reload_node<'a, 'b, 'c>(node: &'a Node<'a, 'b, 'c>, default_config: UserConfig, chanman_encoded: &[u8], monitors_encoded: &[&[u8]]) -> TestChannelManager<'b, 'c> { +pub fn _reload_node<'a, 'b, 'c>( + node: &'a Node<'a, 'b, 'c>, default_config: UserConfig, chanman_encoded: &[u8], + monitors_encoded: &[&[u8]], +) -> TestChannelManager<'b, 'c> { let mut monitors_read = Vec::with_capacity(monitors_encoded.len()); for encoded in monitors_encoded { let mut monitor_read = &encoded[..]; - let (_, monitor) = <(BlockHash, ChannelMonitor)> - ::read(&mut monitor_read, (node.keys_manager, node.keys_manager)).unwrap(); + let (_, monitor) = <(BlockHash, ChannelMonitor)>::read( + &mut monitor_read, + (node.keys_manager, node.keys_manager), + ) + .unwrap(); assert!(monitor_read.is_empty()); monitors_read.push(monitor); } @@ -1180,26 +1283,32 @@ pub fn _reload_node<'a, 'b, 'c>(node: &'a Node<'a, 'b, 'c>, default_config: User for monitor in monitors_read.iter() { assert!(channel_monitors.insert(monitor.channel_id(), monitor).is_none()); } - <(BlockHash, TestChannelManager<'b, 'c>)>::read(&mut node_read, ChannelManagerReadArgs { - default_config, - entropy_source: node.keys_manager, - node_signer: node.keys_manager, - signer_provider: node.keys_manager, - fee_estimator: node.fee_estimator, - router: node.router, - message_router: node.message_router, - chain_monitor: node.chain_monitor, - tx_broadcaster: node.tx_broadcaster, - logger: node.logger, - channel_monitors, - }).unwrap() + <(BlockHash, TestChannelManager<'b, 'c>)>::read( + &mut node_read, + ChannelManagerReadArgs { + default_config, + entropy_source: node.keys_manager, + node_signer: node.keys_manager, + signer_provider: node.keys_manager, + fee_estimator: node.fee_estimator, + router: node.router, + message_router: node.message_router, + chain_monitor: node.chain_monitor, + tx_broadcaster: node.tx_broadcaster, + logger: node.logger, + channel_monitors, + }, + ) + .unwrap() }; assert!(node_read.is_empty()); for monitor in monitors_read.drain(..) { let channel_id = monitor.channel_id(); - assert_eq!(node.chain_monitor.watch_channel(channel_id, monitor), - Ok(ChannelMonitorUpdateStatus::Completed)); + assert_eq!( + node.chain_monitor.watch_channel(channel_id, monitor), + Ok(ChannelMonitorUpdateStatus::Completed) + ); check_added_monitors!(node, 1); } @@ -1212,57 +1321,95 @@ macro_rules! reload_node { let chanman_encoded = $chanman_encoded; $persister = $crate::util::test_utils::TestPersister::new(); - $new_chain_monitor = $crate::util::test_utils::TestChainMonitor::new(Some($node.chain_source), $node.tx_broadcaster.clone(), $node.logger, $node.fee_estimator, &$persister, &$node.keys_manager); + $new_chain_monitor = $crate::util::test_utils::TestChainMonitor::new( + Some($node.chain_source), + $node.tx_broadcaster.clone(), + $node.logger, + $node.fee_estimator, + &$persister, + &$node.keys_manager, + ); $node.chain_monitor = &$new_chain_monitor; - $new_channelmanager = _reload_node(&$node, $new_config, &chanman_encoded, $monitors_encoded); + $new_channelmanager = + _reload_node(&$node, $new_config, &chanman_encoded, $monitors_encoded); $node.node = &$new_channelmanager; $node.onion_messenger.set_offers_handler(&$new_channelmanager); }; ($node: expr, $chanman_encoded: expr, $monitors_encoded: expr, $persister: ident, $new_chain_monitor: ident, $new_channelmanager: ident) => { - reload_node!($node, $crate::util::config::UserConfig::default(), $chanman_encoded, $monitors_encoded, $persister, $new_chain_monitor, $new_channelmanager); + reload_node!( + $node, + $crate::util::config::UserConfig::default(), + $chanman_encoded, + $monitors_encoded, + $persister, + $new_chain_monitor, + $new_channelmanager + ); }; } -pub fn create_funding_transaction<'a, 'b, 'c>(node: &Node<'a, 'b, 'c>, - expected_counterparty_node_id: &PublicKey, expected_chan_value: u64, expected_user_chan_id: u128) - -> (ChannelId, Transaction, OutPoint) -{ - internal_create_funding_transaction(node, expected_counterparty_node_id, expected_chan_value, expected_user_chan_id, false) +pub fn create_funding_transaction<'a, 'b, 'c>( + node: &Node<'a, 'b, 'c>, expected_counterparty_node_id: &PublicKey, expected_chan_value: u64, + expected_user_chan_id: u128, +) -> (ChannelId, Transaction, OutPoint) { + internal_create_funding_transaction( + node, + expected_counterparty_node_id, + expected_chan_value, + expected_user_chan_id, + false, + ) } -pub fn create_coinbase_funding_transaction<'a, 'b, 'c>(node: &Node<'a, 'b, 'c>, - expected_counterparty_node_id: &PublicKey, expected_chan_value: u64, expected_user_chan_id: u128) - -> (ChannelId, Transaction, OutPoint) -{ - internal_create_funding_transaction(node, expected_counterparty_node_id, expected_chan_value, expected_user_chan_id, true) +pub fn create_coinbase_funding_transaction<'a, 'b, 'c>( + node: &Node<'a, 'b, 'c>, expected_counterparty_node_id: &PublicKey, expected_chan_value: u64, + expected_user_chan_id: u128, +) -> (ChannelId, Transaction, OutPoint) { + internal_create_funding_transaction( + node, + expected_counterparty_node_id, + expected_chan_value, + expected_user_chan_id, + true, + ) } -fn internal_create_funding_transaction<'a, 'b, 'c>(node: &Node<'a, 'b, 'c>, - expected_counterparty_node_id: &PublicKey, expected_chan_value: u64, expected_user_chan_id: u128, - coinbase: bool) -> (ChannelId, Transaction, OutPoint) { +fn internal_create_funding_transaction<'a, 'b, 'c>( + node: &Node<'a, 'b, 'c>, expected_counterparty_node_id: &PublicKey, expected_chan_value: u64, + expected_user_chan_id: u128, coinbase: bool, +) -> (ChannelId, Transaction, OutPoint) { let chan_id = *node.network_chan_count.borrow(); let events = node.node.get_and_clear_pending_events(); assert_eq!(events.len(), 1); match events[0] { - Event::FundingGenerationReady { ref temporary_channel_id, ref counterparty_node_id, ref channel_value_satoshis, ref output_script, user_channel_id } => { + Event::FundingGenerationReady { + ref temporary_channel_id, + ref counterparty_node_id, + ref channel_value_satoshis, + ref output_script, + user_channel_id, + } => { assert_eq!(counterparty_node_id, expected_counterparty_node_id); assert_eq!(*channel_value_satoshis, expected_chan_value); assert_eq!(user_channel_id, expected_user_chan_id); let input = if coinbase { - vec![TxIn { - previous_output: bitcoin::OutPoint::null(), - ..Default::default() - }] + vec![TxIn { previous_output: bitcoin::OutPoint::null(), ..Default::default() }] } else { Vec::new() }; - let tx = Transaction { version: transaction::Version(chan_id as i32), lock_time: LockTime::ZERO, input, output: vec![TxOut { - value: Amount::from_sat(*channel_value_satoshis), script_pubkey: output_script.clone(), - }]}; + let tx = Transaction { + version: transaction::Version(chan_id as i32), + lock_time: LockTime::ZERO, + input, + output: vec![TxOut { + value: Amount::from_sat(*channel_value_satoshis), + script_pubkey: output_script.clone(), + }], + }; let funding_outpoint = OutPoint { txid: tx.compute_txid(), index: 0 }; (*temporary_channel_id, tx, funding_outpoint) }, @@ -1279,22 +1426,27 @@ pub fn create_dual_funding_utxos_with_prev_txs( let tx = Transaction { version: TxVersion::TWO, lock_time: LockTime::from_height( - u32::from_be_bytes(node.keys_manager.get_secure_random_bytes()[0..4].try_into().unwrap()) % LOCK_TIME_THRESHOLD - ).unwrap(), + u32::from_be_bytes( + node.keys_manager.get_secure_random_bytes()[0..4].try_into().unwrap(), + ) % LOCK_TIME_THRESHOLD, + ) + .unwrap(), input: vec![], - output: utxo_values_in_satoshis.iter().map(|value_satoshis| TxOut { - value: Amount::from_sat(*value_satoshis), script_pubkey: ScriptBuf::new_p2wpkh(&WPubkeyHash::all_zeros()), - }).collect() + output: utxo_values_in_satoshis + .iter() + .map(|value_satoshis| TxOut { + value: Amount::from_sat(*value_satoshis), + script_pubkey: ScriptBuf::new_p2wpkh(&WPubkeyHash::all_zeros()), + }) + .collect(), }; let mut inputs = vec![]; for i in 0..utxo_values_in_satoshis.len() { - inputs.push( - (TxIn { - previous_output: OutPoint { - txid: tx.compute_txid(), - index: i as u16, - }.into_bitcoin_outpoint(), + inputs.push(( + TxIn { + previous_output: OutPoint { txid: tx.compute_txid(), index: i as u16 } + .into_bitcoin_outpoint(), script_sig: ScriptBuf::new(), sequence: Sequence::ZERO, witness: Witness::new(), @@ -1307,18 +1459,31 @@ pub fn create_dual_funding_utxos_with_prev_txs( inputs } -pub fn sign_funding_transaction<'a, 'b, 'c>(node_a: &Node<'a, 'b, 'c>, node_b: &Node<'a, 'b, 'c>, channel_value: u64, expected_temporary_channel_id: ChannelId) -> Transaction { - let (temporary_channel_id, tx, _) = create_funding_transaction(node_a, &node_b.node.get_our_node_id(), channel_value, 42); +pub fn sign_funding_transaction<'a, 'b, 'c>( + node_a: &Node<'a, 'b, 'c>, node_b: &Node<'a, 'b, 'c>, channel_value: u64, + expected_temporary_channel_id: ChannelId, +) -> Transaction { + let (temporary_channel_id, tx, _) = + create_funding_transaction(node_a, &node_b.node.get_our_node_id(), channel_value, 42); assert_eq!(temporary_channel_id, expected_temporary_channel_id); - assert!(node_a.node.funding_transaction_generated(temporary_channel_id, node_b.node.get_our_node_id(), tx.clone()).is_ok()); + assert!(node_a + .node + .funding_transaction_generated( + temporary_channel_id, + node_b.node.get_our_node_id(), + tx.clone() + ) + .is_ok()); check_added_monitors!(node_a, 0); - let funding_created_msg = get_event_msg!(node_a, MessageSendEvent::SendFundingCreated, node_b.node.get_our_node_id()); + let funding_created_msg = + get_event_msg!(node_a, MessageSendEvent::SendFundingCreated, node_b.node.get_our_node_id()); assert_eq!(funding_created_msg.temporary_channel_id, expected_temporary_channel_id); let channel_id = ChannelId::v1_from_funding_txid( - funding_created_msg.funding_txid.as_byte_array(), funding_created_msg.funding_output_index + funding_created_msg.funding_txid.as_byte_array(), + funding_created_msg.funding_output_index, ); node_b.node.handle_funding_created(node_a.node.get_our_node_id(), &funding_created_msg); @@ -1330,7 +1495,10 @@ pub fn sign_funding_transaction<'a, 'b, 'c>(node_a: &Node<'a, 'b, 'c>, node_b: & } expect_channel_pending_event(&node_b, &node_a.node.get_our_node_id()); - node_a.node.handle_funding_signed(node_b.node.get_our_node_id(), &get_event_msg!(node_b, MessageSendEvent::SendFundingSigned, node_a.node.get_our_node_id())); + node_a.node.handle_funding_signed( + node_b.node.get_our_node_id(), + &get_event_msg!(node_b, MessageSendEvent::SendFundingSigned, node_a.node.get_our_node_id()), + ); { let mut added_monitors = node_a.chain_monitor.added_monitors.lock().unwrap(); assert_eq!(added_monitors.len(), 1); @@ -1347,7 +1515,14 @@ pub fn sign_funding_transaction<'a, 'b, 'c>(node_a: &Node<'a, 'b, 'c>, node_b: & node_a.tx_broadcaster.txn_broadcasted.lock().unwrap().clear(); // Ensure that funding_transaction_generated is idempotent. - assert!(node_a.node.funding_transaction_generated(temporary_channel_id, node_b.node.get_our_node_id(), tx.clone()).is_err()); + assert!(node_a + .node + .funding_transaction_generated( + temporary_channel_id, + node_b.node.get_our_node_id(), + tx.clone() + ) + .is_err()); assert!(node_a.node.get_and_clear_pending_msg_events().is_empty()); check_added_monitors!(node_a, 0); @@ -1355,30 +1530,71 @@ pub fn sign_funding_transaction<'a, 'b, 'c>(node_a: &Node<'a, 'b, 'c>, node_b: & } // Receiver must have been initialized with manually_accept_inbound_channels set to true. -pub fn open_zero_conf_channel<'a, 'b, 'c, 'd>(initiator: &'a Node<'b, 'c, 'd>, receiver: &'a Node<'b, 'c, 'd>, initiator_config: Option) -> (bitcoin::Transaction, ChannelId) { +pub fn open_zero_conf_channel<'a, 'b, 'c, 'd>( + initiator: &'a Node<'b, 'c, 'd>, receiver: &'a Node<'b, 'c, 'd>, + initiator_config: Option, +) -> (bitcoin::Transaction, ChannelId) { let initiator_channels = initiator.node.list_usable_channels().len(); let receiver_channels = receiver.node.list_usable_channels().len(); - initiator.node.create_channel(receiver.node.get_our_node_id(), 100_000, 10_001, 42, None, initiator_config).unwrap(); - let open_channel = get_event_msg!(initiator, MessageSendEvent::SendOpenChannel, receiver.node.get_our_node_id()); + initiator + .node + .create_channel( + receiver.node.get_our_node_id(), + 100_000, + 10_001, + 42, + None, + initiator_config, + ) + .unwrap(); + let open_channel = get_event_msg!( + initiator, + MessageSendEvent::SendOpenChannel, + receiver.node.get_our_node_id() + ); receiver.node.handle_open_channel(initiator.node.get_our_node_id(), &open_channel); let events = receiver.node.get_and_clear_pending_events(); assert_eq!(events.len(), 1); match events[0] { Event::OpenChannelRequest { temporary_channel_id, .. } => { - receiver.node.accept_inbound_channel_from_trusted_peer_0conf(&temporary_channel_id, &initiator.node.get_our_node_id(), 0, None).unwrap(); + receiver + .node + .accept_inbound_channel_from_trusted_peer_0conf( + &temporary_channel_id, + &initiator.node.get_our_node_id(), + 0, + None, + ) + .unwrap(); }, _ => panic!("Unexpected event"), }; - let accept_channel = get_event_msg!(receiver, MessageSendEvent::SendAcceptChannel, initiator.node.get_our_node_id()); + let accept_channel = get_event_msg!( + receiver, + MessageSendEvent::SendAcceptChannel, + initiator.node.get_our_node_id() + ); assert_eq!(accept_channel.common_fields.minimum_depth, 0); initiator.node.handle_accept_channel(receiver.node.get_our_node_id(), &accept_channel); - let (temporary_channel_id, tx, _) = create_funding_transaction(&initiator, &receiver.node.get_our_node_id(), 100_000, 42); - initiator.node.funding_transaction_generated(temporary_channel_id, receiver.node.get_our_node_id(), tx.clone()).unwrap(); - let funding_created = get_event_msg!(initiator, MessageSendEvent::SendFundingCreated, receiver.node.get_our_node_id()); + let (temporary_channel_id, tx, _) = + create_funding_transaction(&initiator, &receiver.node.get_our_node_id(), 100_000, 42); + initiator + .node + .funding_transaction_generated( + temporary_channel_id, + receiver.node.get_our_node_id(), + tx.clone(), + ) + .unwrap(); + let funding_created = get_event_msg!( + initiator, + MessageSendEvent::SendFundingCreated, + receiver.node.get_our_node_id() + ); receiver.node.handle_funding_created(initiator.node.get_our_node_id(), &funding_created); check_added_monitors!(receiver, 1); @@ -1394,10 +1610,17 @@ pub fn open_zero_conf_channel<'a, 'b, 'c, 'd>(initiator: &'a Node<'b, 'c, 'd>, r check_added_monitors!(initiator, 1); assert_eq!(initiator.tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1); - assert_eq!(initiator.tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0)[0], tx); - - as_channel_ready = get_event_msg!(initiator, MessageSendEvent::SendChannelReady, receiver.node.get_our_node_id()); - } + assert_eq!( + initiator.tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0)[0], + tx + ); + + as_channel_ready = get_event_msg!( + initiator, + MessageSendEvent::SendChannelReady, + receiver.node.get_our_node_id() + ); + }, _ => panic!("Unexpected event"), } match &bs_signed_locked[1] { @@ -1405,15 +1628,23 @@ pub fn open_zero_conf_channel<'a, 'b, 'c, 'd>(initiator: &'a Node<'b, 'c, 'd>, r assert_eq!(*node_id, initiator.node.get_our_node_id()); initiator.node.handle_channel_ready(receiver.node.get_our_node_id(), &msg); expect_channel_ready_event(&initiator, &receiver.node.get_our_node_id()); - } + }, _ => panic!("Unexpected event"), } receiver.node.handle_channel_ready(initiator.node.get_our_node_id(), &as_channel_ready); expect_channel_ready_event(&receiver, &initiator.node.get_our_node_id()); - let as_channel_update = get_event_msg!(initiator, MessageSendEvent::SendChannelUpdate, receiver.node.get_our_node_id()); - let bs_channel_update = get_event_msg!(receiver, MessageSendEvent::SendChannelUpdate, initiator.node.get_our_node_id()); + let as_channel_update = get_event_msg!( + initiator, + MessageSendEvent::SendChannelUpdate, + receiver.node.get_our_node_id() + ); + let bs_channel_update = get_event_msg!( + receiver, + MessageSendEvent::SendChannelUpdate, + initiator.node.get_our_node_id() + ); initiator.node.handle_channel_update(receiver.node.get_our_node_id(), &bs_channel_update); receiver.node.handle_channel_update(initiator.node.get_our_node_id(), &as_channel_update); @@ -1424,69 +1655,122 @@ pub fn open_zero_conf_channel<'a, 'b, 'c, 'd>(initiator: &'a Node<'b, 'c, 'd>, r (tx, as_channel_ready.channel_id) } -pub fn exchange_open_accept_chan<'a, 'b, 'c>(node_a: &Node<'a, 'b, 'c>, node_b: &Node<'a, 'b, 'c>, channel_value: u64, push_msat: u64) -> ChannelId { - let create_chan_id = node_a.node.create_channel(node_b.node.get_our_node_id(), channel_value, push_msat, 42, None, None).unwrap(); - let open_channel_msg = get_event_msg!(node_a, MessageSendEvent::SendOpenChannel, node_b.node.get_our_node_id()); +pub fn exchange_open_accept_chan<'a, 'b, 'c>( + node_a: &Node<'a, 'b, 'c>, node_b: &Node<'a, 'b, 'c>, channel_value: u64, push_msat: u64, +) -> ChannelId { + let create_chan_id = node_a + .node + .create_channel(node_b.node.get_our_node_id(), channel_value, push_msat, 42, None, None) + .unwrap(); + let open_channel_msg = + get_event_msg!(node_a, MessageSendEvent::SendOpenChannel, node_b.node.get_our_node_id()); assert_eq!(open_channel_msg.common_fields.temporary_channel_id, create_chan_id); - assert_eq!(node_a.node.list_channels().iter().find(|channel| channel.channel_id == create_chan_id).unwrap().user_channel_id, 42); + assert_eq!( + node_a + .node + .list_channels() + .iter() + .find(|channel| channel.channel_id == create_chan_id) + .unwrap() + .user_channel_id, + 42 + ); node_b.node.handle_open_channel(node_a.node.get_our_node_id(), &open_channel_msg); if node_b.node.get_current_default_configuration().manually_accept_inbound_channels { let events = node_b.node.get_and_clear_pending_events(); assert_eq!(events.len(), 1); match &events[0] { - Event::OpenChannelRequest { temporary_channel_id, counterparty_node_id, .. } => - node_b.node.accept_inbound_channel(temporary_channel_id, counterparty_node_id, 42, None).unwrap(), + Event::OpenChannelRequest { temporary_channel_id, counterparty_node_id, .. } => node_b + .node + .accept_inbound_channel(temporary_channel_id, counterparty_node_id, 42, None) + .unwrap(), _ => panic!("Unexpected event"), }; } - let accept_channel_msg = get_event_msg!(node_b, MessageSendEvent::SendAcceptChannel, node_a.node.get_our_node_id()); + let accept_channel_msg = + get_event_msg!(node_b, MessageSendEvent::SendAcceptChannel, node_a.node.get_our_node_id()); assert_eq!(accept_channel_msg.common_fields.temporary_channel_id, create_chan_id); node_a.node.handle_accept_channel(node_b.node.get_our_node_id(), &accept_channel_msg); - assert_ne!(node_b.node.list_channels().iter().find(|channel| channel.channel_id == create_chan_id).unwrap().user_channel_id, 0); + assert_ne!( + node_b + .node + .list_channels() + .iter() + .find(|channel| channel.channel_id == create_chan_id) + .unwrap() + .user_channel_id, + 0 + ); create_chan_id } -pub fn create_chan_between_nodes_with_value_init<'a, 'b, 'c>(node_a: &Node<'a, 'b, 'c>, node_b: &Node<'a, 'b, 'c>, channel_value: u64, push_msat: u64) -> Transaction { +pub fn create_chan_between_nodes_with_value_init<'a, 'b, 'c>( + node_a: &Node<'a, 'b, 'c>, node_b: &Node<'a, 'b, 'c>, channel_value: u64, push_msat: u64, +) -> Transaction { let create_chan_id = exchange_open_accept_chan(node_a, node_b, channel_value, push_msat); sign_funding_transaction(node_a, node_b, channel_value, create_chan_id) } -pub fn create_chan_between_nodes_with_value_confirm_first<'a, 'b, 'c, 'd>(node_recv: &'a Node<'b, 'c, 'c>, node_conf: &'a Node<'b, 'c, 'd>, tx: &Transaction, conf_height: u32) { +pub fn create_chan_between_nodes_with_value_confirm_first<'a, 'b, 'c, 'd>( + node_recv: &'a Node<'b, 'c, 'c>, node_conf: &'a Node<'b, 'c, 'd>, tx: &Transaction, + conf_height: u32, +) { confirm_transaction_at(node_conf, tx, conf_height); connect_blocks(node_conf, CHAN_CONFIRM_DEPTH - 1); - node_recv.node.handle_channel_ready(node_conf.node.get_our_node_id(), &get_event_msg!(node_conf, MessageSendEvent::SendChannelReady, node_recv.node.get_our_node_id())); + node_recv.node.handle_channel_ready( + node_conf.node.get_our_node_id(), + &get_event_msg!( + node_conf, + MessageSendEvent::SendChannelReady, + node_recv.node.get_our_node_id() + ), + ); } -pub fn create_chan_between_nodes_with_value_confirm_second<'a, 'b, 'c>(node_recv: &Node<'a, 'b, 'c>, node_conf: &Node<'a, 'b, 'c>) -> ((msgs::ChannelReady, msgs::AnnouncementSignatures), ChannelId) { +pub fn create_chan_between_nodes_with_value_confirm_second<'a, 'b, 'c>( + node_recv: &Node<'a, 'b, 'c>, node_conf: &Node<'a, 'b, 'c>, +) -> ((msgs::ChannelReady, msgs::AnnouncementSignatures), ChannelId) { let channel_id; let events_6 = node_conf.node.get_and_clear_pending_msg_events(); assert_eq!(events_6.len(), 3); - let announcement_sigs_idx = if let MessageSendEvent::SendChannelUpdate { ref node_id, msg: _ } = events_6[1] { - assert_eq!(*node_id, node_recv.node.get_our_node_id()); - 2 - } else if let MessageSendEvent::SendChannelUpdate { ref node_id, msg: _ } = events_6[2] { - assert_eq!(*node_id, node_recv.node.get_our_node_id()); - 1 - } else { panic!("Unexpected event: {:?}", events_6[1]); }; - ((match events_6[0] { - MessageSendEvent::SendChannelReady { ref node_id, ref msg } => { - channel_id = msg.channel_id.clone(); + let announcement_sigs_idx = + if let MessageSendEvent::SendChannelUpdate { ref node_id, msg: _ } = events_6[1] { assert_eq!(*node_id, node_recv.node.get_our_node_id()); - msg.clone() - }, - _ => panic!("Unexpected event"), - }, match events_6[announcement_sigs_idx] { - MessageSendEvent::SendAnnouncementSignatures { ref node_id, ref msg } => { + 2 + } else if let MessageSendEvent::SendChannelUpdate { ref node_id, msg: _ } = events_6[2] { assert_eq!(*node_id, node_recv.node.get_our_node_id()); - msg.clone() - }, - _ => panic!("Unexpected event"), - }), channel_id) + 1 + } else { + panic!("Unexpected event: {:?}", events_6[1]); + }; + ( + ( + match events_6[0] { + MessageSendEvent::SendChannelReady { ref node_id, ref msg } => { + channel_id = msg.channel_id.clone(); + assert_eq!(*node_id, node_recv.node.get_our_node_id()); + msg.clone() + }, + _ => panic!("Unexpected event"), + }, + match events_6[announcement_sigs_idx] { + MessageSendEvent::SendAnnouncementSignatures { ref node_id, ref msg } => { + assert_eq!(*node_id, node_recv.node.get_our_node_id()); + msg.clone() + }, + _ => panic!("Unexpected event"), + }, + ), + channel_id, + ) } -pub fn create_chan_between_nodes_with_value_confirm<'a, 'b, 'c: 'd, 'd>(node_a: &'a Node<'b, 'c, 'd>, node_b: &'a Node<'b, 'c, 'd>, tx: &Transaction) -> ((msgs::ChannelReady, msgs::AnnouncementSignatures), ChannelId) { - let conf_height = core::cmp::max(node_a.best_block_info().1 + 1, node_b.best_block_info().1 + 1); +pub fn create_chan_between_nodes_with_value_confirm<'a, 'b, 'c: 'd, 'd>( + node_a: &'a Node<'b, 'c, 'd>, node_b: &'a Node<'b, 'c, 'd>, tx: &Transaction, +) -> ((msgs::ChannelReady, msgs::AnnouncementSignatures), ChannelId) { + let conf_height = + core::cmp::max(node_a.best_block_info().1 + 1, node_b.best_block_info().1 + 1); create_chan_between_nodes_with_value_confirm_first(node_a, node_b, tx, conf_height); confirm_transaction_at(node_a, tx, conf_height); connect_blocks(node_a, CHAN_CONFIRM_DEPTH - 1); @@ -1494,15 +1778,24 @@ pub fn create_chan_between_nodes_with_value_confirm<'a, 'b, 'c: 'd, 'd>(node_a: create_chan_between_nodes_with_value_confirm_second(node_b, node_a) } -pub fn create_chan_between_nodes_with_value_a<'a, 'b, 'c: 'd, 'd>(node_a: &'a Node<'b, 'c, 'd>, node_b: &'a Node<'b, 'c, 'd>, channel_value: u64, push_msat: u64) -> ((msgs::ChannelReady, msgs::AnnouncementSignatures), ChannelId, Transaction) { +pub fn create_chan_between_nodes_with_value_a<'a, 'b, 'c: 'd, 'd>( + node_a: &'a Node<'b, 'c, 'd>, node_b: &'a Node<'b, 'c, 'd>, channel_value: u64, push_msat: u64, +) -> ((msgs::ChannelReady, msgs::AnnouncementSignatures), ChannelId, Transaction) { let tx = create_chan_between_nodes_with_value_init(node_a, node_b, channel_value, push_msat); let (msgs, chan_id) = create_chan_between_nodes_with_value_confirm(node_a, node_b, &tx); (msgs, chan_id, tx) } -pub fn create_chan_between_nodes_with_value_b<'a, 'b, 'c>(node_a: &Node<'a, 'b, 'c>, node_b: &Node<'a, 'b, 'c>, as_funding_msgs: &(msgs::ChannelReady, msgs::AnnouncementSignatures)) -> (msgs::ChannelAnnouncement, msgs::ChannelUpdate, msgs::ChannelUpdate) { +pub fn create_chan_between_nodes_with_value_b<'a, 'b, 'c>( + node_a: &Node<'a, 'b, 'c>, node_b: &Node<'a, 'b, 'c>, + as_funding_msgs: &(msgs::ChannelReady, msgs::AnnouncementSignatures), +) -> (msgs::ChannelAnnouncement, msgs::ChannelUpdate, msgs::ChannelUpdate) { node_b.node.handle_channel_ready(node_a.node.get_our_node_id(), &as_funding_msgs.0); - let bs_announcement_sigs = get_event_msg!(node_b, MessageSendEvent::SendAnnouncementSignatures, node_a.node.get_our_node_id()); + let bs_announcement_sigs = get_event_msg!( + node_b, + MessageSendEvent::SendAnnouncementSignatures, + node_a.node.get_our_node_id() + ); node_b.node.handle_announcement_signatures(node_a.node.get_our_node_id(), &as_funding_msgs.1); let events_7 = node_b.node.get_and_clear_pending_msg_events(); @@ -1514,14 +1807,19 @@ pub fn create_chan_between_nodes_with_value_b<'a, 'b, 'c>(node_a: &Node<'a, 'b, _ => panic!("Unexpected event"), }; - node_a.node.handle_announcement_signatures(node_b.node.get_our_node_id(), &bs_announcement_sigs); + node_a + .node + .handle_announcement_signatures(node_b.node.get_our_node_id(), &bs_announcement_sigs); let events_8 = node_a.node.get_and_clear_pending_msg_events(); assert_eq!(events_8.len(), 1); let as_update = match events_8[0] { MessageSendEvent::BroadcastChannelAnnouncement { ref msg, ref update_msg } => { assert!(*announcement == *msg); let update_msg = update_msg.clone().unwrap(); - assert_eq!(update_msg.contents.short_channel_id, announcement.contents.short_channel_id); + assert_eq!( + update_msg.contents.short_channel_id, + announcement.contents.short_channel_id + ); assert_eq!(update_msg.contents.short_channel_id, bs_update.contents.short_channel_id); update_msg }, @@ -1534,31 +1832,82 @@ pub fn create_chan_between_nodes_with_value_b<'a, 'b, 'c>(node_a: &Node<'a, 'b, ((*announcement).clone(), as_update, bs_update) } -pub fn create_announced_chan_between_nodes<'a, 'b, 'c: 'd, 'd>(nodes: &'a Vec>, a: usize, b: usize) -> (msgs::ChannelUpdate, msgs::ChannelUpdate, ChannelId, Transaction) { +pub fn create_announced_chan_between_nodes<'a, 'b, 'c: 'd, 'd>( + nodes: &'a Vec>, a: usize, b: usize, +) -> (msgs::ChannelUpdate, msgs::ChannelUpdate, ChannelId, Transaction) { create_announced_chan_between_nodes_with_value(nodes, a, b, 100000, 10001) } -pub fn create_announced_chan_between_nodes_with_value<'a, 'b, 'c: 'd, 'd>(nodes: &'a Vec>, a: usize, b: usize, channel_value: u64, push_msat: u64) -> (msgs::ChannelUpdate, msgs::ChannelUpdate, ChannelId, Transaction) { - let chan_announcement = create_chan_between_nodes_with_value(&nodes[a], &nodes[b], channel_value, push_msat); - update_nodes_with_chan_announce(nodes, a, b, &chan_announcement.0, &chan_announcement.1, &chan_announcement.2); +pub fn create_announced_chan_between_nodes_with_value<'a, 'b, 'c: 'd, 'd>( + nodes: &'a Vec>, a: usize, b: usize, channel_value: u64, push_msat: u64, +) -> (msgs::ChannelUpdate, msgs::ChannelUpdate, ChannelId, Transaction) { + let chan_announcement = + create_chan_between_nodes_with_value(&nodes[a], &nodes[b], channel_value, push_msat); + update_nodes_with_chan_announce( + nodes, + a, + b, + &chan_announcement.0, + &chan_announcement.1, + &chan_announcement.2, + ); (chan_announcement.1, chan_announcement.2, chan_announcement.3, chan_announcement.4) } -pub fn create_unannounced_chan_between_nodes_with_value<'a, 'b, 'c, 'd>(nodes: &'a Vec>, a: usize, b: usize, channel_value: u64, push_msat: u64) -> (msgs::ChannelReady, Transaction) { +pub fn create_unannounced_chan_between_nodes_with_value<'a, 'b, 'c, 'd>( + nodes: &'a Vec>, a: usize, b: usize, channel_value: u64, push_msat: u64, +) -> (msgs::ChannelReady, Transaction) { let mut no_announce_cfg = nodes[a].node.get_current_default_configuration().clone(); no_announce_cfg.channel_handshake_config.announce_for_forwarding = false; - nodes[a].node.create_channel(nodes[b].node.get_our_node_id(), channel_value, push_msat, 42, None, Some(no_announce_cfg)).unwrap(); - let open_channel = get_event_msg!(nodes[a], MessageSendEvent::SendOpenChannel, nodes[b].node.get_our_node_id()); + nodes[a] + .node + .create_channel( + nodes[b].node.get_our_node_id(), + channel_value, + push_msat, + 42, + None, + Some(no_announce_cfg), + ) + .unwrap(); + let open_channel = get_event_msg!( + nodes[a], + MessageSendEvent::SendOpenChannel, + nodes[b].node.get_our_node_id() + ); nodes[b].node.handle_open_channel(nodes[a].node.get_our_node_id(), &open_channel); - let accept_channel = get_event_msg!(nodes[b], MessageSendEvent::SendAcceptChannel, nodes[a].node.get_our_node_id()); + let accept_channel = get_event_msg!( + nodes[b], + MessageSendEvent::SendAcceptChannel, + nodes[a].node.get_our_node_id() + ); nodes[a].node.handle_accept_channel(nodes[b].node.get_our_node_id(), &accept_channel); - let (temporary_channel_id, tx, _) = create_funding_transaction(&nodes[a], &nodes[b].node.get_our_node_id(), channel_value, 42); - nodes[a].node.funding_transaction_generated(temporary_channel_id, nodes[b].node.get_our_node_id(), tx.clone()).unwrap(); - nodes[b].node.handle_funding_created(nodes[a].node.get_our_node_id(), &get_event_msg!(nodes[a], MessageSendEvent::SendFundingCreated, nodes[b].node.get_our_node_id())); + let (temporary_channel_id, tx, _) = + create_funding_transaction(&nodes[a], &nodes[b].node.get_our_node_id(), channel_value, 42); + nodes[a] + .node + .funding_transaction_generated( + temporary_channel_id, + nodes[b].node.get_our_node_id(), + tx.clone(), + ) + .unwrap(); + nodes[b].node.handle_funding_created( + nodes[a].node.get_our_node_id(), + &get_event_msg!( + nodes[a], + MessageSendEvent::SendFundingCreated, + nodes[b].node.get_our_node_id() + ), + ); check_added_monitors!(nodes[b], 1); - let cs_funding_signed = get_event_msg!(nodes[b], MessageSendEvent::SendFundingSigned, nodes[a].node.get_our_node_id()); + let cs_funding_signed = get_event_msg!( + nodes[b], + MessageSendEvent::SendFundingSigned, + nodes[a].node.get_our_node_id() + ); expect_channel_pending_event(&nodes[b], &nodes[a].node.get_our_node_id()); nodes[a].node.handle_funding_signed(nodes[b].node.get_our_node_id(), &cs_funding_signed); @@ -1569,18 +1918,38 @@ pub fn create_unannounced_chan_between_nodes_with_value<'a, 'b, 'c, 'd>(nodes: & assert_eq!(nodes[a].tx_broadcaster.txn_broadcasted.lock().unwrap()[0], tx); nodes[a].tx_broadcaster.txn_broadcasted.lock().unwrap().clear(); - let conf_height = core::cmp::max(nodes[a].best_block_info().1 + 1, nodes[b].best_block_info().1 + 1); + let conf_height = + core::cmp::max(nodes[a].best_block_info().1 + 1, nodes[b].best_block_info().1 + 1); confirm_transaction_at(&nodes[a], &tx, conf_height); connect_blocks(&nodes[a], CHAN_CONFIRM_DEPTH - 1); confirm_transaction_at(&nodes[b], &tx, conf_height); connect_blocks(&nodes[b], CHAN_CONFIRM_DEPTH - 1); - let as_channel_ready = get_event_msg!(nodes[a], MessageSendEvent::SendChannelReady, nodes[b].node.get_our_node_id()); - nodes[a].node.handle_channel_ready(nodes[b].node.get_our_node_id(), &get_event_msg!(nodes[b], MessageSendEvent::SendChannelReady, nodes[a].node.get_our_node_id())); + let as_channel_ready = get_event_msg!( + nodes[a], + MessageSendEvent::SendChannelReady, + nodes[b].node.get_our_node_id() + ); + nodes[a].node.handle_channel_ready( + nodes[b].node.get_our_node_id(), + &get_event_msg!( + nodes[b], + MessageSendEvent::SendChannelReady, + nodes[a].node.get_our_node_id() + ), + ); expect_channel_ready_event(&nodes[a], &nodes[b].node.get_our_node_id()); - let as_update = get_event_msg!(nodes[a], MessageSendEvent::SendChannelUpdate, nodes[b].node.get_our_node_id()); + let as_update = get_event_msg!( + nodes[a], + MessageSendEvent::SendChannelUpdate, + nodes[b].node.get_our_node_id() + ); nodes[b].node.handle_channel_ready(nodes[a].node.get_our_node_id(), &as_channel_ready); expect_channel_ready_event(&nodes[b], &nodes[a].node.get_our_node_id()); - let bs_update = get_event_msg!(nodes[b], MessageSendEvent::SendChannelUpdate, nodes[a].node.get_our_node_id()); + let bs_update = get_event_msg!( + nodes[b], + MessageSendEvent::SendChannelUpdate, + nodes[a].node.get_our_node_id() + ); nodes[a].node.handle_channel_update(nodes[b].node.get_our_node_id(), &bs_update); nodes[b].node.handle_channel_update(nodes[a].node.get_our_node_id(), &as_update); @@ -1608,7 +1977,10 @@ pub fn create_unannounced_chan_between_nodes_with_value<'a, 'b, 'c, 'd>(nodes: & (as_channel_ready, tx) } -pub fn update_nodes_with_chan_announce<'a, 'b, 'c, 'd>(nodes: &'a Vec>, a: usize, b: usize, ann: &msgs::ChannelAnnouncement, upd_1: &msgs::ChannelUpdate, upd_2: &msgs::ChannelUpdate) { +pub fn update_nodes_with_chan_announce<'a, 'b, 'c, 'd>( + nodes: &'a Vec>, a: usize, b: usize, ann: &msgs::ChannelAnnouncement, + upd_1: &msgs::ChannelUpdate, upd_2: &msgs::ChannelUpdate, +) { for node in nodes { let node_id_a = nodes[a].node.get_our_node_id(); let node_id_b = nodes[b].node.get_our_node_id(); @@ -1623,9 +1995,14 @@ pub fn update_nodes_with_chan_announce<'a, 'b, 'c, 'd>(nodes: &'a Vec Option>(tx: &Transaction, get_output: F) { +pub fn do_check_spends Option>( + tx: &Transaction, get_output: F, +) { for outp in tx.output.iter() { - assert!(outp.value >= outp.script_pubkey.minimal_non_dust(), "Spending tx output didn't meet dust limit"); + assert!( + outp.value >= outp.script_pubkey.minimal_non_dust(), + "Spending tx output didn't meet dust limit" + ); } let mut total_value_in = 0; for input in tx.input.iter() { @@ -1636,7 +2013,7 @@ pub fn do_check_spends Option>( total_value_out += output.value.to_sat(); } let min_fee = (tx.weight().to_wu() as u64 + 3) / 4; // One sat per vbyte (ie per weight/4, rounded up) - // Input amount - output amount = fee, so check that out + min_fee is smaller than input + // Input amount - output amount = fee, so check that out + min_fee is smaller than input assert!(total_value_out + min_fee <= total_value_in); tx.verify(get_output).unwrap(); } @@ -1664,17 +2041,18 @@ macro_rules! check_spends { } macro_rules! get_closing_signed_broadcast { - ($node: expr, $dest_pubkey: expr) => { - { - let events = $node.get_and_clear_pending_msg_events(); - assert!(events.len() == 1 || events.len() == 2); - (match events[events.len() - 1] { + ($node: expr, $dest_pubkey: expr) => {{ + let events = $node.get_and_clear_pending_msg_events(); + assert!(events.len() == 1 || events.len() == 2); + ( + match events[events.len() - 1] { MessageSendEvent::BroadcastChannelUpdate { ref msg } => { assert_eq!(msg.contents.channel_flags & 2, 2); msg.clone() }, _ => panic!("Unexpected event"), - }, if events.len() == 2 { + }, + if events.len() == 2 { match events[0] { MessageSendEvent::SendClosingSigned { ref node_id, ref msg } => { assert_eq!(*node_id, $dest_pubkey); @@ -1682,9 +2060,11 @@ macro_rules! get_closing_signed_broadcast { }, _ => panic!("Unexpected event"), } - } else { None }) - } - } + } else { + None + }, + ) + }}; } #[cfg(test)] @@ -1693,14 +2073,17 @@ macro_rules! check_warn_msg { let msg_events = $node.node.get_and_clear_pending_msg_events(); assert_eq!(msg_events.len(), 1); match msg_events[0] { - MessageSendEvent::HandleError { action: ErrorAction::SendWarningMessage { ref msg, log_level: _ }, node_id } => { + MessageSendEvent::HandleError { + action: ErrorAction::SendWarningMessage { ref msg, log_level: _ }, + node_id, + } => { assert_eq!(node_id, $recipient_node_id); assert_eq!(msg.channel_id, $chan_id); msg.data.clone() }, _ => panic!("Unexpected event"), } - }} + }}; } /// Checks if at least one peer is connected. @@ -1708,14 +2091,18 @@ fn is_any_peer_connected(node: &Node) -> bool { let peer_state = node.node.per_peer_state.read().unwrap(); for (_, peer_mutex) in peer_state.iter() { let peer = peer_mutex.lock().unwrap(); - if peer.is_connected { return true; } + if peer.is_connected { + return true; + } } false } /// Check that a channel's closing channel update has been broadcasted, and optionally /// check whether an error message event has occurred. -pub fn check_closed_broadcast(node: &Node, num_channels: usize, with_error_msg: bool) -> Vec { +pub fn check_closed_broadcast( + node: &Node, num_channels: usize, with_error_msg: bool, +) -> Vec { let mut dummy_connected = false; if !is_any_peer_connected(&node) { connect_dummy_node(&node); @@ -1726,25 +2113,34 @@ pub fn check_closed_broadcast(node: &Node, num_channels: usize, with_error_msg: if dummy_connected { disconnect_dummy_node(&node); } - msg_events.into_iter().filter_map(|msg_event| { - match msg_event { - MessageSendEvent::BroadcastChannelUpdate { ref msg } => { - assert_eq!(msg.contents.channel_flags & 2, 2); - None - }, - MessageSendEvent::HandleError { action: msgs::ErrorAction::SendErrorMessage { msg }, node_id: _ } => { - assert!(with_error_msg); - // TODO: Check node_id - Some(msg) - }, - MessageSendEvent::HandleError { action: msgs::ErrorAction::DisconnectPeer { msg }, node_id: _ } => { - assert!(with_error_msg); - // TODO: Check node_id - Some(msg.unwrap()) - }, - _ => panic!("Unexpected event"), - } - }).collect() + msg_events + .into_iter() + .filter_map(|msg_event| { + match msg_event { + MessageSendEvent::BroadcastChannelUpdate { ref msg } => { + assert_eq!(msg.contents.channel_flags & 2, 2); + None + }, + MessageSendEvent::HandleError { + action: msgs::ErrorAction::SendErrorMessage { msg }, + node_id: _, + } => { + assert!(with_error_msg); + // TODO: Check node_id + Some(msg) + }, + MessageSendEvent::HandleError { + action: msgs::ErrorAction::DisconnectPeer { msg }, + node_id: _, + } => { + assert!(with_error_msg); + // TODO: Check node_id + Some(msg.unwrap()) + }, + _ => panic!("Unexpected event"), + } + }) + .collect() } /// Check that a channel's closing channel update has been broadcasted, and optionally @@ -1755,7 +2151,7 @@ pub fn check_closed_broadcast(node: &Node, num_channels: usize, with_error_msg: macro_rules! check_closed_broadcast { ($node: expr, $with_error_msg: expr) => { $crate::ln::functional_test_utils::check_closed_broadcast(&$node, 1, $with_error_msg).pop() - } + }; } #[derive(Default)] @@ -1770,7 +2166,9 @@ pub struct ExpectedCloseEvent { } impl ExpectedCloseEvent { - pub fn from_id_reason(channel_id: ChannelId, discard_funding: bool, reason: ClosureReason) -> Self { + pub fn from_id_reason( + channel_id: ChannelId, discard_funding: bool, reason: ClosureReason, + ) -> Self { Self { channel_capacity_sats: None, channel_id: Some(channel_id), @@ -1814,30 +2212,36 @@ pub fn check_closed_events(node: &Node, expected_close_events: &[ExpectedCloseEv ) ))); } - assert_eq!(events.iter().filter(|e| matches!( - e, - Event::DiscardFunding { .. }, - )).count(), discard_events_count); + assert_eq!( + events.iter().filter(|e| matches!(e, Event::DiscardFunding { .. },)).count(), + discard_events_count + ); } /// Check that a channel's closing channel events has been issued -pub fn check_closed_event(node: &Node, events_count: usize, expected_reason: ClosureReason, is_check_discard_funding: bool, - expected_counterparty_node_ids: &[PublicKey], expected_channel_capacity: u64) { +pub fn check_closed_event( + node: &Node, events_count: usize, expected_reason: ClosureReason, + is_check_discard_funding: bool, expected_counterparty_node_ids: &[PublicKey], + expected_channel_capacity: u64, +) { let expected_events_count = if is_check_discard_funding { 2 * expected_counterparty_node_ids.len() } else { expected_counterparty_node_ids.len() }; assert_eq!(events_count, expected_events_count); - let expected_close_events = expected_counterparty_node_ids.iter().map(|node_id| ExpectedCloseEvent { - channel_capacity_sats: Some(expected_channel_capacity), - channel_id: None, - counterparty_node_id: Some(*node_id), - discard_funding: is_check_discard_funding, - reason: Some(expected_reason.clone()), - channel_funding_txo: None, - user_channel_id: None, - }).collect::>(); + let expected_close_events = expected_counterparty_node_ids + .iter() + .map(|node_id| ExpectedCloseEvent { + channel_capacity_sats: Some(expected_channel_capacity), + channel_id: None, + counterparty_node_id: Some(*node_id), + discard_funding: is_check_discard_funding, + reason: Some(expected_reason.clone()), + channel_funding_txo: None, + user_channel_id: None, + }) + .collect::>(); check_closed_events(node, expected_close_events.as_slice()); } @@ -1847,12 +2251,25 @@ pub fn check_closed_event(node: &Node, events_count: usize, expected_reason: Clo #[macro_export] macro_rules! check_closed_event { ($node: expr, $events: expr, $reason: expr, $counterparty_node_ids: expr, $channel_capacity: expr) => { - check_closed_event!($node, $events, $reason, false, $counterparty_node_ids, $channel_capacity); + check_closed_event!( + $node, + $events, + $reason, + false, + $counterparty_node_ids, + $channel_capacity + ); }; ($node: expr, $events: expr, $reason: expr, $is_check_discard_funding: expr, $counterparty_node_ids: expr, $channel_capacity: expr) => { - $crate::ln::functional_test_utils::check_closed_event(&$node, $events, $reason, - $is_check_discard_funding, &$counterparty_node_ids, $channel_capacity); - } + $crate::ln::functional_test_utils::check_closed_event( + &$node, + $events, + $reason, + $is_check_discard_funding, + &$counterparty_node_ids, + $channel_capacity, + ); + }; } pub fn handle_bump_htlc_event(node: &Node, count: usize) { @@ -1861,8 +2278,10 @@ pub fn handle_bump_htlc_event(node: &Node, count: usize) { for event in events { match event { Event::BumpTransaction(bump_event) => { - if let BumpTransactionEvent::HTLCResolution { .. } = &bump_event {} - else { panic!(); } + if let BumpTransactionEvent::HTLCResolution { .. } = &bump_event { + } else { + panic!(); + } node.bump_tx_handler.handle_event(&bump_event); }, _ => panic!(), @@ -1870,13 +2289,27 @@ pub fn handle_bump_htlc_event(node: &Node, count: usize) { } } -pub fn close_channel<'a, 'b, 'c>(outbound_node: &Node<'a, 'b, 'c>, inbound_node: &Node<'a, 'b, 'c>, channel_id: &ChannelId, funding_tx: Transaction, close_inbound_first: bool) -> (msgs::ChannelUpdate, msgs::ChannelUpdate, Transaction) { - let (node_a, broadcaster_a, struct_a) = if close_inbound_first { (&inbound_node.node, &inbound_node.tx_broadcaster, inbound_node) } else { (&outbound_node.node, &outbound_node.tx_broadcaster, outbound_node) }; - let (node_b, broadcaster_b, struct_b) = if close_inbound_first { (&outbound_node.node, &outbound_node.tx_broadcaster, outbound_node) } else { (&inbound_node.node, &inbound_node.tx_broadcaster, inbound_node) }; +pub fn close_channel<'a, 'b, 'c>( + outbound_node: &Node<'a, 'b, 'c>, inbound_node: &Node<'a, 'b, 'c>, channel_id: &ChannelId, + funding_tx: Transaction, close_inbound_first: bool, +) -> (msgs::ChannelUpdate, msgs::ChannelUpdate, Transaction) { + let (node_a, broadcaster_a, struct_a) = if close_inbound_first { + (&inbound_node.node, &inbound_node.tx_broadcaster, inbound_node) + } else { + (&outbound_node.node, &outbound_node.tx_broadcaster, outbound_node) + }; + let (node_b, broadcaster_b, struct_b) = if close_inbound_first { + (&outbound_node.node, &outbound_node.tx_broadcaster, outbound_node) + } else { + (&inbound_node.node, &inbound_node.tx_broadcaster, inbound_node) + }; let (tx_a, tx_b); node_a.close_channel(channel_id, &node_b.get_our_node_id()).unwrap(); - node_b.handle_shutdown(node_a.get_our_node_id(), &get_event_msg!(struct_a, MessageSendEvent::SendShutdown, node_b.get_our_node_id())); + node_b.handle_shutdown( + node_a.get_our_node_id(), + &get_event_msg!(struct_a, MessageSendEvent::SendShutdown, node_b.get_our_node_id()), + ); let events_1 = node_b.get_and_clear_pending_msg_events(); assert!(events_1.len() >= 1); @@ -1906,10 +2339,18 @@ pub fn close_channel<'a, 'b, 'c>(outbound_node: &Node<'a, 'b, 'c>, inbound_node: assert!(node_a.get_and_clear_pending_msg_events().is_empty()); node_a.handle_closing_signed(node_b.get_our_node_id(), &closing_signed_b.unwrap()); - node_b.handle_closing_signed(node_a.get_our_node_id(), &get_event_msg!(struct_a, MessageSendEvent::SendClosingSigned, node_b.get_our_node_id())); + node_b.handle_closing_signed( + node_a.get_our_node_id(), + &get_event_msg!( + struct_a, + MessageSendEvent::SendClosingSigned, + node_b.get_our_node_id() + ), + ); assert_eq!(broadcaster_b.txn_broadcasted.lock().unwrap().len(), 1); tx_b = broadcaster_b.txn_broadcasted.lock().unwrap().remove(0); - let (bs_update, closing_signed_b) = get_closing_signed_broadcast!(node_b, node_a.get_our_node_id()); + let (bs_update, closing_signed_b) = + get_closing_signed_broadcast!(node_b, node_a.get_our_node_id()); node_a.handle_closing_signed(node_b.get_our_node_id(), &closing_signed_b.unwrap()); let (as_update, none_a) = get_closing_signed_broadcast!(node_a, node_b.get_our_node_id()); @@ -1918,14 +2359,23 @@ pub fn close_channel<'a, 'b, 'c>(outbound_node: &Node<'a, 'b, 'c>, inbound_node: tx_a = broadcaster_a.txn_broadcasted.lock().unwrap().remove(0); (as_update, bs_update) } else { - let closing_signed_a = get_event_msg!(struct_a, MessageSendEvent::SendClosingSigned, node_b.get_our_node_id()); + let closing_signed_a = + get_event_msg!(struct_a, MessageSendEvent::SendClosingSigned, node_b.get_our_node_id()); node_b.handle_closing_signed(node_a.get_our_node_id(), &closing_signed_a); - node_a.handle_closing_signed(node_b.get_our_node_id(), &get_event_msg!(struct_b, MessageSendEvent::SendClosingSigned, node_a.get_our_node_id())); + node_a.handle_closing_signed( + node_b.get_our_node_id(), + &get_event_msg!( + struct_b, + MessageSendEvent::SendClosingSigned, + node_a.get_our_node_id() + ), + ); assert_eq!(broadcaster_a.txn_broadcasted.lock().unwrap().len(), 1); tx_a = broadcaster_a.txn_broadcasted.lock().unwrap().remove(0); - let (as_update, closing_signed_a) = get_closing_signed_broadcast!(node_a, node_b.get_our_node_id()); + let (as_update, closing_signed_a) = + get_closing_signed_broadcast!(node_a, node_b.get_our_node_id()); node_b.handle_closing_signed(node_a.get_our_node_id(), &closing_signed_a.unwrap()); let (bs_update, none_b) = get_closing_signed_broadcast!(node_b, node_a.get_our_node_id()); @@ -1947,17 +2397,26 @@ pub struct SendEvent { pub commitment_msg: Vec, } impl SendEvent { - pub fn from_commitment_update(node_id: PublicKey, channel_id: ChannelId, updates: msgs::CommitmentUpdate) -> SendEvent { + pub fn from_commitment_update( + node_id: PublicKey, channel_id: ChannelId, updates: msgs::CommitmentUpdate, + ) -> SendEvent { assert!(updates.update_fulfill_htlcs.is_empty()); assert!(updates.update_fail_htlcs.is_empty()); assert!(updates.update_fail_malformed_htlcs.is_empty()); assert!(updates.update_fee.is_none()); - SendEvent { node_id, channel_id, msgs: updates.update_add_htlcs, commitment_msg: updates.commitment_signed } + SendEvent { + node_id, + channel_id, + msgs: updates.update_add_htlcs, + commitment_msg: updates.commitment_signed, + } } pub fn from_event(event: MessageSendEvent) -> SendEvent { match event { - MessageSendEvent::UpdateHTLCs { node_id, channel_id, updates } => SendEvent::from_commitment_update(node_id, channel_id, updates), + MessageSendEvent::UpdateHTLCs { node_id, channel_id, updates } => { + SendEvent::from_commitment_update(node_id, channel_id, updates) + }, _ => panic!("Unexpected event type!"), } } @@ -1973,8 +2432,11 @@ impl SendEvent { /// Don't use this, use the identically-named function instead. macro_rules! expect_pending_htlcs_forwardable_conditions { ($node: expr, $expected_failures: expr) => { - $crate::ln::functional_test_utils::expect_pending_htlcs_forwardable_conditions($node.node.get_and_clear_pending_events(), &$expected_failures); - } + $crate::ln::functional_test_utils::expect_pending_htlcs_forwardable_conditions( + $node.node.get_and_clear_pending_events(), + &$expected_failures, + ); + }; } #[macro_export] @@ -1983,7 +2445,7 @@ macro_rules! expect_htlc_handling_failed_destinations { let mut num_expected_failures = $expected_failures.len(); for event in $events { match event { - $crate::events::Event::PendingHTLCsForwardable { .. } => { }, + $crate::events::Event::PendingHTLCsForwardable { .. } => {}, $crate::events::Event::HTLCHandlingFailed { ref failure_type, .. } => { assert!($expected_failures.contains(&failure_type)); num_expected_failures -= 1; @@ -1992,16 +2454,21 @@ macro_rules! expect_htlc_handling_failed_destinations { } } assert_eq!(num_expected_failures, 0); - }} + }}; } /// Checks that an [`Event::PendingHTLCsForwardable`] is available in the given events and, if /// there are any [`Event::HTLCHandlingFailed`] events their [`HTLCHandlingFailureType`] is included in the /// `expected_failures` set. -pub fn expect_pending_htlcs_forwardable_conditions(events: Vec, expected_failures: &[HTLCHandlingFailureType]) { +pub fn expect_pending_htlcs_forwardable_conditions( + events: Vec, expected_failures: &[HTLCHandlingFailureType], +) { let count = expected_failures.len() + 1; assert_eq!(events.len(), count); - assert!(events.iter().find(|event| matches!(event, Event::PendingHTLCsForwardable { .. })).is_some()); + assert!(events + .iter() + .find(|event| matches!(event, Event::PendingHTLCsForwardable { .. })) + .is_some()); if expected_failures.len() > 0 { expect_htlc_handling_failed_destinations!(events, expected_failures) } @@ -2014,8 +2481,11 @@ pub fn expect_pending_htlcs_forwardable_conditions(events: Vec, expected_ /// set instead. macro_rules! expect_pending_htlcs_forwardable_ignore { ($node: expr) => { - $crate::ln::functional_test_utils::expect_pending_htlcs_forwardable_conditions($node.node.get_and_clear_pending_events(), &[]); - } + $crate::ln::functional_test_utils::expect_pending_htlcs_forwardable_conditions( + $node.node.get_and_clear_pending_events(), + &[], + ); + }; } #[macro_export] @@ -2024,15 +2494,21 @@ macro_rules! expect_pending_htlcs_forwardable_ignore { /// Don't use this, call [`expect_pending_htlcs_forwardable_conditions()`] instead. macro_rules! expect_pending_htlcs_forwardable_and_htlc_handling_failed_ignore { ($node: expr, $expected_failures: expr) => { - $crate::ln::functional_test_utils::expect_pending_htlcs_forwardable_conditions($node.node.get_and_clear_pending_events(), &$expected_failures); - } + $crate::ln::functional_test_utils::expect_pending_htlcs_forwardable_conditions( + $node.node.get_and_clear_pending_events(), + &$expected_failures, + ); + }; } #[macro_export] /// Handles a PendingHTLCsForwardable event macro_rules! expect_pending_htlcs_forwardable { ($node: expr) => {{ - $crate::ln::functional_test_utils::expect_pending_htlcs_forwardable_conditions($node.node.get_and_clear_pending_events(), &[]); + $crate::ln::functional_test_utils::expect_pending_htlcs_forwardable_conditions( + $node.node.get_and_clear_pending_events(), + &[], + ); $node.node.process_pending_htlc_forwards(); // Ensure process_pending_htlc_forwards is idempotent. @@ -2044,12 +2520,15 @@ macro_rules! expect_pending_htlcs_forwardable { /// Handles a PendingHTLCsForwardable and HTLCHandlingFailed event macro_rules! expect_pending_htlcs_forwardable_and_htlc_handling_failed { ($node: expr, $expected_failures: expr) => {{ - $crate::ln::functional_test_utils::expect_pending_htlcs_forwardable_conditions($node.node.get_and_clear_pending_events(), &$expected_failures); + $crate::ln::functional_test_utils::expect_pending_htlcs_forwardable_conditions( + $node.node.get_and_clear_pending_events(), + &$expected_failures, + ); $node.node.process_pending_htlc_forwards(); // Ensure process_pending_htlc_forwards is idempotent. $node.node.process_pending_htlc_forwards(); - }} + }}; } #[cfg(any(test, feature = "_externalize_tests"))] @@ -2057,7 +2536,7 @@ macro_rules! expect_pending_htlcs_forwardable_from_events { ($node: expr, $events: expr, $ignore: expr) => {{ assert_eq!($events.len(), 1); match $events[0] { - Event::PendingHTLCsForwardable { .. } => { }, + Event::PendingHTLCsForwardable { .. } => {}, _ => panic!("Unexpected event"), }; if $ignore { @@ -2066,7 +2545,7 @@ macro_rules! expect_pending_htlcs_forwardable_from_events { // Ensure process_pending_htlc_forwards is idempotent. $node.node.process_pending_htlc_forwards(); } - }} + }}; } #[macro_export] @@ -2074,28 +2553,56 @@ macro_rules! expect_pending_htlcs_forwardable_from_events { /// commitment update. macro_rules! commitment_signed_dance { ($node_a: expr, $node_b: expr, $commitment_signed: expr, $fail_backwards: expr, true /* skip last step */) => { - $crate::ln::functional_test_utils::do_commitment_signed_dance(&$node_a, &$node_b, &$commitment_signed, $fail_backwards, true); + $crate::ln::functional_test_utils::do_commitment_signed_dance( + &$node_a, + &$node_b, + &$commitment_signed, + $fail_backwards, + true, + ); }; ($node_a: expr, $node_b: expr, (), $fail_backwards: expr, true /* skip last step */, true /* return extra message */, true /* return last RAA */) => { - $crate::ln::functional_test_utils::do_main_commitment_signed_dance(&$node_a, &$node_b, $fail_backwards) - }; - ($node_a: expr, $node_b: expr, $commitment_signed: expr, $fail_backwards: expr, true /* skip last step */, false /* return extra message */, true /* return last RAA */) => { - { - $crate::ln::functional_test_utils::check_added_monitors(&$node_a, 0); - assert!($node_a.node.get_and_clear_pending_msg_events().is_empty()); - $node_a.node.handle_commitment_signed_batch_test($node_b.node.get_our_node_id(), &$commitment_signed); - check_added_monitors(&$node_a, 1); - let (extra_msg_option, bs_revoke_and_ack) = $crate::ln::functional_test_utils::do_main_commitment_signed_dance(&$node_a, &$node_b, $fail_backwards); - assert!(extra_msg_option.is_none()); - bs_revoke_and_ack - } + $crate::ln::functional_test_utils::do_main_commitment_signed_dance( + &$node_a, + &$node_b, + $fail_backwards, + ) }; + ($node_a: expr, $node_b: expr, $commitment_signed: expr, $fail_backwards: expr, true /* skip last step */, false /* return extra message */, true /* return last RAA */) => {{ + $crate::ln::functional_test_utils::check_added_monitors(&$node_a, 0); + assert!($node_a.node.get_and_clear_pending_msg_events().is_empty()); + $node_a.node.handle_commitment_signed_batch_test( + $node_b.node.get_our_node_id(), + &$commitment_signed, + ); + check_added_monitors(&$node_a, 1); + let (extra_msg_option, bs_revoke_and_ack) = + $crate::ln::functional_test_utils::do_main_commitment_signed_dance( + &$node_a, + &$node_b, + $fail_backwards, + ); + assert!(extra_msg_option.is_none()); + bs_revoke_and_ack + }}; ($node_a: expr, $node_b: expr, (), $fail_backwards: expr, true /* skip last step */, false /* no extra message */, $incl_claim: expr) => { - assert!($crate::ln::functional_test_utils::commitment_signed_dance_through_cp_raa(&$node_a, &$node_b, $fail_backwards, $incl_claim).is_none()); + assert!($crate::ln::functional_test_utils::commitment_signed_dance_through_cp_raa( + &$node_a, + &$node_b, + $fail_backwards, + $incl_claim + ) + .is_none()); }; ($node_a: expr, $node_b: expr, $commitment_signed: expr, $fail_backwards: expr) => { - $crate::ln::functional_test_utils::do_commitment_signed_dance(&$node_a, &$node_b, &$commitment_signed, $fail_backwards, false); - } + $crate::ln::functional_test_utils::do_commitment_signed_dance( + &$node_a, + &$node_b, + &$commitment_signed, + $fail_backwards, + false, + ); + }; } /// Runs the commitment_signed dance after the initial commitment_signed is delivered through to @@ -2108,8 +2615,12 @@ macro_rules! commitment_signed_dance { /// the commitment we're exchanging. `includes_claim` provides that information. /// /// Returns any additional message `node_b` generated in addition to the `revoke_and_ack` response. -pub fn commitment_signed_dance_through_cp_raa(node_a: &Node<'_, '_, '_>, node_b: &Node<'_, '_, '_>, fail_backwards: bool, includes_claim: bool) -> Option { - let (extra_msg_option, bs_revoke_and_ack) = do_main_commitment_signed_dance(node_a, node_b, fail_backwards); +pub fn commitment_signed_dance_through_cp_raa( + node_a: &Node<'_, '_, '_>, node_b: &Node<'_, '_, '_>, fail_backwards: bool, + includes_claim: bool, +) -> Option { + let (extra_msg_option, bs_revoke_and_ack) = + do_main_commitment_signed_dance(node_a, node_b, fail_backwards); node_a.node.handle_revoke_and_ack(node_b.node.get_our_node_id(), &bs_revoke_and_ack); check_added_monitors(node_a, if includes_claim { 0 } else { 1 }); extra_msg_option @@ -2119,25 +2630,34 @@ pub fn commitment_signed_dance_through_cp_raa(node_a: &Node<'_, '_, '_>, node_b: /// been delivered, this method picks up and delivers the response `revoke_and_ack` and /// `commitment_signed`, returning the recipient's `revoke_and_ack` and any extra message it may /// have included. -pub fn do_main_commitment_signed_dance(node_a: &Node<'_, '_, '_>, node_b: &Node<'_, '_, '_>, fail_backwards: bool) -> (Option, msgs::RevokeAndACK) { - let (as_revoke_and_ack, as_commitment_signed) = get_revoke_commit_msgs!(node_a, node_b.node.get_our_node_id()); +pub fn do_main_commitment_signed_dance( + node_a: &Node<'_, '_, '_>, node_b: &Node<'_, '_, '_>, fail_backwards: bool, +) -> (Option, msgs::RevokeAndACK) { + let (as_revoke_and_ack, as_commitment_signed) = + get_revoke_commit_msgs!(node_a, node_b.node.get_our_node_id()); check_added_monitors!(node_b, 0); assert!(node_b.node.get_and_clear_pending_msg_events().is_empty()); node_b.node.handle_revoke_and_ack(node_a.node.get_our_node_id(), &as_revoke_and_ack); assert!(node_b.node.get_and_clear_pending_msg_events().is_empty()); check_added_monitors!(node_b, 1); - node_b.node.handle_commitment_signed_batch_test(node_a.node.get_our_node_id(), &as_commitment_signed); + node_b + .node + .handle_commitment_signed_batch_test(node_a.node.get_our_node_id(), &as_commitment_signed); let (bs_revoke_and_ack, extra_msg_option) = { let mut events = node_b.node.get_and_clear_pending_msg_events(); assert!(events.len() <= 2); - let node_a_event = remove_first_msg_event_to_node(&node_a.node.get_our_node_id(), &mut events); - (match node_a_event { - MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => { - assert_eq!(*node_id, node_a.node.get_our_node_id()); - (*msg).clone() + let node_a_event = + remove_first_msg_event_to_node(&node_a.node.get_our_node_id(), &mut events); + ( + match node_a_event { + MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => { + assert_eq!(*node_id, node_a.node.get_our_node_id()); + (*msg).clone() + }, + _ => panic!("Unexpected event"), }, - _ => panic!("Unexpected event"), - }, events.get(0).map(|e| e.clone())) + events.get(0).map(|e| e.clone()), + ) }; check_added_monitors!(node_b, 1); if fail_backwards { @@ -2152,23 +2672,38 @@ pub fn do_main_commitment_signed_dance(node_a: &Node<'_, '_, '_>, node_b: &Node< /// /// If `skip_last_step` is unset, also checks for the payment failure update for the previous hop /// on failure or that no new messages are left over on success. -pub fn do_commitment_signed_dance(node_a: &Node<'_, '_, '_>, node_b: &Node<'_, '_, '_>, commitment_signed: &Vec, fail_backwards: bool, skip_last_step: bool) { +pub fn do_commitment_signed_dance( + node_a: &Node<'_, '_, '_>, node_b: &Node<'_, '_, '_>, + commitment_signed: &Vec, fail_backwards: bool, skip_last_step: bool, +) { check_added_monitors!(node_a, 0); assert!(node_a.node.get_and_clear_pending_msg_events().is_empty()); - node_a.node.handle_commitment_signed_batch_test(node_b.node.get_our_node_id(), commitment_signed); + node_a + .node + .handle_commitment_signed_batch_test(node_b.node.get_our_node_id(), commitment_signed); check_added_monitors!(node_a, 1); // If this commitment signed dance was due to a claim, don't check for an RAA monitor update. let channel_id = commitment_signed[0].channel_id; - let got_claim = node_a.node.test_raa_monitor_updates_held(node_b.node.get_our_node_id(), channel_id); - if fail_backwards { assert!(!got_claim); } + let got_claim = + node_a.node.test_raa_monitor_updates_held(node_b.node.get_our_node_id(), channel_id); + if fail_backwards { + assert!(!got_claim); + } commitment_signed_dance!(node_a, node_b, (), fail_backwards, true, false, got_claim); - if skip_last_step { return; } + if skip_last_step { + return; + } if fail_backwards { - expect_pending_htlcs_forwardable_and_htlc_handling_failed!(node_a, - [crate::events::HTLCHandlingFailureType::Forward{ node_id: Some(node_b.node.get_our_node_id()), channel_id }]); + expect_pending_htlcs_forwardable_and_htlc_handling_failed!( + node_a, + [crate::events::HTLCHandlingFailureType::Forward { + node_id: Some(node_b.node.get_our_node_id()), + channel_id + }] + ); check_added_monitors!(node_a, 1); let node_a_per_peer_state = node_a.node.per_peer_state.read().unwrap(); @@ -2180,7 +2715,9 @@ pub fn do_commitment_signed_dance(node_a: &Node<'_, '_, '_>, node_b: &Node<'_, ' if cp_pending_msg_events.len() == 1 { if let MessageSendEvent::UpdateHTLCs { .. } = cp_pending_msg_events[0] { assert_ne!(*cp_id, node_b.node.get_our_node_id()); - } else { panic!("Unexpected event"); } + } else { + panic!("Unexpected event"); + } } } // Expecting the failure backwards event to the previous hop (not `node_b`) @@ -2191,12 +2728,22 @@ pub fn do_commitment_signed_dance(node_a: &Node<'_, '_, '_>, node_b: &Node<'_, ' } /// Get a payment preimage and hash. -pub fn get_payment_preimage_hash(recipient: &Node, min_value_msat: Option, min_final_cltv_expiry_delta: Option) -> (PaymentPreimage, PaymentHash, PaymentSecret) { +pub fn get_payment_preimage_hash( + recipient: &Node, min_value_msat: Option, min_final_cltv_expiry_delta: Option, +) -> (PaymentPreimage, PaymentHash, PaymentSecret) { let mut payment_count = recipient.network_payment_count.borrow_mut(); let payment_preimage = PaymentPreimage([*payment_count; 32]); *payment_count += 1; let payment_hash = PaymentHash(Sha256::hash(&payment_preimage.0[..]).to_byte_array()); - let payment_secret = recipient.node.create_inbound_payment_for_hash(payment_hash, min_value_msat, 7200, min_final_cltv_expiry_delta).unwrap(); + let payment_secret = recipient + .node + .create_inbound_payment_for_hash( + payment_hash, + min_value_msat, + 7200, + min_final_cltv_expiry_delta, + ) + .unwrap(); (payment_preimage, payment_hash, payment_secret) } @@ -2212,7 +2759,11 @@ macro_rules! get_payment_preimage_hash { $crate::get_payment_preimage_hash!($dest_node, $min_value_msat, None) }; ($dest_node: expr, $min_value_msat: expr, $min_final_cltv_expiry_delta: expr) => { - $crate::ln::functional_test_utils::get_payment_preimage_hash(&$dest_node, $min_value_msat, $min_final_cltv_expiry_delta) + $crate::ln::functional_test_utils::get_payment_preimage_hash( + &$dest_node, + $min_value_msat, + $min_final_cltv_expiry_delta, + ) }; } @@ -2222,9 +2773,14 @@ pub fn get_route(send_node: &Node, route_params: &RouteParameters) -> Result>()), - send_node.logger, &scorer, &Default::default(), &random_seed_bytes + send_node.logger, + &scorer, + &Default::default(), + &random_seed_bytes, ) } @@ -2234,9 +2790,14 @@ pub fn find_route(send_node: &Node, route_params: &RouteParameters) -> Result>()), - send_node.logger, &scorer, &Default::default(), &random_seed_bytes + send_node.logger, + &scorer, + &Default::default(), + &random_seed_bytes, ) } @@ -2246,29 +2807,50 @@ pub fn find_route(send_node: &Node, route_params: &RouteParameters) -> Result {{ - let route_params = $crate::routing::router::RouteParameters::from_payment_params_and_value($payment_params, $recv_value); + let route_params = $crate::routing::router::RouteParameters::from_payment_params_and_value( + $payment_params, + $recv_value, + ); $crate::ln::functional_test_utils::get_route(&$send_node, &route_params) - }} + }}; } #[macro_export] macro_rules! get_route_and_payment_hash { ($send_node: expr, $recv_node: expr, $recv_value: expr) => {{ - let payment_params = $crate::routing::router::PaymentParameters::from_node_id($recv_node.node.get_our_node_id(), TEST_FINAL_CLTV) - .with_bolt11_features($recv_node.node.bolt11_invoice_features()).unwrap(); + let payment_params = $crate::routing::router::PaymentParameters::from_node_id( + $recv_node.node.get_our_node_id(), + TEST_FINAL_CLTV, + ) + .with_bolt11_features($recv_node.node.bolt11_invoice_features()) + .unwrap(); $crate::get_route_and_payment_hash!($send_node, $recv_node, payment_params, $recv_value) }}; ($send_node: expr, $recv_node: expr, $payment_params: expr, $recv_value: expr) => {{ - $crate::get_route_and_payment_hash!($send_node, $recv_node, $payment_params, $recv_value, None) + $crate::get_route_and_payment_hash!( + $send_node, + $recv_node, + $payment_params, + $recv_value, + None + ) }}; ($send_node: expr, $recv_node: expr, $payment_params: expr, $recv_value: expr, $max_total_routing_fee_msat: expr) => {{ - let mut route_params = $crate::routing::router::RouteParameters::from_payment_params_and_value($payment_params, $recv_value); + let mut route_params = + $crate::routing::router::RouteParameters::from_payment_params_and_value( + $payment_params, + $recv_value, + ); route_params.max_total_routing_fee_msat = $max_total_routing_fee_msat; let (payment_preimage, payment_hash, payment_secret) = - $crate::ln::functional_test_utils::get_payment_preimage_hash(&$recv_node, Some($recv_value), None); + $crate::ln::functional_test_utils::get_payment_preimage_hash( + &$recv_node, + Some($recv_value), + None, + ); let route = $crate::ln::functional_test_utils::get_route(&$send_node, &route_params); (route.unwrap(), payment_hash, payment_preimage, payment_secret) - }} + }}; } pub fn check_payment_claimable( @@ -2277,12 +2859,20 @@ pub fn check_payment_claimable( expected_receiver_node_id: PublicKey, ) { match event { - Event::PaymentClaimable { ref payment_hash, ref purpose, amount_msat, receiver_node_id, .. } => { + Event::PaymentClaimable { + ref payment_hash, + ref purpose, + amount_msat, + receiver_node_id, + .. + } => { assert_eq!(expected_payment_hash, *payment_hash); assert_eq!(expected_recv_value, *amount_msat); assert_eq!(expected_receiver_node_id, receiver_node_id.unwrap()); match purpose { - PaymentPurpose::Bolt11InvoicePayment { payment_preimage, payment_secret, .. } => { + PaymentPurpose::Bolt11InvoicePayment { + payment_preimage, payment_secret, .. + } => { assert_eq!(&expected_payment_preimage, payment_preimage); assert_eq!(expected_payment_secret, *payment_secret); }, @@ -2290,7 +2880,9 @@ pub fn check_payment_claimable( assert_eq!(&expected_payment_preimage, payment_preimage); assert_eq!(expected_payment_secret, *payment_secret); }, - PaymentPurpose::Bolt12RefundPayment { payment_preimage, payment_secret, .. } => { + PaymentPurpose::Bolt12RefundPayment { + payment_preimage, payment_secret, .. + } => { assert_eq!(&expected_payment_preimage, payment_preimage); assert_eq!(expected_payment_secret, *payment_secret); }, @@ -2305,12 +2897,26 @@ pub fn check_payment_claimable( #[cfg(any(test, ldk_bench, feature = "_test_utils"))] macro_rules! expect_payment_claimable { ($node: expr, $expected_payment_hash: expr, $expected_payment_secret: expr, $expected_recv_value: expr) => { - expect_payment_claimable!($node, $expected_payment_hash, $expected_payment_secret, $expected_recv_value, None, $node.node.get_our_node_id()) + expect_payment_claimable!( + $node, + $expected_payment_hash, + $expected_payment_secret, + $expected_recv_value, + None, + $node.node.get_our_node_id() + ) }; ($node: expr, $expected_payment_hash: expr, $expected_payment_secret: expr, $expected_recv_value: expr, $expected_payment_preimage: expr, $expected_receiver_node_id: expr) => { let events = $node.node.get_and_clear_pending_events(); assert_eq!(events.len(), 1); - $crate::ln::functional_test_utils::check_payment_claimable(&events[0], $expected_payment_hash, $expected_payment_secret, $expected_recv_value, $expected_payment_preimage, $expected_receiver_node_id) + $crate::ln::functional_test_utils::check_payment_claimable( + &events[0], + $expected_payment_hash, + $expected_payment_secret, + $expected_recv_value, + $expected_payment_preimage, + $expected_receiver_node_id, + ) }; } @@ -2327,16 +2933,18 @@ macro_rules! expect_payment_claimed { }, _ => panic!("Unexpected event"), } - } + }; } -pub fn expect_payment_sent>(node: &H, - expected_payment_preimage: PaymentPreimage, expected_fee_msat_opt: Option>, - expect_per_path_claims: bool, expect_post_ev_mon_update: bool, +pub fn expect_payment_sent>( + node: &H, expected_payment_preimage: PaymentPreimage, + expected_fee_msat_opt: Option>, expect_per_path_claims: bool, + expect_post_ev_mon_update: bool, ) -> Option { let events = node.node().get_and_clear_pending_events(); let expected_payment_hash = PaymentHash( - bitcoin::hashes::sha256::Hash::hash(&expected_payment_preimage.0).to_byte_array()); + bitcoin::hashes::sha256::Hash::hash(&expected_payment_preimage.0).to_byte_array(), + ); if expect_per_path_claims { assert!(events.len() > 1); } else { @@ -2348,7 +2956,14 @@ pub fn expect_payment_sent>(node: &H, // We return the invoice because some test may want to check the invoice details. let invoice; let expected_payment_id = match events[0] { - Event::PaymentSent { ref payment_id, ref payment_preimage, ref payment_hash, ref amount_msat, ref fee_paid_msat, ref bolt12_invoice } => { + Event::PaymentSent { + ref payment_id, + ref payment_preimage, + ref payment_hash, + ref amount_msat, + ref fee_paid_msat, + ref bolt12_invoice, + } => { assert_eq!(expected_payment_preimage, *payment_preimage); assert_eq!(expected_payment_hash, *payment_hash); assert!(amount_msat.is_some()); @@ -2382,12 +2997,22 @@ macro_rules! expect_payment_sent { $crate::expect_payment_sent!($node, $expected_payment_preimage, None::, true) }; ($node: expr, $expected_payment_preimage: expr, $expected_fee_msat_opt: expr) => { - $crate::expect_payment_sent!($node, $expected_payment_preimage, $expected_fee_msat_opt, true) + $crate::expect_payment_sent!( + $node, + $expected_payment_preimage, + $expected_fee_msat_opt, + true + ) }; ($node: expr, $expected_payment_preimage: expr, $expected_fee_msat_opt: expr, $expect_paths: expr) => { - $crate::ln::functional_test_utils::expect_payment_sent(&$node, $expected_payment_preimage, - $expected_fee_msat_opt.map(|o| Some(o)), $expect_paths, true) - } + $crate::ln::functional_test_utils::expect_payment_sent( + &$node, + $expected_payment_preimage, + $expected_fee_msat_opt.map(|o| Some(o)), + $expect_paths, + true, + ) + }; } #[macro_export] @@ -2399,20 +3024,27 @@ macro_rules! expect_payment_path_successful { $crate::events::Event::PaymentPathSuccessful { .. } => {}, _ => panic!("Unexpected event"), } - } + }; } /// Returns the total fee earned by this HTLC forward, in msat. -pub fn expect_payment_forwarded>( +pub fn expect_payment_forwarded>( event: Event, node: &H, prev_node: &H, next_node: &H, expected_fee: Option, expected_extra_fees_msat: Option, upstream_force_closed: bool, downstream_force_closed: bool, allow_1_msat_fee_overpay: bool, ) -> Option { match event { Event::PaymentForwarded { - prev_channel_id, next_channel_id, prev_user_channel_id, next_user_channel_id, - prev_node_id, next_node_id, total_fee_earned_msat, - skimmed_fee_msat, claim_from_onchain_tx, .. + prev_channel_id, + next_channel_id, + prev_user_channel_id, + next_user_channel_id, + prev_node_id, + next_node_id, + total_fee_earned_msat, + skimmed_fee_msat, + claim_from_onchain_tx, + .. } => { if allow_1_msat_fee_overpay { // Aggregating fees for blinded paths may result in a rounding error, causing slight @@ -2429,12 +3061,11 @@ pub fn expect_payment_forwarded>( assert!(skimmed_fee_msat == expected_extra_fees_msat); if !upstream_force_closed { // Is the event prev_channel_id in one of the channels between the two nodes? - assert!(node.node().list_channels().iter().any(|x| - x.counterparty.node_id == prev_node.node().get_our_node_id() && - prev_node.node().get_our_node_id() == prev_node_id.unwrap() && - x.channel_id == prev_channel_id.unwrap() && - x.user_channel_id == prev_user_channel_id.unwrap() - )); + assert!(node.node().list_channels().iter().any(|x| x.counterparty.node_id + == prev_node.node().get_our_node_id() + && prev_node.node().get_our_node_id() == prev_node_id.unwrap() + && x.channel_id == prev_channel_id.unwrap() + && x.user_channel_id == prev_user_channel_id.unwrap())); } // We check for force closures since a force closed channel is removed from the // node's channel list @@ -2444,18 +3075,19 @@ pub fn expect_payment_forwarded>( // introducing yet another variable, we use the latter's state as a flag to detect // this and only check if it's `Some`. if total_fee_earned_msat.is_none() { - assert!(node.node().list_channels().iter().any(|x| - x.counterparty.node_id == next_node.node().get_our_node_id() && - next_node.node().get_our_node_id() == next_node_id.unwrap() && - x.channel_id == next_channel_id.unwrap() - )); + assert!(node + .node() + .list_channels() + .iter() + .any(|x| x.counterparty.node_id == next_node.node().get_our_node_id() + && next_node.node().get_our_node_id() == next_node_id.unwrap() + && x.channel_id == next_channel_id.unwrap())); } else { - assert!(node.node().list_channels().iter().any(|x| - x.counterparty.node_id == next_node.node().get_our_node_id() && - next_node.node().get_our_node_id() == next_node_id.unwrap() && - x.channel_id == next_channel_id.unwrap() && - x.user_channel_id == next_user_channel_id.unwrap() - )); + assert!(node.node().list_channels().iter().any(|x| x.counterparty.node_id + == next_node.node().get_our_node_id() + && next_node.node().get_our_node_id() == next_node_id.unwrap() + && x.channel_id == next_channel_id.unwrap() + && x.user_channel_id == next_user_channel_id.unwrap())); } } assert_eq!(claim_from_onchain_tx, downstream_force_closed); @@ -2471,23 +3103,37 @@ macro_rules! expect_payment_forwarded { let mut events = $node.node.get_and_clear_pending_events(); assert_eq!(events.len(), 1); $crate::ln::functional_test_utils::expect_payment_forwarded( - events.pop().unwrap(), &$node, &$prev_node, &$next_node, $expected_fee, None, - $upstream_force_closed, $downstream_force_closed, false + events.pop().unwrap(), + &$node, + &$prev_node, + &$next_node, + $expected_fee, + None, + $upstream_force_closed, + $downstream_force_closed, + false, ); - } + }; } #[macro_export] macro_rules! expect_channel_shutdown_state { ($node: expr, $chan_id: expr, $state: path) => { - let chan_details = $node.node.list_channels().into_iter().filter(|cd| cd.channel_id == $chan_id).collect::>(); + let chan_details = $node + .node + .list_channels() + .into_iter() + .filter(|cd| cd.channel_id == $chan_id) + .collect::>(); assert_eq!(chan_details.len(), 1); assert_eq!(chan_details[0].channel_shutdown_state, Some($state)); - } + }; } #[cfg(any(test, ldk_bench, feature = "_test_utils"))] -pub fn expect_channel_pending_event<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, expected_counterparty_node_id: &PublicKey) -> ChannelId { +pub fn expect_channel_pending_event<'a, 'b, 'c, 'd>( + node: &'a Node<'b, 'c, 'd>, expected_counterparty_node_id: &PublicKey, +) -> ChannelId { let events = node.node.get_and_clear_pending_events(); assert_eq!(events.len(), 1); match &events[0] { @@ -2500,31 +3146,37 @@ pub fn expect_channel_pending_event<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, } #[cfg(any(test, ldk_bench, feature = "_test_utils"))] -pub fn expect_channel_ready_event<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, expected_counterparty_node_id: &PublicKey) { +pub fn expect_channel_ready_event<'a, 'b, 'c, 'd>( + node: &'a Node<'b, 'c, 'd>, expected_counterparty_node_id: &PublicKey, +) { let events = node.node.get_and_clear_pending_events(); assert_eq!(events.len(), 1); match events[0] { - crate::events::Event::ChannelReady{ ref counterparty_node_id, .. } => { + crate::events::Event::ChannelReady { ref counterparty_node_id, .. } => { assert_eq!(*expected_counterparty_node_id, *counterparty_node_id); }, _ => panic!("Unexpected event"), } } -pub fn expect_probe_successful_events(node: &Node, mut probe_results: Vec<(PaymentHash, PaymentId)>) { +pub fn expect_probe_successful_events( + node: &Node, mut probe_results: Vec<(PaymentHash, PaymentId)>, +) { let mut events = node.node.get_and_clear_pending_events(); for event in events.drain(..) { match event { - Event::ProbeSuccessful { payment_hash: ev_ph, payment_id: ev_pid, ..} => { - let result_idx = probe_results.iter().position(|(payment_hash, payment_id)| *payment_hash == ev_ph && *payment_id == ev_pid); + Event::ProbeSuccessful { payment_hash: ev_ph, payment_id: ev_pid, .. } => { + let result_idx = probe_results.iter().position(|(payment_hash, payment_id)| { + *payment_hash == ev_ph && *payment_id == ev_pid + }); assert!(result_idx.is_some()); probe_results.remove(result_idx.unwrap()); }, _ => panic!(), } - }; + } // Ensure that we received a ProbeSuccessful event for each probe result. assert!(probe_results.is_empty()); @@ -2560,7 +3212,9 @@ impl<'a> PaymentFailedConditions<'a> { self.expected_blamed_chan_closed = Some(closed); self } - pub fn expected_htlc_error_data(mut self, reason: LocalHTLCFailureReason, data: &'a [u8]) -> Self { + pub fn expected_htlc_error_data( + mut self, reason: LocalHTLCFailureReason, data: &'a [u8], + ) -> Self { self.expected_htlc_error_data = Some((reason, data)); self } @@ -2574,10 +3228,14 @@ impl<'a> PaymentFailedConditions<'a> { macro_rules! expect_payment_failed_with_update { ($node: expr, $expected_payment_hash: expr, $payment_failed_permanently: expr, $scid: expr, $chan_closed: expr) => { $crate::ln::functional_test_utils::expect_payment_failed_conditions( - &$node, $expected_payment_hash, $payment_failed_permanently, + &$node, + $expected_payment_hash, + $payment_failed_permanently, $crate::ln::functional_test_utils::PaymentFailedConditions::new() - .blamed_scid($scid).blamed_chan_closed($chan_closed)); - } + .blamed_scid($scid) + .blamed_chan_closed($chan_closed), + ); + }; } #[cfg(any(test, feature = "_externalize_tests"))] @@ -2594,16 +3252,28 @@ macro_rules! expect_payment_failed { pub fn expect_payment_failed_conditions_event<'a, 'b, 'c, 'd, 'e>( payment_failed_events: Vec, expected_payment_hash: PaymentHash, - expected_payment_failed_permanently: bool, conditions: PaymentFailedConditions<'e> + expected_payment_failed_permanently: bool, conditions: PaymentFailedConditions<'e>, ) { - if conditions.expected_mpp_parts_remain { assert_eq!(payment_failed_events.len(), 1); } else { assert_eq!(payment_failed_events.len(), 2); } + if conditions.expected_mpp_parts_remain { + assert_eq!(payment_failed_events.len(), 1); + } else { + assert_eq!(payment_failed_events.len(), 2); + } let expected_payment_id = match &payment_failed_events[0] { - Event::PaymentPathFailed { payment_hash, payment_failed_permanently, payment_id, failure, - error_code, - error_data, .. + Event::PaymentPathFailed { + payment_hash, + payment_failed_permanently, + payment_id, + failure, + error_code, + error_data, + .. } => { assert_eq!(*payment_hash, expected_payment_hash, "unexpected payment_hash"); - assert_eq!(*payment_failed_permanently, expected_payment_failed_permanently, "unexpected payment_failed_permanently value"); + assert_eq!( + *payment_failed_permanently, expected_payment_failed_permanently, + "unexpected payment_failed_permanently value" + ); { assert!(error_code.is_some(), "expected error_code.is_some() = true"); assert!(error_data.is_some(), "expected error_data.is_some() = true"); @@ -2625,7 +3295,9 @@ pub fn expect_payment_failed_conditions_event<'a, 'b, 'c, 'd, 'e>( }, _ => panic!("Unexpected update type"), } - } else { panic!("Expected network update"); } + } else { + panic!("Expected network update"); + } } payment_id.unwrap() @@ -2635,14 +3307,21 @@ pub fn expect_payment_failed_conditions_event<'a, 'b, 'c, 'd, 'e>( if !conditions.expected_mpp_parts_remain && !conditions.retry_expected { match &payment_failed_events[1] { Event::PaymentFailed { ref payment_hash, ref payment_id, ref reason } => { - assert_eq!(*payment_hash, Some(expected_payment_hash), "unexpected second payment_hash"); + assert_eq!( + *payment_hash, + Some(expected_payment_hash), + "unexpected second payment_hash" + ); assert_eq!(*payment_id, expected_payment_id); - assert_eq!(reason.unwrap(), if expected_payment_failed_permanently { - PaymentFailureReason::RecipientRejected - } else { - PaymentFailureReason::RetriesExhausted - }); - } + assert_eq!( + reason.unwrap(), + if expected_payment_failed_permanently { + PaymentFailureReason::RecipientRejected + } else { + PaymentFailureReason::RetriesExhausted + } + ); + }, _ => panic!("Unexpected second event"), } } else if conditions.retry_expected { @@ -2654,20 +3333,34 @@ pub fn expect_payment_failed_conditions_event<'a, 'b, 'c, 'd, 'e>( } pub fn expect_payment_failed_conditions<'a, 'b, 'c, 'd, 'e>( - node: &'a Node<'b, 'c, 'd>, expected_payment_hash: PaymentHash, expected_payment_failed_permanently: bool, - conditions: PaymentFailedConditions<'e> + node: &'a Node<'b, 'c, 'd>, expected_payment_hash: PaymentHash, + expected_payment_failed_permanently: bool, conditions: PaymentFailedConditions<'e>, ) { let events = node.node.get_and_clear_pending_events(); - expect_payment_failed_conditions_event(events, expected_payment_hash, expected_payment_failed_permanently, conditions); + expect_payment_failed_conditions_event( + events, + expected_payment_hash, + expected_payment_failed_permanently, + conditions, + ); } -pub fn send_along_route_with_secret<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, route: Route, expected_paths: &[&[&Node<'a, 'b, 'c>]], recv_value: u64, our_payment_hash: PaymentHash, our_payment_secret: PaymentSecret) -> PaymentId { +pub fn send_along_route_with_secret<'a, 'b, 'c>( + origin_node: &Node<'a, 'b, 'c>, route: Route, expected_paths: &[&[&Node<'a, 'b, 'c>]], + recv_value: u64, our_payment_hash: PaymentHash, our_payment_secret: PaymentSecret, +) -> PaymentId { let payment_id = PaymentId(origin_node.keys_manager.backing.get_secure_random_bytes()); origin_node.router.expect_find_route(route.route_params.clone().unwrap(), Ok(route.clone())); - origin_node.node.send_payment( - our_payment_hash, RecipientOnionFields::secret_only(our_payment_secret), payment_id, - route.route_params.unwrap(), Retry::Attempts(0) - ).unwrap(); + origin_node + .node + .send_payment( + our_payment_hash, + RecipientOnionFields::secret_only(our_payment_secret), + payment_id, + route.route_params.unwrap(), + Retry::Attempts(0), + ) + .unwrap(); check_added_monitors!(origin_node, expected_paths.len()); pass_along_route(origin_node, expected_paths, recv_value, our_payment_hash, our_payment_secret); payment_id @@ -2679,7 +3372,9 @@ fn fail_payment_along_path<'a, 'b, 'c>(expected_path: &[&Node<'a, 'b, 'c>]) { // iterate from the receiving node to the origin node and handle update fail htlc. for (&node, &prev_node) in expected_path.iter().rev().zip(expected_path.iter().rev().skip(1)) { let updates = get_htlc_update_msgs!(node, prev_node.node.get_our_node_id()); - prev_node.node.handle_update_fail_htlc(node.node.get_our_node_id(), &updates.update_fail_htlcs[0]); + prev_node + .node + .handle_update_fail_htlc(node.node.get_our_node_id(), &updates.update_fail_htlcs[0]); check_added_monitors!(prev_node, 0); let is_first_hop = origin_node_id == prev_node.node.get_our_node_id(); @@ -2706,13 +3401,23 @@ pub struct PassAlongPathArgs<'a, 'b, 'c, 'd> { impl<'a, 'b, 'c, 'd> PassAlongPathArgs<'a, 'b, 'c, 'd> { pub fn new( - origin_node: &'a Node<'b, 'c, 'd>, expected_path: &'a [&'a Node<'b, 'c, 'd>], recv_value: u64, - payment_hash: PaymentHash, event: MessageSendEvent, + origin_node: &'a Node<'b, 'c, 'd>, expected_path: &'a [&'a Node<'b, 'c, 'd>], + recv_value: u64, payment_hash: PaymentHash, event: MessageSendEvent, ) -> Self { Self { - origin_node, expected_path, recv_value, payment_hash, payment_secret: None, event, - payment_claimable_expected: true, clear_recipient_events: true, expected_preimage: None, - is_probe: false, custom_tlvs: Vec::new(), payment_metadata: None, expected_failure: None, + origin_node, + expected_path, + recv_value, + payment_hash, + payment_secret: None, + event, + payment_claimable_expected: true, + clear_recipient_events: true, + expected_preimage: None, + is_probe: false, + custom_tlvs: Vec::new(), + payment_metadata: None, + expected_failure: None, } } pub fn without_clearing_recipient_events(mut self) -> Self { @@ -2753,10 +3458,19 @@ impl<'a, 'b, 'c, 'd> PassAlongPathArgs<'a, 'b, 'c, 'd> { pub fn do_pass_along_path<'a, 'b, 'c>(args: PassAlongPathArgs) -> Option { let PassAlongPathArgs { - origin_node, expected_path, recv_value, payment_hash: our_payment_hash, - payment_secret: our_payment_secret, event: ev, payment_claimable_expected, - clear_recipient_events, expected_preimage, is_probe, custom_tlvs, payment_metadata, - expected_failure + origin_node, + expected_path, + recv_value, + payment_hash: our_payment_hash, + payment_secret: our_payment_secret, + event: ev, + payment_claimable_expected, + clear_recipient_events, + expected_preimage, + is_probe, + custom_tlvs, + payment_metadata, + expected_failure, } = args; let mut payment_event = SendEvent::from_event(ev); @@ -2784,44 +3498,80 @@ pub fn do_pass_along_path<'a, 'b, 'c>(args: PassAlongPathArgs) -> Option if payment_claimable_expected { assert_eq!(events_2.len(), 1); match &events_2[0] { - Event::PaymentClaimable { ref payment_hash, ref purpose, amount_msat, - receiver_node_id, ref via_channel_ids, - claim_deadline, onion_fields, .. + Event::PaymentClaimable { + ref payment_hash, + ref purpose, + amount_msat, + receiver_node_id, + ref via_channel_ids, + claim_deadline, + onion_fields, + .. } => { assert_eq!(our_payment_hash, *payment_hash); assert_eq!(node.node.get_our_node_id(), receiver_node_id.unwrap()); assert!(onion_fields.is_some()); assert_eq!(onion_fields.as_ref().unwrap().custom_tlvs, custom_tlvs); - assert_eq!(onion_fields.as_ref().unwrap().payment_metadata, payment_metadata); + assert_eq!( + onion_fields.as_ref().unwrap().payment_metadata, + payment_metadata + ); match &purpose { - PaymentPurpose::Bolt11InvoicePayment { payment_preimage, payment_secret, .. } => { + PaymentPurpose::Bolt11InvoicePayment { + payment_preimage, + payment_secret, + .. + } => { assert_eq!(expected_preimage, *payment_preimage); assert_eq!(our_payment_secret.unwrap(), *payment_secret); - assert_eq!(Some(*payment_secret), onion_fields.as_ref().unwrap().payment_secret); + assert_eq!( + Some(*payment_secret), + onion_fields.as_ref().unwrap().payment_secret + ); }, - PaymentPurpose::Bolt12OfferPayment { payment_preimage, payment_secret, .. } => { + PaymentPurpose::Bolt12OfferPayment { + payment_preimage, + payment_secret, + .. + } => { if let Some(preimage) = expected_preimage { assert_eq!(preimage, payment_preimage.unwrap()); } if let Some(secret) = our_payment_secret { assert_eq!(secret, *payment_secret); } - assert_eq!(Some(*payment_secret), onion_fields.as_ref().unwrap().payment_secret); + assert_eq!( + Some(*payment_secret), + onion_fields.as_ref().unwrap().payment_secret + ); }, - PaymentPurpose::Bolt12RefundPayment { payment_preimage, payment_secret, .. } => { + PaymentPurpose::Bolt12RefundPayment { + payment_preimage, + payment_secret, + .. + } => { assert_eq!(expected_preimage, *payment_preimage); assert_eq!(our_payment_secret.unwrap(), *payment_secret); - assert_eq!(Some(*payment_secret), onion_fields.as_ref().unwrap().payment_secret); + assert_eq!( + Some(*payment_secret), + onion_fields.as_ref().unwrap().payment_secret + ); }, PaymentPurpose::SpontaneousPayment(payment_preimage) => { assert_eq!(expected_preimage.unwrap(), *payment_preimage); - assert_eq!(our_payment_secret, onion_fields.as_ref().unwrap().payment_secret); + assert_eq!( + our_payment_secret, + onion_fields.as_ref().unwrap().payment_secret + ); }, } assert_eq!(*amount_msat, recv_value); let channels = node.node.list_channels(); for (chan_id, user_chan_id) in via_channel_ids { - let chan = channels.iter().find(|details| &details.channel_id == chan_id).unwrap(); + let chan = channels + .iter() + .find(|details| &details.channel_id == chan_id) + .unwrap(); assert_eq!(*user_chan_id, Some(chan.user_channel_id)); } assert!(claim_deadline.unwrap() > node.best_block_info().1); @@ -2854,8 +3604,13 @@ pub fn do_pass_along_path<'a, 'b, 'c>(args: PassAlongPathArgs) -> Option event } -pub fn pass_along_path<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_path: &[&Node<'a, 'b, 'c>], recv_value: u64, our_payment_hash: PaymentHash, our_payment_secret: Option, ev: MessageSendEvent, payment_claimable_expected: bool, expected_preimage: Option) -> Option { - let mut args = PassAlongPathArgs::new(origin_node, expected_path, recv_value, our_payment_hash, ev); +pub fn pass_along_path<'a, 'b, 'c>( + origin_node: &Node<'a, 'b, 'c>, expected_path: &[&Node<'a, 'b, 'c>], recv_value: u64, + our_payment_hash: PaymentHash, our_payment_secret: Option, ev: MessageSendEvent, + payment_claimable_expected: bool, expected_preimage: Option, +) -> Option { + let mut args = + PassAlongPathArgs::new(origin_node, expected_path, recv_value, our_payment_hash, ev); if !payment_claimable_expected { args = args.without_claimable_event(); } @@ -2868,7 +3623,9 @@ pub fn pass_along_path<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_path do_pass_along_path(args) } -pub fn send_probe_along_route<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[(&[&Node<'a, 'b, 'c>], PaymentHash)]) { +pub fn send_probe_along_route<'a, 'b, 'c>( + origin_node: &Node<'a, 'b, 'c>, expected_route: &[(&[&Node<'a, 'b, 'c>], PaymentHash)], +) { let mut events = origin_node.node.get_and_clear_pending_msg_events(); assert_eq!(events.len(), expected_route.len()); @@ -2877,11 +3634,14 @@ pub fn send_probe_along_route<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expect for (path, payment_hash) in expected_route.iter() { let ev = remove_first_msg_event_to_node(&path[0].node.get_our_node_id(), &mut events); - do_pass_along_path(PassAlongPathArgs::new(origin_node, path, 0, *payment_hash, ev) - .is_probe() - .without_clearing_recipient_events()); + do_pass_along_path( + PassAlongPathArgs::new(origin_node, path, 0, *payment_hash, ev) + .is_probe() + .without_clearing_recipient_events(), + ); - let nodes_to_fail_payment: Vec<_> = vec![origin_node].into_iter().chain(path.iter().cloned()).collect(); + let nodes_to_fail_payment: Vec<_> = + vec![origin_node].into_iter().chain(path.iter().cloned()).collect(); fail_payment_along_path(nodes_to_fail_payment.as_slice()); expect_htlc_handling_failed_destinations!( @@ -2891,28 +3651,55 @@ pub fn send_probe_along_route<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expect } } -pub fn pass_along_route<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&[&Node<'a, 'b, 'c>]], recv_value: u64, our_payment_hash: PaymentHash, our_payment_secret: PaymentSecret) { +pub fn pass_along_route<'a, 'b, 'c>( + origin_node: &Node<'a, 'b, 'c>, expected_route: &[&[&Node<'a, 'b, 'c>]], recv_value: u64, + our_payment_hash: PaymentHash, our_payment_secret: PaymentSecret, +) { let mut events = origin_node.node.get_and_clear_pending_msg_events(); assert_eq!(events.len(), expected_route.len()); for (path_idx, expected_path) in expected_route.iter().enumerate() { - let ev = remove_first_msg_event_to_node(&expected_path[0].node.get_our_node_id(), &mut events); + let ev = + remove_first_msg_event_to_node(&expected_path[0].node.get_our_node_id(), &mut events); // Once we've gotten through all the HTLCs, the last one should result in a // PaymentClaimable (but each previous one should not!). let expect_payment = path_idx == expected_route.len() - 1; - pass_along_path(origin_node, expected_path, recv_value, our_payment_hash.clone(), Some(our_payment_secret), ev, expect_payment, None); + pass_along_path( + origin_node, + expected_path, + recv_value, + our_payment_hash.clone(), + Some(our_payment_secret), + ev, + expect_payment, + None, + ); } } -pub fn send_along_route<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, route: Route, expected_route: &[&Node<'a, 'b, 'c>], recv_value: u64) -> (PaymentPreimage, PaymentHash, PaymentSecret, PaymentId) { - let (our_payment_preimage, our_payment_hash, our_payment_secret) = get_payment_preimage_hash!(expected_route.last().unwrap()); - let payment_id = send_along_route_with_secret(origin_node, route, &[expected_route], recv_value, our_payment_hash, our_payment_secret); +pub fn send_along_route<'a, 'b, 'c>( + origin_node: &Node<'a, 'b, 'c>, route: Route, expected_route: &[&Node<'a, 'b, 'c>], + recv_value: u64, +) -> (PaymentPreimage, PaymentHash, PaymentSecret, PaymentId) { + let (our_payment_preimage, our_payment_hash, our_payment_secret) = + get_payment_preimage_hash!(expected_route.last().unwrap()); + let payment_id = send_along_route_with_secret( + origin_node, + route, + &[expected_route], + recv_value, + our_payment_hash, + our_payment_secret, + ); (our_payment_preimage, our_payment_hash, our_payment_secret, payment_id) } pub fn do_claim_payment_along_route(args: ClaimAlongRouteArgs) -> u64 { for path in args.expected_paths.iter() { - assert_eq!(path.last().unwrap().node.get_our_node_id(), args.expected_paths[0].last().unwrap().node.get_our_node_id()); + assert_eq!( + path.last().unwrap().node.get_our_node_id(), + args.expected_paths[0].last().unwrap().node.get_our_node_id() + ); } args.expected_paths[0].last().unwrap().node.claim_funds(args.payment_preimage); pass_claimed_payment_along_route(args) @@ -2942,9 +3729,14 @@ impl<'a, 'b, 'c, 'd> ClaimAlongRouteArgs<'a, 'b, 'c, 'd> { payment_preimage: PaymentPreimage, ) -> Self { Self { - origin_node, expected_paths, expected_extra_fees: vec![0; expected_paths.len()], - expected_min_htlc_overpay: vec![0; expected_paths.len()], skip_last: false, payment_preimage, - allow_1_msat_fee_overpay: false, custom_tlvs: vec![], + origin_node, + expected_paths, + expected_extra_fees: vec![0; expected_paths.len()], + expected_min_htlc_overpay: vec![0; expected_paths.len()], + skip_last: false, + payment_preimage, + allow_1_msat_fee_overpay: false, + custom_tlvs: vec![], } } pub fn skip_last(mut self, skip_last: bool) -> Self { @@ -2971,8 +3763,14 @@ impl<'a, 'b, 'c, 'd> ClaimAlongRouteArgs<'a, 'b, 'c, 'd> { pub fn pass_claimed_payment_along_route(args: ClaimAlongRouteArgs) -> u64 { let ClaimAlongRouteArgs { - origin_node, expected_paths, expected_extra_fees, expected_min_htlc_overpay, skip_last, - payment_preimage: our_payment_preimage, allow_1_msat_fee_overpay, custom_tlvs, + origin_node, + expected_paths, + expected_extra_fees, + expected_min_htlc_overpay, + skip_last, + payment_preimage: our_payment_preimage, + allow_1_msat_fee_overpay, + custom_tlvs, } = args; let claim_event = expected_paths[0].last().unwrap().node.get_and_clear_pending_events(); assert_eq!(claim_event.len(), 1); @@ -2980,7 +3778,8 @@ pub fn pass_claimed_payment_along_route(args: ClaimAlongRouteArgs) -> u64 { let mut fwd_amt_msat = 0; match claim_event[0] { Event::PaymentClaimed { - purpose: PaymentPurpose::SpontaneousPayment(preimage) + purpose: + PaymentPurpose::SpontaneousPayment(preimage) | PaymentPurpose::Bolt11InvoicePayment { payment_preimage: Some(preimage), .. } | PaymentPurpose::Bolt12OfferPayment { payment_preimage: Some(preimage), .. } | PaymentPurpose::Bolt12RefundPayment { payment_preimage: Some(preimage), .. }, @@ -2990,14 +3789,15 @@ pub fn pass_claimed_payment_along_route(args: ClaimAlongRouteArgs) -> u64 { .. } => { assert_eq!(preimage, our_payment_preimage); - assert_eq!(htlcs.len(), expected_paths.len()); // One per path. + assert_eq!(htlcs.len(), expected_paths.len()); // One per path. assert_eq!(htlcs.iter().map(|h| h.value_msat).sum::(), amount_msat); assert_eq!(onion_fields.as_ref().unwrap().custom_tlvs, custom_tlvs); check_claimed_htlcs_match_route(origin_node, expected_paths, htlcs); fwd_amt_msat = amount_msat; }, Event::PaymentClaimed { - purpose: PaymentPurpose::Bolt11InvoicePayment { .. } + purpose: + PaymentPurpose::Bolt11InvoicePayment { .. } | PaymentPurpose::Bolt12OfferPayment { .. } | PaymentPurpose::Bolt12RefundPayment { .. }, payment_hash, @@ -3007,12 +3807,12 @@ pub fn pass_claimed_payment_along_route(args: ClaimAlongRouteArgs) -> u64 { .. } => { assert_eq!(&payment_hash.0, &Sha256::hash(&our_payment_preimage.0)[..]); - assert_eq!(htlcs.len(), expected_paths.len()); // One per path. + assert_eq!(htlcs.len(), expected_paths.len()); // One per path. assert_eq!(htlcs.iter().map(|h| h.value_msat).sum::(), amount_msat); assert_eq!(onion_fields.as_ref().unwrap().custom_tlvs, custom_tlvs); check_claimed_htlcs_match_route(origin_node, expected_paths, htlcs); fwd_amt_msat = amount_msat; - } + }, _ => panic!(), } @@ -3023,7 +3823,19 @@ pub fn pass_claimed_payment_along_route(args: ClaimAlongRouteArgs) -> u64 { macro_rules! msgs_from_ev { ($ev: expr) => { match $ev { - &MessageSendEvent::UpdateHTLCs { ref node_id, ref channel_id, updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fulfill_htlcs, ref update_fail_htlcs, ref update_fail_malformed_htlcs, ref update_fee, ref commitment_signed } } => { + &MessageSendEvent::UpdateHTLCs { + ref node_id, + ref channel_id, + updates: + msgs::CommitmentUpdate { + ref update_add_htlcs, + ref update_fulfill_htlcs, + ref update_fail_htlcs, + ref update_fail_malformed_htlcs, + ref update_fee, + ref commitment_signed, + }, + } => { assert!(update_add_htlcs.is_empty()); assert_eq!(update_fulfill_htlcs.len(), 1); assert!(update_fail_htlcs.is_empty()); @@ -3034,9 +3846,12 @@ pub fn pass_claimed_payment_along_route(args: ClaimAlongRouteArgs) -> u64 { }, _ => panic!("Unexpected event"), } - } + }; } - let mut per_path_msgs: Vec<((msgs::UpdateFulfillHTLC, Vec), PublicKey)> = Vec::with_capacity(expected_paths.len()); + let mut per_path_msgs: Vec<( + (msgs::UpdateFulfillHTLC, Vec), + PublicKey, + )> = Vec::with_capacity(expected_paths.len()); let mut events = expected_paths[0].last().unwrap().node.get_and_clear_pending_msg_events(); assert_eq!(events.len(), expected_paths.len()); @@ -3046,7 +3861,11 @@ pub fn pass_claimed_payment_along_route(args: ClaimAlongRouteArgs) -> u64 { for expected_path in expected_paths.iter() { // For MPP payments, we want the fulfill message from the payee to the penultimate hop in the // path. - let penultimate_hop_node_id = expected_path.iter().rev().skip(1).next() + let penultimate_hop_node_id = expected_path + .iter() + .rev() + .skip(1) + .next() .map(|n| n.node.get_our_node_id()) .unwrap_or(origin_node.node.get_our_node_id()); let ev = remove_first_msg_event_to_node(&penultimate_hop_node_id, &mut events); @@ -3054,68 +3873,96 @@ pub fn pass_claimed_payment_along_route(args: ClaimAlongRouteArgs) -> u64 { } } - for (i, (expected_route, (path_msgs, next_hop))) in expected_paths.iter().zip(per_path_msgs.drain(..)).enumerate() { + for (i, (expected_route, (path_msgs, next_hop))) in + expected_paths.iter().zip(per_path_msgs.drain(..)).enumerate() + { let mut next_msgs = Some(path_msgs); let mut expected_next_node = next_hop; macro_rules! last_update_fulfill_dance { - ($node: expr, $prev_node: expr) => { - { - $node.node.handle_update_fulfill_htlc($prev_node.node.get_our_node_id(), &next_msgs.as_ref().unwrap().0); - check_added_monitors!($node, 0); - assert!($node.node.get_and_clear_pending_msg_events().is_empty()); - commitment_signed_dance!($node, $prev_node, next_msgs.as_ref().unwrap().1, false); - } - } + ($node: expr, $prev_node: expr) => {{ + $node.node.handle_update_fulfill_htlc( + $prev_node.node.get_our_node_id(), + &next_msgs.as_ref().unwrap().0, + ); + check_added_monitors!($node, 0); + assert!($node.node.get_and_clear_pending_msg_events().is_empty()); + commitment_signed_dance!($node, $prev_node, next_msgs.as_ref().unwrap().1, false); + }}; } macro_rules! mid_update_fulfill_dance { - ($idx: expr, $node: expr, $prev_node: expr, $next_node: expr, $new_msgs: expr) => { - { - $node.node.handle_update_fulfill_htlc($prev_node.node.get_our_node_id(), &next_msgs.as_ref().unwrap().0); - let mut fee = { - let (base_fee, prop_fee) = { - let per_peer_state = $node.node.per_peer_state.read().unwrap(); - let peer_state = per_peer_state.get(&$prev_node.node.get_our_node_id()) - .unwrap().lock().unwrap(); - let channel = peer_state.channel_by_id.get(&next_msgs.as_ref().unwrap().0.channel_id).unwrap(); - if let Some(prev_config) = channel.context().prev_config() { - (prev_config.forwarding_fee_base_msat as u64, - prev_config.forwarding_fee_proportional_millionths as u64) - } else { - (channel.context().config().forwarding_fee_base_msat as u64, - channel.context().config().forwarding_fee_proportional_millionths as u64) - } - }; - ((fwd_amt_msat * prop_fee / 1_000_000) + base_fee) as u32 + ($idx: expr, $node: expr, $prev_node: expr, $next_node: expr, $new_msgs: expr) => {{ + $node.node.handle_update_fulfill_htlc( + $prev_node.node.get_our_node_id(), + &next_msgs.as_ref().unwrap().0, + ); + let mut fee = { + let (base_fee, prop_fee) = { + let per_peer_state = $node.node.per_peer_state.read().unwrap(); + let peer_state = per_peer_state + .get(&$prev_node.node.get_our_node_id()) + .unwrap() + .lock() + .unwrap(); + let channel = peer_state + .channel_by_id + .get(&next_msgs.as_ref().unwrap().0.channel_id) + .unwrap(); + if let Some(prev_config) = channel.context().prev_config() { + ( + prev_config.forwarding_fee_base_msat as u64, + prev_config.forwarding_fee_proportional_millionths as u64, + ) + } else { + ( + channel.context().config().forwarding_fee_base_msat as u64, + channel.context().config().forwarding_fee_proportional_millionths + as u64, + ) + } }; - - let mut expected_extra_fee = None; - if $idx == 1 { - fee += expected_extra_fees[i]; - fee += expected_min_htlc_overpay[i]; - expected_extra_fee = if expected_extra_fees[i] > 0 { Some(expected_extra_fees[i] as u64) } else { None }; - } - let mut events = $node.node.get_and_clear_pending_events(); - assert_eq!(events.len(), 1); - let actual_fee = expect_payment_forwarded(events.pop().unwrap(), *$node, $next_node, $prev_node, - Some(fee as u64), expected_extra_fee, false, false, allow_1_msat_fee_overpay); - expected_total_fee_msat += actual_fee.unwrap(); - fwd_amt_msat += actual_fee.unwrap(); - check_added_monitors!($node, 1); - let new_next_msgs = if $new_msgs { - let events = $node.node.get_and_clear_pending_msg_events(); - assert_eq!(events.len(), 1); - let (res, nexthop) = msgs_from_ev!(&events[0]); - expected_next_node = nexthop; - Some(res) + ((fwd_amt_msat * prop_fee / 1_000_000) + base_fee) as u32 + }; + + let mut expected_extra_fee = None; + if $idx == 1 { + fee += expected_extra_fees[i]; + fee += expected_min_htlc_overpay[i]; + expected_extra_fee = if expected_extra_fees[i] > 0 { + Some(expected_extra_fees[i] as u64) } else { - assert!($node.node.get_and_clear_pending_msg_events().is_empty()); None }; - commitment_signed_dance!($node, $prev_node, next_msgs.as_ref().unwrap().1, false); - next_msgs = new_next_msgs; } - } + let mut events = $node.node.get_and_clear_pending_events(); + assert_eq!(events.len(), 1); + let actual_fee = expect_payment_forwarded( + events.pop().unwrap(), + *$node, + $next_node, + $prev_node, + Some(fee as u64), + expected_extra_fee, + false, + false, + allow_1_msat_fee_overpay, + ); + expected_total_fee_msat += actual_fee.unwrap(); + fwd_amt_msat += actual_fee.unwrap(); + check_added_monitors!($node, 1); + let new_next_msgs = if $new_msgs { + let events = $node.node.get_and_clear_pending_msg_events(); + assert_eq!(events.len(), 1); + let (res, nexthop) = msgs_from_ev!(&events[0]); + expected_next_node = nexthop; + Some(res) + } else { + assert!($node.node.get_and_clear_pending_msg_events().is_empty()); + None + }; + commitment_signed_dance!($node, $prev_node, next_msgs.as_ref().unwrap().1, false); + next_msgs = new_next_msgs; + }}; } let mut prev_node = expected_route.last().unwrap(); @@ -3166,17 +4013,28 @@ pub fn claim_payment_along_route(args: ClaimAlongRouteArgs) -> Option(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], our_payment_preimage: PaymentPreimage) -> Option { - claim_payment_along_route( - ClaimAlongRouteArgs::new(origin_node, &[expected_route], our_payment_preimage) - ) +pub fn claim_payment<'a, 'b, 'c>( + origin_node: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], + our_payment_preimage: PaymentPreimage, +) -> Option { + claim_payment_along_route(ClaimAlongRouteArgs::new( + origin_node, + &[expected_route], + our_payment_preimage, + )) } pub const TEST_FINAL_CLTV: u32 = 70; -pub fn route_payment<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], recv_value: u64) -> (PaymentPreimage, PaymentHash, PaymentSecret, PaymentId) { - let payment_params = PaymentParameters::from_node_id(expected_route.last().unwrap().node.get_our_node_id(), TEST_FINAL_CLTV) - .with_bolt11_features(expected_route.last().unwrap().node.bolt11_invoice_features()).unwrap(); +pub fn route_payment<'a, 'b, 'c>( + origin_node: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], recv_value: u64, +) -> (PaymentPreimage, PaymentHash, PaymentSecret, PaymentId) { + let payment_params = PaymentParameters::from_node_id( + expected_route.last().unwrap().node.get_our_node_id(), + TEST_FINAL_CLTV, + ) + .with_bolt11_features(expected_route.last().unwrap().node.bolt11_invoice_features()) + .unwrap(); let route_params = RouteParameters::from_payment_params_and_value(payment_params, recv_value); let route = get_route(origin_node, &route_params).unwrap(); assert_eq!(route.paths.len(), 1); @@ -3189,33 +4047,69 @@ pub fn route_payment<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: (res.0, res.1, res.2, res.3) } -pub fn send_payment<'a, 'b, 'c>(origin: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], recv_value: u64) -> (PaymentPreimage, PaymentHash, PaymentSecret, PaymentId) { +pub fn send_payment<'a, 'b, 'c>( + origin: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], recv_value: u64, +) -> (PaymentPreimage, PaymentHash, PaymentSecret, PaymentId) { let res = route_payment(&origin, expected_route, recv_value); claim_payment(&origin, expected_route, res.0); res } -pub fn fail_payment_along_route<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_paths: &[&[&Node<'a, 'b, 'c>]], skip_last: bool, our_payment_hash: PaymentHash) { +pub fn fail_payment_along_route<'a, 'b, 'c>( + origin_node: &Node<'a, 'b, 'c>, expected_paths: &[&[&Node<'a, 'b, 'c>]], skip_last: bool, + our_payment_hash: PaymentHash, +) { for path in expected_paths.iter() { - assert_eq!(path.last().unwrap().node.get_our_node_id(), expected_paths[0].last().unwrap().node.get_our_node_id()); + assert_eq!( + path.last().unwrap().node.get_our_node_id(), + expected_paths[0].last().unwrap().node.get_our_node_id() + ); } expected_paths[0].last().unwrap().node.fail_htlc_backwards(&our_payment_hash); - let expected_destinations: Vec = repeat(HTLCHandlingFailureType::Receive { payment_hash: our_payment_hash }).take(expected_paths.len()).collect(); - expect_pending_htlcs_forwardable_and_htlc_handling_failed!(expected_paths[0].last().unwrap(), expected_destinations); + let expected_destinations: Vec = + repeat(HTLCHandlingFailureType::Receive { payment_hash: our_payment_hash }) + .take(expected_paths.len()) + .collect(); + expect_pending_htlcs_forwardable_and_htlc_handling_failed!( + expected_paths[0].last().unwrap(), + expected_destinations + ); - pass_failed_payment_back(origin_node, expected_paths, skip_last, our_payment_hash, PaymentFailureReason::RecipientRejected); + pass_failed_payment_back( + origin_node, + expected_paths, + skip_last, + our_payment_hash, + PaymentFailureReason::RecipientRejected, + ); } -pub fn pass_failed_payment_back<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_paths_slice: &[&[&Node<'a, 'b, 'c>]], skip_last: bool, our_payment_hash: PaymentHash, expected_fail_reason: PaymentFailureReason) { +pub fn pass_failed_payment_back<'a, 'b, 'c>( + origin_node: &Node<'a, 'b, 'c>, expected_paths_slice: &[&[&Node<'a, 'b, 'c>]], skip_last: bool, + our_payment_hash: PaymentHash, expected_fail_reason: PaymentFailureReason, +) { let mut expected_paths: Vec<_> = expected_paths_slice.iter().collect(); check_added_monitors!(expected_paths[0].last().unwrap(), expected_paths.len()); - let mut per_path_msgs: Vec<((msgs::UpdateFailHTLC, Vec), PublicKey)> = Vec::with_capacity(expected_paths.len()); + let mut per_path_msgs: Vec<((msgs::UpdateFailHTLC, Vec), PublicKey)> = + Vec::with_capacity(expected_paths.len()); let events = expected_paths[0].last().unwrap().node.get_and_clear_pending_msg_events(); assert_eq!(events.len(), expected_paths.len()); for ev in events.iter() { let (update_fail, commitment_signed, node_id) = match ev { - &MessageSendEvent::UpdateHTLCs { ref node_id, ref channel_id, updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fulfill_htlcs, ref update_fail_htlcs, ref update_fail_malformed_htlcs, ref update_fee, ref commitment_signed } } => { + &MessageSendEvent::UpdateHTLCs { + ref node_id, + ref channel_id, + updates: + msgs::CommitmentUpdate { + ref update_add_htlcs, + ref update_fulfill_htlcs, + ref update_fail_htlcs, + ref update_fail_malformed_htlcs, + ref update_fee, + ref commitment_signed, + }, + } => { assert!(update_add_htlcs.is_empty()); assert!(update_fulfill_htlcs.is_empty()); assert_eq!(update_fail_htlcs.len(), 1); @@ -3229,9 +4123,16 @@ pub fn pass_failed_payment_back<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expe per_path_msgs.push(((update_fail, commitment_signed), node_id)); } per_path_msgs.sort_unstable_by(|(_, node_id_a), (_, node_id_b)| node_id_a.cmp(node_id_b)); - expected_paths.sort_unstable_by(|path_a, path_b| path_a[path_a.len() - 2].node.get_our_node_id().cmp(&path_b[path_b.len() - 2].node.get_our_node_id())); + expected_paths.sort_unstable_by(|path_a, path_b| { + path_a[path_a.len() - 2] + .node + .get_our_node_id() + .cmp(&path_b[path_b.len() - 2].node.get_our_node_id()) + }); - for (i, (expected_route, (path_msgs, next_hop))) in expected_paths.iter().zip(per_path_msgs.drain(..)).enumerate() { + for (i, (expected_route, (path_msgs, next_hop))) in + expected_paths.iter().zip(per_path_msgs.drain(..)).enumerate() + { let mut next_msgs = Some(path_msgs); let mut expected_next_node = next_hop; let mut prev_node = expected_route.last().unwrap(); @@ -3240,17 +4141,43 @@ pub fn pass_failed_payment_back<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expe assert_eq!(expected_next_node, node.node.get_our_node_id()); let update_next_node = !skip_last || idx != expected_route.len() - 1; if next_msgs.is_some() { - node.node.handle_update_fail_htlc(prev_node.node.get_our_node_id(), &next_msgs.as_ref().unwrap().0); - commitment_signed_dance!(node, prev_node, next_msgs.as_ref().unwrap().1, update_next_node); + node.node.handle_update_fail_htlc( + prev_node.node.get_our_node_id(), + &next_msgs.as_ref().unwrap().0, + ); + commitment_signed_dance!( + node, + prev_node, + next_msgs.as_ref().unwrap().1, + update_next_node + ); if !update_next_node { - expect_pending_htlcs_forwardable_and_htlc_handling_failed!(node, [HTLCHandlingFailureType::Forward { node_id: Some(prev_node.node.get_our_node_id()), channel_id: next_msgs.as_ref().unwrap().0.channel_id }]); + expect_pending_htlcs_forwardable_and_htlc_handling_failed!( + node, + [HTLCHandlingFailureType::Forward { + node_id: Some(prev_node.node.get_our_node_id()), + channel_id: next_msgs.as_ref().unwrap().0.channel_id + }] + ); } } let events = node.node.get_and_clear_pending_msg_events(); if update_next_node { assert_eq!(events.len(), 1); match events[0] { - MessageSendEvent::UpdateHTLCs { ref node_id, ref channel_id, updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fulfill_htlcs, ref update_fail_htlcs, ref update_fail_malformed_htlcs, ref update_fee, ref commitment_signed } } => { + MessageSendEvent::UpdateHTLCs { + ref node_id, + ref channel_id, + updates: + msgs::CommitmentUpdate { + ref update_add_htlcs, + ref update_fulfill_htlcs, + ref update_fail_htlcs, + ref update_fail_malformed_htlcs, + ref update_fee, + ref commitment_signed, + }, + } => { assert!(update_add_htlcs.is_empty()); assert!(update_fulfill_htlcs.is_empty()); assert_eq!(update_fail_htlcs.len(), 1); @@ -3274,15 +4201,28 @@ pub fn pass_failed_payment_back<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expe if !skip_last { let prev_node = expected_route.first().unwrap(); - origin_node.node.handle_update_fail_htlc(prev_node.node.get_our_node_id(), &next_msgs.as_ref().unwrap().0); + origin_node.node.handle_update_fail_htlc( + prev_node.node.get_our_node_id(), + &next_msgs.as_ref().unwrap().0, + ); check_added_monitors!(origin_node, 0); assert!(origin_node.node.get_and_clear_pending_msg_events().is_empty()); commitment_signed_dance!(origin_node, prev_node, next_msgs.as_ref().unwrap().1, false); let events = origin_node.node.get_and_clear_pending_events(); - if i == expected_paths.len() - 1 { assert_eq!(events.len(), 2); } else { assert_eq!(events.len(), 1); } + if i == expected_paths.len() - 1 { + assert_eq!(events.len(), 2); + } else { + assert_eq!(events.len(), 1); + } let expected_payment_id = match events[0] { - Event::PaymentPathFailed { payment_hash, payment_failed_permanently, ref path, ref payment_id, .. } => { + Event::PaymentPathFailed { + payment_hash, + payment_failed_permanently, + ref path, + ref payment_id, + .. + } => { assert_eq!(payment_hash, our_payment_hash); assert!(payment_failed_permanently); for (idx, hop) in expected_route.iter().enumerate() { @@ -3295,10 +4235,14 @@ pub fn pass_failed_payment_back<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expe if i == expected_paths.len() - 1 { match events[1] { Event::PaymentFailed { ref payment_hash, ref payment_id, ref reason } => { - assert_eq!(*payment_hash, Some(our_payment_hash), "unexpected second payment_hash"); + assert_eq!( + *payment_hash, + Some(our_payment_hash), + "unexpected second payment_hash" + ); assert_eq!(*payment_id, expected_payment_id); assert_eq!(reason.unwrap(), expected_fail_reason); - } + }, _ => panic!("Unexpected second event"), } } @@ -3312,7 +4256,10 @@ pub fn pass_failed_payment_back<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expe check_added_monitors!(expected_paths[0].last().unwrap(), 0); } -pub fn fail_payment<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_path: &[&Node<'a, 'b, 'c>], our_payment_hash: PaymentHash) { +pub fn fail_payment<'a, 'b, 'c>( + origin_node: &Node<'a, 'b, 'c>, expected_path: &[&Node<'a, 'b, 'c>], + our_payment_hash: PaymentHash, +) { fail_payment_along_route(origin_node, &[&expected_path[..]], false, our_payment_hash); } @@ -3320,7 +4267,9 @@ pub fn create_chanmon_cfgs(node_count: usize) -> Vec { create_chanmon_cfgs_with_keys(node_count, None) } -pub fn create_chanmon_cfgs_with_keys(node_count: usize, predefined_keys_ids: Option>) -> Vec { +pub fn create_chanmon_cfgs_with_keys( + node_count: usize, predefined_keys_ids: Option>, +) -> Vec { let mut chan_mon_cfgs = Vec::new(); for i in 0..node_count { let tx_broadcaster = test_utils::TestBroadcaster::new(Network::Testnet); @@ -3339,21 +4288,45 @@ pub fn create_chanmon_cfgs_with_keys(node_count: usize, predefined_keys_ids: Opt } } - chan_mon_cfgs.push(TestChanMonCfg { tx_broadcaster, fee_estimator, chain_source, logger, persister, keys_manager, scorer }); + chan_mon_cfgs.push(TestChanMonCfg { + tx_broadcaster, + fee_estimator, + chain_source, + logger, + persister, + keys_manager, + scorer, + }); } chan_mon_cfgs } -pub fn create_node_cfgs<'a>(node_count: usize, chanmon_cfgs: &'a Vec) -> Vec> { - create_node_cfgs_with_persisters(node_count, chanmon_cfgs, chanmon_cfgs.iter().map(|c| &c.persister).collect()) +pub fn create_node_cfgs<'a>( + node_count: usize, chanmon_cfgs: &'a Vec, +) -> Vec> { + create_node_cfgs_with_persisters( + node_count, + chanmon_cfgs, + chanmon_cfgs.iter().map(|c| &c.persister).collect(), + ) } -pub fn create_node_cfgs_with_persisters<'a>(node_count: usize, chanmon_cfgs: &'a Vec, persisters: Vec<&'a impl test_utils::SyncPersist>) -> Vec> { +pub fn create_node_cfgs_with_persisters<'a>( + node_count: usize, chanmon_cfgs: &'a Vec, + persisters: Vec<&'a impl test_utils::SyncPersist>, +) -> Vec> { let mut nodes = Vec::new(); for i in 0..node_count { - let chain_monitor = test_utils::TestChainMonitor::new(Some(&chanmon_cfgs[i].chain_source), &chanmon_cfgs[i].tx_broadcaster, &chanmon_cfgs[i].logger, &chanmon_cfgs[i].fee_estimator, persisters[i], &chanmon_cfgs[i].keys_manager); + let chain_monitor = test_utils::TestChainMonitor::new( + Some(&chanmon_cfgs[i].chain_source), + &chanmon_cfgs[i].tx_broadcaster, + &chanmon_cfgs[i].logger, + &chanmon_cfgs[i].fee_estimator, + persisters[i], + &chanmon_cfgs[i].keys_manager, + ); let network_graph = Arc::new(NetworkGraph::new(Network::Testnet, &chanmon_cfgs[i].logger)); let seed = [i as u8; 32]; nodes.push(NodeCfg { @@ -3361,8 +4334,15 @@ pub fn create_node_cfgs_with_persisters<'a>(node_count: usize, chanmon_cfgs: &'a logger: &chanmon_cfgs[i].logger, tx_broadcaster: &chanmon_cfgs[i].tx_broadcaster, fee_estimator: &chanmon_cfgs[i].fee_estimator, - router: test_utils::TestRouter::new(Arc::clone(&network_graph), &chanmon_cfgs[i].logger, &chanmon_cfgs[i].scorer), - message_router: test_utils::TestMessageRouter::new(Arc::clone(&network_graph), &chanmon_cfgs[i].keys_manager), + router: test_utils::TestRouter::new( + Arc::clone(&network_graph), + &chanmon_cfgs[i].logger, + &chanmon_cfgs[i].scorer, + ), + message_router: test_utils::TestMessageRouter::new( + Arc::clone(&network_graph), + &chanmon_cfgs[i].keys_manager, + ), chain_monitor, keys_manager: &chanmon_cfgs[i].keys_manager, node_seed: seed, @@ -3392,24 +4372,66 @@ pub fn test_default_channel_config() -> UserConfig { default_config } -pub fn create_node_chanmgrs<'a, 'b>(node_count: usize, cfgs: &'a Vec>, node_config: &[Option]) -> Vec, &'b test_utils::TestBroadcaster, &'a test_utils::TestKeysInterface, &'a test_utils::TestKeysInterface, &'a test_utils::TestKeysInterface, &'b test_utils::TestFeeEstimator, &'a test_utils::TestRouter<'b>, &'a test_utils::TestMessageRouter<'b>, &'b test_utils::TestLogger>> { +pub fn create_node_chanmgrs<'a, 'b>( + node_count: usize, cfgs: &'a Vec>, node_config: &[Option], +) -> Vec< + ChannelManager< + &'a TestChainMonitor<'b>, + &'b test_utils::TestBroadcaster, + &'a test_utils::TestKeysInterface, + &'a test_utils::TestKeysInterface, + &'a test_utils::TestKeysInterface, + &'b test_utils::TestFeeEstimator, + &'a test_utils::TestRouter<'b>, + &'a test_utils::TestMessageRouter<'b>, + &'b test_utils::TestLogger, + >, +> { let mut chanmgrs = Vec::new(); for i in 0..node_count { let network = Network::Testnet; let genesis_block = bitcoin::constants::genesis_block(network); - let params = ChainParameters { - network, - best_block: BestBlock::from_network(network), - }; - let node = ChannelManager::new(cfgs[i].fee_estimator, &cfgs[i].chain_monitor, cfgs[i].tx_broadcaster, &cfgs[i].router, &cfgs[i].message_router, cfgs[i].logger, cfgs[i].keys_manager, - cfgs[i].keys_manager, cfgs[i].keys_manager, if node_config[i].is_some() { node_config[i].clone().unwrap() } else { test_default_channel_config() }, params, genesis_block.header.time); + let params = ChainParameters { network, best_block: BestBlock::from_network(network) }; + let node = ChannelManager::new( + cfgs[i].fee_estimator, + &cfgs[i].chain_monitor, + cfgs[i].tx_broadcaster, + &cfgs[i].router, + &cfgs[i].message_router, + cfgs[i].logger, + cfgs[i].keys_manager, + cfgs[i].keys_manager, + cfgs[i].keys_manager, + if node_config[i].is_some() { + node_config[i].clone().unwrap() + } else { + test_default_channel_config() + }, + params, + genesis_block.header.time, + ); chanmgrs.push(node); } chanmgrs } -pub fn create_network<'a, 'b: 'a, 'c: 'b>(node_count: usize, cfgs: &'b Vec>, chan_mgrs: &'a Vec, &'c test_utils::TestBroadcaster, &'b test_utils::TestKeysInterface, &'b test_utils::TestKeysInterface, &'b test_utils::TestKeysInterface, &'c test_utils::TestFeeEstimator, &'c test_utils::TestRouter, &'c test_utils::TestMessageRouter, &'c test_utils::TestLogger>>) -> Vec> { +pub fn create_network<'a, 'b: 'a, 'c: 'b>( + node_count: usize, cfgs: &'b Vec>, + chan_mgrs: &'a Vec< + ChannelManager< + &'b TestChainMonitor<'c>, + &'c test_utils::TestBroadcaster, + &'b test_utils::TestKeysInterface, + &'b test_utils::TestKeysInterface, + &'b test_utils::TestKeysInterface, + &'c test_utils::TestFeeEstimator, + &'c test_utils::TestRouter, + &'c test_utils::TestMessageRouter, + &'c test_utils::TestLogger, + >, + >, +) -> Vec> { let mut nodes = Vec::new(); let chan_count = Rc::new(RefCell::new(0)); let payment_count = Rc::new(RefCell::new(0)); @@ -3419,40 +4441,64 @@ pub fn create_network<'a, 'b: 'a, 'c: 'b>(node_count: usize, cfgs: &'b Vec(node: &Node<'a, 'b, 'c>) { let mut dummy_init_features = InitFeatures::empty(); dummy_init_features.set_static_remote_key_required(); - let init_dummy = msgs::Init { - features: dummy_init_features, - networks: None, - remote_network_address: None - }; + let init_dummy = + msgs::Init { features: dummy_init_features, networks: None, remote_network_address: None }; node.node.peer_connected(node_id_dummy, &init_dummy, true).unwrap(); node.onion_messenger.peer_connected(node_id_dummy, &init_dummy, true).unwrap(); @@ -3508,7 +4551,11 @@ pub const ACCEPTED_HTLC_SCRIPT_WEIGHT: usize = 137; // Here we have a diff due t pub const ACCEPTED_HTLC_SCRIPT_WEIGHT_ANCHORS: usize = 140; // Here we have a diff due to HTLC CLTV expiry being < 2^15 in test #[derive(PartialEq)] -pub enum HTLCType { NONE, TIMEOUT, SUCCESS } +pub enum HTLCType { + NONE, + TIMEOUT, + SUCCESS, +} /// Tests that the given node has broadcast transactions for the given Channel /// /// First checks that the latest holder commitment tx has been broadcast, unless an explicit @@ -3520,11 +4567,19 @@ pub enum HTLCType { NONE, TIMEOUT, SUCCESS } /// /// All broadcast transactions must be accounted for in one of the above three types of we'll /// also fail. -pub fn test_txn_broadcast<'a, 'b, 'c>(node: &Node<'a, 'b, 'c>, chan: &(msgs::ChannelUpdate, msgs::ChannelUpdate, ChannelId, Transaction), commitment_tx: Option, has_htlc_tx: HTLCType) -> Vec { +pub fn test_txn_broadcast<'a, 'b, 'c>( + node: &Node<'a, 'b, 'c>, + chan: &(msgs::ChannelUpdate, msgs::ChannelUpdate, ChannelId, Transaction), + commitment_tx: Option, has_htlc_tx: HTLCType, +) -> Vec { let mut node_txn = node.tx_broadcaster.txn_broadcasted.lock().unwrap(); let mut txn_seen = new_hash_set(); node_txn.retain(|tx| txn_seen.insert(tx.compute_txid())); - assert!(node_txn.len() >= if commitment_tx.is_some() { 0 } else { 1 } + if has_htlc_tx == HTLCType::NONE { 0 } else { 1 }); + assert!( + node_txn.len() + >= if commitment_tx.is_some() { 0 } else { 1 } + + if has_htlc_tx == HTLCType::NONE { 0 } else { 1 } + ); let mut res = Vec::with_capacity(2); node_txn.retain(|tx| { @@ -3534,7 +4589,9 @@ pub fn test_txn_broadcast<'a, 'b, 'c>(node: &Node<'a, 'b, 'c>, chan: &(msgs::Cha res.push(tx.clone()); } false - } else { true } + } else { + true + } }); if let Some(explicit_tx) = commitment_tx { res.push(explicit_tx.clone()); @@ -3553,7 +4610,9 @@ pub fn test_txn_broadcast<'a, 'b, 'c>(node: &Node<'a, 'b, 'c>, chan: &(msgs::Cha } res.push(tx.clone()); false - } else { true } + } else { + true + } }); assert!(res.len() == 2 || res.len() == 3); if res.len() == 3 { @@ -3567,16 +4626,22 @@ pub fn test_txn_broadcast<'a, 'b, 'c>(node: &Node<'a, 'b, 'c>, chan: &(msgs::Cha /// Tests that the given node has broadcast a claim transaction against the provided revoked /// HTLC transaction. -pub fn test_revoked_htlc_claim_txn_broadcast<'a, 'b, 'c>(node: &Node<'a, 'b, 'c>, revoked_tx: Transaction, commitment_revoked_tx: Transaction) { +pub fn test_revoked_htlc_claim_txn_broadcast<'a, 'b, 'c>( + node: &Node<'a, 'b, 'c>, revoked_tx: Transaction, commitment_revoked_tx: Transaction, +) { let mut node_txn = node.tx_broadcaster.txn_broadcasted.lock().unwrap(); // We may issue multiple claiming transaction on revoked outputs due to block rescan // for revoked htlc outputs - if node_txn.len() != 1 && node_txn.len() != 2 && node_txn.len() != 3 { assert!(false); } + if node_txn.len() != 1 && node_txn.len() != 2 && node_txn.len() != 3 { + assert!(false); + } node_txn.retain(|tx| { if tx.input.len() == 1 && tx.input[0].previous_output.txid == revoked_tx.compute_txid() { check_spends!(tx, revoked_tx); false - } else { true } + } else { + true + } }); node_txn.retain(|tx| { check_spends!(tx, commitment_revoked_tx); @@ -3585,7 +4650,9 @@ pub fn test_revoked_htlc_claim_txn_broadcast<'a, 'b, 'c>(node: &Node<'a, 'b, 'c> assert!(node_txn.is_empty()); } -pub fn check_preimage_claim<'a, 'b, 'c>(node: &Node<'a, 'b, 'c>, prev_txn: &Vec) -> Vec { +pub fn check_preimage_claim<'a, 'b, 'c>( + node: &Node<'a, 'b, 'c>, prev_txn: &Vec, +) -> Vec { let mut node_txn = node.tx_broadcaster.txn_broadcasted.lock().unwrap(); let mut txn_seen = new_hash_set(); node_txn.retain(|tx| txn_seen.insert(tx.compute_txid())); @@ -3613,7 +4680,9 @@ pub fn check_preimage_claim<'a, 'b, 'c>(node: &Node<'a, 'b, 'c>, prev_txn: &Vec< res } -pub fn handle_announce_close_broadcast_events<'a, 'b, 'c>(nodes: &Vec>, a: usize, b: usize, needs_err_handle: bool, expected_error: &str) { +pub fn handle_announce_close_broadcast_events<'a, 'b, 'c>( + nodes: &Vec>, a: usize, b: usize, needs_err_handle: bool, expected_error: &str, +) { let mut dummy_connected = false; if !is_any_peer_connected(&nodes[a]) { connect_dummy_node(&nodes[a]); @@ -3623,20 +4692,24 @@ pub fn handle_announce_close_broadcast_events<'a, 'b, 'c>(nodes: &Vec { - msg.clone() - }, + MessageSendEvent::BroadcastChannelUpdate { ref msg } => msg.clone(), _ => panic!("Unexpected event"), }; match events_1[0] { - MessageSendEvent::HandleError { node_id, action: msgs::ErrorAction::SendErrorMessage { ref msg } } => { + MessageSendEvent::HandleError { + node_id, + action: msgs::ErrorAction::SendErrorMessage { ref msg }, + } => { assert_eq!(node_id, nodes[b].node.get_our_node_id()); assert_eq!(msg.data, expected_error); if needs_err_handle { nodes[b].node.handle_error(nodes[a].node.get_our_node_id(), msg); } }, - MessageSendEvent::HandleError { node_id, action: msgs::ErrorAction::DisconnectPeer { ref msg } } => { + MessageSendEvent::HandleError { + node_id, + action: msgs::ErrorAction::DisconnectPeer { ref msg }, + } => { assert_eq!(node_id, nodes[b].node.get_our_node_id()); assert_eq!(msg.as_ref().unwrap().data, expected_error); if needs_err_handle { @@ -3656,18 +4729,22 @@ pub fn handle_announce_close_broadcast_events<'a, 'b, 'c>(nodes: &Vec { - msg.clone() - }, + MessageSendEvent::BroadcastChannelUpdate { ref msg } => msg.clone(), _ => panic!("Unexpected event"), }; if !needs_err_handle { match events_2[0] { - MessageSendEvent::HandleError { node_id, action: msgs::ErrorAction::SendErrorMessage { ref msg } } => { + MessageSendEvent::HandleError { + node_id, + action: msgs::ErrorAction::SendErrorMessage { ref msg }, + } => { assert_eq!(node_id, nodes[a].node.get_our_node_id()); assert_eq!(msg.data, expected_error); }, - MessageSendEvent::HandleError { node_id, action: msgs::ErrorAction::DisconnectPeer { ref msg } } => { + MessageSendEvent::HandleError { + node_id, + action: msgs::ErrorAction::DisconnectPeer { ref msg }, + } => { assert_eq!(node_id, nodes[a].node.get_our_node_id()); assert_eq!(msg.as_ref().unwrap().data, expected_error); }, @@ -3684,48 +4761,63 @@ pub fn handle_announce_close_broadcast_events<'a, 'b, 'c>(nodes: &Vec(nodes: &Vec>, a: usize, b: usize) { - handle_announce_close_broadcast_events(nodes, a, b, false, "Channel closed because commitment or closing transaction was confirmed on chain."); +pub fn get_announce_close_broadcast_events<'a, 'b, 'c>( + nodes: &Vec>, a: usize, b: usize, +) { + handle_announce_close_broadcast_events( + nodes, + a, + b, + false, + "Channel closed because commitment or closing transaction was confirmed on chain.", + ); } #[cfg(any(test, feature = "_externalize_tests"))] macro_rules! get_channel_value_stat { ($node: expr, $counterparty_node: expr, $channel_id: expr) => {{ let peer_state_lock = $node.node.per_peer_state.read().unwrap(); - let chan_lock = peer_state_lock.get(&$counterparty_node.node.get_our_node_id()).unwrap().lock().unwrap(); + let chan_lock = peer_state_lock + .get(&$counterparty_node.node.get_our_node_id()) + .unwrap() + .lock() + .unwrap(); let chan = chan_lock.channel_by_id.get(&$channel_id).and_then(Channel::as_funded).unwrap(); chan.get_value_stat() - }} + }}; } macro_rules! get_chan_reestablish_msgs { - ($src_node: expr, $dst_node: expr) => { - { - let mut announcements = $crate::prelude::new_hash_set(); - let mut res = Vec::with_capacity(1); - for msg in $src_node.node.get_and_clear_pending_msg_events() { - if let MessageSendEvent::SendChannelReestablish { ref node_id, ref msg } = msg { - assert_eq!(*node_id, $dst_node.node.get_our_node_id()); - res.push(msg.clone()); - } else if let MessageSendEvent::SendChannelAnnouncement { ref node_id, ref msg, .. } = msg { - assert_eq!(*node_id, $dst_node.node.get_our_node_id()); - announcements.insert(msg.contents.short_channel_id); - } else { - panic!("Unexpected event") - } + ($src_node: expr, $dst_node: expr) => {{ + let mut announcements = $crate::prelude::new_hash_set(); + let mut res = Vec::with_capacity(1); + for msg in $src_node.node.get_and_clear_pending_msg_events() { + if let MessageSendEvent::SendChannelReestablish { ref node_id, ref msg } = msg { + assert_eq!(*node_id, $dst_node.node.get_our_node_id()); + res.push(msg.clone()); + } else if let MessageSendEvent::SendChannelAnnouncement { + ref node_id, ref msg, .. + } = msg + { + assert_eq!(*node_id, $dst_node.node.get_our_node_id()); + announcements.insert(msg.contents.short_channel_id); + } else { + panic!("Unexpected event") } - assert!(announcements.is_empty()); - res } - } + assert!(announcements.is_empty()); + res + }}; } macro_rules! handle_chan_reestablish_msgs { - ($src_node: expr, $dst_node: expr) => { - { - let msg_events = $src_node.node.get_and_clear_pending_msg_events(); - let mut idx = 0; - let channel_ready = if let Some(&MessageSendEvent::SendChannelReady { ref node_id, ref msg }) = msg_events.get(0) { + ($src_node: expr, $dst_node: expr) => {{ + let msg_events = $src_node.node.get_and_clear_pending_msg_events(); + let mut idx = 0; + let channel_ready = + if let Some(&MessageSendEvent::SendChannelReady { ref node_id, ref msg }) = + msg_events.get(0) + { idx += 1; assert_eq!(*node_id, $dst_node.node.get_our_node_id()); Some(msg.clone()) @@ -3733,71 +4825,80 @@ macro_rules! handle_chan_reestablish_msgs { None }; - if let Some(&MessageSendEvent::SendAnnouncementSignatures { ref node_id, msg: _ }) = msg_events.get(idx) { - idx += 1; - assert_eq!(*node_id, $dst_node.node.get_our_node_id()); - } - - let mut had_channel_update = false; // ChannelUpdate may be now or later, but not both - if let Some(&MessageSendEvent::SendChannelUpdate { ref node_id, .. }) = msg_events.get(idx) { - assert_eq!(*node_id, $dst_node.node.get_our_node_id()); - idx += 1; - had_channel_update = true; - } + if let Some(&MessageSendEvent::SendAnnouncementSignatures { ref node_id, msg: _ }) = + msg_events.get(idx) + { + idx += 1; + assert_eq!(*node_id, $dst_node.node.get_our_node_id()); + } - let mut revoke_and_ack = None; - let mut commitment_update = None; - let order = if let Some(ev) = msg_events.get(idx) { - match ev { - &MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => { - assert_eq!(*node_id, $dst_node.node.get_our_node_id()); - revoke_and_ack = Some(msg.clone()); - idx += 1; - RAACommitmentOrder::RevokeAndACKFirst - }, - &MessageSendEvent::UpdateHTLCs { ref node_id, ref channel_id, ref updates } => { - assert_eq!(*node_id, $dst_node.node.get_our_node_id()); - assert!(updates.commitment_signed.iter().all(|cs| cs.channel_id == *channel_id)); - commitment_update = Some(updates.clone()); - idx += 1; - RAACommitmentOrder::CommitmentFirst - }, - _ => RAACommitmentOrder::CommitmentFirst, - } - } else { - RAACommitmentOrder::CommitmentFirst - }; + let mut had_channel_update = false; // ChannelUpdate may be now or later, but not both + if let Some(&MessageSendEvent::SendChannelUpdate { ref node_id, .. }) = msg_events.get(idx) + { + assert_eq!(*node_id, $dst_node.node.get_our_node_id()); + idx += 1; + had_channel_update = true; + } - if let Some(ev) = msg_events.get(idx) { - match ev { - &MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => { - assert_eq!(*node_id, $dst_node.node.get_our_node_id()); - assert!(revoke_and_ack.is_none()); - revoke_and_ack = Some(msg.clone()); - idx += 1; - }, - &MessageSendEvent::UpdateHTLCs { ref node_id, ref channel_id, ref updates } => { - assert_eq!(*node_id, $dst_node.node.get_our_node_id()); - assert!(commitment_update.is_none()); - assert!(updates.commitment_signed.iter().all(|cs| cs.channel_id == *channel_id)); - commitment_update = Some(updates.clone()); - idx += 1; - }, - _ => {}, - } + let mut revoke_and_ack = None; + let mut commitment_update = None; + let order = if let Some(ev) = msg_events.get(idx) { + match ev { + &MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => { + assert_eq!(*node_id, $dst_node.node.get_our_node_id()); + revoke_and_ack = Some(msg.clone()); + idx += 1; + RAACommitmentOrder::RevokeAndACKFirst + }, + &MessageSendEvent::UpdateHTLCs { ref node_id, ref channel_id, ref updates } => { + assert_eq!(*node_id, $dst_node.node.get_our_node_id()); + assert!(updates + .commitment_signed + .iter() + .all(|cs| cs.channel_id == *channel_id)); + commitment_update = Some(updates.clone()); + idx += 1; + RAACommitmentOrder::CommitmentFirst + }, + _ => RAACommitmentOrder::CommitmentFirst, } + } else { + RAACommitmentOrder::CommitmentFirst + }; - if let Some(&MessageSendEvent::SendChannelUpdate { ref node_id, .. }) = msg_events.get(idx) { - assert_eq!(*node_id, $dst_node.node.get_our_node_id()); - idx += 1; - assert!(!had_channel_update); + if let Some(ev) = msg_events.get(idx) { + match ev { + &MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => { + assert_eq!(*node_id, $dst_node.node.get_our_node_id()); + assert!(revoke_and_ack.is_none()); + revoke_and_ack = Some(msg.clone()); + idx += 1; + }, + &MessageSendEvent::UpdateHTLCs { ref node_id, ref channel_id, ref updates } => { + assert_eq!(*node_id, $dst_node.node.get_our_node_id()); + assert!(commitment_update.is_none()); + assert!(updates + .commitment_signed + .iter() + .all(|cs| cs.channel_id == *channel_id)); + commitment_update = Some(updates.clone()); + idx += 1; + }, + _ => {}, } + } - assert_eq!(msg_events.len(), idx); - - (channel_ready, revoke_and_ack, commitment_update, order) + if let Some(&MessageSendEvent::SendChannelUpdate { ref node_id, .. }) = msg_events.get(idx) + { + assert_eq!(*node_id, $dst_node.node.get_our_node_id()); + idx += 1; + assert!(!had_channel_update); } - } + + assert_eq!(msg_events.len(), idx); + + (channel_ready, revoke_and_ack, commitment_update, order) + }}; } pub struct ReconnectArgs<'a, 'b, 'c, 'd> { @@ -3838,9 +4939,17 @@ impl<'a, 'b, 'c, 'd> ReconnectArgs<'a, 'b, 'c, 'd> { /// for claims/fails they are separated out. pub fn reconnect_nodes<'a, 'b, 'c, 'd>(args: ReconnectArgs<'a, 'b, 'c, 'd>) { let ReconnectArgs { - node_a, node_b, send_channel_ready, pending_htlc_adds, pending_htlc_claims, pending_htlc_fails, - pending_cell_htlc_claims, pending_cell_htlc_fails, pending_raa, - pending_responding_commitment_signed, pending_responding_commitment_signed_dup_monitor, + node_a, + node_b, + send_channel_ready, + pending_htlc_adds, + pending_htlc_claims, + pending_htlc_fails, + pending_cell_htlc_claims, + pending_cell_htlc_fails, + pending_raa, + pending_responding_commitment_signed, + pending_responding_commitment_signed_dup_monitor, } = args; connect_nodes(node_a, node_b); let reestablish_1 = get_chan_reestablish_msgs!(node_a, node_b); @@ -3898,10 +5007,18 @@ pub fn reconnect_nodes<'a, 'b, 'c, 'd>(args: ReconnectArgs<'a, 'b, 'c, 'd>) { } // We don't yet support both needing updates, as that would require a different commitment dance: - assert!((pending_htlc_adds.0 == 0 && pending_htlc_claims.0 == 0 && pending_htlc_fails.0 == 0 && - pending_cell_htlc_claims.0 == 0 && pending_cell_htlc_fails.0 == 0) || - (pending_htlc_adds.1 == 0 && pending_htlc_claims.1 == 0 && pending_htlc_fails.1 == 0 && - pending_cell_htlc_claims.1 == 0 && pending_cell_htlc_fails.1 == 0)); + assert!( + (pending_htlc_adds.0 == 0 + && pending_htlc_claims.0 == 0 + && pending_htlc_fails.0 == 0 + && pending_cell_htlc_claims.0 == 0 + && pending_cell_htlc_fails.0 == 0) + || (pending_htlc_adds.1 == 0 + && pending_htlc_claims.1 == 0 + && pending_htlc_fails.1 == 0 + && pending_cell_htlc_claims.1 == 0 + && pending_cell_htlc_fails.1 == 0) + ); for chan_msgs in resp_1.drain(..) { if send_channel_ready.0 { @@ -3911,7 +5028,9 @@ pub fn reconnect_nodes<'a, 'b, 'c, 'd>(args: ReconnectArgs<'a, 'b, 'c, 'd>) { assert_eq!(announcement_event.len(), 1); if let MessageSendEvent::SendChannelUpdate { .. } = announcement_event[0] { //TODO: Test announcement_sigs re-sending - } else { panic!("Unexpected event! {:?}", announcement_event[0]); } + } else { + panic!("Unexpected event! {:?}", announcement_event[0]); + } } } else { assert!(chan_msgs.0.is_none()); @@ -3924,35 +5043,63 @@ pub fn reconnect_nodes<'a, 'b, 'c, 'd>(args: ReconnectArgs<'a, 'b, 'c, 'd>) { } else { assert!(chan_msgs.1.is_none()); } - if pending_htlc_adds.0 != 0 || pending_htlc_claims.0 != 0 || pending_htlc_fails.0 != 0 || - pending_cell_htlc_claims.0 != 0 || pending_cell_htlc_fails.0 != 0 || - pending_responding_commitment_signed.0 + if pending_htlc_adds.0 != 0 + || pending_htlc_claims.0 != 0 + || pending_htlc_fails.0 != 0 + || pending_cell_htlc_claims.0 != 0 + || pending_cell_htlc_fails.0 != 0 + || pending_responding_commitment_signed.0 { let commitment_update = chan_msgs.2.unwrap(); assert_eq!(commitment_update.update_add_htlcs.len(), pending_htlc_adds.0); - assert_eq!(commitment_update.update_fulfill_htlcs.len(), pending_htlc_claims.0 + pending_cell_htlc_claims.0); - assert_eq!(commitment_update.update_fail_htlcs.len(), pending_htlc_fails.0 + pending_cell_htlc_fails.0); + assert_eq!( + commitment_update.update_fulfill_htlcs.len(), + pending_htlc_claims.0 + pending_cell_htlc_claims.0 + ); + assert_eq!( + commitment_update.update_fail_htlcs.len(), + pending_htlc_fails.0 + pending_cell_htlc_fails.0 + ); assert!(commitment_update.update_fail_malformed_htlcs.is_empty()); for update_add in commitment_update.update_add_htlcs { node_a.node.handle_update_add_htlc(node_b.node.get_our_node_id(), &update_add); } for update_fulfill in commitment_update.update_fulfill_htlcs { - node_a.node.handle_update_fulfill_htlc(node_b.node.get_our_node_id(), &update_fulfill); + node_a + .node + .handle_update_fulfill_htlc(node_b.node.get_our_node_id(), &update_fulfill); } for update_fail in commitment_update.update_fail_htlcs { node_a.node.handle_update_fail_htlc(node_b.node.get_our_node_id(), &update_fail); } if !pending_responding_commitment_signed.0 { - commitment_signed_dance!(node_a, node_b, commitment_update.commitment_signed, false); + commitment_signed_dance!( + node_a, + node_b, + commitment_update.commitment_signed, + false + ); } else { - node_a.node.handle_commitment_signed_batch_test(node_b.node.get_our_node_id(), &commitment_update.commitment_signed); + node_a.node.handle_commitment_signed_batch_test( + node_b.node.get_our_node_id(), + &commitment_update.commitment_signed, + ); check_added_monitors!(node_a, 1); - let as_revoke_and_ack = get_event_msg!(node_a, MessageSendEvent::SendRevokeAndACK, node_b.node.get_our_node_id()); + let as_revoke_and_ack = get_event_msg!( + node_a, + MessageSendEvent::SendRevokeAndACK, + node_b.node.get_our_node_id() + ); // No commitment_signed so get_event_msg's assert(len == 1) passes - node_b.node.handle_revoke_and_ack(node_a.node.get_our_node_id(), &as_revoke_and_ack); + node_b + .node + .handle_revoke_and_ack(node_a.node.get_our_node_id(), &as_revoke_and_ack); assert!(node_b.node.get_and_clear_pending_msg_events().is_empty()); - check_added_monitors!(node_b, if pending_responding_commitment_signed_dup_monitor.0 { 0 } else { 1 }); + check_added_monitors!( + node_b, + if pending_responding_commitment_signed_dup_monitor.0 { 0 } else { 1 } + ); } } else { assert!(chan_msgs.2.is_none()); @@ -3982,35 +5129,63 @@ pub fn reconnect_nodes<'a, 'b, 'c, 'd>(args: ReconnectArgs<'a, 'b, 'c, 'd>) { } else { assert!(chan_msgs.1.is_none()); } - if pending_htlc_adds.1 != 0 || pending_htlc_claims.1 != 0 || pending_htlc_fails.1 != 0 || - pending_cell_htlc_claims.1 != 0 || pending_cell_htlc_fails.1 != 0 || - pending_responding_commitment_signed.1 + if pending_htlc_adds.1 != 0 + || pending_htlc_claims.1 != 0 + || pending_htlc_fails.1 != 0 + || pending_cell_htlc_claims.1 != 0 + || pending_cell_htlc_fails.1 != 0 + || pending_responding_commitment_signed.1 { let commitment_update = chan_msgs.2.unwrap(); assert_eq!(commitment_update.update_add_htlcs.len(), pending_htlc_adds.1); - assert_eq!(commitment_update.update_fulfill_htlcs.len(), pending_htlc_claims.1 + pending_cell_htlc_claims.1); - assert_eq!(commitment_update.update_fail_htlcs.len(), pending_htlc_fails.1 + pending_cell_htlc_fails.1); + assert_eq!( + commitment_update.update_fulfill_htlcs.len(), + pending_htlc_claims.1 + pending_cell_htlc_claims.1 + ); + assert_eq!( + commitment_update.update_fail_htlcs.len(), + pending_htlc_fails.1 + pending_cell_htlc_fails.1 + ); assert!(commitment_update.update_fail_malformed_htlcs.is_empty()); for update_add in commitment_update.update_add_htlcs { node_b.node.handle_update_add_htlc(node_a.node.get_our_node_id(), &update_add); } for update_fulfill in commitment_update.update_fulfill_htlcs { - node_b.node.handle_update_fulfill_htlc(node_a.node.get_our_node_id(), &update_fulfill); + node_b + .node + .handle_update_fulfill_htlc(node_a.node.get_our_node_id(), &update_fulfill); } for update_fail in commitment_update.update_fail_htlcs { node_b.node.handle_update_fail_htlc(node_a.node.get_our_node_id(), &update_fail); } if !pending_responding_commitment_signed.1 { - commitment_signed_dance!(node_b, node_a, commitment_update.commitment_signed, false); + commitment_signed_dance!( + node_b, + node_a, + commitment_update.commitment_signed, + false + ); } else { - node_b.node.handle_commitment_signed_batch_test(node_a.node.get_our_node_id(), &commitment_update.commitment_signed); + node_b.node.handle_commitment_signed_batch_test( + node_a.node.get_our_node_id(), + &commitment_update.commitment_signed, + ); check_added_monitors!(node_b, 1); - let bs_revoke_and_ack = get_event_msg!(node_b, MessageSendEvent::SendRevokeAndACK, node_a.node.get_our_node_id()); + let bs_revoke_and_ack = get_event_msg!( + node_b, + MessageSendEvent::SendRevokeAndACK, + node_a.node.get_our_node_id() + ); // No commitment_signed so get_event_msg's assert(len == 1) passes - node_a.node.handle_revoke_and_ack(node_b.node.get_our_node_id(), &bs_revoke_and_ack); + node_a + .node + .handle_revoke_and_ack(node_b.node.get_our_node_id(), &bs_revoke_and_ack); assert!(node_a.node.get_and_clear_pending_msg_events().is_empty()); - check_added_monitors!(node_a, if pending_responding_commitment_signed_dup_monitor.1 { 0 } else { 1 }); + check_added_monitors!( + node_a, + if pending_responding_commitment_signed_dup_monitor.1 { 0 } else { 1 } + ); } } else { assert!(chan_msgs.2.is_none()); @@ -4029,17 +5204,34 @@ pub fn create_batch_channel_funding<'a, 'b, 'c>( let mut temp_chan_ids = Vec::new(); let mut funding_created_msgs = Vec::new(); - for (other_node, channel_value_satoshis, push_msat, user_channel_id, override_config) in params { + for (other_node, channel_value_satoshis, push_msat, user_channel_id, override_config) in params + { // Initialize channel opening. - let temp_chan_id = funding_node.node.create_channel( - other_node.node.get_our_node_id(), *channel_value_satoshis, *push_msat, *user_channel_id, - None, - override_config.clone(), - ).unwrap(); - let open_channel_msg = get_event_msg!(funding_node, MessageSendEvent::SendOpenChannel, other_node.node.get_our_node_id()); + let temp_chan_id = funding_node + .node + .create_channel( + other_node.node.get_our_node_id(), + *channel_value_satoshis, + *push_msat, + *user_channel_id, + None, + override_config.clone(), + ) + .unwrap(); + let open_channel_msg = get_event_msg!( + funding_node, + MessageSendEvent::SendOpenChannel, + other_node.node.get_our_node_id() + ); other_node.node.handle_open_channel(funding_node.node.get_our_node_id(), &open_channel_msg); - let accept_channel_msg = get_event_msg!(other_node, MessageSendEvent::SendAcceptChannel, funding_node.node.get_our_node_id()); - funding_node.node.handle_accept_channel(other_node.node.get_our_node_id(), &accept_channel_msg); + let accept_channel_msg = get_event_msg!( + other_node, + MessageSendEvent::SendAcceptChannel, + funding_node.node.get_our_node_id() + ); + funding_node + .node + .handle_accept_channel(other_node.node.get_our_node_id(), &accept_channel_msg); // Create the corresponding funding output. let events = funding_node.node.get_and_clear_pending_events(); @@ -4050,14 +5242,15 @@ pub fn create_batch_channel_funding<'a, 'b, 'c>( ref counterparty_node_id, channel_value_satoshis: ref event_channel_value_satoshis, ref output_script, - user_channel_id: ref event_user_channel_id + user_channel_id: ref event_user_channel_id, } => { assert_eq!(temporary_channel_id, &temp_chan_id); assert_eq!(counterparty_node_id, &other_node.node.get_our_node_id()); assert_eq!(channel_value_satoshis, event_channel_value_satoshis); assert_eq!(user_channel_id, event_user_channel_id); tx_outs.push(TxOut { - value: Amount::from_sat(*channel_value_satoshis), script_pubkey: output_script.clone(), + value: Amount::from_sat(*channel_value_satoshis), + script_pubkey: output_script.clone(), }); }, _ => panic!("Unexpected event"), @@ -4072,10 +5265,13 @@ pub fn create_batch_channel_funding<'a, 'b, 'c>( input: Vec::new(), output: tx_outs, }; - assert!(funding_node.node.batch_funding_transaction_generated( - temp_chan_ids.iter().map(|(a, b)| (a, b)).collect::>().as_slice(), - tx.clone(), - ).is_ok()); + assert!(funding_node + .node + .batch_funding_transaction_generated( + temp_chan_ids.iter().map(|(a, b)| (a, b)).collect::>().as_slice(), + tx.clone(), + ) + .is_ok()); check_added_monitors!(funding_node, 0); let events = funding_node.node.get_and_clear_pending_msg_events(); assert_eq!(events.len(), params.len()); @@ -4083,7 +5279,11 @@ pub fn create_batch_channel_funding<'a, 'b, 'c>( let funding_created = events .iter() .find_map(|event| match event { - MessageSendEvent::SendFundingCreated { node_id, msg } if node_id == &other_node.node.get_our_node_id() => Some(msg.clone()), + MessageSendEvent::SendFundingCreated { node_id, msg } + if node_id == &other_node.node.get_our_node_id() => + { + Some(msg.clone()) + }, _ => None, }) .unwrap(); diff --git a/lightning/src/ln/priv_short_conf_tests.rs b/lightning/src/ln/priv_short_conf_tests.rs index 8da1f98c6a9..96a3ee77dcf 100644 --- a/lightning/src/ln/priv_short_conf_tests.rs +++ b/lightning/src/ln/priv_short_conf_tests.rs @@ -1,5 +1,3 @@ -#![cfg_attr(rustfmt, rustfmt_skip)] - // This file is Copyright its original authors, visible in version control // history. // @@ -15,14 +13,16 @@ use crate::chain::ChannelMonitorUpdateStatus; use crate::events::{ClosureReason, Event, HTLCHandlingFailureType}; -use crate::ln::channelmanager::{MIN_CLTV_EXPIRY_DELTA, PaymentId, RecipientOnionFields}; +use crate::ln::channelmanager::{PaymentId, RecipientOnionFields, MIN_CLTV_EXPIRY_DELTA}; +use crate::ln::msgs; +use crate::ln::msgs::{ + BaseMessageHandler, ChannelMessageHandler, ErrorAction, MessageSendEvent, RoutingMessageHandler, +}; use crate::ln::onion_utils::LocalHTLCFailureReason; +use crate::ln::types::ChannelId; use crate::routing::gossip::RoutingFees; use crate::routing::router::{PaymentParameters, RouteHint, RouteHintHop}; use crate::types::features::ChannelTypeFeatures; -use crate::ln::msgs; -use crate::ln::types::ChannelId; -use crate::ln::msgs::{BaseMessageHandler, ChannelMessageHandler, RoutingMessageHandler, ErrorAction, MessageSendEvent}; use crate::util::config::{MaxDustHTLCExposure, UserConfig}; use crate::util::ser::Writeable; @@ -41,12 +41,20 @@ fn test_priv_forwarding_rejection() { no_announce_cfg.accept_forwards_to_priv_channels = false; let persister; let new_chain_monitor; - let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, Some(no_announce_cfg.clone()), None]); + let node_chanmgrs = + create_node_chanmgrs(3, &node_cfgs, &[None, Some(no_announce_cfg.clone()), None]); let nodes_1_deserialized; let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); + let node_c_id = nodes[2].node.get_our_node_id(); - let chan_id_1 = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 500_000_000).2; - let chan_id_2 = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 500_000_000).0.channel_id; + let chan_id_1 = + create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 500_000_000).2; + let chan_id_2 = + create_unannounced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 500_000_000) + .0 + .channel_id; // We should always be able to forward through nodes[1] as long as its out through a public // channel: @@ -55,7 +63,7 @@ fn test_priv_forwarding_rejection() { // ... however, if we send to nodes[2], we will have to pass the private channel from nodes[1] // to nodes[2], which should be rejected: let route_hint = RouteHint(vec![RouteHintHop { - src_node_id: nodes[1].node.get_our_node_id(), + src_node_id: node_b_id, short_channel_id: nodes[2].node.list_channels()[0].short_channel_id.unwrap(), fees: RoutingFees { base_msat: 1000, proportional_millionths: 0 }, cltv_expiry_delta: MIN_CLTV_EXPIRY_DELTA, @@ -63,77 +71,151 @@ fn test_priv_forwarding_rejection() { htlc_maximum_msat: None, }]); let last_hops = vec![route_hint]; - let payment_params = PaymentParameters::from_node_id(nodes[2].node.get_our_node_id(), TEST_FINAL_CLTV) - .with_bolt11_features(nodes[2].node.bolt11_invoice_features()).unwrap() - .with_route_hints(last_hops).unwrap(); - let (route, our_payment_hash, our_payment_preimage, our_payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[2], payment_params, 10_000); - - nodes[0].node.send_payment_with_route(route.clone(), our_payment_hash, - RecipientOnionFields::secret_only(our_payment_secret), PaymentId(our_payment_hash.0)).unwrap(); + let payment_params = PaymentParameters::from_node_id(node_c_id, TEST_FINAL_CLTV) + .with_bolt11_features(nodes[2].node.bolt11_invoice_features()) + .unwrap() + .with_route_hints(last_hops) + .unwrap(); + let (route, our_payment_hash, our_payment_preimage, our_payment_secret) = + get_route_and_payment_hash!(nodes[0], nodes[2], payment_params, 10_000); + + nodes[0] + .node + .send_payment_with_route( + route.clone(), + our_payment_hash, + RecipientOnionFields::secret_only(our_payment_secret), + PaymentId(our_payment_hash.0), + ) + .unwrap(); check_added_monitors!(nodes[0], 1); - let payment_event = SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0)); - nodes[1].node.handle_update_add_htlc(nodes[0].node.get_our_node_id(), &payment_event.msgs[0]); + let payment_event = + SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0)); + nodes[1].node.handle_update_add_htlc(node_a_id, &payment_event.msgs[0]); commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false, true); expect_pending_htlcs_forwardable!(nodes[1]); expect_htlc_handling_failed_destinations!( nodes[1].node.get_and_clear_pending_events(), - &[HTLCHandlingFailureType::Forward { node_id: Some(nodes[2].node.get_our_node_id()), channel_id: chan_id_2 }] + &[HTLCHandlingFailureType::Forward { node_id: Some(node_c_id), channel_id: chan_id_2 }] ); check_added_monitors(&nodes[1], 1); - let htlc_fail_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); + let htlc_fail_updates = get_htlc_update_msgs!(nodes[1], node_a_id); assert!(htlc_fail_updates.update_add_htlcs.is_empty()); assert_eq!(htlc_fail_updates.update_fail_htlcs.len(), 1); assert!(htlc_fail_updates.update_fail_malformed_htlcs.is_empty()); assert!(htlc_fail_updates.update_fee.is_none()); - nodes[0].node.handle_update_fail_htlc(nodes[1].node.get_our_node_id(), &htlc_fail_updates.update_fail_htlcs[0]); + nodes[0].node.handle_update_fail_htlc(node_b_id, &htlc_fail_updates.update_fail_htlcs[0]); commitment_signed_dance!(nodes[0], nodes[1], htlc_fail_updates.commitment_signed, true, true); - expect_payment_failed_with_update!(nodes[0], our_payment_hash, false, nodes[2].node.list_channels()[0].short_channel_id.unwrap(), true); + expect_payment_failed_with_update!( + nodes[0], + our_payment_hash, + false, + nodes[2].node.list_channels()[0].short_channel_id.unwrap(), + true + ); // Now disconnect nodes[1] from its peers and restart with accept_forwards_to_priv_channels set // to true. Sadly there is currently no way to change it at runtime. - nodes[0].node.peer_disconnected(nodes[1].node.get_our_node_id()); - nodes[2].node.peer_disconnected(nodes[1].node.get_our_node_id()); + nodes[0].node.peer_disconnected(node_b_id); + nodes[2].node.peer_disconnected(node_b_id); let nodes_1_serialized = nodes[1].node.encode(); let monitor_a_serialized = get_monitor!(nodes[1], chan_id_1).encode(); let monitor_b_serialized = get_monitor!(nodes[1], chan_id_2).encode(); no_announce_cfg.accept_forwards_to_priv_channels = true; - reload_node!(nodes[1], no_announce_cfg, &nodes_1_serialized, &[&monitor_a_serialized, &monitor_b_serialized], persister, new_chain_monitor, nodes_1_deserialized); - - nodes[0].node.peer_connected(nodes[1].node.get_our_node_id(), &msgs::Init { - features: nodes[1].node.init_features(), networks: None, remote_network_address: None - }, true).unwrap(); - nodes[1].node.peer_connected(nodes[0].node.get_our_node_id(), &msgs::Init { - features: nodes[0].node.init_features(), networks: None, remote_network_address: None - }, false).unwrap(); + reload_node!( + nodes[1], + no_announce_cfg, + &nodes_1_serialized, + &[&monitor_a_serialized, &monitor_b_serialized], + persister, + new_chain_monitor, + nodes_1_deserialized + ); + + nodes[0] + .node + .peer_connected( + node_b_id, + &msgs::Init { + features: nodes[1].node.init_features(), + networks: None, + remote_network_address: None, + }, + true, + ) + .unwrap(); + nodes[1] + .node + .peer_connected( + node_a_id, + &msgs::Init { + features: nodes[0].node.init_features(), + networks: None, + remote_network_address: None, + }, + false, + ) + .unwrap(); let as_reestablish = get_chan_reestablish_msgs!(nodes[0], nodes[1]).pop().unwrap(); let bs_reestablish = get_chan_reestablish_msgs!(nodes[1], nodes[0]).pop().unwrap(); - nodes[1].node.handle_channel_reestablish(nodes[0].node.get_our_node_id(), &as_reestablish); - nodes[0].node.handle_channel_reestablish(nodes[1].node.get_our_node_id(), &bs_reestablish); - get_event_msg!(nodes[0], MessageSendEvent::SendChannelUpdate, nodes[1].node.get_our_node_id()); - get_event_msg!(nodes[1], MessageSendEvent::SendChannelUpdate, nodes[0].node.get_our_node_id()); - - nodes[1].node.peer_connected(nodes[2].node.get_our_node_id(), &msgs::Init { - features: nodes[2].node.init_features(), networks: None, remote_network_address: None - }, true).unwrap(); - nodes[2].node.peer_connected(nodes[1].node.get_our_node_id(), &msgs::Init { - features: nodes[1].node.init_features(), networks: None, remote_network_address: None - }, false).unwrap(); + nodes[1].node.handle_channel_reestablish(node_a_id, &as_reestablish); + nodes[0].node.handle_channel_reestablish(node_b_id, &bs_reestablish); + get_event_msg!(nodes[0], MessageSendEvent::SendChannelUpdate, node_b_id); + get_event_msg!(nodes[1], MessageSendEvent::SendChannelUpdate, node_a_id); + + nodes[1] + .node + .peer_connected( + node_c_id, + &msgs::Init { + features: nodes[2].node.init_features(), + networks: None, + remote_network_address: None, + }, + true, + ) + .unwrap(); + nodes[2] + .node + .peer_connected( + node_b_id, + &msgs::Init { + features: nodes[1].node.init_features(), + networks: None, + remote_network_address: None, + }, + false, + ) + .unwrap(); let bs_reestablish = get_chan_reestablish_msgs!(nodes[1], nodes[2]).pop().unwrap(); let cs_reestablish = get_chan_reestablish_msgs!(nodes[2], nodes[1]).pop().unwrap(); - nodes[2].node.handle_channel_reestablish(nodes[1].node.get_our_node_id(), &bs_reestablish); - nodes[1].node.handle_channel_reestablish(nodes[2].node.get_our_node_id(), &cs_reestablish); - get_event_msg!(nodes[1], MessageSendEvent::SendChannelUpdate, nodes[2].node.get_our_node_id()); - get_event_msg!(nodes[2], MessageSendEvent::SendChannelUpdate, nodes[1].node.get_our_node_id()); - - nodes[0].node.send_payment_with_route(route, our_payment_hash, - RecipientOnionFields::secret_only(our_payment_secret), PaymentId(our_payment_hash.0)).unwrap(); + nodes[2].node.handle_channel_reestablish(node_b_id, &bs_reestablish); + nodes[1].node.handle_channel_reestablish(node_c_id, &cs_reestablish); + get_event_msg!(nodes[1], MessageSendEvent::SendChannelUpdate, node_c_id); + get_event_msg!(nodes[2], MessageSendEvent::SendChannelUpdate, node_b_id); + + nodes[0] + .node + .send_payment_with_route( + route, + our_payment_hash, + RecipientOnionFields::secret_only(our_payment_secret), + PaymentId(our_payment_hash.0), + ) + .unwrap(); check_added_monitors!(nodes[0], 1); - pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[2]]], 10_000, our_payment_hash, our_payment_secret); + pass_along_route( + &nodes[0], + &[&[&nodes[1], &nodes[2]]], + 10_000, + our_payment_hash, + our_payment_secret, + ); claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], our_payment_preimage); } @@ -144,42 +226,57 @@ fn do_test_1_conf_open(connect_style: ConnectStyle) { alice_config.channel_handshake_config.minimum_depth = 1; alice_config.channel_handshake_config.announce_for_forwarding = true; alice_config.channel_handshake_limits.force_announced_channel_preference = false; - alice_config.channel_config.max_dust_htlc_exposure = MaxDustHTLCExposure::FeeRateMultiplier(5_000_000 / 253); + alice_config.channel_config.max_dust_htlc_exposure = + MaxDustHTLCExposure::FeeRateMultiplier(5_000_000 / 253); let mut bob_config = UserConfig::default(); bob_config.channel_handshake_config.minimum_depth = 1; bob_config.channel_handshake_config.announce_for_forwarding = true; bob_config.channel_handshake_limits.force_announced_channel_preference = false; - bob_config.channel_config.max_dust_htlc_exposure = MaxDustHTLCExposure::FeeRateMultiplier(5_000_000 / 253); + bob_config.channel_config.max_dust_htlc_exposure = + MaxDustHTLCExposure::FeeRateMultiplier(5_000_000 / 253); let chanmon_cfgs = create_chanmon_cfgs(2); let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); - let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[Some(alice_config), Some(bob_config)]); + let node_chanmgrs = + create_node_chanmgrs(2, &node_cfgs, &[Some(alice_config), Some(bob_config)]); let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); *nodes[0].connect_style.borrow_mut() = connect_style; let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 100000, 10001); mine_transaction(&nodes[1], &tx); - nodes[0].node.handle_channel_ready(nodes[1].node.get_our_node_id(), &get_event_msg!(nodes[1], MessageSendEvent::SendChannelReady, nodes[0].node.get_our_node_id())); + nodes[0].node.handle_channel_ready( + node_b_id, + &get_event_msg!(nodes[1], MessageSendEvent::SendChannelReady, node_a_id), + ); assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); mine_transaction(&nodes[0], &tx); let as_msg_events = nodes[0].node.get_and_clear_pending_msg_events(); assert_eq!(as_msg_events.len(), 2); - let as_channel_ready = if let MessageSendEvent::SendChannelReady { ref node_id, ref msg } = as_msg_events[0] { - assert_eq!(*node_id, nodes[1].node.get_our_node_id()); - msg.clone() - } else { panic!("Unexpected event"); }; + let as_channel_ready = + if let MessageSendEvent::SendChannelReady { ref node_id, ref msg } = as_msg_events[0] { + assert_eq!(*node_id, node_b_id); + msg.clone() + } else { + panic!("Unexpected event"); + }; if let MessageSendEvent::SendChannelUpdate { ref node_id, msg: _ } = as_msg_events[1] { - assert_eq!(*node_id, nodes[1].node.get_our_node_id()); - } else { panic!("Unexpected event"); } + assert_eq!(*node_id, node_b_id); + } else { + panic!("Unexpected event"); + } - nodes[1].node.handle_channel_ready(nodes[0].node.get_our_node_id(), &as_channel_ready); - expect_channel_ready_event(&nodes[0], &nodes[1].node.get_our_node_id()); - expect_channel_ready_event(&nodes[1], &nodes[0].node.get_our_node_id()); + nodes[1].node.handle_channel_ready(node_a_id, &as_channel_ready); + expect_channel_ready_event(&nodes[0], &node_b_id); + expect_channel_ready_event(&nodes[1], &node_a_id); let bs_msg_events = nodes[1].node.get_and_clear_pending_msg_events(); assert_eq!(bs_msg_events.len(), 1); if let MessageSendEvent::SendChannelUpdate { ref node_id, msg: _ } = bs_msg_events[0] { - assert_eq!(*node_id, nodes[0].node.get_our_node_id()); - } else { panic!("Unexpected event"); } + assert_eq!(*node_id, node_a_id); + } else { + panic!("Unexpected event"); + } send_payment(&nodes[0], &[&nodes[1]], 100_000); @@ -188,31 +285,52 @@ fn do_test_1_conf_open(connect_style: ConnectStyle) { connect_blocks(&nodes[0], 4); assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); connect_blocks(&nodes[0], 1); - nodes[1].node.handle_announcement_signatures(nodes[0].node.get_our_node_id(), &get_event_msg!(nodes[0], MessageSendEvent::SendAnnouncementSignatures, nodes[1].node.get_our_node_id())); + nodes[1].node.handle_announcement_signatures( + node_a_id, + &get_event_msg!(nodes[0], MessageSendEvent::SendAnnouncementSignatures, node_b_id), + ); assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); connect_blocks(&nodes[1], 5); let bs_announce_events = nodes[1].node.get_and_clear_pending_msg_events(); assert_eq!(bs_announce_events.len(), 2); - let bs_announcement_sigs = if let MessageSendEvent::SendAnnouncementSignatures { ref node_id, ref msg } = bs_announce_events[1] { - assert_eq!(*node_id, nodes[0].node.get_our_node_id()); - msg.clone() - } else { panic!("Unexpected event"); }; - let (bs_announcement, bs_update) = if let MessageSendEvent::BroadcastChannelAnnouncement { ref msg, ref update_msg } = bs_announce_events[0] { - (msg.clone(), update_msg.clone().unwrap()) - } else { panic!("Unexpected event"); }; - - nodes[0].node.handle_announcement_signatures(nodes[1].node.get_our_node_id(), &bs_announcement_sigs); + let bs_announcement_sigs = + if let MessageSendEvent::SendAnnouncementSignatures { ref node_id, ref msg } = + bs_announce_events[1] + { + assert_eq!(*node_id, node_a_id); + msg.clone() + } else { + panic!("Unexpected event"); + }; + let (bs_announcement, bs_update) = + if let MessageSendEvent::BroadcastChannelAnnouncement { ref msg, ref update_msg } = + bs_announce_events[0] + { + (msg.clone(), update_msg.clone().unwrap()) + } else { + panic!("Unexpected event"); + }; + + nodes[0].node.handle_announcement_signatures(node_b_id, &bs_announcement_sigs); let as_announce_events = nodes[0].node.get_and_clear_pending_msg_events(); assert_eq!(as_announce_events.len(), 1); - let (announcement, as_update) = if let MessageSendEvent::BroadcastChannelAnnouncement { ref msg, ref update_msg } = as_announce_events[0] { - (msg.clone(), update_msg.clone().unwrap()) - } else { panic!("Unexpected event"); }; + let (announcement, as_update) = + if let MessageSendEvent::BroadcastChannelAnnouncement { ref msg, ref update_msg } = + as_announce_events[0] + { + (msg.clone(), update_msg.clone().unwrap()) + } else { + panic!("Unexpected event"); + }; assert_eq!(announcement, bs_announcement); for (i, node) in nodes.iter().enumerate() { let counterparty_node_id = nodes[(i + 1) % 2].node.get_our_node_id(); - assert!(node.gossip_sync.handle_channel_announcement(Some(counterparty_node_id), &announcement).unwrap()); + assert!(node + .gossip_sync + .handle_channel_announcement(Some(counterparty_node_id), &announcement) + .unwrap()); node.gossip_sync.handle_channel_update(Some(counterparty_node_id), &as_update).unwrap(); node.gossip_sync.handle_channel_update(Some(counterparty_node_id), &bs_update).unwrap(); } @@ -233,48 +351,71 @@ fn test_routed_scid_alias() { no_announce_cfg.accept_forwards_to_priv_channels = true; let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, Some(no_announce_cfg), None]); let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); + let node_b_id = nodes[1].node.get_our_node_id(); + let node_c_id = nodes[2].node.get_our_node_id(); create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 500_000_000); - let mut as_channel_ready = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 500_000_000).0; + let mut as_channel_ready = + create_unannounced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 500_000_000).0; let last_hop = nodes[2].node.list_usable_channels(); let hop_hints = vec![RouteHint(vec![RouteHintHop { - src_node_id: nodes[1].node.get_our_node_id(), + src_node_id: node_b_id, short_channel_id: last_hop[0].inbound_scid_alias.unwrap(), fees: RoutingFees { base_msat: last_hop[0].counterparty.forwarding_info.as_ref().unwrap().fee_base_msat, - proportional_millionths: last_hop[0].counterparty.forwarding_info.as_ref().unwrap().fee_proportional_millionths, + proportional_millionths: last_hop[0] + .counterparty + .forwarding_info + .as_ref() + .unwrap() + .fee_proportional_millionths, }, - cltv_expiry_delta: last_hop[0].counterparty.forwarding_info.as_ref().unwrap().cltv_expiry_delta, + cltv_expiry_delta: last_hop[0] + .counterparty + .forwarding_info + .as_ref() + .unwrap() + .cltv_expiry_delta, htlc_maximum_msat: None, htlc_minimum_msat: None, }])]; - let payment_params = PaymentParameters::from_node_id(nodes[2].node.get_our_node_id(), TEST_FINAL_CLTV) - .with_bolt11_features(nodes[2].node.bolt11_invoice_features()).unwrap() - .with_route_hints(hop_hints).unwrap(); - let (route, payment_hash, payment_preimage, payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[2], payment_params, 100_000); + let payment_params = PaymentParameters::from_node_id(node_c_id, TEST_FINAL_CLTV) + .with_bolt11_features(nodes[2].node.bolt11_invoice_features()) + .unwrap() + .with_route_hints(hop_hints) + .unwrap(); + let (route, payment_hash, payment_preimage, payment_secret) = + get_route_and_payment_hash!(nodes[0], nodes[2], payment_params, 100_000); assert_eq!(route.paths[0].hops[1].short_channel_id, last_hop[0].inbound_scid_alias.unwrap()); - nodes[0].node.send_payment_with_route(route, payment_hash, - RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_hash.0)).unwrap(); + nodes[0] + .node + .send_payment_with_route( + route, + payment_hash, + RecipientOnionFields::secret_only(payment_secret), + PaymentId(payment_hash.0), + ) + .unwrap(); check_added_monitors!(nodes[0], 1); pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[2]]], 100_000, payment_hash, payment_secret); as_channel_ready.short_channel_id_alias = Some(0xeadbeef); - nodes[2].node.handle_channel_ready(nodes[1].node.get_our_node_id(), &as_channel_ready); + nodes[2].node.handle_channel_ready(node_b_id, &as_channel_ready); // Note that we always respond to a channel_ready with a channel_update. Not a lot of reason // to bother updating that code, so just drop the message here. - get_event_msg!(nodes[2], MessageSendEvent::SendChannelUpdate, nodes[1].node.get_our_node_id()); + get_event_msg!(nodes[2], MessageSendEvent::SendChannelUpdate, node_b_id); claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage); // Now test that if a peer sends us a second channel_ready after the channel is operational we // will use the new alias. as_channel_ready.short_channel_id_alias = Some(0xdeadbeef); - nodes[2].node.handle_channel_ready(nodes[1].node.get_our_node_id(), &as_channel_ready); + nodes[2].node.handle_channel_ready(node_b_id, &as_channel_ready); // Note that we always respond to a channel_ready with a channel_update. Not a lot of reason // to bother updating that code, so just drop the message here. - get_event_msg!(nodes[2], MessageSendEvent::SendChannelUpdate, nodes[1].node.get_our_node_id()); + get_event_msg!(nodes[2], MessageSendEvent::SendChannelUpdate, node_b_id); let updated_channel_info = nodes[2].node.list_usable_channels(); assert_eq!(updated_channel_info.len(), 1); assert_eq!(updated_channel_info[0].inbound_scid_alias.unwrap(), 0xdeadbeef); @@ -290,19 +431,24 @@ fn test_scid_privacy_on_pub_channel() { let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); let mut scid_privacy_cfg = test_default_channel_config(); scid_privacy_cfg.channel_handshake_config.announce_for_forwarding = true; scid_privacy_cfg.channel_handshake_config.negotiate_scid_privacy = true; - nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None, Some(scid_privacy_cfg)).unwrap(); - let mut open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); + nodes[0] + .node + .create_channel(node_b_id, 100000, 10001, 42, None, Some(scid_privacy_cfg)) + .unwrap(); + let mut open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, node_b_id); assert!(!open_channel.common_fields.channel_type.as_ref().unwrap().supports_scid_privacy()); // we ignore `negotiate_scid_privacy` on pub channels open_channel.common_fields.channel_type.as_mut().unwrap().set_scid_privacy_required(); assert_eq!(open_channel.common_fields.channel_flags & 1, 1); // The `announce_channel` bit is set. - nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel); - let err = get_err_msg(&nodes[1], &nodes[0].node.get_our_node_id()); + nodes[1].node.handle_open_channel(node_a_id, &open_channel); + let err = get_err_msg(&nodes[1], &node_a_id); assert_eq!(err.data, "SCID Alias/Privacy Channel Type cannot be set on a public channel"); } @@ -314,28 +460,45 @@ fn test_scid_privacy_negotiation() { let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); let mut scid_privacy_cfg = test_default_channel_config(); scid_privacy_cfg.channel_handshake_config.announce_for_forwarding = false; scid_privacy_cfg.channel_handshake_config.negotiate_scid_privacy = true; - nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None, Some(scid_privacy_cfg)).unwrap(); + nodes[0] + .node + .create_channel(node_b_id, 100000, 10001, 42, None, Some(scid_privacy_cfg)) + .unwrap(); - let init_open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); + let init_open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, node_b_id); assert!(init_open_channel.common_fields.channel_type.as_ref().unwrap().supports_scid_privacy()); assert!(nodes[0].node.list_channels()[0].channel_type.is_none()); // channel_type is none until counterparty accepts // now simulate nodes[1] responding with an Error message, indicating it doesn't understand // SCID alias. - nodes[0].node.handle_error(nodes[1].node.get_our_node_id(), &msgs::ErrorMessage { - channel_id: init_open_channel.common_fields.temporary_channel_id, - data: "Yo, no SCID aliases, no privacy here!".to_string() - }); + nodes[0].node.handle_error( + node_b_id, + &msgs::ErrorMessage { + channel_id: init_open_channel.common_fields.temporary_channel_id, + data: "Yo, no SCID aliases, no privacy here!".to_string(), + }, + ); assert!(nodes[0].node.list_channels()[0].channel_type.is_none()); // channel_type is none until counterparty accepts - let second_open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); - assert!(!second_open_channel.common_fields.channel_type.as_ref().unwrap().supports_scid_privacy()); - nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &second_open_channel); - nodes[0].node.handle_accept_channel(nodes[1].node.get_our_node_id(), &get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id())); + let second_open_channel = + get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, node_b_id); + assert!(!second_open_channel + .common_fields + .channel_type + .as_ref() + .unwrap() + .supports_scid_privacy()); + nodes[1].node.handle_open_channel(node_a_id, &second_open_channel); + nodes[0].node.handle_accept_channel( + node_b_id, + &get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, node_a_id), + ); let events = nodes[0].node.get_and_clear_pending_events(); assert_eq!(events.len(), 1); @@ -344,8 +507,16 @@ fn test_scid_privacy_negotiation() { _ => panic!("Unexpected event"), } - assert!(!nodes[0].node.list_channels()[0].channel_type.as_ref().unwrap().supports_scid_privacy()); - assert!(!nodes[1].node.list_channels()[0].channel_type.as_ref().unwrap().supports_scid_privacy()); + assert!(!nodes[0].node.list_channels()[0] + .channel_type + .as_ref() + .unwrap() + .supports_scid_privacy()); + assert!(!nodes[1].node.list_channels()[0] + .channel_type + .as_ref() + .unwrap() + .supports_scid_privacy()); } #[test] @@ -356,72 +527,111 @@ fn test_inbound_scid_privacy() { let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); let mut accept_forward_cfg = test_default_channel_config(); accept_forward_cfg.accept_forwards_to_priv_channels = true; - let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, Some(accept_forward_cfg), None]); + let node_chanmgrs = + create_node_chanmgrs(3, &node_cfgs, &[None, Some(accept_forward_cfg), None]); let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); + let node_c_id = nodes[2].node.get_our_node_id(); create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0); let mut no_announce_cfg = test_default_channel_config(); no_announce_cfg.channel_handshake_config.announce_for_forwarding = false; no_announce_cfg.channel_handshake_config.negotiate_scid_privacy = true; - nodes[1].node.create_channel(nodes[2].node.get_our_node_id(), 100_000, 10_000, 42, None, Some(no_announce_cfg)).unwrap(); - let mut open_channel = get_event_msg!(nodes[1], MessageSendEvent::SendOpenChannel, nodes[2].node.get_our_node_id()); + nodes[1] + .node + .create_channel(node_c_id, 100_000, 10_000, 42, None, Some(no_announce_cfg)) + .unwrap(); + let mut open_channel = get_event_msg!(nodes[1], MessageSendEvent::SendOpenChannel, node_c_id); assert!(open_channel.common_fields.channel_type.as_ref().unwrap().requires_scid_privacy()); - nodes[2].node.handle_open_channel(nodes[1].node.get_our_node_id(), &open_channel); - let accept_channel = get_event_msg!(nodes[2], MessageSendEvent::SendAcceptChannel, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_accept_channel(nodes[2].node.get_our_node_id(), &accept_channel); - - let (temporary_channel_id, tx, _) = create_funding_transaction(&nodes[1], &nodes[2].node.get_our_node_id(), 100_000, 42); - nodes[1].node.funding_transaction_generated(temporary_channel_id, nodes[2].node.get_our_node_id(), tx.clone()).unwrap(); - nodes[2].node.handle_funding_created(nodes[1].node.get_our_node_id(), &get_event_msg!(nodes[1], MessageSendEvent::SendFundingCreated, nodes[2].node.get_our_node_id())); + nodes[2].node.handle_open_channel(node_b_id, &open_channel); + let accept_channel = get_event_msg!(nodes[2], MessageSendEvent::SendAcceptChannel, node_b_id); + nodes[1].node.handle_accept_channel(node_c_id, &accept_channel); + + let (temporary_channel_id, tx, _) = + create_funding_transaction(&nodes[1], &node_c_id, 100_000, 42); + nodes[1] + .node + .funding_transaction_generated(temporary_channel_id, node_c_id, tx.clone()) + .unwrap(); + nodes[2].node.handle_funding_created( + node_b_id, + &get_event_msg!(nodes[1], MessageSendEvent::SendFundingCreated, node_c_id), + ); check_added_monitors!(nodes[2], 1); - let cs_funding_signed = get_event_msg!(nodes[2], MessageSendEvent::SendFundingSigned, nodes[1].node.get_our_node_id()); - expect_channel_pending_event(&nodes[2], &nodes[1].node.get_our_node_id()); + let cs_funding_signed = + get_event_msg!(nodes[2], MessageSendEvent::SendFundingSigned, node_b_id); + expect_channel_pending_event(&nodes[2], &node_b_id); - nodes[1].node.handle_funding_signed(nodes[2].node.get_our_node_id(), &cs_funding_signed); - expect_channel_pending_event(&nodes[1], &nodes[2].node.get_our_node_id()); + nodes[1].node.handle_funding_signed(node_c_id, &cs_funding_signed); + expect_channel_pending_event(&nodes[1], &node_c_id); check_added_monitors!(nodes[1], 1); - let conf_height = core::cmp::max(nodes[1].best_block_info().1 + 1, nodes[2].best_block_info().1 + 1); + let conf_height = + core::cmp::max(nodes[1].best_block_info().1 + 1, nodes[2].best_block_info().1 + 1); confirm_transaction_at(&nodes[1], &tx, conf_height); connect_blocks(&nodes[1], CHAN_CONFIRM_DEPTH - 1); confirm_transaction_at(&nodes[2], &tx, conf_height); connect_blocks(&nodes[2], CHAN_CONFIRM_DEPTH - 1); - let bs_channel_ready = get_event_msg!(nodes[1], MessageSendEvent::SendChannelReady, nodes[2].node.get_our_node_id()); - nodes[1].node.handle_channel_ready(nodes[2].node.get_our_node_id(), &get_event_msg!(nodes[2], MessageSendEvent::SendChannelReady, nodes[1].node.get_our_node_id())); - expect_channel_ready_event(&nodes[1], &nodes[2].node.get_our_node_id()); - let bs_update = get_event_msg!(nodes[1], MessageSendEvent::SendChannelUpdate, nodes[2].node.get_our_node_id()); - nodes[2].node.handle_channel_ready(nodes[1].node.get_our_node_id(), &bs_channel_ready); - expect_channel_ready_event(&nodes[2], &nodes[1].node.get_our_node_id()); - let cs_update = get_event_msg!(nodes[2], MessageSendEvent::SendChannelUpdate, nodes[1].node.get_our_node_id()); + let bs_channel_ready = get_event_msg!(nodes[1], MessageSendEvent::SendChannelReady, node_c_id); + nodes[1].node.handle_channel_ready( + node_c_id, + &get_event_msg!(nodes[2], MessageSendEvent::SendChannelReady, node_b_id), + ); + expect_channel_ready_event(&nodes[1], &node_c_id); + let bs_update = get_event_msg!(nodes[1], MessageSendEvent::SendChannelUpdate, node_c_id); + nodes[2].node.handle_channel_ready(node_b_id, &bs_channel_ready); + expect_channel_ready_event(&nodes[2], &node_b_id); + let cs_update = get_event_msg!(nodes[2], MessageSendEvent::SendChannelUpdate, node_b_id); - nodes[1].node.handle_channel_update(nodes[2].node.get_our_node_id(), &cs_update); - nodes[2].node.handle_channel_update(nodes[1].node.get_our_node_id(), &bs_update); + nodes[1].node.handle_channel_update(node_c_id, &cs_update); + nodes[2].node.handle_channel_update(node_b_id, &bs_update); // Now we can pay just fine using the SCID alias nodes[2] gave to nodes[1]... let last_hop = nodes[2].node.list_usable_channels(); let mut hop_hints = vec![RouteHint(vec![RouteHintHop { - src_node_id: nodes[1].node.get_our_node_id(), + src_node_id: node_b_id, short_channel_id: last_hop[0].inbound_scid_alias.unwrap(), fees: RoutingFees { base_msat: last_hop[0].counterparty.forwarding_info.as_ref().unwrap().fee_base_msat, - proportional_millionths: last_hop[0].counterparty.forwarding_info.as_ref().unwrap().fee_proportional_millionths, + proportional_millionths: last_hop[0] + .counterparty + .forwarding_info + .as_ref() + .unwrap() + .fee_proportional_millionths, }, - cltv_expiry_delta: last_hop[0].counterparty.forwarding_info.as_ref().unwrap().cltv_expiry_delta, + cltv_expiry_delta: last_hop[0] + .counterparty + .forwarding_info + .as_ref() + .unwrap() + .cltv_expiry_delta, htlc_maximum_msat: None, htlc_minimum_msat: None, }])]; - let payment_params = PaymentParameters::from_node_id(nodes[2].node.get_our_node_id(), TEST_FINAL_CLTV) - .with_bolt11_features(nodes[2].node.bolt11_invoice_features()).unwrap() - .with_route_hints(hop_hints.clone()).unwrap(); - let (route, payment_hash, payment_preimage, payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[2], payment_params, 100_000); + let payment_params = PaymentParameters::from_node_id(node_c_id, TEST_FINAL_CLTV) + .with_bolt11_features(nodes[2].node.bolt11_invoice_features()) + .unwrap() + .with_route_hints(hop_hints.clone()) + .unwrap(); + let (route, payment_hash, payment_preimage, payment_secret) = + get_route_and_payment_hash!(nodes[0], nodes[2], payment_params, 100_000); assert_eq!(route.paths[0].hops[1].short_channel_id, last_hop[0].inbound_scid_alias.unwrap()); - nodes[0].node.send_payment_with_route(route, payment_hash, - RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_hash.0)).unwrap(); + nodes[0] + .node + .send_payment_with_route( + route, + payment_hash, + RecipientOnionFields::secret_only(payment_secret), + PaymentId(payment_hash.0), + ) + .unwrap(); check_added_monitors!(nodes[0], 1); pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[2]]], 100_000, payment_hash, payment_secret); @@ -431,36 +641,58 @@ fn test_inbound_scid_privacy() { // what channel we're talking about. hop_hints[0].0[0].short_channel_id = last_hop[0].short_channel_id.unwrap(); - let payment_params_2 = PaymentParameters::from_node_id(nodes[2].node.get_our_node_id(), TEST_FINAL_CLTV) - .with_bolt11_features(nodes[2].node.bolt11_invoice_features()).unwrap() - .with_route_hints(hop_hints).unwrap(); - let (route_2, payment_hash_2, _, payment_secret_2) = get_route_and_payment_hash!(nodes[0], nodes[2], payment_params_2, 100_000); + let payment_params_2 = PaymentParameters::from_node_id(node_c_id, TEST_FINAL_CLTV) + .with_bolt11_features(nodes[2].node.bolt11_invoice_features()) + .unwrap() + .with_route_hints(hop_hints) + .unwrap(); + let (route_2, payment_hash_2, _, payment_secret_2) = + get_route_and_payment_hash!(nodes[0], nodes[2], payment_params_2, 100_000); assert_eq!(route_2.paths[0].hops[1].short_channel_id, last_hop[0].short_channel_id.unwrap()); - nodes[0].node.send_payment_with_route(route_2, payment_hash_2, - RecipientOnionFields::secret_only(payment_secret_2), PaymentId(payment_hash_2.0)).unwrap(); + nodes[0] + .node + .send_payment_with_route( + route_2, + payment_hash_2, + RecipientOnionFields::secret_only(payment_secret_2), + PaymentId(payment_hash_2.0), + ) + .unwrap(); check_added_monitors!(nodes[0], 1); let payment_event = SendEvent::from_node(&nodes[0]); - assert_eq!(nodes[1].node.get_our_node_id(), payment_event.node_id); - nodes[1].node.handle_update_add_htlc(nodes[0].node.get_our_node_id(), &payment_event.msgs[0]); + assert_eq!(node_b_id, payment_event.node_id); + nodes[1].node.handle_update_add_htlc(node_a_id, &payment_event.msgs[0]); commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, true, true); expect_pending_htlcs_forwardable!(nodes[1]); expect_htlc_handling_failed_destinations!( nodes[1].node.get_and_clear_pending_events(), - &[HTLCHandlingFailureType::Forward { node_id: Some(nodes[2].node.get_our_node_id()), channel_id: last_hop[0].channel_id }] + &[HTLCHandlingFailureType::Forward { + node_id: Some(node_c_id), + channel_id: last_hop[0].channel_id + }] ); check_added_monitors(&nodes[1], 1); - nodes[1].logger.assert_log_regex("lightning::ln::channelmanager", - regex::Regex::new(r"Failed to accept/forward incoming HTLC: RealSCIDForward").unwrap(), 1); + nodes[1].logger.assert_log_regex( + "lightning::ln::channelmanager", + regex::Regex::new(r"Failed to accept/forward incoming HTLC: RealSCIDForward").unwrap(), + 1, + ); - let mut updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); - nodes[0].node.handle_update_fail_htlc(nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]); + let mut updates = get_htlc_update_msgs!(nodes[1], node_a_id); + nodes[0].node.handle_update_fail_htlc(node_b_id, &updates.update_fail_htlcs[0]); commitment_signed_dance!(nodes[0], nodes[1], updates.commitment_signed, false); - expect_payment_failed_conditions(&nodes[0], payment_hash_2, false, - PaymentFailedConditions::new().blamed_scid(last_hop[0].short_channel_id.unwrap()) - .blamed_chan_closed(true).expected_htlc_error_data(LocalHTLCFailureReason::UnknownNextPeer, &[0; 0])); + expect_payment_failed_conditions( + &nodes[0], + payment_hash_2, + false, + PaymentFailedConditions::new() + .blamed_scid(last_hop[0].short_channel_id.unwrap()) + .blamed_chan_closed(true) + .expected_htlc_error_data(LocalHTLCFailureReason::UnknownNextPeer, &[0; 0]), + ); } #[test] @@ -472,81 +704,136 @@ fn test_scid_alias_returned() { let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); let mut accept_forward_cfg = test_default_channel_config(); accept_forward_cfg.accept_forwards_to_priv_channels = true; - let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, Some(accept_forward_cfg), None]); + let node_chanmgrs = + create_node_chanmgrs(3, &node_cfgs, &[None, Some(accept_forward_cfg), None]); let nodes = create_network(3, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); + let node_c_id = nodes[2].node.get_our_node_id(); create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 10_000_000, 0); let chan = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 2, 10_000, 0); let last_hop = nodes[2].node.list_usable_channels(); let mut hop_hints = vec![RouteHint(vec![RouteHintHop { - src_node_id: nodes[1].node.get_our_node_id(), + src_node_id: node_b_id, short_channel_id: last_hop[0].inbound_scid_alias.unwrap(), fees: RoutingFees { base_msat: last_hop[0].counterparty.forwarding_info.as_ref().unwrap().fee_base_msat, - proportional_millionths: last_hop[0].counterparty.forwarding_info.as_ref().unwrap().fee_proportional_millionths, + proportional_millionths: last_hop[0] + .counterparty + .forwarding_info + .as_ref() + .unwrap() + .fee_proportional_millionths, }, - cltv_expiry_delta: last_hop[0].counterparty.forwarding_info.as_ref().unwrap().cltv_expiry_delta, + cltv_expiry_delta: last_hop[0] + .counterparty + .forwarding_info + .as_ref() + .unwrap() + .cltv_expiry_delta, htlc_maximum_msat: None, htlc_minimum_msat: None, }])]; - let payment_params = PaymentParameters::from_node_id(nodes[2].node.get_our_node_id(), 42) - .with_bolt11_features(nodes[2].node.bolt11_invoice_features()).unwrap() - .with_route_hints(hop_hints).unwrap(); - let (mut route, payment_hash, _, payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[2], payment_params, 10_000); - assert_eq!(route.paths[0].hops[1].short_channel_id, nodes[2].node.list_usable_channels()[0].inbound_scid_alias.unwrap()); + let payment_params = PaymentParameters::from_node_id(node_c_id, 42) + .with_bolt11_features(nodes[2].node.bolt11_invoice_features()) + .unwrap() + .with_route_hints(hop_hints) + .unwrap(); + let (mut route, payment_hash, _, payment_secret) = + get_route_and_payment_hash!(nodes[0], nodes[2], payment_params, 10_000); + assert_eq!( + route.paths[0].hops[1].short_channel_id, + nodes[2].node.list_usable_channels()[0].inbound_scid_alias.unwrap() + ); route.paths[0].hops[1].fee_msat = 10_000_000; // Overshoot the last channel's value // Route the HTLC through to the destination. - nodes[0].node.send_payment_with_route(route.clone(), payment_hash, - RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_hash.0)).unwrap(); + nodes[0] + .node + .send_payment_with_route( + route.clone(), + payment_hash, + RecipientOnionFields::secret_only(payment_secret), + PaymentId(payment_hash.0), + ) + .unwrap(); check_added_monitors!(nodes[0], 1); - let as_updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id()); - nodes[1].node.handle_update_add_htlc(nodes[0].node.get_our_node_id(), &as_updates.update_add_htlcs[0]); + let as_updates = get_htlc_update_msgs!(nodes[0], node_b_id); + nodes[1].node.handle_update_add_htlc(node_a_id, &as_updates.update_add_htlcs[0]); commitment_signed_dance!(nodes[1], nodes[0], &as_updates.commitment_signed, false, true); expect_pending_htlcs_forwardable!(nodes[1]); - expect_pending_htlcs_forwardable_and_htlc_handling_failed!(nodes[1], [HTLCHandlingFailureType::Forward { node_id: Some(nodes[2].node.get_our_node_id()), channel_id: chan.0.channel_id }]); + expect_pending_htlcs_forwardable_and_htlc_handling_failed!( + nodes[1], + [HTLCHandlingFailureType::Forward { + node_id: Some(node_c_id), + channel_id: chan.0.channel_id + }] + ); check_added_monitors!(nodes[1], 1); - let bs_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); - nodes[0].node.handle_update_fail_htlc(nodes[1].node.get_our_node_id(), &bs_updates.update_fail_htlcs[0]); + let bs_updates = get_htlc_update_msgs!(nodes[1], node_a_id); + nodes[0].node.handle_update_fail_htlc(node_b_id, &bs_updates.update_fail_htlcs[0]); commitment_signed_dance!(nodes[0], nodes[1], bs_updates.commitment_signed, false, true); let err_data = 0u16.to_be_bytes(); - expect_payment_failed_conditions(&nodes[0], payment_hash, false, - PaymentFailedConditions::new().blamed_scid(last_hop[0].inbound_scid_alias.unwrap()) - .blamed_chan_closed(false).expected_htlc_error_data(LocalHTLCFailureReason::TemporaryChannelFailure, &err_data)); + expect_payment_failed_conditions( + &nodes[0], + payment_hash, + false, + PaymentFailedConditions::new() + .blamed_scid(last_hop[0].inbound_scid_alias.unwrap()) + .blamed_chan_closed(false) + .expected_htlc_error_data(LocalHTLCFailureReason::TemporaryChannelFailure, &err_data), + ); route.paths[0].hops[1].fee_msat = 10_000; // Reset to the correct payment amount route.paths[0].hops[0].fee_msat = 0; // But set fee paid to the middle hop to 0 // Route the HTLC through to the destination. - nodes[0].node.send_payment_with_route(route, payment_hash, - RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_hash.0)).unwrap(); + nodes[0] + .node + .send_payment_with_route( + route, + payment_hash, + RecipientOnionFields::secret_only(payment_secret), + PaymentId(payment_hash.0), + ) + .unwrap(); check_added_monitors!(nodes[0], 1); - let as_updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id()); - nodes[1].node.handle_update_add_htlc(nodes[0].node.get_our_node_id(), &as_updates.update_add_htlcs[0]); + let as_updates = get_htlc_update_msgs!(nodes[0], node_b_id); + nodes[1].node.handle_update_add_htlc(node_a_id, &as_updates.update_add_htlcs[0]); commitment_signed_dance!(nodes[1], nodes[0], &as_updates.commitment_signed, false, true); expect_pending_htlcs_forwardable!(nodes[1]); expect_htlc_handling_failed_destinations!( nodes[1].node.get_and_clear_pending_events(), - &[HTLCHandlingFailureType::Forward { node_id: Some(nodes[2].node.get_our_node_id()), channel_id: chan.0.channel_id }] + &[HTLCHandlingFailureType::Forward { + node_id: Some(node_c_id), + channel_id: chan.0.channel_id + }] ); check_added_monitors(&nodes[1], 1); - let bs_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); - nodes[0].node.handle_update_fail_htlc(nodes[1].node.get_our_node_id(), &bs_updates.update_fail_htlcs[0]); + let bs_updates = get_htlc_update_msgs!(nodes[1], node_a_id); + nodes[0].node.handle_update_fail_htlc(node_b_id, &bs_updates.update_fail_htlcs[0]); commitment_signed_dance!(nodes[0], nodes[1], bs_updates.commitment_signed, false, true); let mut err_data = Vec::new(); err_data.extend_from_slice(&10_000u64.to_be_bytes()); err_data.extend_from_slice(&0u16.to_be_bytes()); - expect_payment_failed_conditions(&nodes[0], payment_hash, false, - PaymentFailedConditions::new().blamed_scid(last_hop[0].inbound_scid_alias.unwrap()) - .blamed_chan_closed(false).expected_htlc_error_data(LocalHTLCFailureReason::FeeInsufficient, &err_data)); + expect_payment_failed_conditions( + &nodes[0], + payment_hash, + false, + PaymentFailedConditions::new() + .blamed_scid(last_hop[0].inbound_scid_alias.unwrap()) + .blamed_chan_closed(false) + .expected_htlc_error_data(LocalHTLCFailureReason::FeeInsufficient, &err_data), + ); } #[test] @@ -581,41 +868,57 @@ fn test_0conf_channel_with_async_monitor() { let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); let mut chan_config = test_default_channel_config(); chan_config.manually_accept_inbound_channels = true; - let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, Some(chan_config.clone()), None]); + let node_chanmgrs = + create_node_chanmgrs(3, &node_cfgs, &[None, Some(chan_config.clone()), None]); let nodes = create_network(3, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0); chan_config.channel_handshake_config.announce_for_forwarding = false; - nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None, Some(chan_config)).unwrap(); - let open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); + nodes[0].node.create_channel(node_b_id, 100000, 10001, 42, None, Some(chan_config)).unwrap(); + let open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, node_b_id); - nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel); + nodes[1].node.handle_open_channel(node_a_id, &open_channel); let events = nodes[1].node.get_and_clear_pending_events(); assert_eq!(events.len(), 1); match events[0] { Event::OpenChannelRequest { temporary_channel_id, .. } => { - nodes[1].node.accept_inbound_channel_from_trusted_peer_0conf(&temporary_channel_id, &nodes[0].node.get_our_node_id(), 0, None).unwrap(); + nodes[1] + .node + .accept_inbound_channel_from_trusted_peer_0conf( + &temporary_channel_id, + &node_a_id, + 0, + None, + ) + .unwrap(); }, _ => panic!("Unexpected event"), }; - let mut accept_channel = get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id()); + let mut accept_channel = + get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, node_a_id); assert_eq!(accept_channel.common_fields.minimum_depth, 0); - nodes[0].node.handle_accept_channel(nodes[1].node.get_our_node_id(), &accept_channel); + nodes[0].node.handle_accept_channel(node_b_id, &accept_channel); - let (temporary_channel_id, tx, funding_output) = create_funding_transaction(&nodes[0], &nodes[1].node.get_our_node_id(), 100000, 42); - nodes[0].node.funding_transaction_generated(temporary_channel_id, nodes[1].node.get_our_node_id(), tx.clone()).unwrap(); - let funding_created = get_event_msg!(nodes[0], MessageSendEvent::SendFundingCreated, nodes[1].node.get_our_node_id()); + let (temporary_channel_id, tx, funding_output) = + create_funding_transaction(&nodes[0], &node_b_id, 100000, 42); + nodes[0] + .node + .funding_transaction_generated(temporary_channel_id, node_b_id, tx.clone()) + .unwrap(); + let funding_created = get_event_msg!(nodes[0], MessageSendEvent::SendFundingCreated, node_b_id); chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - nodes[1].node.handle_funding_created(nodes[0].node.get_our_node_id(), &funding_created); + nodes[1].node.handle_funding_created(node_a_id, &funding_created); check_added_monitors!(nodes[1], 1); assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); let channel_id = ChannelId::v1_from_funding_outpoint(funding_output); nodes[1].chain_monitor.complete_sole_pending_chan_update(&channel_id); - expect_channel_pending_event(&nodes[1], &nodes[0].node.get_our_node_id()); + expect_channel_pending_event(&nodes[1], &node_a_id); let bs_signed_locked = nodes[1].node.get_and_clear_pending_msg_events(); assert_eq!(bs_signed_locked.len(), 2); @@ -623,17 +926,17 @@ fn test_0conf_channel_with_async_monitor() { match &bs_signed_locked[0] { MessageSendEvent::SendFundingSigned { node_id, msg } => { - assert_eq!(*node_id, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_funding_signed(nodes[1].node.get_our_node_id(), &msg); + assert_eq!(*node_id, node_a_id); + nodes[0].node.handle_funding_signed(node_b_id, &msg); check_added_monitors!(nodes[0], 1); - } + }, _ => panic!("Unexpected event"), } match &bs_signed_locked[1] { MessageSendEvent::SendChannelReady { node_id, msg } => { - assert_eq!(*node_id, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_channel_ready(nodes[1].node.get_our_node_id(), &msg); - } + assert_eq!(*node_id, node_a_id); + nodes[0].node.handle_channel_ready(node_b_id, &msg); + }, _ => panic!("Unexpected event"), } @@ -646,13 +949,13 @@ fn test_0conf_channel_with_async_monitor() { assert_eq!(events.len(), 2); match events[0] { crate::events::Event::ChannelPending { ref counterparty_node_id, .. } => { - assert_eq!(nodes[1].node.get_our_node_id(), *counterparty_node_id); + assert_eq!(node_b_id, *counterparty_node_id); }, _ => panic!("Unexpected event"), } match events[1] { crate::events::Event::ChannelReady { ref counterparty_node_id, .. } => { - assert_eq!(nodes[1].node.get_our_node_id(), *counterparty_node_id); + assert_eq!(node_b_id, *counterparty_node_id); }, _ => panic!("Unexpected event"), } @@ -666,28 +969,29 @@ fn test_0conf_channel_with_async_monitor() { match &as_locked_update[0] { MessageSendEvent::SendChannelReady { node_id, msg } => { - assert_eq!(*node_id, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_channel_ready(nodes[0].node.get_our_node_id(), &msg); - } + assert_eq!(*node_id, node_b_id); + nodes[1].node.handle_channel_ready(node_a_id, &msg); + }, _ => panic!("Unexpected event"), } - expect_channel_ready_event(&nodes[1], &nodes[0].node.get_our_node_id()); + expect_channel_ready_event(&nodes[1], &node_a_id); - let bs_channel_update = get_event_msg!(nodes[1], MessageSendEvent::SendChannelUpdate, nodes[0].node.get_our_node_id()); + let bs_channel_update = + get_event_msg!(nodes[1], MessageSendEvent::SendChannelUpdate, node_a_id); let as_channel_update = match &as_locked_update[1] { MessageSendEvent::SendChannelUpdate { node_id, msg } => { - assert_eq!(*node_id, nodes[1].node.get_our_node_id()); + assert_eq!(*node_id, node_b_id); msg.clone() - } + }, _ => panic!("Unexpected event"), }; chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); - nodes[0].node.handle_channel_update(nodes[1].node.get_our_node_id(), &bs_channel_update); - nodes[1].node.handle_channel_update(nodes[0].node.get_our_node_id(), &as_channel_update); + nodes[0].node.handle_channel_update(node_b_id, &bs_channel_update); + nodes[1].node.handle_channel_update(node_a_id, &as_channel_update); assert_eq!(nodes[0].node.list_usable_channels().len(), 1); assert_eq!(nodes[1].node.list_usable_channels().len(), 2); @@ -696,38 +1000,60 @@ fn test_0conf_channel_with_async_monitor() { // Now that we have useful channels, try sending a payment where the we hit a temporary monitor // failure before we've ever confirmed the funding transaction. This previously caused a panic. - let (route, payment_hash, payment_preimage, payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[2], 1_000_000); - - nodes[0].node.send_payment_with_route(route, payment_hash, - RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_hash.0)).unwrap(); + let (route, payment_hash, payment_preimage, payment_secret) = + get_route_and_payment_hash!(nodes[0], nodes[2], 1_000_000); + + nodes[0] + .node + .send_payment_with_route( + route, + payment_hash, + RecipientOnionFields::secret_only(payment_secret), + PaymentId(payment_hash.0), + ) + .unwrap(); check_added_monitors!(nodes[0], 1); let as_send = SendEvent::from_node(&nodes[0]); - nodes[1].node.handle_update_add_htlc(nodes[0].node.get_our_node_id(), &as_send.msgs[0]); - nodes[1].node.handle_commitment_signed_batch_test(nodes[0].node.get_our_node_id(), &as_send.commitment_msg); + nodes[1].node.handle_update_add_htlc(node_a_id, &as_send.msgs[0]); + nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &as_send.commitment_msg); check_added_monitors!(nodes[1], 1); - let (bs_raa, bs_commitment_signed) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id()); - nodes[0].node.handle_revoke_and_ack(nodes[1].node.get_our_node_id(), &bs_raa); + let (bs_raa, bs_commitment_signed) = get_revoke_commit_msgs!(nodes[1], node_a_id); + nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_raa); check_added_monitors!(nodes[0], 1); - nodes[0].node.handle_commitment_signed_batch_test(nodes[1].node.get_our_node_id(), &bs_commitment_signed); + nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &bs_commitment_signed); check_added_monitors!(nodes[0], 1); chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - nodes[1].node.handle_revoke_and_ack(nodes[0].node.get_our_node_id(), &get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id())); + nodes[1].node.handle_revoke_and_ack( + node_a_id, + &get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id), + ); check_added_monitors!(nodes[1], 1); assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); - let (_, latest_update) = nodes[1].chain_monitor.latest_monitor_update_id.lock().unwrap().get(&bs_raa.channel_id).unwrap().clone(); - nodes[1].chain_monitor.chain_monitor.channel_monitor_updated(bs_raa.channel_id, latest_update).unwrap(); + let (_, latest_update) = nodes[1] + .chain_monitor + .latest_monitor_update_id + .lock() + .unwrap() + .get(&bs_raa.channel_id) + .unwrap() + .clone(); + nodes[1] + .chain_monitor + .chain_monitor + .channel_monitor_updated(bs_raa.channel_id, latest_update) + .unwrap(); check_added_monitors!(nodes[1], 0); expect_pending_htlcs_forwardable!(nodes[1]); check_added_monitors!(nodes[1], 1); let bs_send = SendEvent::from_node(&nodes[1]); - nodes[2].node.handle_update_add_htlc(nodes[1].node.get_our_node_id(), &bs_send.msgs[0]); + nodes[2].node.handle_update_add_htlc(node_b_id, &bs_send.msgs[0]); commitment_signed_dance!(nodes[2], nodes[1], bs_send.commitment_msg, false); expect_pending_htlcs_forwardable!(nodes[2]); expect_payment_claimable!(nodes[2], payment_hash, payment_secret, 1_000_000); @@ -750,6 +1076,7 @@ fn test_0conf_close_no_early_chan_update() { let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, Some(chan_config.clone())]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let node_b_id = nodes[1].node.get_our_node_id(); let error_message = "Channel force-closed"; // This is the default but we force it on anyway @@ -761,8 +1088,14 @@ fn test_0conf_close_no_early_chan_update() { nodes[0].node.force_close_all_channels_broadcasting_latest_txn(error_message.to_string()); check_added_monitors!(nodes[0], 1); - check_closed_event!(&nodes[0], 1, ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }, [nodes[1].node.get_our_node_id()], 100000); - let _ = get_err_msg(&nodes[0], &nodes[1].node.get_our_node_id()); + check_closed_event!( + &nodes[0], + 1, + ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }, + [node_b_id], + 100000 + ); + let _ = get_err_msg(&nodes[0], &node_b_id); } #[test] @@ -775,6 +1108,8 @@ fn test_public_0conf_channel() { let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, Some(chan_config.clone())]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); // This is the default but we force it on anyway chan_config.channel_handshake_config.announce_for_forwarding = true; @@ -784,12 +1119,14 @@ fn test_public_0conf_channel() { send_payment(&nodes[0], &[&nodes[1]], 100_000); let scid = confirm_transaction(&nodes[0], &tx); - let as_announcement_sigs = get_event_msg!(nodes[0], MessageSendEvent::SendAnnouncementSignatures, nodes[1].node.get_our_node_id()); + let as_announcement_sigs = + get_event_msg!(nodes[0], MessageSendEvent::SendAnnouncementSignatures, node_b_id); assert_eq!(confirm_transaction(&nodes[1], &tx), scid); - let bs_announcement_sigs = get_event_msg!(nodes[1], MessageSendEvent::SendAnnouncementSignatures, nodes[0].node.get_our_node_id()); + let bs_announcement_sigs = + get_event_msg!(nodes[1], MessageSendEvent::SendAnnouncementSignatures, node_a_id); - nodes[1].node.handle_announcement_signatures(nodes[0].node.get_our_node_id(), &as_announcement_sigs); - nodes[0].node.handle_announcement_signatures(nodes[1].node.get_our_node_id(), &bs_announcement_sigs); + nodes[1].node.handle_announcement_signatures(node_a_id, &as_announcement_sigs); + nodes[0].node.handle_announcement_signatures(node_b_id, &bs_announcement_sigs); let bs_announcement = nodes[1].node.get_and_clear_pending_msg_events(); assert_eq!(bs_announcement.len(), 1); @@ -810,7 +1147,10 @@ fn test_public_0conf_channel() { assert!(announcement == *msg); let update_msg = update_msg.as_ref().unwrap(); assert_eq!(update_msg.contents.short_channel_id, scid); - assert_eq!(update_msg.contents.short_channel_id, announcement.contents.short_channel_id); + assert_eq!( + update_msg.contents.short_channel_id, + announcement.contents.short_channel_id + ); assert_eq!(update_msg.contents.short_channel_id, bs_update.contents.short_channel_id); }, _ => panic!("Unexpected event"), @@ -829,6 +1169,8 @@ fn test_0conf_channel_reorg() { let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, Some(chan_config.clone())]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); // This is the default but we force it on anyway chan_config.channel_handshake_config.announce_for_forwarding = true; @@ -845,9 +1187,17 @@ fn test_0conf_channel_reorg() { let real_scid = nodes[0].node.list_usable_channels()[0].short_channel_id.unwrap(); assert_eq!(nodes[1].node.list_usable_channels()[0].short_channel_id.unwrap(), real_scid); - let (mut route, payment_hash, payment_preimage, payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[1], 10_000); + let (mut route, payment_hash, payment_preimage, payment_secret) = + get_route_and_payment_hash!(nodes[0], nodes[1], 10_000); assert_eq!(route.paths[0].hops[0].short_channel_id, real_scid); - send_along_route_with_secret(&nodes[0], route, &[&[&nodes[1]]], 10_000, payment_hash, payment_secret); + send_along_route_with_secret( + &nodes[0], + route, + &[&[&nodes[1]]], + 10_000, + payment_hash, + payment_secret, + ); claim_payment(&nodes[0], &[&nodes[1]], payment_preimage); disconnect_blocks(&nodes[0], 1); @@ -856,14 +1206,28 @@ fn test_0conf_channel_reorg() { // At this point the channel no longer has an SCID again. In the future we should likely // support simply un-setting the SCID and waiting until the channel gets re-confirmed, but for // now we force-close the channel here. - check_closed_event!(&nodes[0], 1, ClosureReason::ProcessingError { - err: "Funding transaction was un-confirmed. Locked at 0 confs, now have 0 confs.".to_owned() - }, [nodes[1].node.get_our_node_id()], 100000); + check_closed_event!( + &nodes[0], + 1, + ClosureReason::ProcessingError { + err: "Funding transaction was un-confirmed. Locked at 0 confs, now have 0 confs." + .to_owned() + }, + [node_b_id], + 100000 + ); check_closed_broadcast!(nodes[0], true); check_added_monitors(&nodes[0], 1); - check_closed_event!(&nodes[1], 1, ClosureReason::ProcessingError { - err: "Funding transaction was un-confirmed. Locked at 0 confs, now have 0 confs.".to_owned() - }, [nodes[0].node.get_our_node_id()], 100000); + check_closed_event!( + &nodes[1], + 1, + ClosureReason::ProcessingError { + err: "Funding transaction was un-confirmed. Locked at 0 confs, now have 0 confs." + .to_owned() + }, + [node_a_id], + 100000 + ); check_closed_broadcast!(nodes[1], true); check_added_monitors(&nodes[1], 1); } @@ -878,17 +1242,23 @@ fn test_zero_conf_accept_reject() { let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); - nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None, None).unwrap(); - let mut open_channel_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); + nodes[0].node.create_channel(node_b_id, 100000, 10001, 42, None, None).unwrap(); + let mut open_channel_msg = + get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, node_b_id); open_channel_msg.common_fields.channel_type = Some(channel_type_features.clone()); - nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel_msg); + nodes[1].node.handle_open_channel(node_a_id, &open_channel_msg); let msg_events = nodes[1].node.get_and_clear_pending_msg_events(); match msg_events[0] { - MessageSendEvent::HandleError { action: ErrorAction::SendErrorMessage { ref msg, .. }, .. } => { + MessageSendEvent::HandleError { + action: ErrorAction::SendErrorMessage { ref msg, .. }, + .. + } => { assert_eq!(msg.data, "No zero confirmation channels accepted".to_owned()); }, _ => panic!(), @@ -900,19 +1270,23 @@ fn test_zero_conf_accept_reject() { let chanmon_cfgs = create_chanmon_cfgs(2); let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); - let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, - &[None, Some(manually_accept_conf.clone())]); + let node_chanmgrs = + create_node_chanmgrs(2, &node_cfgs, &[None, Some(manually_accept_conf.clone())]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); // 2.1 First try the non-0conf method to manually accept - nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, - None, Some(manually_accept_conf.clone())).unwrap(); - let mut open_channel_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, - nodes[1].node.get_our_node_id()); + nodes[0] + .node + .create_channel(node_b_id, 100000, 10001, 42, None, Some(manually_accept_conf.clone())) + .unwrap(); + let mut open_channel_msg = + get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, node_b_id); open_channel_msg.common_fields.channel_type = Some(channel_type_features.clone()); - nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel_msg); + nodes[1].node.handle_open_channel(node_a_id, &open_channel_msg); // Assert that `nodes[1]` has no `MessageSendEvent::SendAcceptChannel` in the `msg_events`. assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); @@ -922,37 +1296,51 @@ fn test_zero_conf_accept_reject() { match events[0] { Event::OpenChannelRequest { temporary_channel_id, .. } => { // Assert we fail to accept via the non-0conf method - assert!(nodes[1].node.accept_inbound_channel(&temporary_channel_id, - &nodes[0].node.get_our_node_id(), 0, None).is_err()); + assert!(nodes[1] + .node + .accept_inbound_channel(&temporary_channel_id, &node_a_id, 0, None) + .is_err()); }, _ => panic!(), } let msg_events = nodes[1].node.get_and_clear_pending_msg_events(); match msg_events[0] { - MessageSendEvent::HandleError { action: ErrorAction::SendErrorMessage { ref msg, .. }, .. } => { + MessageSendEvent::HandleError { + action: ErrorAction::SendErrorMessage { ref msg, .. }, + .. + } => { assert_eq!(msg.data, "No zero confirmation channels accepted".to_owned()); }, _ => panic!(), } // 2.2 Try again with the 0conf method to manually accept - nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, - None, Some(manually_accept_conf)).unwrap(); - let mut open_channel_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, - nodes[1].node.get_our_node_id()); + nodes[0] + .node + .create_channel(node_b_id, 100000, 10001, 42, None, Some(manually_accept_conf)) + .unwrap(); + let mut open_channel_msg = + get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, node_b_id); open_channel_msg.common_fields.channel_type = Some(channel_type_features); - nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel_msg); + nodes[1].node.handle_open_channel(node_a_id, &open_channel_msg); let events = nodes[1].node.get_and_clear_pending_events(); match events[0] { Event::OpenChannelRequest { temporary_channel_id, .. } => { // Assert we can accept via the 0conf method - assert!(nodes[1].node.accept_inbound_channel_from_trusted_peer_0conf( - &temporary_channel_id, &nodes[0].node.get_our_node_id(), 0, None).is_ok()); + assert!(nodes[1] + .node + .accept_inbound_channel_from_trusted_peer_0conf( + &temporary_channel_id, + &node_a_id, + 0, + None + ) + .is_ok()); }, _ => panic!(), } @@ -978,23 +1366,34 @@ fn test_connect_before_funding() { let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, Some(manually_accept_conf)]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); - nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100_000, 10_001, 42, None, None).unwrap(); - let open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); + nodes[0].node.create_channel(node_b_id, 100_000, 10_001, 42, None, None).unwrap(); + let open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, node_b_id); - nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel); + nodes[1].node.handle_open_channel(node_a_id, &open_channel); let events = nodes[1].node.get_and_clear_pending_events(); assert_eq!(events.len(), 1); match events[0] { Event::OpenChannelRequest { temporary_channel_id, .. } => { - nodes[1].node.accept_inbound_channel_from_trusted_peer_0conf(&temporary_channel_id, &nodes[0].node.get_our_node_id(), 0, None).unwrap(); + nodes[1] + .node + .accept_inbound_channel_from_trusted_peer_0conf( + &temporary_channel_id, + &node_a_id, + 0, + None, + ) + .unwrap(); }, _ => panic!("Unexpected event"), }; - let mut accept_channel = get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id()); + let mut accept_channel = + get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, node_a_id); assert_eq!(accept_channel.common_fields.minimum_depth, 0); - nodes[0].node.handle_accept_channel(nodes[1].node.get_our_node_id(), &accept_channel); + nodes[0].node.handle_accept_channel(node_b_id, &accept_channel); let events = nodes[0].node.get_and_clear_pending_events(); assert_eq!(events.len(), 1); @@ -1020,6 +1419,8 @@ fn test_0conf_ann_sigs_racing_conf() { let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, Some(chan_config.clone())]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); // This is the default but we force it on anyway chan_config.channel_handshake_config.announce_for_forwarding = true; @@ -1029,15 +1430,17 @@ fn test_0conf_ann_sigs_racing_conf() { send_payment(&nodes[0], &[&nodes[1]], 100_000); let scid = confirm_transaction(&nodes[0], &tx); - let as_announcement_sigs = get_event_msg!(nodes[0], MessageSendEvent::SendAnnouncementSignatures, nodes[1].node.get_our_node_id()); + let as_announcement_sigs = + get_event_msg!(nodes[0], MessageSendEvent::SendAnnouncementSignatures, node_b_id); // Handling the announcement_signatures prior to the first confirmation would panic before. - nodes[1].node.handle_announcement_signatures(nodes[0].node.get_our_node_id(), &as_announcement_sigs); + nodes[1].node.handle_announcement_signatures(node_a_id, &as_announcement_sigs); assert_eq!(confirm_transaction(&nodes[1], &tx), scid); - let bs_announcement_sigs = get_event_msg!(nodes[1], MessageSendEvent::SendAnnouncementSignatures, nodes[0].node.get_our_node_id()); + let bs_announcement_sigs = + get_event_msg!(nodes[1], MessageSendEvent::SendAnnouncementSignatures, node_a_id); - nodes[0].node.handle_announcement_signatures(nodes[1].node.get_our_node_id(), &bs_announcement_sigs); + nodes[0].node.handle_announcement_signatures(node_b_id, &bs_announcement_sigs); let as_announcement = nodes[0].node.get_and_clear_pending_msg_events(); assert_eq!(as_announcement.len(), 1); } diff --git a/lightning/src/ln/shutdown_tests.rs b/lightning/src/ln/shutdown_tests.rs index d5c3fe3c387..4ada551b3d3 100644 --- a/lightning/src/ln/shutdown_tests.rs +++ b/lightning/src/ln/shutdown_tests.rs @@ -1,5 +1,3 @@ -#![cfg_attr(rustfmt, rustfmt_skip)] - // This file is Copyright its original authors, visible in version control // history. // @@ -12,32 +10,32 @@ //! Tests of our shutdown and closing_signed negotiation logic as well as some assorted force-close //! handling tests. -use crate::sign::{EntropySource, SignerProvider}; -use crate::chain::ChannelMonitorUpdateStatus; use crate::chain::transaction::OutPoint; -use crate::events::{Event, HTLCHandlingFailureType, ClosureReason}; +use crate::chain::ChannelMonitorUpdateStatus; +use crate::events::{ClosureReason, Event, HTLCHandlingFailureType}; use crate::ln::channel_state::{ChannelDetails, ChannelShutdownState}; use crate::ln::channelmanager::{self, PaymentId, RecipientOnionFields, Retry}; -use crate::routing::router::{PaymentParameters, get_route, RouteParameters}; use crate::ln::msgs; -use crate::ln::types::ChannelId; use crate::ln::msgs::{BaseMessageHandler, ChannelMessageHandler, ErrorAction, MessageSendEvent}; use crate::ln::onion_utils::LocalHTLCFailureReason; use crate::ln::script::ShutdownScript; -use crate::util::test_utils; -use crate::util::test_utils::OnGetShutdownScriptpubkey; -use crate::util::errors::APIError; +use crate::ln::types::ChannelId; +use crate::prelude::*; +use crate::routing::router::{get_route, PaymentParameters, RouteParameters}; +use crate::sign::{EntropySource, SignerProvider}; use crate::util::config::UserConfig; +use crate::util::errors::APIError; use crate::util::string::UntrustedString; -use crate::prelude::*; +use crate::util::test_utils; +use crate::util::test_utils::OnGetShutdownScriptpubkey; -use bitcoin::{Transaction, TxOut, WitnessProgram, WitnessVersion}; use bitcoin::amount::Amount; use bitcoin::locktime::absolute::LockTime; -use bitcoin::script::Builder; -use bitcoin::opcodes; use bitcoin::network::Network; +use bitcoin::opcodes; +use bitcoin::script::Builder; use bitcoin::transaction::Version; +use bitcoin::{Transaction, TxOut, WitnessProgram, WitnessVersion}; use crate::ln::functional_test_utils::*; @@ -48,29 +46,51 @@ fn pre_funding_lock_shutdown_test() { let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 8000000, 0); mine_transaction(&nodes[0], &tx); mine_transaction(&nodes[1], &tx); - nodes[0].node.close_channel(&ChannelId::v1_from_funding_outpoint(OutPoint { txid: tx.compute_txid(), index: 0 }), &nodes[1].node.get_our_node_id()).unwrap(); - let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); - let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_shutdown); - - let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); - let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); - let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap()); - let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); + nodes[0] + .node + .close_channel( + &ChannelId::v1_from_funding_outpoint(OutPoint { txid: tx.compute_txid(), index: 0 }), + &node_b_id, + ) + .unwrap(); + let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, node_b_id); + nodes[1].node.handle_shutdown(node_a_id, &node_0_shutdown); + let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, node_a_id); + nodes[0].node.handle_shutdown(node_b_id, &node_1_shutdown); + + let node_0_closing_signed = + get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, node_b_id); + nodes[1].node.handle_closing_signed(node_a_id, &node_0_closing_signed); + let node_1_closing_signed = + get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, node_a_id); + nodes[0].node.handle_closing_signed(node_b_id, &node_1_closing_signed); + let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, node_b_id); + nodes[1].node.handle_closing_signed(node_a_id, &node_0_2nd_closing_signed.unwrap()); + let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, node_a_id); assert!(node_1_none.is_none()); assert!(nodes[0].node.list_channels().is_empty()); assert!(nodes[1].node.list_channels().is_empty()); - check_closed_event!(nodes[0], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 8000000); - check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 8000000); + check_closed_event!( + nodes[0], + 1, + ClosureReason::LocallyInitiatedCooperativeClosure, + [node_b_id], + 8000000 + ); + check_closed_event!( + nodes[1], + 1, + ClosureReason::CounterpartyInitiatedCooperativeClosure, + [node_a_id], + 8000000 + ); } #[test] @@ -80,42 +100,58 @@ fn expect_channel_shutdown_state() { let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1); expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::NotShuttingDown); - nodes[0].node.close_channel(&chan_1.2, &nodes[1].node.get_our_node_id()).unwrap(); + nodes[0].node.close_channel(&chan_1.2, &node_b_id).unwrap(); expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::ShutdownInitiated); expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NotShuttingDown); - let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); + let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, node_b_id); + nodes[1].node.handle_shutdown(node_a_id, &node_0_shutdown); // node1 goes into NegotiatingClosingFee since there are no HTLCs in flight, note that it // doesnt mean that node1 has sent/recved its closing signed message expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::ShutdownInitiated); expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NegotiatingClosingFee); - let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_shutdown); + let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, node_a_id); + nodes[0].node.handle_shutdown(node_b_id, &node_1_shutdown); expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::NegotiatingClosingFee); expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NegotiatingClosingFee); - let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); - let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); - let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap()); - let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); + let node_0_closing_signed = + get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, node_b_id); + nodes[1].node.handle_closing_signed(node_a_id, &node_0_closing_signed); + let node_1_closing_signed = + get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, node_a_id); + nodes[0].node.handle_closing_signed(node_b_id, &node_1_closing_signed); + let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, node_b_id); + nodes[1].node.handle_closing_signed(node_a_id, &node_0_2nd_closing_signed.unwrap()); + let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, node_a_id); assert!(node_1_none.is_none()); assert!(nodes[0].node.list_channels().is_empty()); assert!(nodes[1].node.list_channels().is_empty()); - check_closed_event!(nodes[0], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); - check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 100000); + check_closed_event!( + nodes[0], + 1, + ClosureReason::LocallyInitiatedCooperativeClosure, + [node_b_id], + 100000 + ); + check_closed_event!( + nodes[1], + 1, + ClosureReason::CounterpartyInitiatedCooperativeClosure, + [node_a_id], + 100000 + ); } #[test] @@ -125,27 +161,31 @@ fn expect_channel_shutdown_state_with_htlc() { let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); + let node_c_id = nodes[2].node.get_our_node_id(); let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1); let _chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2); - let (payment_preimage_0, payment_hash_0, ..) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100_000); + let (payment_preimage_0, payment_hash_0, ..) = + route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100_000); expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::NotShuttingDown); expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NotShuttingDown); - nodes[0].node.close_channel(&chan_1.2, &nodes[1].node.get_our_node_id()).unwrap(); + nodes[0].node.close_channel(&chan_1.2, &node_b_id).unwrap(); expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::ShutdownInitiated); expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NotShuttingDown); - let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); + let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, node_b_id); + nodes[1].node.handle_shutdown(node_a_id, &node_0_shutdown); expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::ShutdownInitiated); expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::ResolvingHTLCs); - let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_shutdown); + let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, node_a_id); + nodes[0].node.handle_shutdown(node_b_id, &node_1_shutdown); expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::ResolvingHTLCs); expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::ResolvingHTLCs); @@ -159,16 +199,16 @@ fn expect_channel_shutdown_state_with_htlc() { expect_payment_claimed!(nodes[2], payment_hash_0, 100_000); // Fulfil HTLCs on node1 and node0 - let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id()); + let updates = get_htlc_update_msgs!(nodes[2], node_b_id); assert!(updates.update_add_htlcs.is_empty()); assert!(updates.update_fail_htlcs.is_empty()); assert!(updates.update_fail_malformed_htlcs.is_empty()); assert!(updates.update_fee.is_none()); assert_eq!(updates.update_fulfill_htlcs.len(), 1); - nodes[1].node.handle_update_fulfill_htlc(nodes[2].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]); + nodes[1].node.handle_update_fulfill_htlc(node_c_id, &updates.update_fulfill_htlcs[0]); expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], Some(1000), false, false); check_added_monitors!(nodes[1], 1); - let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); + let updates_2 = get_htlc_update_msgs!(nodes[1], node_a_id); commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false); // Still in "resolvingHTLCs" on chan1 after htlc removed on chan2 @@ -180,7 +220,7 @@ fn expect_channel_shutdown_state_with_htlc() { assert!(updates_2.update_fail_malformed_htlcs.is_empty()); assert!(updates_2.update_fee.is_none()); assert_eq!(updates_2.update_fulfill_htlcs.len(), 1); - nodes[0].node.handle_update_fulfill_htlc(nodes[1].node.get_our_node_id(), &updates_2.update_fulfill_htlcs[0]); + nodes[0].node.handle_update_fulfill_htlc(node_b_id, &updates_2.update_fulfill_htlcs[0]); commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true); expect_payment_sent!(nodes[0], payment_preimage_0); @@ -189,16 +229,30 @@ fn expect_channel_shutdown_state_with_htlc() { expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NegotiatingClosingFee); // ClosingSignNegotion process - let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); - let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); - let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap()); - let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); + let node_0_closing_signed = + get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, node_b_id); + nodes[1].node.handle_closing_signed(node_a_id, &node_0_closing_signed); + let node_1_closing_signed = + get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, node_a_id); + nodes[0].node.handle_closing_signed(node_b_id, &node_1_closing_signed); + let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, node_b_id); + nodes[1].node.handle_closing_signed(node_a_id, &node_0_2nd_closing_signed.unwrap()); + let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, node_a_id); assert!(node_1_none.is_none()); - check_closed_event!(nodes[0], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); - check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 100000); + check_closed_event!( + nodes[0], + 1, + ClosureReason::LocallyInitiatedCooperativeClosure, + [node_b_id], + 100000 + ); + check_closed_event!( + nodes[1], + 1, + ClosureReason::CounterpartyInitiatedCooperativeClosure, + [node_a_id], + 100000 + ); // Shutdown basically removes the channelDetails, testing of shutdowncomplete state unnecessary assert!(nodes[0].node.list_channels().is_empty()); @@ -213,27 +267,36 @@ fn test_lnd_bug_6039() { let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); let chan = create_announced_chan_between_nodes(&nodes, 0, 1); let (payment_preimage, ..) = route_payment(&nodes[0], &[&nodes[1]], 100_000); - nodes[0].node.close_channel(&chan.2, &nodes[1].node.get_our_node_id()).unwrap(); - let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); + nodes[0].node.close_channel(&chan.2, &node_b_id).unwrap(); + let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, node_b_id); + nodes[1].node.handle_shutdown(node_a_id, &node_0_shutdown); // Generate an lnd-like error message and check that we respond by simply screaming louder to // see if LND will accept our protocol compliance. - let err_msg = msgs::ErrorMessage { channel_id: chan.2, data: "link failed to shutdown".to_string() }; - nodes[0].node.handle_error(nodes[1].node.get_our_node_id(), &err_msg); + let err_msg = + msgs::ErrorMessage { channel_id: chan.2, data: "link failed to shutdown".to_string() }; + nodes[0].node.handle_error(node_b_id, &err_msg); let node_a_responses = nodes[0].node.get_and_clear_pending_msg_events(); - assert_eq!(node_a_responses[0], MessageSendEvent::SendShutdown { - node_id: nodes[1].node.get_our_node_id(), - msg: node_0_shutdown, - }); - if let MessageSendEvent::HandleError { action: msgs::ErrorAction::SendWarningMessage { .. }, .. } - = node_a_responses[1] {} else { panic!(); } + assert_eq!( + node_a_responses[0], + MessageSendEvent::SendShutdown { node_id: node_b_id, msg: node_0_shutdown } + ); + if let MessageSendEvent::HandleError { + action: msgs::ErrorAction::SendWarningMessage { .. }, + .. + } = node_a_responses[1] + { + } else { + panic!(); + } - let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); + let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, node_a_id); assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); @@ -241,19 +304,33 @@ fn test_lnd_bug_6039() { claim_payment(&nodes[0], &[&nodes[1]], payment_preimage); // Assume that LND will eventually respond to our Shutdown if we clear all the remaining HTLCs - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_shutdown); + nodes[0].node.handle_shutdown(node_b_id, &node_1_shutdown); // ClosingSignNegotion process - let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); - let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); - let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap()); - let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); + let node_0_closing_signed = + get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, node_b_id); + nodes[1].node.handle_closing_signed(node_a_id, &node_0_closing_signed); + let node_1_closing_signed = + get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, node_a_id); + nodes[0].node.handle_closing_signed(node_b_id, &node_1_closing_signed); + let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, node_b_id); + nodes[1].node.handle_closing_signed(node_a_id, &node_0_2nd_closing_signed.unwrap()); + let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, node_a_id); assert!(node_1_none.is_none()); - check_closed_event!(nodes[0], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); - check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 100000); + check_closed_event!( + nodes[0], + 1, + ClosureReason::LocallyInitiatedCooperativeClosure, + [node_b_id], + 100000 + ); + check_closed_event!( + nodes[1], + 1, + ClosureReason::CounterpartyInitiatedCooperativeClosure, + [node_a_id], + 100000 + ); // Shutdown basically removes the channelDetails, testing of shutdowncomplete state unnecessary assert!(nodes[0].node.list_channels().is_empty()); @@ -266,19 +343,28 @@ fn shutdown_on_unfunded_channel() { let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let node_b_id = nodes[1].node.get_our_node_id(); - nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 1_000_000, 100_000, 0, None, None).unwrap(); - let open_chan = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); + nodes[0].node.create_channel(node_b_id, 1_000_000, 100_000, 0, None, None).unwrap(); + let open_chan = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, node_b_id); // Create a dummy P2WPKH script - let script = Builder::new().push_int(0) - .push_slice(&[0; 20]) - .into_script(); - - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &msgs::Shutdown { - channel_id: open_chan.common_fields.temporary_channel_id, scriptpubkey: script, - }); - check_closed_event!(nodes[0], 1, ClosureReason::CounterpartyCoopClosedUnfundedChannel, [nodes[1].node.get_our_node_id()], 1_000_000); + let script = Builder::new().push_int(0).push_slice(&[0; 20]).into_script(); + + nodes[0].node.handle_shutdown( + node_b_id, + &msgs::Shutdown { + channel_id: open_chan.common_fields.temporary_channel_id, + scriptpubkey: script, + }, + ); + check_closed_event!( + nodes[0], + 1, + ClosureReason::CounterpartyCoopClosedUnfundedChannel, + [node_b_id], + 1_000_000 + ); } #[test] @@ -288,12 +374,20 @@ fn close_on_unfunded_channel() { let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - let chan_id = nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 1_000_000, 100_000, 0, None, None).unwrap(); - let _open_chan = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); - - nodes[0].node.close_channel(&chan_id, &nodes[1].node.get_our_node_id()).unwrap(); - check_closed_event!(nodes[0], 1, ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(false) }, [nodes[1].node.get_our_node_id()], 1_000_000); + let node_b_id = nodes[1].node.get_our_node_id(); + + let chan_id = + nodes[0].node.create_channel(node_b_id, 1_000_000, 100_000, 0, None, None).unwrap(); + let _open_chan = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, node_b_id); + + nodes[0].node.close_channel(&chan_id, &node_b_id).unwrap(); + check_closed_event!( + nodes[0], + 1, + ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(false) }, + [node_b_id], + 1_000_000 + ); } #[test] @@ -303,13 +397,18 @@ fn expect_channel_shutdown_state_with_force_closure() { let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1); let error_message = "Channel force-closed"; expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::NotShuttingDown); expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NotShuttingDown); - nodes[1].node.force_close_broadcasting_latest_txn(&chan_1.2, &nodes[0].node.get_our_node_id(), error_message.to_string()).unwrap(); + nodes[1] + .node + .force_close_broadcasting_latest_txn(&chan_1.2, &node_a_id, error_message.to_string()) + .unwrap(); check_closed_broadcast!(nodes[1], true); check_added_monitors!(nodes[1], 1); @@ -325,8 +424,14 @@ fn expect_channel_shutdown_state_with_force_closure() { assert!(nodes[0].node.list_channels().is_empty()); assert!(nodes[1].node.list_channels().is_empty()); check_closed_broadcast!(nodes[0], true); - check_closed_event!(nodes[0], 1, ClosureReason::CommitmentTxConfirmed, [nodes[1].node.get_our_node_id()], 100000); - check_closed_event!(nodes[1], 1, ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }, [nodes[0].node.get_our_node_id()], 100000); + check_closed_event!(nodes[0], 1, ClosureReason::CommitmentTxConfirmed, [node_b_id], 100000); + check_closed_event!( + nodes[1], + 1, + ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }, + [node_a_id], + 100000 + ); } #[test] @@ -336,6 +441,9 @@ fn updates_shutdown_wait() { let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); + let node_c_id = nodes[2].node.get_our_node_id(); let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1); let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2); let logger = test_utils::TestLogger::new(); @@ -343,50 +451,89 @@ fn updates_shutdown_wait() { let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet); let random_seed_bytes = keys_manager.get_secure_random_bytes(); - let (payment_preimage_0, payment_hash_0, ..) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100_000); + let (payment_preimage_0, payment_hash_0, ..) = + route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100_000); - nodes[0].node.close_channel(&chan_1.2, &nodes[1].node.get_our_node_id()).unwrap(); - let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); - let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_shutdown); + nodes[0].node.close_channel(&chan_1.2, &node_b_id).unwrap(); + let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, node_b_id); + nodes[1].node.handle_shutdown(node_a_id, &node_0_shutdown); + let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, node_a_id); + nodes[0].node.handle_shutdown(node_b_id, &node_1_shutdown); assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); let (_, payment_hash, payment_secret) = get_payment_preimage_hash!(nodes[0]); - let payment_params_1 = PaymentParameters::from_node_id(nodes[1].node.get_our_node_id(), TEST_FINAL_CLTV) - .with_bolt11_features(nodes[1].node.bolt11_invoice_features()).unwrap(); + let payment_params_1 = PaymentParameters::from_node_id(node_b_id, TEST_FINAL_CLTV) + .with_bolt11_features(nodes[1].node.bolt11_invoice_features()) + .unwrap(); let route_params = RouteParameters::from_payment_params_and_value(payment_params_1, 100_000); - let route_1 = get_route(&nodes[0].node.get_our_node_id(), &route_params, - &nodes[0].network_graph.read_only(), None, &logger, &scorer, &Default::default(), &random_seed_bytes).unwrap(); - let payment_params_2 = PaymentParameters::from_node_id(nodes[0].node.get_our_node_id(), TEST_FINAL_CLTV) - .with_bolt11_features(nodes[0].node.bolt11_invoice_features()).unwrap(); + let route_1 = get_route( + &node_a_id, + &route_params, + &nodes[0].network_graph.read_only(), + None, + &logger, + &scorer, + &Default::default(), + &random_seed_bytes, + ) + .unwrap(); + let payment_params_2 = PaymentParameters::from_node_id(node_a_id, TEST_FINAL_CLTV) + .with_bolt11_features(nodes[0].node.bolt11_invoice_features()) + .unwrap(); let route_params = RouteParameters::from_payment_params_and_value(payment_params_2, 100_000); - let route_2 = get_route(&nodes[1].node.get_our_node_id(), &route_params, - &nodes[1].network_graph.read_only(), None, &logger, &scorer, &Default::default(), &random_seed_bytes).unwrap(); - unwrap_send_err!(nodes[0], nodes[0].node.send_payment_with_route(route_1, payment_hash, - RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_hash.0) - ), true, APIError::ChannelUnavailable {..}, {}); - unwrap_send_err!(nodes[1], nodes[1].node.send_payment_with_route(route_2, payment_hash, - RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_hash.0) - ), true, APIError::ChannelUnavailable {..}, {}); + let route_2 = get_route( + &node_b_id, + &route_params, + &nodes[1].network_graph.read_only(), + None, + &logger, + &scorer, + &Default::default(), + &random_seed_bytes, + ) + .unwrap(); + unwrap_send_err!( + nodes[0], + nodes[0].node.send_payment_with_route( + route_1, + payment_hash, + RecipientOnionFields::secret_only(payment_secret), + PaymentId(payment_hash.0) + ), + true, + APIError::ChannelUnavailable { .. }, + {} + ); + unwrap_send_err!( + nodes[1], + nodes[1].node.send_payment_with_route( + route_2, + payment_hash, + RecipientOnionFields::secret_only(payment_secret), + PaymentId(payment_hash.0) + ), + true, + APIError::ChannelUnavailable { .. }, + {} + ); nodes[2].node.claim_funds(payment_preimage_0); check_added_monitors!(nodes[2], 1); expect_payment_claimed!(nodes[2], payment_hash_0, 100_000); - let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id()); + let updates = get_htlc_update_msgs!(nodes[2], node_b_id); assert!(updates.update_add_htlcs.is_empty()); assert!(updates.update_fail_htlcs.is_empty()); assert!(updates.update_fail_malformed_htlcs.is_empty()); assert!(updates.update_fee.is_none()); assert_eq!(updates.update_fulfill_htlcs.len(), 1); - nodes[1].node.handle_update_fulfill_htlc(nodes[2].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]); + nodes[1].node.handle_update_fulfill_htlc(node_c_id, &updates.update_fulfill_htlcs[0]); expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], Some(1000), false, false); check_added_monitors!(nodes[1], 1); - let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); + let updates_2 = get_htlc_update_msgs!(nodes[1], node_a_id); commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false); assert!(updates_2.update_add_htlcs.is_empty()); @@ -394,20 +541,34 @@ fn updates_shutdown_wait() { assert!(updates_2.update_fail_malformed_htlcs.is_empty()); assert!(updates_2.update_fee.is_none()); assert_eq!(updates_2.update_fulfill_htlcs.len(), 1); - nodes[0].node.handle_update_fulfill_htlc(nodes[1].node.get_our_node_id(), &updates_2.update_fulfill_htlcs[0]); + nodes[0].node.handle_update_fulfill_htlc(node_b_id, &updates_2.update_fulfill_htlcs[0]); commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true); expect_payment_sent!(nodes[0], payment_preimage_0); - let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); - let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); - let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap()); - let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); + let node_0_closing_signed = + get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, node_b_id); + nodes[1].node.handle_closing_signed(node_a_id, &node_0_closing_signed); + let node_1_closing_signed = + get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, node_a_id); + nodes[0].node.handle_closing_signed(node_b_id, &node_1_closing_signed); + let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, node_b_id); + nodes[1].node.handle_closing_signed(node_a_id, &node_0_2nd_closing_signed.unwrap()); + let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, node_a_id); assert!(node_1_none.is_none()); - check_closed_event!(nodes[0], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); - check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 100000); + check_closed_event!( + nodes[0], + 1, + ClosureReason::LocallyInitiatedCooperativeClosure, + [node_b_id], + 100000 + ); + check_closed_event!( + nodes[1], + 1, + ClosureReason::CounterpartyInitiatedCooperativeClosure, + [node_a_id], + 100000 + ); assert!(nodes[0].node.list_channels().is_empty()); @@ -416,8 +577,20 @@ fn updates_shutdown_wait() { close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true); assert!(nodes[1].node.list_channels().is_empty()); assert!(nodes[2].node.list_channels().is_empty()); - check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[2].node.get_our_node_id()], 100000); - check_closed_event!(nodes[2], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); + check_closed_event!( + nodes[1], + 1, + ClosureReason::CounterpartyInitiatedCooperativeClosure, + [node_c_id], + 100000 + ); + check_closed_event!( + nodes[2], + 1, + ClosureReason::LocallyInitiatedCooperativeClosure, + [node_b_id], + 100000 + ); } #[test] @@ -432,82 +605,112 @@ fn do_htlc_fail_async_shutdown(blinded_recipient: bool) { let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); + let node_c_id = nodes[2].node.get_our_node_id(); let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1); let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2); let amt_msat = 100000; - let (_, our_payment_hash, our_payment_secret) = get_payment_preimage_hash(&nodes[2], Some(amt_msat), None); + let (_, our_payment_hash, our_payment_secret) = + get_payment_preimage_hash(&nodes[2], Some(amt_msat), None); let route_params = if blinded_recipient { crate::ln::blinded_payment_tests::get_blinded_route_parameters( - amt_msat, our_payment_secret, 1, 100000000, - nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&chan_2.0.contents], - &chanmon_cfgs[2].keys_manager) + amt_msat, + our_payment_secret, + 1, + 100000000, + nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), + &[&chan_2.0.contents], + &chanmon_cfgs[2].keys_manager, + ) } else { RouteParameters::from_payment_params_and_value( - PaymentParameters::from_node_id(nodes[2].node.get_our_node_id(), TEST_FINAL_CLTV), amt_msat) + PaymentParameters::from_node_id(node_c_id, TEST_FINAL_CLTV), + amt_msat, + ) }; - nodes[0].node.send_payment(our_payment_hash, - RecipientOnionFields::secret_only(our_payment_secret), - PaymentId(our_payment_hash.0), route_params, Retry::Attempts(0)).unwrap(); + nodes[0] + .node + .send_payment( + our_payment_hash, + RecipientOnionFields::secret_only(our_payment_secret), + PaymentId(our_payment_hash.0), + route_params, + Retry::Attempts(0), + ) + .unwrap(); check_added_monitors!(nodes[0], 1); - let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id()); + let updates = get_htlc_update_msgs!(nodes[0], node_b_id); assert_eq!(updates.update_add_htlcs.len(), 1); assert!(updates.update_fulfill_htlcs.is_empty()); assert!(updates.update_fail_htlcs.is_empty()); assert!(updates.update_fail_malformed_htlcs.is_empty()); assert!(updates.update_fee.is_none()); - nodes[1].node.close_channel(&chan_1.2, &nodes[0].node.get_our_node_id()).unwrap(); - let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_shutdown); - let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); + nodes[1].node.close_channel(&chan_1.2, &node_a_id).unwrap(); + let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, node_a_id); + nodes[0].node.handle_shutdown(node_b_id, &node_1_shutdown); + let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, node_b_id); - nodes[1].node.handle_update_add_htlc(nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]); - nodes[1].node.handle_commitment_signed_batch_test(nodes[0].node.get_our_node_id(), &updates.commitment_signed); + nodes[1].node.handle_update_add_htlc(node_a_id, &updates.update_add_htlcs[0]); + nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &updates.commitment_signed); check_added_monitors!(nodes[1], 1); - nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); + nodes[1].node.handle_shutdown(node_a_id, &node_0_shutdown); commitment_signed_dance!(nodes[1], nodes[0], (), false, true, false, false); expect_pending_htlcs_forwardable!(nodes[1]); expect_htlc_handling_failed_destinations!( nodes[1].node.get_and_clear_pending_events(), - &[HTLCHandlingFailureType::Forward { node_id: Some(nodes[2].node.get_our_node_id()), channel_id: chan_2.2 }] + &[HTLCHandlingFailureType::Forward { node_id: Some(node_c_id), channel_id: chan_2.2 }] ); check_added_monitors(&nodes[1], 1); - let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); + let updates_2 = get_htlc_update_msgs!(nodes[1], node_a_id); assert!(updates_2.update_add_htlcs.is_empty()); assert!(updates_2.update_fulfill_htlcs.is_empty()); assert_eq!(updates_2.update_fail_htlcs.len(), 1); assert!(updates_2.update_fail_malformed_htlcs.is_empty()); assert!(updates_2.update_fee.is_none()); - nodes[0].node.handle_update_fail_htlc(nodes[1].node.get_our_node_id(), &updates_2.update_fail_htlcs[0]); + nodes[0].node.handle_update_fail_htlc(node_b_id, &updates_2.update_fail_htlcs[0]); commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true); if blinded_recipient { - expect_payment_failed_conditions(&nodes[0], our_payment_hash, false, - PaymentFailedConditions::new().expected_htlc_error_data(LocalHTLCFailureReason::InvalidOnionBlinding, &[0; 32])); + expect_payment_failed_conditions( + &nodes[0], + our_payment_hash, + false, + PaymentFailedConditions::new() + .expected_htlc_error_data(LocalHTLCFailureReason::InvalidOnionBlinding, &[0; 32]), + ); } else { - expect_payment_failed_with_update!(nodes[0], our_payment_hash, false, chan_2.0.contents.short_channel_id, true); + expect_payment_failed_with_update!( + nodes[0], + our_payment_hash, + false, + chan_2.0.contents.short_channel_id, + true + ); } let msg_events = nodes[0].node.get_and_clear_pending_msg_events(); assert_eq!(msg_events.len(), 1); let node_0_closing_signed = match msg_events[0] { MessageSendEvent::SendClosingSigned { ref node_id, ref msg } => { - assert_eq!(*node_id, nodes[1].node.get_our_node_id()); + assert_eq!(*node_id, node_b_id); (*msg).clone() }, _ => panic!("Unexpected event"), }; assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); - let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); - let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap()); - let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); + nodes[1].node.handle_closing_signed(node_a_id, &node_0_closing_signed); + let node_1_closing_signed = + get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, node_a_id); + nodes[0].node.handle_closing_signed(node_b_id, &node_1_closing_signed); + let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, node_b_id); + nodes[1].node.handle_closing_signed(node_a_id, &node_0_2nd_closing_signed.unwrap()); + let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, node_a_id); assert!(node_1_none.is_none()); assert!(nodes[0].node.list_channels().is_empty()); @@ -517,11 +720,17 @@ fn do_htlc_fail_async_shutdown(blinded_recipient: bool) { close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true); assert!(nodes[1].node.list_channels().is_empty()); assert!(nodes[2].node.list_channels().is_empty()); - check_closed_event!(nodes[0], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); + check_closed_event!( + nodes[0], + 1, + ClosureReason::CounterpartyInitiatedCooperativeClosure, + [node_b_id], + 100000 + ); let event1 = ExpectedCloseEvent { channel_capacity_sats: Some(100000), channel_id: None, - counterparty_node_id: Some(nodes[0].node.get_our_node_id()), + counterparty_node_id: Some(node_a_id), discard_funding: false, reason: Some(ClosureReason::LocallyInitiatedCooperativeClosure), channel_funding_txo: None, @@ -530,14 +739,20 @@ fn do_htlc_fail_async_shutdown(blinded_recipient: bool) { let event2 = ExpectedCloseEvent { channel_capacity_sats: Some(100000), channel_id: None, - counterparty_node_id: Some(nodes[2].node.get_our_node_id()), + counterparty_node_id: Some(node_c_id), discard_funding: false, reason: Some(ClosureReason::CounterpartyInitiatedCooperativeClosure), channel_funding_txo: None, user_channel_id: None, }; check_closed_events(&nodes[1], &[event1, event2]); - check_closed_event!(nodes[2], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); + check_closed_event!( + nodes[2], + 1, + ClosureReason::LocallyInitiatedCooperativeClosure, + [node_b_id], + 100000 + ); } fn do_test_shutdown_rebroadcast(recv_count: u8) { @@ -547,49 +762,73 @@ fn do_test_shutdown_rebroadcast(recv_count: u8) { let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); let nodes = create_network(3, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); + let node_c_id = nodes[2].node.get_our_node_id(); let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1); let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2); - let (payment_preimage, payment_hash, ..) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100_000); + let (payment_preimage, payment_hash, ..) = + route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100_000); - nodes[1].node.close_channel(&chan_1.2, &nodes[0].node.get_our_node_id()).unwrap(); - let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); + nodes[1].node.close_channel(&chan_1.2, &node_a_id).unwrap(); + let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, node_a_id); if recv_count > 0 { - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_shutdown); - let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); + nodes[0].node.handle_shutdown(node_b_id, &node_1_shutdown); + let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, node_b_id); if recv_count > 1 { - nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); + nodes[1].node.handle_shutdown(node_a_id, &node_0_shutdown); } } - nodes[0].node.peer_disconnected(nodes[1].node.get_our_node_id()); - nodes[1].node.peer_disconnected(nodes[0].node.get_our_node_id()); - - nodes[0].node.peer_connected(nodes[1].node.get_our_node_id(), &msgs::Init { - features: nodes[1].node.init_features(), networks: None, remote_network_address: None - }, true).unwrap(); + nodes[0].node.peer_disconnected(node_b_id); + nodes[1].node.peer_disconnected(node_a_id); + + nodes[0] + .node + .peer_connected( + node_b_id, + &msgs::Init { + features: nodes[1].node.init_features(), + networks: None, + remote_network_address: None, + }, + true, + ) + .unwrap(); let node_0_reestablish = get_chan_reestablish_msgs!(nodes[0], nodes[1]).pop().unwrap(); - nodes[1].node.peer_connected(nodes[0].node.get_our_node_id(), &msgs::Init { - features: nodes[0].node.init_features(), networks: None, remote_network_address: None - }, false).unwrap(); + nodes[1] + .node + .peer_connected( + node_a_id, + &msgs::Init { + features: nodes[0].node.init_features(), + networks: None, + remote_network_address: None, + }, + false, + ) + .unwrap(); let node_1_reestablish = get_chan_reestablish_msgs!(nodes[1], nodes[0]).pop().unwrap(); - nodes[1].node.handle_channel_reestablish(nodes[0].node.get_our_node_id(), &node_0_reestablish); - let node_1_2nd_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); + nodes[1].node.handle_channel_reestablish(node_a_id, &node_0_reestablish); + let node_1_2nd_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, node_a_id); assert!(node_1_shutdown == node_1_2nd_shutdown); - nodes[0].node.handle_channel_reestablish(nodes[1].node.get_our_node_id(), &node_1_reestablish); + nodes[0].node.handle_channel_reestablish(node_b_id, &node_1_reestablish); let node_0_2nd_shutdown = if recv_count > 0 { - let node_0_2nd_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_2nd_shutdown); + let node_0_2nd_shutdown = + get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, node_b_id); + nodes[0].node.handle_shutdown(node_b_id, &node_1_2nd_shutdown); node_0_2nd_shutdown } else { - let node_0_chan_update = get_event_msg!(nodes[0], MessageSendEvent::SendChannelUpdate, nodes[1].node.get_our_node_id()); + let node_0_chan_update = + get_event_msg!(nodes[0], MessageSendEvent::SendChannelUpdate, node_b_id); assert_eq!(node_0_chan_update.contents.channel_flags & 2, 0); // "disabled" flag must not be set as we just reconnected. - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_2nd_shutdown); - get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()) + nodes[0].node.handle_shutdown(node_b_id, &node_1_2nd_shutdown); + get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, node_b_id) }; - nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_2nd_shutdown); + nodes[1].node.handle_shutdown(node_a_id, &node_0_2nd_shutdown); assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); @@ -598,16 +837,16 @@ fn do_test_shutdown_rebroadcast(recv_count: u8) { check_added_monitors!(nodes[2], 1); expect_payment_claimed!(nodes[2], payment_hash, 100_000); - let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id()); + let updates = get_htlc_update_msgs!(nodes[2], node_b_id); assert!(updates.update_add_htlcs.is_empty()); assert!(updates.update_fail_htlcs.is_empty()); assert!(updates.update_fail_malformed_htlcs.is_empty()); assert!(updates.update_fee.is_none()); assert_eq!(updates.update_fulfill_htlcs.len(), 1); - nodes[1].node.handle_update_fulfill_htlc(nodes[2].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]); + nodes[1].node.handle_update_fulfill_htlc(node_c_id, &updates.update_fulfill_htlcs[0]); expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], Some(1000), false, false); check_added_monitors!(nodes[1], 1); - let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); + let updates_2 = get_htlc_update_msgs!(nodes[1], node_a_id); commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false); assert!(updates_2.update_add_htlcs.is_empty()); @@ -615,34 +854,55 @@ fn do_test_shutdown_rebroadcast(recv_count: u8) { assert!(updates_2.update_fail_malformed_htlcs.is_empty()); assert!(updates_2.update_fee.is_none()); assert_eq!(updates_2.update_fulfill_htlcs.len(), 1); - nodes[0].node.handle_update_fulfill_htlc(nodes[1].node.get_our_node_id(), &updates_2.update_fulfill_htlcs[0]); + nodes[0].node.handle_update_fulfill_htlc(node_b_id, &updates_2.update_fulfill_htlcs[0]); commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true); expect_payment_sent!(nodes[0], payment_preimage); - let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id()); + let node_0_closing_signed = + get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, node_b_id); if recv_count > 0 { - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); - let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); - let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); + nodes[1].node.handle_closing_signed(node_a_id, &node_0_closing_signed); + let node_1_closing_signed = + get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, node_a_id); + nodes[0].node.handle_closing_signed(node_b_id, &node_1_closing_signed); + let (_, node_0_2nd_closing_signed) = + get_closing_signed_broadcast!(nodes[0].node, node_b_id); assert!(node_0_2nd_closing_signed.is_some()); } - nodes[0].node.peer_disconnected(nodes[1].node.get_our_node_id()); - nodes[1].node.peer_disconnected(nodes[0].node.get_our_node_id()); - - nodes[1].node.peer_connected(nodes[0].node.get_our_node_id(), &msgs::Init { - features: nodes[0].node.init_features(), networks: None, remote_network_address: None - }, true).unwrap(); + nodes[0].node.peer_disconnected(node_b_id); + nodes[1].node.peer_disconnected(node_a_id); + + nodes[1] + .node + .peer_connected( + node_a_id, + &msgs::Init { + features: nodes[0].node.init_features(), + networks: None, + remote_network_address: None, + }, + true, + ) + .unwrap(); let node_1_2nd_reestablish = get_chan_reestablish_msgs!(nodes[1], nodes[0]).pop().unwrap(); - nodes[0].node.peer_connected(nodes[1].node.get_our_node_id(), &msgs::Init { - features: nodes[1].node.init_features(), networks: None, remote_network_address: None - }, false).unwrap(); + nodes[0] + .node + .peer_connected( + node_b_id, + &msgs::Init { + features: nodes[1].node.init_features(), + networks: None, + remote_network_address: None, + }, + false, + ) + .unwrap(); if recv_count == 0 { // If all closing_signeds weren't delivered we can just resume where we left off... let node_0_2nd_reestablish = get_chan_reestablish_msgs!(nodes[0], nodes[1]).pop().unwrap(); - nodes[0].node.handle_channel_reestablish(nodes[1].node.get_our_node_id(), &node_1_2nd_reestablish); + nodes[0].node.handle_channel_reestablish(node_b_id, &node_1_2nd_reestablish); let node_0_msgs = nodes[0].node.get_and_clear_pending_msg_events(); assert_eq!(node_0_msgs.len(), 2); let node_0_2nd_closing_signed = match node_0_msgs[1] { @@ -662,23 +922,32 @@ fn do_test_shutdown_rebroadcast(recv_count: u8) { }; assert!(node_0_2nd_shutdown == node_0_3rd_shutdown); - nodes[1].node.handle_channel_reestablish(nodes[0].node.get_our_node_id(), &node_0_2nd_reestablish); - let node_1_3rd_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); + nodes[1].node.handle_channel_reestablish(node_a_id, &node_0_2nd_reestablish); + let node_1_3rd_shutdown = + get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, node_a_id); assert!(node_1_3rd_shutdown == node_1_2nd_shutdown); - nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_3rd_shutdown); + nodes[1].node.handle_shutdown(node_a_id, &node_0_3rd_shutdown); assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_3rd_shutdown); + nodes[0].node.handle_shutdown(node_b_id, &node_1_3rd_shutdown); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed); - let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); - let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap()); - let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); + nodes[1].node.handle_closing_signed(node_a_id, &node_0_2nd_closing_signed); + let node_1_closing_signed = + get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, node_a_id); + nodes[0].node.handle_closing_signed(node_b_id, &node_1_closing_signed); + let (_, node_0_2nd_closing_signed) = + get_closing_signed_broadcast!(nodes[0].node, node_b_id); + nodes[1].node.handle_closing_signed(node_a_id, &node_0_2nd_closing_signed.unwrap()); + let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, node_a_id); assert!(node_1_none.is_none()); - check_closed_event!(nodes[1], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 100000); + check_closed_event!( + nodes[1], + 1, + ClosureReason::LocallyInitiatedCooperativeClosure, + [node_a_id], + 100000 + ); } else { // If one node, however, received + responded with an identical closing_signed we end // up erroring and node[0] will try to broadcast its own latest commitment transaction. @@ -689,26 +958,28 @@ fn do_test_shutdown_rebroadcast(recv_count: u8) { // transaction. assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - nodes[0].node.handle_channel_reestablish(nodes[1].node.get_our_node_id(), &node_1_2nd_reestablish); + nodes[0].node.handle_channel_reestablish(node_b_id, &node_1_2nd_reestablish); let msg_events = nodes[0].node.get_and_clear_pending_msg_events(); assert_eq!(msg_events.len(), 2); if let MessageSendEvent::HandleError { ref action, .. } = msg_events[1] { match action { &ErrorAction::SendErrorMessage { ref msg } => { - nodes[1].node.handle_error(nodes[0].node.get_our_node_id(), &msg); + nodes[1].node.handle_error(node_a_id, &msg); assert_eq!(msg.channel_id, chan_1.2); }, _ => panic!("Unexpected event!"), } - } else { panic!("Needed SendErrorMessage close"); } + } else { + panic!("Needed SendErrorMessage close"); + } // get_closing_signed_broadcast usually eats the BroadcastChannelUpdate for us and // checks it, but in this case nodes[1] didn't ever get a chance to receive a // closing_signed so we do it ourselves check_closed_broadcast!(nodes[1], false); check_added_monitors!(nodes[1], 1); - check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyForceClosed { peer_msg: UntrustedString(format!("Got a message for a channel from the wrong node! No such channel for the passed counterparty_node_id {}", &nodes[1].node.get_our_node_id())) } - , [nodes[0].node.get_our_node_id()], 100000); + check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyForceClosed { peer_msg: UntrustedString(format!("Got a message for a channel from the wrong node! No such channel for the passed counterparty_node_id {}", &node_b_id)) } + , [node_a_id], 100000); } assert!(nodes[0].node.list_channels().is_empty()); @@ -718,9 +989,27 @@ fn do_test_shutdown_rebroadcast(recv_count: u8) { close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true); assert!(nodes[1].node.list_channels().is_empty()); assert!(nodes[2].node.list_channels().is_empty()); - check_closed_event!(nodes[0], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); - check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[2].node.get_our_node_id()], 100000); - check_closed_event!(nodes[2], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); + check_closed_event!( + nodes[0], + 1, + ClosureReason::CounterpartyInitiatedCooperativeClosure, + [node_b_id], + 100000 + ); + check_closed_event!( + nodes[1], + 1, + ClosureReason::CounterpartyInitiatedCooperativeClosure, + [node_c_id], + 100000 + ); + check_closed_event!( + nodes[2], + 1, + ClosureReason::LocallyInitiatedCooperativeClosure, + [node_b_id], + 100000 + ); } #[test] @@ -744,32 +1033,38 @@ fn test_upfront_shutdown_script() { let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs); let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); + let node_c_id = nodes[2].node.get_our_node_id(); // We test that in case of peer committing upfront to a script, if it changes at closing, we refuse to sign let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 1000000, 1000000); - nodes[0].node.close_channel(&chan.2, &nodes[2].node.get_our_node_id()).unwrap(); - let node_0_orig_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[2].node.get_our_node_id()); + nodes[0].node.close_channel(&chan.2, &node_c_id).unwrap(); + let node_0_orig_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, node_c_id); let mut node_0_shutdown = node_0_orig_shutdown.clone(); - node_0_shutdown.scriptpubkey = Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script().to_p2sh(); + node_0_shutdown.scriptpubkey = + Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script().to_p2sh(); // Test we enforce upfront_scriptpbukey if by providing a different one at closing that we warn // the peer and ignore the message. - nodes[2].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); + nodes[2].node.handle_shutdown(node_a_id, &node_0_shutdown); assert!(regex::Regex::new(r"Got shutdown request with a scriptpubkey \([A-Fa-f0-9]+\) which did not match their previous scriptpubkey.") - .unwrap().is_match(&check_warn_msg!(nodes[2], nodes[0].node.get_our_node_id(), chan.2))); + .unwrap().is_match(&check_warn_msg!(nodes[2], node_a_id, chan.2))); // This allows nodes[2] to retry the shutdown message, which should get a response: - nodes[2].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_orig_shutdown); - get_event_msg!(nodes[2], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); + nodes[2].node.handle_shutdown(node_a_id, &node_0_orig_shutdown); + get_event_msg!(nodes[2], MessageSendEvent::SendShutdown, node_a_id); // We test that in case of peer committing upfront to a script, if it doesn't change at closing, we sign let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 1000000, 1000000); - nodes[0].node.close_channel(&chan.2, &nodes[2].node.get_our_node_id()).unwrap(); - let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[2].node.get_our_node_id()); + nodes[0].node.close_channel(&chan.2, &node_c_id).unwrap(); + let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, node_c_id); // We test that in case of peer committing upfront to a script, if it oesn't change at closing, we sign - nodes[2].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); + nodes[2].node.handle_shutdown(node_a_id, &node_0_shutdown); let events = nodes[2].node.get_and_clear_pending_msg_events(); assert_eq!(events.len(), 1); match events[0] { - MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[0].node.get_our_node_id()) } + MessageSendEvent::SendShutdown { node_id, .. } => { + assert_eq!(node_id, node_a_id) + }, _ => panic!("Unexpected event"), } @@ -778,14 +1073,16 @@ fn test_upfront_shutdown_script() { features.clear_upfront_shutdown_script(); *nodes[0].override_init_features.borrow_mut() = Some(features); let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000); - nodes[0].node.close_channel(&chan.2, &nodes[1].node.get_our_node_id()).unwrap(); - let node_1_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_1_shutdown); + nodes[0].node.close_channel(&chan.2, &node_b_id).unwrap(); + let node_1_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, node_b_id); + nodes[1].node.handle_shutdown(node_a_id, &node_1_shutdown); check_added_monitors!(nodes[1], 1); let events = nodes[1].node.get_and_clear_pending_msg_events(); assert_eq!(events.len(), 1); match events[0] { - MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[0].node.get_our_node_id()) } + MessageSendEvent::SendShutdown { node_id, .. } => { + assert_eq!(node_id, node_a_id) + }, _ => panic!("Unexpected event"), } @@ -793,32 +1090,38 @@ fn test_upfront_shutdown_script() { // channel smoothly, opt-out is from channel initiator here *nodes[0].override_init_features.borrow_mut() = None; let chan = create_announced_chan_between_nodes_with_value(&nodes, 1, 0, 1000000, 1000000); - nodes[1].node.close_channel(&chan.2, &nodes[0].node.get_our_node_id()).unwrap(); + nodes[1].node.close_channel(&chan.2, &node_a_id).unwrap(); check_added_monitors!(nodes[1], 1); - let node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_0_shutdown); + let node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, node_a_id); + nodes[0].node.handle_shutdown(node_b_id, &node_0_shutdown); let events = nodes[0].node.get_and_clear_pending_msg_events(); assert_eq!(events.len(), 1); match events[0] { - MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) } + MessageSendEvent::SendShutdown { node_id, .. } => { + assert_eq!(node_id, node_b_id) + }, _ => panic!("Unexpected event"), } //// We test that if user opt-out, we provide a zero-length script at channel opening and we are able to close //// channel smoothly let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000); - nodes[1].node.close_channel(&chan.2, &nodes[0].node.get_our_node_id()).unwrap(); + nodes[1].node.close_channel(&chan.2, &node_a_id).unwrap(); check_added_monitors!(nodes[1], 1); - let node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_0_shutdown); + let node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, node_a_id); + nodes[0].node.handle_shutdown(node_b_id, &node_0_shutdown); let events = nodes[0].node.get_and_clear_pending_msg_events(); assert_eq!(events.len(), 2); match events[0] { - MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) } + MessageSendEvent::SendShutdown { node_id, .. } => { + assert_eq!(node_id, node_b_id) + }, _ => panic!("Unexpected event"), } match events[1] { - MessageSendEvent::SendClosingSigned { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) } + MessageSendEvent::SendClosingSigned { node_id, .. } => { + assert_eq!(node_id, node_b_id) + }, _ => panic!("Unexpected event"), } } @@ -833,24 +1136,26 @@ fn test_unsupported_anysegwit_upfront_shutdown_script() { *node_cfgs[0].override_init_features.borrow_mut() = Some(features); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); // Use a non-v0 segwit script supported by option_shutdown_anysegwit - let anysegwit_shutdown_script = Builder::new() - .push_int(16) - .push_slice(&[0, 40]) - .into_script(); + let anysegwit_shutdown_script = Builder::new().push_int(16).push_slice(&[0, 40]).into_script(); // Check script when handling an open_channel message - nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None, None).unwrap(); - let mut open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); + nodes[0].node.create_channel(node_b_id, 100000, 10001, 42, None, None).unwrap(); + let mut open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, node_b_id); open_channel.common_fields.shutdown_scriptpubkey = Some(anysegwit_shutdown_script.clone()); - nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel); + nodes[1].node.handle_open_channel(node_a_id, &open_channel); let events = nodes[1].node.get_and_clear_pending_msg_events(); assert_eq!(events.len(), 1); match events[0] { - MessageSendEvent::HandleError { action: ErrorAction::SendErrorMessage { ref msg }, node_id } => { - assert_eq!(node_id, nodes[0].node.get_our_node_id()); + MessageSendEvent::HandleError { + action: ErrorAction::SendErrorMessage { ref msg }, + node_id, + } => { + assert_eq!(node_id, node_a_id); assert_eq!(msg.data, "Peer is signaling upfront_shutdown but has provided an unacceptable scriptpubkey format: OP_PUSHNUM_16 OP_PUSHBYTES_2 0028"); }, _ => panic!("Unexpected event"), @@ -864,26 +1169,32 @@ fn test_unsupported_anysegwit_upfront_shutdown_script() { *node_cfgs[1].override_init_features.borrow_mut() = Some(features); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); // Check script when handling an accept_channel message - nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None, None).unwrap(); - let open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel); - let mut accept_channel = get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id()); + nodes[0].node.create_channel(node_b_id, 100000, 10001, 42, None, None).unwrap(); + let open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, node_b_id); + nodes[1].node.handle_open_channel(node_a_id, &open_channel); + let mut accept_channel = + get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, node_a_id); accept_channel.common_fields.shutdown_scriptpubkey = Some(anysegwit_shutdown_script.clone()); - nodes[0].node.handle_accept_channel(nodes[1].node.get_our_node_id(), &accept_channel); + nodes[0].node.handle_accept_channel(node_b_id, &accept_channel); let events = nodes[0].node.get_and_clear_pending_msg_events(); assert_eq!(events.len(), 1); match events[0] { - MessageSendEvent::HandleError { action: ErrorAction::SendErrorMessage { ref msg }, node_id } => { - assert_eq!(node_id, nodes[1].node.get_our_node_id()); + MessageSendEvent::HandleError { + action: ErrorAction::SendErrorMessage { ref msg }, + node_id, + } => { + assert_eq!(node_id, node_b_id); assert_eq!(msg.data, "Peer is signaling upfront_shutdown but has provided an unacceptable scriptpubkey format: OP_PUSHNUM_16 OP_PUSHBYTES_2 0028"); }, _ => panic!("Unexpected event"), } check_closed_event!(nodes[0], 1, ClosureReason::ProcessingError { err: "Peer is signaling upfront_shutdown but has provided an unacceptable scriptpubkey format: OP_PUSHNUM_16 OP_PUSHBYTES_2 0028".to_string() } - , [nodes[1].node.get_our_node_id()], 100000); + , [node_b_id], 100000); } #[test] @@ -892,21 +1203,25 @@ fn test_invalid_upfront_shutdown_script() { let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); - nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None, None).unwrap(); + nodes[0].node.create_channel(node_b_id, 100000, 10001, 42, None, None).unwrap(); // Use a segwit v0 script with an unsupported witness program - let mut open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); - open_channel.common_fields.shutdown_scriptpubkey = Some(Builder::new().push_int(0) - .push_slice(&[0, 0]) - .into_script()); - nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel); + let mut open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, node_b_id); + open_channel.common_fields.shutdown_scriptpubkey = + Some(Builder::new().push_int(0).push_slice(&[0, 0]).into_script()); + nodes[1].node.handle_open_channel(node_a_id, &open_channel); let events = nodes[1].node.get_and_clear_pending_msg_events(); assert_eq!(events.len(), 1); match events[0] { - MessageSendEvent::HandleError { action: ErrorAction::SendErrorMessage { ref msg }, node_id } => { - assert_eq!(node_id, nodes[0].node.get_our_node_id()); + MessageSendEvent::HandleError { + action: ErrorAction::SendErrorMessage { ref msg }, + node_id, + } => { + assert_eq!(node_id, node_a_id); assert_eq!(msg.data, "Peer is signaling upfront_shutdown but has provided an unacceptable scriptpubkey format: OP_0 OP_PUSHBYTES_2 0000"); }, _ => panic!("Unexpected event"), @@ -924,26 +1239,30 @@ fn test_segwit_v0_shutdown_script() { let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs); let nodes = create_network(3, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); let chan = create_announced_chan_between_nodes(&nodes, 0, 1); - nodes[1].node.close_channel(&chan.2, &nodes[0].node.get_our_node_id()).unwrap(); + nodes[1].node.close_channel(&chan.2, &node_a_id).unwrap(); check_added_monitors!(nodes[1], 1); // Use a segwit v0 script supported even without option_shutdown_anysegwit - let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - node_0_shutdown.scriptpubkey = Builder::new().push_int(0) - .push_slice(&[0; 20]) - .into_script(); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_0_shutdown); + let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, node_a_id); + node_0_shutdown.scriptpubkey = Builder::new().push_int(0).push_slice(&[0; 20]).into_script(); + nodes[0].node.handle_shutdown(node_b_id, &node_0_shutdown); let events = nodes[0].node.get_and_clear_pending_msg_events(); assert_eq!(events.len(), 2); match events[0] { - MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) } + MessageSendEvent::SendShutdown { node_id, .. } => { + assert_eq!(node_id, node_b_id) + }, _ => panic!("Unexpected event"), } match events[1] { - MessageSendEvent::SendClosingSigned { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) } + MessageSendEvent::SendClosingSigned { node_id, .. } => { + assert_eq!(node_id, node_b_id) + }, _ => panic!("Unexpected event"), } } @@ -959,26 +1278,30 @@ fn test_anysegwit_shutdown_script() { let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs); let nodes = create_network(3, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); let chan = create_announced_chan_between_nodes(&nodes, 0, 1); - nodes[1].node.close_channel(&chan.2, &nodes[0].node.get_our_node_id()).unwrap(); + nodes[1].node.close_channel(&chan.2, &node_a_id).unwrap(); check_added_monitors!(nodes[1], 1); // Use a non-v0 segwit script supported by option_shutdown_anysegwit - let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - node_0_shutdown.scriptpubkey = Builder::new().push_int(16) - .push_slice(&[0, 0]) - .into_script(); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_0_shutdown); + let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, node_a_id); + node_0_shutdown.scriptpubkey = Builder::new().push_int(16).push_slice(&[0, 0]).into_script(); + nodes[0].node.handle_shutdown(node_b_id, &node_0_shutdown); let events = nodes[0].node.get_and_clear_pending_msg_events(); assert_eq!(events.len(), 2); match events[0] { - MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) } + MessageSendEvent::SendShutdown { node_id, .. } => { + assert_eq!(node_id, node_b_id) + }, _ => panic!("Unexpected event"), } match events[1] { - MessageSendEvent::SendClosingSigned { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) } + MessageSendEvent::SendClosingSigned { node_id, .. } => { + assert_eq!(node_id, node_b_id) + }, _ => panic!("Unexpected event"), } } @@ -998,34 +1321,40 @@ fn test_unsupported_anysegwit_shutdown_script() { *node_cfgs[1].override_init_features.borrow_mut() = Some(features); let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs); let nodes = create_network(3, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); // Check that using an unsupported shutdown script fails and a supported one succeeds. - let supported_shutdown_script = chanmon_cfgs[1].keys_manager.get_shutdown_scriptpubkey().unwrap(); + let supported_shutdown_script = + chanmon_cfgs[1].keys_manager.get_shutdown_scriptpubkey().unwrap(); let unsupported_witness_program = WitnessProgram::new(WitnessVersion::V16, &[0, 40]).unwrap(); let unsupported_shutdown_script = ShutdownScript::new_witness_program(&unsupported_witness_program).unwrap(); - chanmon_cfgs[1].keys_manager + chanmon_cfgs[1] + .keys_manager .expect(OnGetShutdownScriptpubkey { returns: unsupported_shutdown_script.clone() }) .expect(OnGetShutdownScriptpubkey { returns: supported_shutdown_script }); let chan = create_announced_chan_between_nodes(&nodes, 0, 1); - match nodes[1].node.close_channel(&chan.2, &nodes[0].node.get_our_node_id()) { + match nodes[1].node.close_channel(&chan.2, &node_a_id) { Err(APIError::IncompatibleShutdownScript { script }) => { assert_eq!(script.into_inner(), unsupported_shutdown_script.clone().into_inner()); }, Err(e) => panic!("Unexpected error: {:?}", e), Ok(_) => panic!("Expected error"), } - nodes[1].node.close_channel(&chan.2, &nodes[0].node.get_our_node_id()).unwrap(); + nodes[1].node.close_channel(&chan.2, &node_a_id).unwrap(); check_added_monitors!(nodes[1], 1); // Use a non-v0 segwit script unsupported without option_shutdown_anysegwit - let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); + let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, node_a_id); node_0_shutdown.scriptpubkey = unsupported_shutdown_script.into_inner(); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_0_shutdown); + nodes[0].node.handle_shutdown(node_b_id, &node_0_shutdown); - assert_eq!(&check_warn_msg!(nodes[0], nodes[1].node.get_our_node_id(), chan.2), - "Got a nonstandard scriptpubkey (60020028) from remote peer"); + assert_eq!( + &check_warn_msg!(nodes[0], node_b_id, chan.2), + "Got a nonstandard scriptpubkey (60020028) from remote peer" + ); } #[test] @@ -1039,20 +1368,22 @@ fn test_invalid_shutdown_script() { let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs); let nodes = create_network(3, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); let chan = create_announced_chan_between_nodes(&nodes, 0, 1); - nodes[1].node.close_channel(&chan.2, &nodes[0].node.get_our_node_id()).unwrap(); + nodes[1].node.close_channel(&chan.2, &node_a_id).unwrap(); check_added_monitors!(nodes[1], 1); // Use a segwit v0 script with an unsupported witness program - let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - node_0_shutdown.scriptpubkey = Builder::new().push_int(0) - .push_slice(&[0, 0]) - .into_script(); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_0_shutdown); - - assert_eq!(&check_warn_msg!(nodes[0], nodes[1].node.get_our_node_id(), chan.2), - "Got a nonstandard scriptpubkey (00020000) from remote peer"); + let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, node_a_id); + node_0_shutdown.scriptpubkey = Builder::new().push_int(0).push_slice(&[0, 0]).into_script(); + nodes[0].node.handle_shutdown(node_b_id, &node_0_shutdown); + + assert_eq!( + &check_warn_msg!(nodes[0], node_b_id, chan.2), + "Got a nonstandard scriptpubkey (00020000) from remote peer" + ); } #[test] @@ -1066,19 +1397,21 @@ fn test_user_shutdown_script() { let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs); let nodes = create_network(3, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); // Segwit v0 script of the form OP_0 <20-byte hash> - let script = Builder::new().push_int(0) - .push_slice(&[0; 20]) - .into_script(); + let script = Builder::new().push_int(0).push_slice(&[0; 20]).into_script(); let shutdown_script = ShutdownScript::try_from(script.clone()).unwrap(); let chan = create_announced_chan_between_nodes(&nodes, 0, 1); - nodes[1].node.close_channel_with_feerate_and_script(&chan.2, &nodes[0].node.get_our_node_id(), None, Some(shutdown_script)).unwrap(); + nodes[1] + .node + .close_channel_with_feerate_and_script(&chan.2, &node_a_id, None, Some(shutdown_script)) + .unwrap(); check_added_monitors!(nodes[1], 1); - let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); + let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, node_a_id); assert_eq!(node_0_shutdown.scriptpubkey, script); } @@ -1093,18 +1426,27 @@ fn test_already_set_user_shutdown_script() { let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs); let nodes = create_network(3, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); // Segwit v0 script of the form OP_0 <20-byte hash> - let script = Builder::new().push_int(0) - .push_slice(&[0; 20]) - .into_script(); + let script = Builder::new().push_int(0).push_slice(&[0; 20]).into_script(); let shutdown_script = ShutdownScript::try_from(script).unwrap(); let chan = create_announced_chan_between_nodes(&nodes, 0, 1); - let result = nodes[1].node.close_channel_with_feerate_and_script(&chan.2, &nodes[0].node.get_our_node_id(), None, Some(shutdown_script)); + let result = nodes[1].node.close_channel_with_feerate_and_script( + &chan.2, + &node_a_id, + None, + Some(shutdown_script), + ); - assert_eq!(result, Err(APIError::APIMisuseError { err: "Cannot override shutdown script for a channel with one already set".to_string() })); + assert_eq!( + result, + Err(APIError::APIMisuseError { + err: "Cannot override shutdown script for a channel with one already set".to_string() + }) + ); } #[derive(PartialEq)] @@ -1127,15 +1469,17 @@ fn do_test_closing_signed_reinit_timeout(timeout_step: TimeoutStep) { let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; send_payment(&nodes[0], &[&nodes[1]], 8_000_000); - nodes[0].node.close_channel(&chan_id, &nodes[1].node.get_our_node_id()).unwrap(); - let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); - let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_shutdown); + nodes[0].node.close_channel(&chan_id, &node_b_id).unwrap(); + let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, node_b_id); + nodes[1].node.handle_shutdown(node_a_id, &node_0_shutdown); + let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, node_a_id); + nodes[0].node.handle_shutdown(node_b_id, &node_1_shutdown); { // Now we set nodes[1] to require a relatively high feerate for closing. This should result @@ -1145,14 +1489,15 @@ fn do_test_closing_signed_reinit_timeout(timeout_step: TimeoutStep) { *feerate_lock *= 10; } - let mut node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id()); + let mut node_0_closing_signed = + get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, node_b_id); // nodes[0] should use a "reasonable" feerate, well under the 10 sat/vByte that nodes[1] thinks // is the current prevailing feerate. assert!(node_0_closing_signed.fee_satoshis <= 500); if timeout_step != TimeoutStep::AfterShutdown { - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); - assert!(check_warn_msg!(nodes[1], nodes[0].node.get_our_node_id(), chan_id) + nodes[1].node.handle_closing_signed(node_a_id, &node_0_closing_signed); + assert!(check_warn_msg!(nodes[1], node_a_id, chan_id) .starts_with("Unable to come to consensus about closing feerate")); // Now deliver a mutated closing_signed indicating a higher acceptable fee range, which @@ -1161,17 +1506,41 @@ fn do_test_closing_signed_reinit_timeout(timeout_step: TimeoutStep) { { let mut node_0_per_peer_lock; let mut node_0_peer_state_lock; - get_channel_ref!(nodes[0], nodes[1], node_0_per_peer_lock, node_0_peer_state_lock, chan_id).context_mut().closing_fee_limits.as_mut().unwrap().1 *= 10; + get_channel_ref!( + nodes[0], + nodes[1], + node_0_per_peer_lock, + node_0_peer_state_lock, + chan_id + ) + .context_mut() + .closing_fee_limits + .as_mut() + .unwrap() + .1 *= 10; } - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); - let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); - let node_0_2nd_closing_signed = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); + nodes[1].node.handle_closing_signed(node_a_id, &node_0_closing_signed); + let node_1_closing_signed = + get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, node_a_id); + nodes[0].node.handle_closing_signed(node_b_id, &node_1_closing_signed); + let node_0_2nd_closing_signed = get_closing_signed_broadcast!(nodes[0].node, node_b_id); if timeout_step == TimeoutStep::NoTimeout { - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.1.unwrap()); - check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 100000); + nodes[1].node.handle_closing_signed(node_a_id, &node_0_2nd_closing_signed.1.unwrap()); + check_closed_event!( + nodes[1], + 1, + ClosureReason::CounterpartyInitiatedCooperativeClosure, + [node_a_id], + 100000 + ); } - check_closed_event!(nodes[0], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); + check_closed_event!( + nodes[0], + 1, + ClosureReason::LocallyInitiatedCooperativeClosure, + [node_b_id], + 100000 + ); } if timeout_step != TimeoutStep::NoTimeout { @@ -1188,14 +1557,24 @@ fn do_test_closing_signed_reinit_timeout(timeout_step: TimeoutStep) { assert_eq!(txn[0].output.len(), 2); if timeout_step != TimeoutStep::NoTimeout { - assert!((txn[0].output[0].script_pubkey.is_p2wpkh() && - txn[0].output[1].script_pubkey.is_p2wsh()) || - (txn[0].output[1].script_pubkey.is_p2wpkh() && - txn[0].output[0].script_pubkey.is_p2wsh())); + assert!( + (txn[0].output[0].script_pubkey.is_p2wpkh() + && txn[0].output[1].script_pubkey.is_p2wsh()) + || (txn[0].output[1].script_pubkey.is_p2wpkh() + && txn[0].output[0].script_pubkey.is_p2wsh()) + ); check_closed_broadcast!(nodes[1], true); check_added_monitors!(nodes[1], 1); - check_closed_event!(nodes[1], 1, ClosureReason::ProcessingError { err: "closing_signed negotiation failed to finish within two timer ticks".to_string() } - , [nodes[0].node.get_our_node_id()], 100000); + check_closed_event!( + nodes[1], + 1, + ClosureReason::ProcessingError { + err: "closing_signed negotiation failed to finish within two timer ticks" + .to_string() + }, + [node_a_id], + 100000 + ); } else { assert!(txn[0].output[0].script_pubkey.is_p2wpkh()); assert!(txn[0].output[1].script_pubkey.is_p2wpkh()); @@ -1224,6 +1603,8 @@ fn do_simple_legacy_shutdown_test(high_initiator_fee: bool) { let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); let chan = create_announced_chan_between_nodes(&nodes, 0, 1); @@ -1234,13 +1615,14 @@ fn do_simple_legacy_shutdown_test(high_initiator_fee: bool) { *feerate_lock *= 10; } - nodes[0].node.close_channel(&chan.2, &nodes[1].node.get_our_node_id()).unwrap(); - let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); - let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_shutdown); + nodes[0].node.close_channel(&chan.2, &node_b_id).unwrap(); + let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, node_b_id); + nodes[1].node.handle_shutdown(node_a_id, &node_0_shutdown); + let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, node_a_id); + nodes[0].node.handle_shutdown(node_b_id, &node_1_shutdown); - let mut node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id()); + let mut node_0_closing_signed = + get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, node_b_id); node_0_closing_signed.fee_range = None; if high_initiator_fee { assert!(node_0_closing_signed.fee_satoshis > 500); @@ -1248,15 +1630,27 @@ fn do_simple_legacy_shutdown_test(high_initiator_fee: bool) { assert!(node_0_closing_signed.fee_satoshis < 500); } - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); - let (_, mut node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); + nodes[1].node.handle_closing_signed(node_a_id, &node_0_closing_signed); + let (_, mut node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, node_a_id); node_1_closing_signed.as_mut().unwrap().fee_range = None; - nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed.unwrap()); - let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); + nodes[0].node.handle_closing_signed(node_b_id, &node_1_closing_signed.unwrap()); + let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, node_b_id); assert!(node_0_none.is_none()); - check_closed_event!(nodes[0], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); - check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 100000); + check_closed_event!( + nodes[0], + 1, + ClosureReason::LocallyInitiatedCooperativeClosure, + [node_b_id], + 100000 + ); + check_closed_event!( + nodes[1], + 1, + ClosureReason::CounterpartyInitiatedCooperativeClosure, + [node_a_id], + 100000 + ); } #[test] @@ -1272,46 +1666,75 @@ fn simple_target_feerate_shutdown() { let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); let chan = create_announced_chan_between_nodes(&nodes, 0, 1); let chan_id = chan.2; - nodes[0].node.close_channel_with_feerate_and_script(&chan_id, &nodes[1].node.get_our_node_id(), Some(253 * 10), None).unwrap(); - let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); - nodes[1].node.close_channel_with_feerate_and_script(&chan_id, &nodes[0].node.get_our_node_id(), Some(253 * 5), None).unwrap(); - let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - - nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_shutdown); - - let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); - let (_, node_1_closing_signed_opt) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); + nodes[0] + .node + .close_channel_with_feerate_and_script(&chan_id, &node_b_id, Some(253 * 10), None) + .unwrap(); + let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, node_b_id); + nodes[1] + .node + .close_channel_with_feerate_and_script(&chan_id, &node_a_id, Some(253 * 5), None) + .unwrap(); + let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, node_a_id); + + nodes[1].node.handle_shutdown(node_a_id, &node_0_shutdown); + nodes[0].node.handle_shutdown(node_b_id, &node_1_shutdown); + + let node_0_closing_signed = + get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, node_b_id); + nodes[1].node.handle_closing_signed(node_a_id, &node_0_closing_signed); + let (_, node_1_closing_signed_opt) = get_closing_signed_broadcast!(nodes[1].node, node_a_id); let node_1_closing_signed = node_1_closing_signed_opt.unwrap(); // nodes[1] was passed a target which was larger than the current channel feerate, which it // should ignore in favor of the channel fee, as there is no use demanding a minimum higher // than what will be paid on a force-close transaction. Note that we have to consider rounding, // so only check that we're within 10 sats. - assert!(node_0_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis >= - node_1_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis * 10 - 5); - assert!(node_0_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis <= - node_1_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis * 10 + 5); + assert!( + node_0_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis + >= node_1_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis * 10 - 5 + ); + assert!( + node_0_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis + <= node_1_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis * 10 + 5 + ); // Further, because nodes[0]'s target fee is larger than the `Normal` fee estimation plus our // force-closure-avoidance buffer, min should equal max, and the nodes[1]-selected fee should // be the nodes[0] only available fee. - assert_eq!(node_0_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis, - node_0_closing_signed.fee_range.as_ref().unwrap().max_fee_satoshis); - assert_eq!(node_0_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis, - node_0_closing_signed.fee_satoshis); + assert_eq!( + node_0_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis, + node_0_closing_signed.fee_range.as_ref().unwrap().max_fee_satoshis + ); + assert_eq!( + node_0_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis, + node_0_closing_signed.fee_satoshis + ); assert_eq!(node_0_closing_signed.fee_satoshis, node_1_closing_signed.fee_satoshis); - nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); - let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); + nodes[0].node.handle_closing_signed(node_b_id, &node_1_closing_signed); + let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, node_b_id); assert!(node_0_none.is_none()); - check_closed_event!(nodes[0], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); - check_closed_event!(nodes[1], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 100000); + check_closed_event!( + nodes[0], + 1, + ClosureReason::LocallyInitiatedCooperativeClosure, + [node_b_id], + 100000 + ); + check_closed_event!( + nodes[1], + 1, + ClosureReason::LocallyInitiatedCooperativeClosure, + [node_a_id], + 100000 + ); } fn do_outbound_update_no_early_closing_signed(use_htlc: bool) { @@ -1325,45 +1748,46 @@ fn do_outbound_update_no_early_closing_signed(use_htlc: bool) { let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let node_a_id = nodes[0].node.get_our_node_id(); + let node_b_id = nodes[1].node.get_our_node_id(); let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; send_payment(&nodes[0], &[&nodes[1]], 1_000_000); - let payment_hash_opt = if use_htlc { - Some(route_payment(&nodes[1], &[&nodes[0]], 10_000).1) - } else { - None - }; + let payment_hash_opt = + if use_htlc { Some(route_payment(&nodes[1], &[&nodes[0]], 10_000).1) } else { None }; if use_htlc { nodes[0].node.fail_htlc_backwards(&payment_hash_opt.unwrap()); - expect_pending_htlcs_forwardable_and_htlc_handling_failed!(nodes[0], - [HTLCHandlingFailureType::Receive { payment_hash: payment_hash_opt.unwrap() }]); + expect_pending_htlcs_forwardable_and_htlc_handling_failed!( + nodes[0], + [HTLCHandlingFailureType::Receive { payment_hash: payment_hash_opt.unwrap() }] + ); } else { *chanmon_cfgs[0].fee_estimator.sat_per_kw.lock().unwrap() *= 10; nodes[0].node.timer_tick_occurred(); } - let updates = get_htlc_update_msgs(&nodes[0], &nodes[1].node.get_our_node_id()); + let updates = get_htlc_update_msgs(&nodes[0], &node_b_id); check_added_monitors(&nodes[0], 1); - nodes[1].node.close_channel(&chan_id, &nodes[0].node.get_our_node_id()).unwrap(); - let node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - nodes[0].node.close_channel(&chan_id, &nodes[1].node.get_our_node_id()).unwrap(); - let node_1_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); + nodes[1].node.close_channel(&chan_id, &node_a_id).unwrap(); + let node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, node_a_id); + nodes[0].node.close_channel(&chan_id, &node_b_id).unwrap(); + let node_1_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, node_b_id); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_0_shutdown); - nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_1_shutdown); + nodes[0].node.handle_shutdown(node_b_id, &node_0_shutdown); + nodes[1].node.handle_shutdown(node_a_id, &node_1_shutdown); if use_htlc { - nodes[1].node.handle_update_fail_htlc(nodes[0].node.get_our_node_id(), &updates.update_fail_htlcs[0]); + nodes[1].node.handle_update_fail_htlc(node_a_id, &updates.update_fail_htlcs[0]); } else { - nodes[1].node.handle_update_fee(nodes[0].node.get_our_node_id(), &updates.update_fee.unwrap()); + nodes[1].node.handle_update_fee(node_a_id, &updates.update_fee.unwrap()); } - nodes[1].node.handle_commitment_signed_batch_test(nodes[0].node.get_our_node_id(), &updates.commitment_signed); + nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &updates.commitment_signed); check_added_monitors(&nodes[1], 1); - let (bs_raa, bs_cs) = get_revoke_commit_msgs(&nodes[1], &nodes[0].node.get_our_node_id()); + let (bs_raa, bs_cs) = get_revoke_commit_msgs(&nodes[1], &node_a_id); - nodes[0].node.handle_revoke_and_ack(nodes[1].node.get_our_node_id(), &bs_raa); + nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_raa); check_added_monitors(&nodes[0], 1); // At this point the Channel on nodes[0] has no record of any HTLCs but the latest @@ -1372,39 +1796,63 @@ fn do_outbound_update_no_early_closing_signed(use_htlc: bool) { assert_eq!(nodes[0].node.get_and_clear_pending_msg_events(), Vec::new()); chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - nodes[0].node.handle_commitment_signed_batch_test(nodes[1].node.get_our_node_id(), &bs_cs); + nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &bs_cs); check_added_monitors(&nodes[0], 1); assert_eq!(nodes[0].node.get_and_clear_pending_msg_events(), Vec::new()); expect_channel_shutdown_state!(nodes[0], chan_id, ChannelShutdownState::ResolvingHTLCs); assert_eq!(nodes[0].node.get_and_clear_pending_msg_events(), Vec::new()); - let (latest_update, _) = nodes[0].chain_monitor.latest_monitor_update_id.lock().unwrap().get(&chan_id).unwrap().clone(); + let (latest_update, _) = nodes[0] + .chain_monitor + .latest_monitor_update_id + .lock() + .unwrap() + .get(&chan_id) + .unwrap() + .clone(); nodes[0].chain_monitor.chain_monitor.force_channel_monitor_updated(chan_id, latest_update); let as_raa_closing_signed = nodes[0].node.get_and_clear_pending_msg_events(); assert_eq!(as_raa_closing_signed.len(), 2); if let MessageSendEvent::SendRevokeAndACK { msg, .. } = &as_raa_closing_signed[0] { - nodes[1].node.handle_revoke_and_ack(nodes[0].node.get_our_node_id(), &msg); + nodes[1].node.handle_revoke_and_ack(node_a_id, &msg); check_added_monitors(&nodes[1], 1); if use_htlc { expect_payment_failed!(nodes[1], payment_hash_opt.unwrap(), true); } - } else { panic!("Unexpected message {:?}", as_raa_closing_signed[0]); } + } else { + panic!("Unexpected message {:?}", as_raa_closing_signed[0]); + } if let MessageSendEvent::SendClosingSigned { msg, .. } = &as_raa_closing_signed[1] { - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &msg); - } else { panic!("Unexpected message {:?}", as_raa_closing_signed[1]); } - - let bs_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &bs_closing_signed); - let (_, as_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &as_2nd_closing_signed.unwrap()); - let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); + nodes[1].node.handle_closing_signed(node_a_id, &msg); + } else { + panic!("Unexpected message {:?}", as_raa_closing_signed[1]); + } + + let bs_closing_signed = + get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, node_a_id); + nodes[0].node.handle_closing_signed(node_b_id, &bs_closing_signed); + let (_, as_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, node_b_id); + nodes[1].node.handle_closing_signed(node_a_id, &as_2nd_closing_signed.unwrap()); + let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, node_a_id); assert!(node_1_none.is_none()); - check_closed_event!(nodes[0], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); - check_closed_event!(nodes[1], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 100000); + check_closed_event!( + nodes[0], + 1, + ClosureReason::LocallyInitiatedCooperativeClosure, + [node_b_id], + 100000 + ); + check_closed_event!( + nodes[1], + 1, + ClosureReason::LocallyInitiatedCooperativeClosure, + [node_a_id], + 100000 + ); } #[test] @@ -1428,23 +1876,49 @@ fn batch_funding_failure() { assert_eq!(events.len(), 2); // Build a transaction which only has the output for one of the two channels we're trying to // confirm. Previously this led to a deadlock in channel closure handling. - let mut tx = Transaction { version: Version::TWO, lock_time: LockTime::ZERO, input: Vec::new(), output: Vec::new() }; + let mut tx = Transaction { + version: Version::TWO, + lock_time: LockTime::ZERO, + input: Vec::new(), + output: Vec::new(), + }; let mut chans = Vec::new(); for (idx, ev) in events.iter().enumerate() { - if let Event::FundingGenerationReady { temporary_channel_id, counterparty_node_id, output_script, .. } = ev { + if let Event::FundingGenerationReady { + temporary_channel_id, + counterparty_node_id, + output_script, + .. + } = ev + { if idx == 0 { - tx.output.push(TxOut { value: Amount::from_sat(1_000_000), script_pubkey: output_script.clone() }); + tx.output.push(TxOut { + value: Amount::from_sat(1_000_000), + script_pubkey: output_script.clone(), + }); } chans.push((temporary_channel_id, counterparty_node_id)); - } else { panic!(); } + } else { + panic!(); + } } let err = "Error in transaction funding: Misuse error: No output matched the script_pubkey and value in the FundingGenerationReady event".to_string(); - let temp_err = "No output matched the script_pubkey and value in the FundingGenerationReady event".to_string(); + let temp_err = + "No output matched the script_pubkey and value in the FundingGenerationReady event" + .to_string(); let post_funding_chan_id_a = ChannelId::v1_from_funding_txid(tx.compute_txid().as_ref(), 0); let close = [ - ExpectedCloseEvent::from_id_reason(post_funding_chan_id_a, true, ClosureReason::ProcessingError { err: err.clone() }), - ExpectedCloseEvent::from_id_reason(temp_chan_id_b, false, ClosureReason::ProcessingError { err: temp_err }), + ExpectedCloseEvent::from_id_reason( + post_funding_chan_id_a, + true, + ClosureReason::ProcessingError { err: err.clone() }, + ), + ExpectedCloseEvent::from_id_reason( + temp_chan_id_b, + false, + ClosureReason::ProcessingError { err: temp_err }, + ), ]; nodes[0].node.batch_funding_transaction_generated(&chans, tx).unwrap_err(); @@ -1454,25 +1928,52 @@ fn batch_funding_failure() { // We currently spuriously send `FundingCreated` for the first channel and then immediately // fail both channels, which isn't ideal but should be fine. assert!(msgs.iter().any(|msg| { - if let MessageSendEvent::HandleError { action: msgs::ErrorAction::SendErrorMessage { - msg: msgs::ErrorMessage { channel_id, .. }, .. - }, .. } = msg { + if let MessageSendEvent::HandleError { + action: + msgs::ErrorAction::SendErrorMessage { + msg: msgs::ErrorMessage { channel_id, .. }, .. + }, + .. + } = msg + { *channel_id == temp_chan_id_b - } else { false } + } else { + false + } })); - let funding_created_pos = msgs.iter().position(|msg| { - if let MessageSendEvent::SendFundingCreated { msg: msgs::FundingCreated { temporary_channel_id, .. }, .. } = msg { - assert_eq!(*temporary_channel_id, temp_chan_id_a); - true - } else { false } - }).unwrap(); - let funded_channel_close_pos = msgs.iter().position(|msg| { - if let MessageSendEvent::HandleError { action: msgs::ErrorAction::SendErrorMessage { - msg: msgs::ErrorMessage { channel_id, .. }, .. - }, .. } = msg { - *channel_id == post_funding_chan_id_a - } else { false } - }).unwrap(); + let funding_created_pos = msgs + .iter() + .position(|msg| { + if let MessageSendEvent::SendFundingCreated { + msg: msgs::FundingCreated { temporary_channel_id, .. }, + .. + } = msg + { + assert_eq!(*temporary_channel_id, temp_chan_id_a); + true + } else { + false + } + }) + .unwrap(); + let funded_channel_close_pos = msgs + .iter() + .position(|msg| { + if let MessageSendEvent::HandleError { + action: + msgs::ErrorAction::SendErrorMessage { + msg: msgs::ErrorMessage { channel_id, .. }, + .. + }, + .. + } = msg + { + *channel_id == post_funding_chan_id_a + } else { + false + } + }) + .unwrap(); // The error message uses the funded channel_id so must come after the funding_created assert!(funded_channel_close_pos > funding_created_pos); @@ -1533,6 +2034,9 @@ fn test_force_closure_on_low_stale_fee() { connect_blocks(&nodes[1], 1); check_added_monitors!(nodes[1], 1); check_closed_broadcast(&nodes[1], 1, true); - let reason = ClosureReason::PeerFeerateTooLow { peer_feerate_sat_per_kw: 253, required_feerate_sat_per_kw: 253 * 2 }; + let reason = ClosureReason::PeerFeerateTooLow { + peer_feerate_sat_per_kw: 253, + required_feerate_sat_per_kw: 253 * 2, + }; check_closed_events(&nodes[1], &[ExpectedCloseEvent::from_id_reason(chan_id, false, reason)]); }