Skip to content

Commit 8035bc5

Browse files
carlaKCcarlaKC
committed
ln/refactor: cleanups in preparation for rustfmt
1 parent 80ad277 commit 8035bc5

File tree

1 file changed

+48
-41
lines changed

1 file changed

+48
-41
lines changed

‎lightning/src/ln/channel_acceptance_tests.rs

Lines changed: 48 additions & 41 deletions
Original file line numberDiff line numberDiff line change
@@ -18,32 +18,33 @@ fn test_outbound_chans_unlimited() {
1818
let chanmon_cfgs = create_chanmon_cfgs(2);
1919
let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
2020
let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
21-
let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
2221

2322
// Note that create_network connects the nodes together for us
24-
25-
nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100_000, 0, 42, None, None).unwrap();
26-
let mut open_channel_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
23+
let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
24+
let node_a = nodes[0].node.get_our_node_id();
25+
let node_b = nodes[1].node.get_our_node_id();
26+
nodes[0].node.create_channel(node_b, 100_000, 0, 42, None, None).unwrap();
27+
let mut open_channel_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, node_b);
2728

2829
for _ in 0..MAX_UNFUNDED_CHANS_PER_PEER {
29-
nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel_msg);
30-
get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id());
30+
nodes[1].node.handle_open_channel(node_a, &open_channel_msg);
31+
get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, node_a);
3132
open_channel_msg.common_fields.temporary_channel_id = ChannelId::temporary_from_entropy_source(&nodes[0].keys_manager);
3233
}
3334

3435
// Once we have MAX_UNFUNDED_CHANS_PER_PEER unfunded channels, new inbound channels will be
3536
// rejected.
36-
nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel_msg);
37-
assert_eq!(get_err_msg(&nodes[1], &nodes[0].node.get_our_node_id()).channel_id,
37+
nodes[1].node.handle_open_channel(node_a, &open_channel_msg);
38+
assert_eq!(get_err_msg(&nodes[1], &node_a).channel_id,
3839
open_channel_msg.common_fields.temporary_channel_id);
3940

4041
// but we can still open an outbound channel.
41-
nodes[1].node.create_channel(nodes[0].node.get_our_node_id(), 100_000, 0, 42, None, None).unwrap();
42-
get_event_msg!(nodes[1], MessageSendEvent::SendOpenChannel, nodes[0].node.get_our_node_id());
42+
nodes[1].node.create_channel(node_a, 100_000, 0, 42, None, None).unwrap();
43+
get_event_msg!(nodes[1], MessageSendEvent::SendOpenChannel, node_a);
4344

4445
// but even with such an outbound channel, additional inbound channels will still fail.
45-
nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel_msg);
46-
assert_eq!(get_err_msg(&nodes[1], &nodes[0].node.get_our_node_id()).channel_id,
46+
nodes[1].node.handle_open_channel(node_a, &open_channel_msg);
47+
assert_eq!(get_err_msg(&nodes[1], &node_a).channel_id,
4748
open_channel_msg.common_fields.temporary_channel_id);
4849
}
4950

@@ -60,17 +61,18 @@ fn test_0conf_limiting() {
6061
let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6162

6263
// Note that create_network connects the nodes together for us
63-
64-
nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100_000, 0, 42, None, None).unwrap();
65-
let mut open_channel_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
64+
let node_b = nodes[1].node.get_our_node_id();
65+
nodes[0].node.create_channel(node_b, 100_000, 0, 42, None, None).unwrap();
66+
let mut open_channel_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, node_b);
67+
let init_msg = &msgs::Init {
68+
features: nodes[0].node.init_features(), networks: None, remote_network_address: None
69+
};
6670

6771
// First, get us up to MAX_UNFUNDED_CHANNEL_PEERS so we can test at the edge
6872
for _ in 0..MAX_UNFUNDED_CHANNEL_PEERS - 1 {
6973
let random_pk = PublicKey::from_secret_key(&nodes[0].node.secp_ctx,
7074
&SecretKey::from_slice(&nodes[1].keys_manager.get_secure_random_bytes()).unwrap());
71-
nodes[1].node.peer_connected(random_pk, &msgs::Init {
72-
features: nodes[0].node.init_features(), networks: None, remote_network_address: None
73-
}, true).unwrap();
75+
nodes[1].node.peer_connected(random_pk, init_msg, true).unwrap();
7476

7577
nodes[1].node.handle_open_channel(random_pk, &open_channel_msg);
7678
let events = nodes[1].node.get_and_clear_pending_events();
@@ -87,9 +89,7 @@ fn test_0conf_limiting() {
8789
// If we try to accept a channel from another peer non-0conf it will fail.
8890
let last_random_pk = PublicKey::from_secret_key(&nodes[0].node.secp_ctx,
8991
&SecretKey::from_slice(&nodes[1].keys_manager.get_secure_random_bytes()).unwrap());
90-
nodes[1].node.peer_connected(last_random_pk, &msgs::Init {
91-
features: nodes[0].node.init_features(), networks: None, remote_network_address: None
92-
}, true).unwrap();
92+
nodes[1].node.peer_connected(last_random_pk, init_msg, true).unwrap();
9393
nodes[1].node.handle_open_channel(last_random_pk, &open_channel_msg);
9494
let events = nodes[1].node.get_and_clear_pending_events();
9595
match events[0] {
@@ -170,15 +170,17 @@ fn do_test_manual_inbound_accept_with_override(start_cfg: UserConfig,
170170
&[Some(start_cfg.clone()), Some(start_cfg.clone()), Some(mannual_accept_cfg.clone())]);
171171
let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
172172

173-
nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100_000, 0, 42, None, None).unwrap();
174-
let open_channel_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
173+
let node_a = nodes[0].node.get_our_node_id();
174+
let node_b = nodes[1].node.get_our_node_id();
175+
nodes[0].node.create_channel(node_b, 100_000, 0, 42, None, None).unwrap();
176+
let open_channel_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, node_b);
175177

176-
nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel_msg);
178+
nodes[1].node.handle_open_channel(node_a, &open_channel_msg);
177179
assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
178180
let msg_events = nodes[1].node.get_and_clear_pending_msg_events();
179181
match &msg_events[0] {
180182
MessageSendEvent::HandleError { node_id, action } => {
181-
assert_eq!(*node_id, nodes[0].node.get_our_node_id());
183+
assert_eq!(*node_id, node_a);
182184
match action {
183185
ErrorAction::SendErrorMessage { msg } =>
184186
assert_eq!(msg.data, "No channels with anchor outputs accepted".to_owned()),
@@ -188,14 +190,14 @@ fn do_test_manual_inbound_accept_with_override(start_cfg: UserConfig,
188190
_ => panic!("Unexpected event"),
189191
}
190192

191-
nodes[2].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel_msg);
193+
nodes[2].node.handle_open_channel(node_a, &open_channel_msg);
192194
let events = nodes[2].node.get_and_clear_pending_events();
193195
match events[0] {
194196
Event::OpenChannelRequest { temporary_channel_id, .. } =>
195-
nodes[2].node.accept_inbound_channel(&temporary_channel_id, &nodes[0].node.get_our_node_id(), 23, config_overrides).unwrap(),
197+
nodes[2].node.accept_inbound_channel(&temporary_channel_id, &node_a, 23, config_overrides).unwrap(),
196198
_ => panic!("Unexpected event"),
197199
}
198-
get_event_msg!(nodes[2], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id())
200+
get_event_msg!(nodes[2], MessageSendEvent::SendAcceptChannel, node_a)
199201
}
200202

201203
#[test]
@@ -291,24 +293,26 @@ fn do_test_channel_type_downgrade(initiator_cfg: UserConfig, acceptor_cfg: UserC
291293
let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
292294
let error_message = "Channel force-closed";
293295

294-
nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100_000, 0, 0, None, None).unwrap();
295-
let mut open_channel_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
296+
let node_a = nodes[0].node.get_our_node_id();
297+
let node_b = nodes[1].node.get_our_node_id();
298+
nodes[0].node.create_channel(node_b, 100_000, 0, 0, None, None).unwrap();
299+
let mut open_channel_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, node_b);
296300
assert_eq!(open_channel_msg.common_fields.channel_type.as_ref().unwrap(), &start_type);
297301

298302
for downgrade_type in downgrade_types {
299-
nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel_msg);
303+
nodes[1].node.handle_open_channel(node_a, &open_channel_msg);
300304
let events = nodes[1].node.get_and_clear_pending_events();
301305
match events[0] {
302306
Event::OpenChannelRequest { temporary_channel_id, .. } => {
303-
nodes[1].node.force_close_broadcasting_latest_txn(&temporary_channel_id, &nodes[0].node.get_our_node_id(), error_message.to_string()).unwrap();
307+
nodes[1].node.force_close_broadcasting_latest_txn(&temporary_channel_id, &node_a, error_message.to_string()).unwrap();
304308
}
305309
_ => panic!("Unexpected event"),
306310
}
307311

308-
let error_msg = get_err_msg(&nodes[1], &nodes[0].node.get_our_node_id());
309-
nodes[0].node.handle_error(nodes[1].node.get_our_node_id(), &error_msg);
312+
let error_msg = get_err_msg(&nodes[1], &node_a);
313+
nodes[0].node.handle_error(node_b, &error_msg);
310314

311-
open_channel_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
315+
open_channel_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, node_b);
312316
let channel_type = open_channel_msg.common_fields.channel_type.as_ref().unwrap();
313317
assert_eq!(channel_type, &downgrade_type);
314318

@@ -334,22 +338,25 @@ fn test_no_channel_downgrade() {
334338
let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
335339
let error_message = "Channel force-closed";
336340

337-
nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100_000, 0, 0, None, None).unwrap();
338-
let open_channel_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
341+
let node_a = nodes[0].node.get_our_node_id();
342+
let node_b = nodes[1].node.get_our_node_id();
343+
344+
nodes[0].node.create_channel(node_b, 100_000, 0, 0, None, None).unwrap();
345+
let open_channel_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, node_b);
339346
let start_type = ChannelTypeFeatures::only_static_remote_key();
340347
assert_eq!(open_channel_msg.common_fields.channel_type.as_ref().unwrap(), &start_type);
341348

342-
nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel_msg);
349+
nodes[1].node.handle_open_channel(node_a, &open_channel_msg);
343350
let events = nodes[1].node.get_and_clear_pending_events();
344351
match events[0] {
345352
Event::OpenChannelRequest { temporary_channel_id, .. } => {
346-
nodes[1].node.force_close_broadcasting_latest_txn(&temporary_channel_id, &nodes[0].node.get_our_node_id(), error_message.to_string()).unwrap();
353+
nodes[1].node.force_close_broadcasting_latest_txn(&temporary_channel_id, &node_a, error_message.to_string()).unwrap();
347354
}
348355
_ => panic!("Unexpected event"),
349356
}
350357

351-
let error_msg = get_err_msg(&nodes[1], &nodes[0].node.get_our_node_id());
352-
nodes[0].node.handle_error(nodes[1].node.get_our_node_id(), &error_msg);
358+
let error_msg = get_err_msg(&nodes[1], &node_a);
359+
nodes[0].node.handle_error(node_b, &error_msg);
353360

354361
// Since nodes[0] could not retry the channel with a different type, it should close it.
355362
let chan_closed_events = nodes[0].node.get_and_clear_pending_events();

0 commit comments

Comments
 (0)