Skip to content

Commit 1283bd1

Browse files
TheBlueMattTheBlueMatt
committed
Test the various shutdown handling updates
1 parent 8adf0cd commit 1283bd1

File tree

3 files changed

+281
-35
lines changed

3 files changed

+281
-35
lines changed

‎src/ln/channelmanager.rs

Lines changed: 277 additions & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -3635,6 +3635,30 @@ mod tests {
36353635
}
36363636
}
36373637

3638+
macro_rules! get_closing_signed_broadcast {
3639+
($node: expr, $dest_pubkey: expr) => {
3640+
{
3641+
let events = $node.get_and_clear_pending_msg_events();
3642+
assert!(events.len() == 1 || events.len() == 2);
3643+
(match events[events.len() - 1] {
3644+
MessageSendEvent::BroadcastChannelUpdate { ref msg } => {
3645+
assert_eq!(msg.contents.flags & 2, 2);
3646+
msg.clone()
3647+
},
3648+
_ => panic!("Unexpected event"),
3649+
}, if events.len() == 2 {
3650+
match events[0] {
3651+
MessageSendEvent::SendClosingSigned { ref node_id, ref msg } => {
3652+
assert_eq!(*node_id, $dest_pubkey);
3653+
Some(msg.clone())
3654+
},
3655+
_ => panic!("Unexpected event"),
3656+
}
3657+
} else { None })
3658+
}
3659+
}
3660+
}
3661+
36383662
fn close_channel(outbound_node: &Node, inbound_node: &Node, channel_id: &[u8; 32], funding_tx: Transaction, close_inbound_first: bool) -> (msgs::ChannelUpdate, msgs::ChannelUpdate) {
36393663
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) };
36403664
let (node_b, broadcaster_b) = if close_inbound_first { (&outbound_node.node, &outbound_node.tx_broadcaster) } else { (&inbound_node.node, &inbound_node.tx_broadcaster) };
@@ -3666,29 +3690,6 @@ mod tests {
36663690
})
36673691
};
36683692

3669-
macro_rules! get_closing_signed_broadcast {
3670-
($node: expr, $dest_pubkey: expr) => {
3671-
{
3672-
let events = $node.get_and_clear_pending_msg_events();
3673-
assert!(events.len() == 1 || events.len() == 2);
3674-
(match events[events.len() - 1] {
3675-
MessageSendEvent::BroadcastChannelUpdate { ref msg } => {
3676-
msg.clone()
3677-
},
3678-
_ => panic!("Unexpected event"),
3679-
}, if events.len() == 2 {
3680-
match events[0] {
3681-
MessageSendEvent::SendClosingSigned { ref node_id, ref msg } => {
3682-
assert_eq!(*node_id, $dest_pubkey);
3683-
Some(msg.clone())
3684-
},
3685-
_ => panic!("Unexpected event"),
3686-
}
3687-
} else { None })
3688-
}
3689-
}
3690-
}
3691-
36923693
node_a.handle_shutdown(&node_b.get_our_node_id(), &shutdown_b).unwrap();
36933694
let (as_update, bs_update) = if close_inbound_first {
36943695
assert!(node_a.get_and_clear_pending_msg_events().is_empty());
@@ -3757,35 +3758,41 @@ mod tests {
37573758
}
37583759

37593760
macro_rules! commitment_signed_dance {
3760-
($node_a: expr, $node_b: expr, $commitment_signed: expr, $fail_backwards: expr) => {
3761+
($node_a: expr, $node_b: expr, $commitment_signed: expr, $fail_backwards: expr, true /* skip last step */) => {
37613762
{
37623763
check_added_monitors!($node_a, 0);
37633764
assert!($node_a.node.get_and_clear_pending_msg_events().is_empty());
37643765
$node_a.node.handle_commitment_signed(&$node_b.node.get_our_node_id(), &$commitment_signed).unwrap();
3765-
let (as_revoke_and_ack, as_commitment_signed) = get_revoke_commit_msgs!($node_a, $node_b.node.get_our_node_id());
37663766
check_added_monitors!($node_a, 1);
3767+
commitment_signed_dance!($node_a, $node_b, (), $fail_backwards, true, false);
3768+
}
3769+
};
3770+
($node_a: expr, $node_b: expr, (), $fail_backwards: expr, true /* skip last step */, true /* return extra message */) => {
3771+
{
3772+
let (as_revoke_and_ack, as_commitment_signed) = get_revoke_commit_msgs!($node_a, $node_b.node.get_our_node_id());
37673773
check_added_monitors!($node_b, 0);
37683774
assert!($node_b.node.get_and_clear_pending_msg_events().is_empty());
37693775
$node_b.node.handle_revoke_and_ack(&$node_a.node.get_our_node_id(), &as_revoke_and_ack).unwrap();
37703776
assert!($node_b.node.get_and_clear_pending_msg_events().is_empty());
37713777
check_added_monitors!($node_b, 1);
37723778
$node_b.node.handle_commitment_signed(&$node_a.node.get_our_node_id(), &as_commitment_signed).unwrap();
3773-
let bs_revoke_and_ack = get_event_msg!($node_b, MessageSendEvent::SendRevokeAndACK, $node_a.node.get_our_node_id());
3779+
let (bs_revoke_and_ack, extra_msg_option) = {
3780+
let events = $node_b.node.get_and_clear_pending_msg_events();
3781+
assert!(events.len() <= 2);
3782+
(match events[0] {
3783+
MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => {
3784+
assert_eq!(*node_id, $node_a.node.get_our_node_id());
3785+
(*msg).clone()
3786+
},
3787+
_ => panic!("Unexpected event"),
3788+
}, events.get(1).map(|e| e.clone()))
3789+
};
37743790
check_added_monitors!($node_b, 1);
37753791
if $fail_backwards {
37763792
assert!($node_a.node.get_and_clear_pending_events().is_empty());
37773793
assert!($node_a.node.get_and_clear_pending_msg_events().is_empty());
37783794
}
37793795
$node_a.node.handle_revoke_and_ack(&$node_b.node.get_our_node_id(), &bs_revoke_and_ack).unwrap();
3780-
if $fail_backwards {
3781-
let channel_state = $node_a.node.channel_state.lock().unwrap();
3782-
assert_eq!(channel_state.pending_msg_events.len(), 1);
3783-
if let MessageSendEvent::UpdateHTLCs { ref node_id, .. } = channel_state.pending_msg_events[0] {
3784-
assert_ne!(*node_id, $node_b.node.get_our_node_id());
3785-
} else { panic!("Unexpected event"); }
3786-
} else {
3787-
assert!($node_a.node.get_and_clear_pending_msg_events().is_empty());
3788-
}
37893796
{
37903797
let mut added_monitors = $node_a.chan_monitor.added_monitors.lock().unwrap();
37913798
if $fail_backwards {
@@ -3796,6 +3803,26 @@ mod tests {
37963803
}
37973804
added_monitors.clear();
37983805
}
3806+
extra_msg_option
3807+
}
3808+
};
3809+
($node_a: expr, $node_b: expr, (), $fail_backwards: expr, true /* skip last step */, false /* no extra message */) => {
3810+
{
3811+
assert!(commitment_signed_dance!($node_a, $node_b, (), $fail_backwards, true, true).is_none());
3812+
}
3813+
};
3814+
($node_a: expr, $node_b: expr, $commitment_signed: expr, $fail_backwards: expr) => {
3815+
{
3816+
commitment_signed_dance!($node_a, $node_b, $commitment_signed, $fail_backwards, true);
3817+
if $fail_backwards {
3818+
let channel_state = $node_a.node.channel_state.lock().unwrap();
3819+
assert_eq!(channel_state.pending_msg_events.len(), 1);
3820+
if let MessageSendEvent::UpdateHTLCs { ref node_id, .. } = channel_state.pending_msg_events[0] {
3821+
assert_ne!(*node_id, $node_b.node.get_our_node_id());
3822+
} else { panic!("Unexpected event"); }
3823+
} else {
3824+
assert!($node_a.node.get_and_clear_pending_msg_events().is_empty());
3825+
}
37993826
}
38003827
}
38013828
}
@@ -4638,6 +4665,221 @@ mod tests {
46384665
close_channel(&nodes[0], &nodes[1], &chan.2, chan.3, true);
46394666
}
46404667

4668+
#[test]
4669+
fn pre_funding_lock_shutdown_test() {
4670+
// Test sending a shutdown prior to funding_locked after funding generation
4671+
let nodes = create_network(2);
4672+
let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 8000000, 0);
4673+
let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4674+
nodes[0].chain_monitor.block_connected_checked(&header, 1, &[&tx; 1], &[1; 1]);
4675+
nodes[1].chain_monitor.block_connected_checked(&header, 1, &[&tx; 1], &[1; 1]);
4676+
4677+
nodes[0].node.close_channel(&OutPoint::new(tx.txid(), 0).to_channel_id()).unwrap();
4678+
let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
4679+
nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown).unwrap();
4680+
let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
4681+
nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown).unwrap();
4682+
4683+
let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
4684+
nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed).unwrap();
4685+
let (_, node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
4686+
nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed.unwrap()).unwrap();
4687+
let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
4688+
assert!(node_0_none.is_none());
4689+
4690+
assert!(nodes[0].node.list_channels().is_empty());
4691+
assert!(nodes[1].node.list_channels().is_empty());
4692+
}
4693+
4694+
#[test]
4695+
fn updates_shutdown_wait() {
4696+
// Test sending a shutdown with outstanding updates pending
4697+
let mut nodes = create_network(3);
4698+
let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
4699+
let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2);
4700+
let route_1 = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV).unwrap();
4701+
let route_2 = nodes[1].router.get_route(&nodes[0].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV).unwrap();
4702+
4703+
let (our_payment_preimage, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100000);
4704+
4705+
nodes[0].node.close_channel(&chan_1.2).unwrap();
4706+
let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
4707+
nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown).unwrap();
4708+
let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
4709+
nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown).unwrap();
4710+
4711+
assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
4712+
assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
4713+
4714+
let (_, payment_hash) = get_payment_preimage_hash!(nodes[0]);
4715+
if let Err(APIError::ChannelUnavailable {..}) = nodes[0].node.send_payment(route_1, payment_hash) {}
4716+
else { panic!("New sends should fail!") };
4717+
if let Err(APIError::ChannelUnavailable {..}) = nodes[1].node.send_payment(route_2, payment_hash) {}
4718+
else { panic!("New sends should fail!") };
4719+
4720+
assert!(nodes[2].node.claim_funds(our_payment_preimage));
4721+
check_added_monitors!(nodes[2], 1);
4722+
let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
4723+
assert!(updates.update_add_htlcs.is_empty());
4724+
assert!(updates.update_fail_htlcs.is_empty());
4725+
assert!(updates.update_fail_malformed_htlcs.is_empty());
4726+
assert!(updates.update_fee.is_none());
4727+
assert_eq!(updates.update_fulfill_htlcs.len(), 1);
4728+
nodes[1].node.handle_update_fulfill_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]).unwrap();
4729+
check_added_monitors!(nodes[1], 1);
4730+
let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
4731+
commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false);
4732+
4733+
assert!(updates_2.update_add_htlcs.is_empty());
4734+
assert!(updates_2.update_fail_htlcs.is_empty());
4735+
assert!(updates_2.update_fail_malformed_htlcs.is_empty());
4736+
assert!(updates_2.update_fee.is_none());
4737+
assert_eq!(updates_2.update_fulfill_htlcs.len(), 1);
4738+
nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &updates_2.update_fulfill_htlcs[0]).unwrap();
4739+
commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true);
4740+
4741+
let events = nodes[0].node.get_and_clear_pending_events();
4742+
assert_eq!(events.len(), 1);
4743+
match events[0] {
4744+
Event::PaymentSent { ref payment_preimage } => {
4745+
assert_eq!(our_payment_preimage, *payment_preimage);
4746+
},
4747+
_ => panic!("Unexpected event"),
4748+
}
4749+
4750+
let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
4751+
nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed).unwrap();
4752+
let (_, node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
4753+
nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed.unwrap()).unwrap();
4754+
let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
4755+
assert!(node_0_none.is_none());
4756+
4757+
assert!(nodes[0].node.list_channels().is_empty());
4758+
4759+
assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1);
4760+
nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clear();
4761+
close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true);
4762+
assert!(nodes[1].node.list_channels().is_empty());
4763+
assert!(nodes[2].node.list_channels().is_empty());
4764+
}
4765+
4766+
#[test]
4767+
fn htlc_fail_async_shutdown() {
4768+
// Test HTLCs fail if shutdown starts even if messages are delivered out-of-order
4769+
let mut nodes = create_network(3);
4770+
let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
4771+
let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2);
4772+
4773+
let route = nodes[0].router.get_route(&nodes[2].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV).unwrap();
4774+
let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
4775+
nodes[0].node.send_payment(route, our_payment_hash).unwrap();
4776+
check_added_monitors!(nodes[0], 1);
4777+
let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
4778+
assert_eq!(updates.update_add_htlcs.len(), 1);
4779+
assert!(updates.update_fulfill_htlcs.is_empty());
4780+
assert!(updates.update_fail_htlcs.is_empty());
4781+
assert!(updates.update_fail_malformed_htlcs.is_empty());
4782+
assert!(updates.update_fee.is_none());
4783+
4784+
nodes[1].node.close_channel(&chan_1.2).unwrap();
4785+
let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
4786+
nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown).unwrap();
4787+
let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
4788+
4789+
nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]).unwrap();
4790+
nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &updates.commitment_signed).unwrap();
4791+
check_added_monitors!(nodes[1], 1);
4792+
nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown).unwrap();
4793+
commitment_signed_dance!(nodes[1], nodes[0], (), false, true, false);
4794+
4795+
let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
4796+
assert!(updates_2.update_add_htlcs.is_empty());
4797+
assert!(updates_2.update_fulfill_htlcs.is_empty());
4798+
assert_eq!(updates_2.update_fail_htlcs.len(), 1);
4799+
assert!(updates_2.update_fail_malformed_htlcs.is_empty());
4800+
assert!(updates_2.update_fee.is_none());
4801+
4802+
nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates_2.update_fail_htlcs[0]).unwrap();
4803+
commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true);
4804+
4805+
let events = nodes[0].node.get_and_clear_pending_events();
4806+
assert_eq!(events.len(), 1);
4807+
match events[0] {
4808+
Event::PaymentFailed { ref payment_hash, ref rejected_by_dest } => {
4809+
assert_eq!(our_payment_hash, *payment_hash);
4810+
assert!(!rejected_by_dest);
4811+
},
4812+
_ => panic!("Unexpected event"),
4813+
}
4814+
4815+
assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
4816+
let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
4817+
nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed).unwrap();
4818+
let (_, node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
4819+
nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed.unwrap()).unwrap();
4820+
let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
4821+
assert!(node_0_none.is_none());
4822+
4823+
assert!(nodes[0].node.list_channels().is_empty());
4824+
4825+
assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1);
4826+
nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clear();
4827+
close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true);
4828+
assert!(nodes[1].node.list_channels().is_empty());
4829+
assert!(nodes[2].node.list_channels().is_empty());
4830+
}
4831+
4832+
#[test]
4833+
fn update_fee_async_shutdown() {
4834+
// Test update_fee works after shutdown start if messages are delivered out-of-order
4835+
let nodes = create_network(2);
4836+
let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
4837+
4838+
let starting_feerate = nodes[0].node.channel_state.lock().unwrap().by_id.get(&chan_1.2).unwrap().get_feerate();
4839+
nodes[0].node.update_fee(chan_1.2.clone(), starting_feerate + 20).unwrap();
4840+
check_added_monitors!(nodes[0], 1);
4841+
let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
4842+
assert!(updates.update_add_htlcs.is_empty());
4843+
assert!(updates.update_fulfill_htlcs.is_empty());
4844+
assert!(updates.update_fail_htlcs.is_empty());
4845+
assert!(updates.update_fail_malformed_htlcs.is_empty());
4846+
assert!(updates.update_fee.is_some());
4847+
4848+
nodes[1].node.close_channel(&chan_1.2).unwrap();
4849+
let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
4850+
nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown).unwrap();
4851+
// Note that we don't actually test normative behavior here. The spec indicates we could
4852+
// actually send a closing_signed here, but is kinda unclear and could possibly be amended
4853+
// to require waiting on the full commitment dance before doing so (see
4854+
// https://github.com/lightningnetwork/lightning-rfc/issues/499). In any case, to avoid
4855+
// ambiguity, we should wait until after the full commitment dance to send closing_signed.
4856+
let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
4857+
4858+
nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), &updates.update_fee.unwrap()).unwrap();
4859+
nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &updates.commitment_signed).unwrap();
4860+
check_added_monitors!(nodes[1], 1);
4861+
nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown).unwrap();
4862+
let node_0_closing_signed = commitment_signed_dance!(nodes[1], nodes[0], (), false, true, true);
4863+
4864+
assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
4865+
nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), match node_0_closing_signed.unwrap() {
4866+
MessageSendEvent::SendClosingSigned { ref node_id, ref msg } => {
4867+
assert_eq!(*node_id, nodes[1].node.get_our_node_id());
4868+
msg
4869+
},
4870+
_ => panic!("Unexpected event"),
4871+
}).unwrap();
4872+
let (_, node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
4873+
nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed.unwrap()).unwrap();
4874+
let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
4875+
assert!(node_0_none.is_none());
4876+
}
4877+
4878+
#[test]
4879+
fn test_shutdown_rebroadcast() {
4880+
// XXX: Test that shutdown/closing_signed is re-sent on reconnect
4881+
}
4882+
46414883
#[test]
46424884
fn fake_network_test() {
46434885
// Simple test which builds a network of ChannelManagers, connects them to each other, and

‎src/ln/msgs.rs

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -151,6 +151,7 @@ pub struct Init {
151151
}
152152

153153
/// An error message to be sent or received from a peer
154+
#[derive(Clone)]
154155
pub struct ErrorMessage {
155156
pub(crate) channel_id: [u8; 32],
156157
pub(crate) data: String,
@@ -448,6 +449,7 @@ pub struct ChannelUpdate {
448449
}
449450

450451
/// Used to put an error message in a HandleError
452+
#[derive(Clone)]
451453
pub enum ErrorAction {
452454
/// The peer took some action which made us think they were useless. Disconnect them.
453455
DisconnectPeer {
@@ -486,6 +488,7 @@ pub struct CommitmentUpdate {
486488
/// The information we received from a peer along the route of a payment we originated. This is
487489
/// returned by ChannelMessageHandler::handle_update_fail_htlc to be passed into
488490
/// RoutingMessageHandler::handle_htlc_fail_channel_update to update our network map.
491+
#[derive(Clone)]
489492
pub enum HTLCFailChannelUpdate {
490493
/// We received an error which included a full ChannelUpdate message.
491494
ChannelUpdateMessage {

‎src/util/events.rs

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -103,6 +103,7 @@ pub enum Event {
103103
/// An event generated by ChannelManager which indicates a message should be sent to a peer (or
104104
/// broadcast to most peers).
105105
/// These events are handled by PeerManager::process_events if you are using a PeerManager.
106+
#[derive(Clone)]
106107
pub enum MessageSendEvent {
107108
/// Used to indicate that we've accepted a channel open and should send the accept_channel
108109
/// message provided to the given peer.

0 commit comments

Comments
 (0)