Skip to content

Commit a5198bc

Browse files
carlaKCcarlaKC
committed
ln/format: run rustfmt on channel_acceptance_tests
1 parent 59718cf commit a5198bc

File tree

1 file changed

+140
-53
lines changed

1 file changed

+140
-53
lines changed

‎lightning/src/ln/channel_acceptance_tests.rs

Lines changed: 140 additions & 53 deletions
Original file line numberDiff line numberDiff line change
@@ -12,7 +12,6 @@ use bitcoin::secp256k1::{PublicKey, SecretKey};
1212
use lightning_types::features::ChannelTypeFeatures;
1313

1414
#[test]
15-
#[rustfmt::skip]
1615
fn test_outbound_chans_unlimited() {
1716
// Test that we never refuse an outbound channel even if a peer is unfuned-channel-limited
1817
let chanmon_cfgs = create_chanmon_cfgs(2);
@@ -23,33 +22,40 @@ fn test_outbound_chans_unlimited() {
2322
// Note that create_network connects the nodes together for us
2423
let node_a = nodes[0].node.get_our_node_id();
2524
let node_b = nodes[1].node.get_our_node_id();
26-
nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100_000, 0, 42, None, None).unwrap();
25+
nodes[0]
26+
.node
27+
.create_channel(nodes[1].node.get_our_node_id(), 100_000, 0, 42, None, None)
28+
.unwrap();
2729
let mut open_channel_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, node_b);
2830

2931
for _ in 0..MAX_UNFUNDED_CHANS_PER_PEER {
3032
nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel_msg);
3133
get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, node_a);
32-
open_channel_msg.common_fields.temporary_channel_id = ChannelId::temporary_from_entropy_source(&nodes[0].keys_manager);
34+
open_channel_msg.common_fields.temporary_channel_id =
35+
ChannelId::temporary_from_entropy_source(&nodes[0].keys_manager);
3336
}
3437

3538
// Once we have MAX_UNFUNDED_CHANS_PER_PEER unfunded channels, new inbound channels will be
3639
// rejected.
3740
nodes[1].node.handle_open_channel(node_a, &open_channel_msg);
38-
assert_eq!(get_err_msg(&nodes[1], &node_a).channel_id,
39-
open_channel_msg.common_fields.temporary_channel_id);
41+
assert_eq!(
42+
get_err_msg(&nodes[1], &node_a).channel_id,
43+
open_channel_msg.common_fields.temporary_channel_id
44+
);
4045

4146
// but we can still open an outbound channel.
4247
nodes[1].node.create_channel(node_a, 100_000, 0, 42, None, None).unwrap();
4348
get_event_msg!(nodes[1], MessageSendEvent::SendOpenChannel, node_a);
4449

4550
// but even with such an outbound channel, additional inbound channels will still fail.
4651
nodes[1].node.handle_open_channel(node_a, &open_channel_msg);
47-
assert_eq!(get_err_msg(&nodes[1], &node_a).channel_id,
48-
open_channel_msg.common_fields.temporary_channel_id);
52+
assert_eq!(
53+
get_err_msg(&nodes[1], &node_a).channel_id,
54+
open_channel_msg.common_fields.temporary_channel_id
55+
);
4956
}
5057

5158
#[test]
52-
#[rustfmt::skip]
5359
fn test_0conf_limiting() {
5460
// Tests that we properly limit inbound channels when we have the manual-channel-acceptance
5561
// flag set and (sometimes) accept channels as 0conf.
@@ -65,53 +71,80 @@ fn test_0conf_limiting() {
6571
nodes[0].node.create_channel(node_b, 100_000, 0, 42, None, None).unwrap();
6672
let mut open_channel_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, node_b);
6773
let init_msg = &msgs::Init {
68-
features: nodes[0].node.init_features(), networks: None, remote_network_address: None
74+
features: nodes[0].node.init_features(),
75+
networks: None,
76+
remote_network_address: None,
6977
};
7078

7179
// First, get us up to MAX_UNFUNDED_CHANNEL_PEERS so we can test at the edge
7280
for _ in 0..MAX_UNFUNDED_CHANNEL_PEERS - 1 {
73-
let random_pk = PublicKey::from_secret_key(&nodes[0].node.secp_ctx,
74-
&SecretKey::from_slice(&nodes[1].keys_manager.get_secure_random_bytes()).unwrap());
81+
let random_pk = PublicKey::from_secret_key(
82+
&nodes[0].node.secp_ctx,
83+
&SecretKey::from_slice(&nodes[1].keys_manager.get_secure_random_bytes()).unwrap(),
84+
);
7585
nodes[1].node.peer_connected(random_pk, init_msg, true).unwrap();
7686

7787
nodes[1].node.handle_open_channel(random_pk, &open_channel_msg);
7888
let events = nodes[1].node.get_and_clear_pending_events();
7989
match events[0] {
8090
Event::OpenChannelRequest { temporary_channel_id, .. } => {
81-
nodes[1].node.accept_inbound_channel(&temporary_channel_id, &random_pk, 23, None).unwrap();
82-
}
91+
nodes[1]
92+
.node
93+
.accept_inbound_channel(&temporary_channel_id, &random_pk, 23, None)
94+
.unwrap();
95+
},
8396
_ => panic!("Unexpected event"),
8497
}
8598
get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, random_pk);
86-
open_channel_msg.common_fields.temporary_channel_id = ChannelId::temporary_from_entropy_source(&nodes[0].keys_manager);
99+
open_channel_msg.common_fields.temporary_channel_id =
100+
ChannelId::temporary_from_entropy_source(&nodes[0].keys_manager);
87101
}
88102

89103
// If we try to accept a channel from another peer non-0conf it will fail.
90-
let last_random_pk = PublicKey::from_secret_key(&nodes[0].node.secp_ctx,
91-
&SecretKey::from_slice(&nodes[1].keys_manager.get_secure_random_bytes()).unwrap());
104+
let last_random_pk = PublicKey::from_secret_key(
105+
&nodes[0].node.secp_ctx,
106+
&SecretKey::from_slice(&nodes[1].keys_manager.get_secure_random_bytes()).unwrap(),
107+
);
92108
nodes[1].node.peer_connected(last_random_pk, init_msg, true).unwrap();
93109
nodes[1].node.handle_open_channel(last_random_pk, &open_channel_msg);
94110
let events = nodes[1].node.get_and_clear_pending_events();
95111
match events[0] {
96112
Event::OpenChannelRequest { temporary_channel_id, .. } => {
97-
match nodes[1].node.accept_inbound_channel(&temporary_channel_id, &last_random_pk, 23, None) {
98-
Err(APIError::APIMisuseError { err }) =>
99-
assert_eq!(err, "Too many peers with unfunded channels, refusing to accept new ones"),
113+
match nodes[1].node.accept_inbound_channel(
114+
&temporary_channel_id,
115+
&last_random_pk,
116+
23,
117+
None,
118+
) {
119+
Err(APIError::APIMisuseError { err }) => assert_eq!(
120+
err,
121+
"Too many peers with unfunded channels, refusing to accept new ones"
122+
),
100123
_ => panic!(),
101124
}
102-
}
125+
},
103126
_ => panic!("Unexpected event"),
104127
}
105-
assert_eq!(get_err_msg(&nodes[1], &last_random_pk).channel_id,
106-
open_channel_msg.common_fields.temporary_channel_id);
128+
assert_eq!(
129+
get_err_msg(&nodes[1], &last_random_pk).channel_id,
130+
open_channel_msg.common_fields.temporary_channel_id
131+
);
107132

108133
// ...however if we accept the same channel 0conf it should work just fine.
109134
nodes[1].node.handle_open_channel(last_random_pk, &open_channel_msg);
110135
let events = nodes[1].node.get_and_clear_pending_events();
111136
match events[0] {
112137
Event::OpenChannelRequest { temporary_channel_id, .. } => {
113-
nodes[1].node.accept_inbound_channel_from_trusted_peer_0conf(&temporary_channel_id, &last_random_pk, 23, None).unwrap();
114-
}
138+
nodes[1]
139+
.node
140+
.accept_inbound_channel_from_trusted_peer_0conf(
141+
&temporary_channel_id,
142+
&last_random_pk,
143+
23,
144+
None,
145+
)
146+
.unwrap();
147+
},
115148
_ => panic!("Unexpected event"),
116149
}
117150
get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, last_random_pk);
@@ -157,21 +190,30 @@ fn test_inbound_zero_fee_commitments_manual_acceptance() {
157190
do_test_manual_inbound_accept_with_override(zero_fee_cfg, None);
158191
}
159192

160-
#[rustfmt::skip]
161-
fn do_test_manual_inbound_accept_with_override(start_cfg: UserConfig,
162-
config_overrides: Option<ChannelConfigOverrides>) -> AcceptChannel {
163-
193+
fn do_test_manual_inbound_accept_with_override(
194+
start_cfg: UserConfig, config_overrides: Option<ChannelConfigOverrides>,
195+
) -> AcceptChannel {
164196
let mut mannual_accept_cfg = start_cfg.clone();
165197
mannual_accept_cfg.manually_accept_inbound_channels = true;
166198

167199
let chanmon_cfgs = create_chanmon_cfgs(3);
168200
let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
169-
let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs,
170-
&[Some(start_cfg.clone()), Some(start_cfg.clone()), Some(mannual_accept_cfg.clone())]);
201+
let node_chanmgrs = create_node_chanmgrs(
202+
3,
203+
&node_cfgs,
204+
&[Some(start_cfg.clone()), Some(start_cfg.clone()), Some(mannual_accept_cfg.clone())],
205+
);
171206
let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
172207

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());
208+
nodes[0]
209+
.node
210+
.create_channel(nodes[1].node.get_our_node_id(), 100_000, 0, 42, None, None)
211+
.unwrap();
212+
let open_channel_msg = get_event_msg!(
213+
nodes[0],
214+
MessageSendEvent::SendOpenChannel,
215+
nodes[1].node.get_our_node_id()
216+
);
175217

176218
nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel_msg);
177219
assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
@@ -180,19 +222,27 @@ fn do_test_manual_inbound_accept_with_override(start_cfg: UserConfig,
180222
MessageSendEvent::HandleError { node_id, action } => {
181223
assert_eq!(*node_id, nodes[0].node.get_our_node_id());
182224
match action {
183-
ErrorAction::SendErrorMessage { msg } =>
184-
assert_eq!(msg.data, "No channels with anchor outputs accepted".to_owned()),
225+
ErrorAction::SendErrorMessage { msg } => {
226+
assert_eq!(msg.data, "No channels with anchor outputs accepted".to_owned())
227+
},
185228
_ => panic!("Unexpected error action"),
186229
}
187-
}
230+
},
188231
_ => panic!("Unexpected event"),
189232
}
190233

191234
nodes[2].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel_msg);
192235
let events = nodes[2].node.get_and_clear_pending_events();
193236
match events[0] {
194-
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(),
237+
Event::OpenChannelRequest { temporary_channel_id, .. } => nodes[2]
238+
.node
239+
.accept_inbound_channel(
240+
&temporary_channel_id,
241+
&nodes[0].node.get_our_node_id(),
242+
23,
243+
config_overrides,
244+
)
245+
.unwrap(),
196246
_ => panic!("Unexpected event"),
197247
}
198248
get_event_msg!(nodes[2], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id())
@@ -282,33 +332,53 @@ fn test_zero_fee_commitments_downgrade_to_static_remote() {
282332
do_test_channel_type_downgrade(initiator_cfg, receiver_cfg, start_type, vec![end_type]);
283333
}
284334

285-
#[rustfmt::skip]
286-
fn do_test_channel_type_downgrade(initiator_cfg: UserConfig, acceptor_cfg: UserConfig,
287-
start_type: ChannelTypeFeatures, downgrade_types: Vec<ChannelTypeFeatures>) {
335+
fn do_test_channel_type_downgrade(
336+
initiator_cfg: UserConfig, acceptor_cfg: UserConfig, start_type: ChannelTypeFeatures,
337+
downgrade_types: Vec<ChannelTypeFeatures>,
338+
) {
288339
let chanmon_cfgs = create_chanmon_cfgs(2);
289340
let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
290-
let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[Some(initiator_cfg), Some(acceptor_cfg)]);
341+
let node_chanmgrs =
342+
create_node_chanmgrs(2, &node_cfgs, &[Some(initiator_cfg), Some(acceptor_cfg)]);
291343
let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
292344
let error_message = "Channel force-closed";
293345

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());
346+
nodes[0]
347+
.node
348+
.create_channel(nodes[1].node.get_our_node_id(), 100_000, 0, 0, None, None)
349+
.unwrap();
350+
let mut open_channel_msg = get_event_msg!(
351+
nodes[0],
352+
MessageSendEvent::SendOpenChannel,
353+
nodes[1].node.get_our_node_id()
354+
);
296355
assert_eq!(open_channel_msg.common_fields.channel_type.as_ref().unwrap(), &start_type);
297356

298357
for downgrade_type in downgrade_types {
299358
nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel_msg);
300359
let events = nodes[1].node.get_and_clear_pending_events();
301360
match events[0] {
302361
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();
304-
}
362+
nodes[1]
363+
.node
364+
.force_close_broadcasting_latest_txn(
365+
&temporary_channel_id,
366+
&nodes[0].node.get_our_node_id(),
367+
error_message.to_string(),
368+
)
369+
.unwrap();
370+
},
305371
_ => panic!("Unexpected event"),
306372
}
307373

308374
let error_msg = get_err_msg(&nodes[1], &nodes[0].node.get_our_node_id());
309375
nodes[0].node.handle_error(nodes[1].node.get_our_node_id(), &error_msg);
310376

311-
open_channel_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
377+
open_channel_msg = get_event_msg!(
378+
nodes[0],
379+
MessageSendEvent::SendOpenChannel,
380+
nodes[1].node.get_our_node_id()
381+
);
312382
let channel_type = open_channel_msg.common_fields.channel_type.as_ref().unwrap();
313383
assert_eq!(channel_type, &downgrade_type);
314384

@@ -319,7 +389,6 @@ fn do_test_channel_type_downgrade(initiator_cfg: UserConfig, acceptor_cfg: UserC
319389
}
320390

321391
#[test]
322-
#[rustfmt::skip]
323392
fn test_no_channel_downgrade() {
324393
// Tests that the local node will not retry when a `option_static_remote` channel is
325394
// rejected by a peer that advertises support for the feature.
@@ -330,21 +399,36 @@ fn test_no_channel_downgrade() {
330399

331400
let chanmon_cfgs = create_chanmon_cfgs(2);
332401
let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
333-
let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[Some(initiator_cfg), Some(receiver_cfg)]);
402+
let node_chanmgrs =
403+
create_node_chanmgrs(2, &node_cfgs, &[Some(initiator_cfg), Some(receiver_cfg)]);
334404
let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
335405
let error_message = "Channel force-closed";
336406

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());
407+
nodes[0]
408+
.node
409+
.create_channel(nodes[1].node.get_our_node_id(), 100_000, 0, 0, None, None)
410+
.unwrap();
411+
let open_channel_msg = get_event_msg!(
412+
nodes[0],
413+
MessageSendEvent::SendOpenChannel,
414+
nodes[1].node.get_our_node_id()
415+
);
339416
let start_type = ChannelTypeFeatures::only_static_remote_key();
340417
assert_eq!(open_channel_msg.common_fields.channel_type.as_ref().unwrap(), &start_type);
341418

342419
nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel_msg);
343420
let events = nodes[1].node.get_and_clear_pending_events();
344421
match events[0] {
345422
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();
347-
}
423+
nodes[1]
424+
.node
425+
.force_close_broadcasting_latest_txn(
426+
&temporary_channel_id,
427+
&nodes[0].node.get_our_node_id(),
428+
error_message.to_string(),
429+
)
430+
.unwrap();
431+
},
348432
_ => panic!("Unexpected event"),
349433
}
350434

@@ -354,5 +438,8 @@ fn test_no_channel_downgrade() {
354438
// Since nodes[0] could not retry the channel with a different type, it should close it.
355439
let chan_closed_events = nodes[0].node.get_and_clear_pending_events();
356440
assert_eq!(chan_closed_events.len(), 1);
357-
if let Event::ChannelClosed { .. } = chan_closed_events[0] { } else { panic!(); }
441+
if let Event::ChannelClosed { .. } = chan_closed_events[0] {
442+
} else {
443+
panic!();
444+
}
358445
}

0 commit comments

Comments
 (0)