Skip to content

Commit c2d9b97

Browse files
tnulltnull
authored
Merge pull request #4022 from TheBlueMatt/2025-08-3897-followups
Post-#3897 fixes and cleanups
2 parents 96f9242 + 0a598a3 commit c2d9b97

File tree

4 files changed

+120
-131
lines changed

4 files changed

+120
-131
lines changed

‎fuzz/src/full_stack.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1182,7 +1182,7 @@ fn two_peer_forwarding_seed() -> Vec<u8> {
11821182

11831183
// broadcast funding transaction
11841184
ext_from_hex("0b", &mut test);
1185-
// by now client should have sent a channel_ready (CHECK 4: SendChannelReady to 03020000 for chan 3f000000)
1185+
// by now client should have sent a channel_ready (CHECK 4: SendChannelReady to 03020000 for chan 2f000000)
11861186

11871187
// inbound read from peer id 1 of len 18
11881188
ext_from_hex("030112", &mut test);
@@ -1441,7 +1441,7 @@ fn two_peer_forwarding_seed() -> Vec<u8> {
14411441
// inbound read from peer id 0 of len 193
14421442
ext_from_hex("0300c1", &mut test);
14431443
// end of update_add_htlc from 0 to 1 via client and mac
1444-
ext_from_hex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 5300000000000000000000000000000000000000000000000000000000000000 03000000000000000000000000000000", &mut test);
1444+
ext_from_hex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 5200000000000000000000000000000000000000000000000000000000000000 03000000000000000000000000000000", &mut test);
14451445

14461446
// inbound read from peer id 0 of len 18
14471447
ext_from_hex("030012", &mut test);

‎lightning/src/ln/channel.rs

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -9608,7 +9608,9 @@ where
96089608
}
96099609

96109610
pub fn get_revoked_counterparty_commitment_transaction_number(&self) -> u64 {
9611-
self.context.cur_counterparty_commitment_transaction_number + 2
9611+
let ret = self.context.cur_counterparty_commitment_transaction_number + 2;
9612+
debug_assert_eq!(self.context.commitment_secrets.get_min_seen_secret(), ret);
9613+
ret
96129614
}
96139615

96149616
#[cfg(any(test, feature = "_externalize_tests"))]

‎lightning/src/ln/channelmanager.rs

Lines changed: 0 additions & 128 deletions
Original file line numberDiff line numberDiff line change
@@ -17542,134 +17542,6 @@ mod tests {
1754217542
}
1754317543
}
1754417544

17545-
#[test]
17546-
#[cfg(peer_storage)]
17547-
fn test_peer_storage() {
17548-
let chanmon_cfgs = create_chanmon_cfgs(2);
17549-
let (persister, chain_monitor);
17550-
let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
17551-
let nodes_0_deserialized;
17552-
let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
17553-
let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
17554-
17555-
let (_, _, cid, _) = create_announced_chan_between_nodes(&nodes, 0, 1);
17556-
send_payment(&nodes[0], &[&nodes[1]], 1000);
17557-
let nodes_0_serialized = nodes[0].node.encode();
17558-
let old_state_monitor = get_monitor!(nodes[0], cid).encode();
17559-
send_payment(&nodes[0], &[&nodes[1]], 10000);
17560-
send_payment(&nodes[0], &[&nodes[1]], 9999);
17561-
17562-
// Update peer storage with latest commitment txns
17563-
connect_blocks(&nodes[0], 1);
17564-
connect_blocks(&nodes[0], 1);
17565-
17566-
let peer_storage_msg_events_node0 =
17567-
nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_msg_events();
17568-
let peer_storage_msg_events_node1 =
17569-
nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_msg_events();
17570-
assert_ne!(peer_storage_msg_events_node0.len(), 0);
17571-
assert_ne!(peer_storage_msg_events_node1.len(), 0);
17572-
17573-
for ps_msg in peer_storage_msg_events_node0 {
17574-
match ps_msg {
17575-
MessageSendEvent::SendPeerStorage { ref node_id, ref msg } => {
17576-
assert_eq!(*node_id, nodes[1].node.get_our_node_id());
17577-
nodes[1].node.handle_peer_storage(nodes[0].node.get_our_node_id(), msg.clone());
17578-
},
17579-
_ => panic!("Unexpected event"),
17580-
}
17581-
}
17582-
17583-
for ps_msg in peer_storage_msg_events_node1 {
17584-
match ps_msg {
17585-
MessageSendEvent::SendPeerStorage { ref node_id, ref msg } => {
17586-
assert_eq!(*node_id, nodes[0].node.get_our_node_id());
17587-
nodes[0].node.handle_peer_storage(nodes[1].node.get_our_node_id(), msg.clone());
17588-
},
17589-
_ => panic!("Unexpected event"),
17590-
}
17591-
}
17592-
17593-
nodes[0].node.peer_disconnected(nodes[1].node.get_our_node_id());
17594-
nodes[1].node.peer_disconnected(nodes[0].node.get_our_node_id());
17595-
17596-
// Reload Node!
17597-
// TODO: Handle the case where we've completely forgotten about an active channel.
17598-
reload_node!(
17599-
nodes[0],
17600-
test_default_channel_config(),
17601-
&nodes_0_serialized,
17602-
&[&old_state_monitor[..]],
17603-
persister,
17604-
chain_monitor,
17605-
nodes_0_deserialized
17606-
);
17607-
17608-
nodes[0]
17609-
.node
17610-
.peer_connected(
17611-
nodes[1].node.get_our_node_id(),
17612-
&msgs::Init {
17613-
features: nodes[1].node.init_features(),
17614-
networks: None,
17615-
remote_network_address: None,
17616-
},
17617-
true,
17618-
)
17619-
.unwrap();
17620-
17621-
nodes[1]
17622-
.node
17623-
.peer_connected(
17624-
nodes[0].node.get_our_node_id(),
17625-
&msgs::Init {
17626-
features: nodes[0].node.init_features(),
17627-
networks: None,
17628-
remote_network_address: None,
17629-
},
17630-
false,
17631-
)
17632-
.unwrap();
17633-
17634-
let node_1_events = nodes[1].node.get_and_clear_pending_msg_events();
17635-
assert_eq!(node_1_events.len(), 2);
17636-
17637-
// Since, node-0 does not have any memory it would not send any message.
17638-
let node_0_events = nodes[0].node.get_and_clear_pending_msg_events();
17639-
assert_eq!(node_0_events.len(), 1);
17640-
17641-
match node_0_events[0] {
17642-
MessageSendEvent::SendChannelReestablish { ref node_id, .. } => {
17643-
assert_eq!(*node_id, nodes[1].node.get_our_node_id());
17644-
// nodes[0] would send a bogus channel reestablish, so there's no need to handle this.
17645-
},
17646-
_ => panic!("Unexpected event"),
17647-
}
17648-
17649-
for msg in node_1_events {
17650-
if let MessageSendEvent::SendChannelReestablish { ref node_id, ref msg } = msg {
17651-
nodes[0].node.handle_channel_reestablish(nodes[1].node.get_our_node_id(), msg);
17652-
assert_eq!(*node_id, nodes[0].node.get_our_node_id());
17653-
} else if let MessageSendEvent::SendPeerStorageRetrieval { ref node_id, ref msg } = msg
17654-
{
17655-
assert_eq!(*node_id, nodes[0].node.get_our_node_id());
17656-
// Should Panic here!
17657-
let res = std::panic::catch_unwind(|| {
17658-
nodes[0]
17659-
.node
17660-
.handle_peer_storage_retrieval(nodes[1].node.get_our_node_id(), msg.clone())
17661-
});
17662-
assert!(res.is_err());
17663-
break;
17664-
} else {
17665-
panic!("Unexpected event")
17666-
}
17667-
}
17668-
// When we panic'd, we expect to panic on `Drop`.
17669-
let res = std::panic::catch_unwind(|| drop(nodes));
17670-
assert!(res.is_err());
17671-
}
17672-
1767317545
#[test]
1767417546
#[rustfmt::skip]
1767517547
fn test_keysend_dup_payment_hash() {

‎lightning/src/ln/reload_tests.rs

Lines changed: 115 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1305,3 +1305,118 @@ fn test_htlc_localremoved_persistence() {
13051305
let htlc_fail_msg_after_reload = msgs.2.unwrap().update_fail_htlcs[0].clone();
13061306
assert_eq!(htlc_fail_msg, htlc_fail_msg_after_reload);
13071307
}
1308+
1309+
1310+
1311+
#[test]
1312+
#[cfg(peer_storage)]
1313+
fn test_peer_storage() {
1314+
let chanmon_cfgs = create_chanmon_cfgs(2);
1315+
let (persister, chain_monitor);
1316+
let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1317+
let nodes_0_deserialized;
1318+
let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1319+
let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1320+
1321+
let node_a_id = nodes[0].node.get_our_node_id();
1322+
let node_b_id = nodes[1].node.get_our_node_id();
1323+
1324+
let (_, _, cid, _) = create_announced_chan_between_nodes(&nodes, 0, 1);
1325+
send_payment(&nodes[0], &[&nodes[1]], 1000);
1326+
let nodes_0_serialized = nodes[0].node.encode();
1327+
let old_state_monitor = get_monitor!(nodes[0], cid).encode();
1328+
send_payment(&nodes[0], &[&nodes[1]], 10000);
1329+
send_payment(&nodes[0], &[&nodes[1]], 9999);
1330+
1331+
// Update peer storage with latest commitment txns
1332+
connect_blocks(&nodes[0], 1);
1333+
connect_blocks(&nodes[0], 1);
1334+
1335+
let peer_storage_msg_events_node0 =
1336+
nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_msg_events();
1337+
let peer_storage_msg_events_node1 =
1338+
nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_msg_events();
1339+
assert_ne!(peer_storage_msg_events_node0.len(), 0);
1340+
assert_ne!(peer_storage_msg_events_node1.len(), 0);
1341+
1342+
for ps_msg in peer_storage_msg_events_node0 {
1343+
match ps_msg {
1344+
MessageSendEvent::SendPeerStorage { ref node_id, ref msg } => {
1345+
assert_eq!(*node_id, node_b_id);
1346+
nodes[1].node.handle_peer_storage(node_a_id, msg.clone());
1347+
},
1348+
_ => panic!("Unexpected event"),
1349+
}
1350+
}
1351+
1352+
for ps_msg in peer_storage_msg_events_node1 {
1353+
match ps_msg {
1354+
MessageSendEvent::SendPeerStorage { ref node_id, ref msg } => {
1355+
assert_eq!(*node_id, node_a_id);
1356+
nodes[0].node.handle_peer_storage(node_b_id, msg.clone());
1357+
},
1358+
_ => panic!("Unexpected event"),
1359+
}
1360+
}
1361+
1362+
nodes[0].node.peer_disconnected(node_b_id);
1363+
nodes[1].node.peer_disconnected(node_a_id);
1364+
1365+
// Reload Node!
1366+
// TODO: Handle the case where we've completely forgotten about an active channel.
1367+
reload_node!(
1368+
nodes[0],
1369+
test_default_channel_config(),
1370+
&nodes_0_serialized,
1371+
&[&old_state_monitor[..]],
1372+
persister,
1373+
chain_monitor,
1374+
nodes_0_deserialized
1375+
);
1376+
1377+
let init_msg = msgs::Init {
1378+
features: nodes[1].node.init_features(),
1379+
networks: None,
1380+
remote_network_address: None,
1381+
};
1382+
1383+
nodes[0].node.peer_connected(node_b_id, &init_msg, true).unwrap();
1384+
nodes[1].node.peer_connected(node_a_id, &init_msg, true).unwrap();
1385+
1386+
let node_1_events = nodes[1].node.get_and_clear_pending_msg_events();
1387+
assert_eq!(node_1_events.len(), 2);
1388+
1389+
let node_0_events = nodes[0].node.get_and_clear_pending_msg_events();
1390+
assert_eq!(node_0_events.len(), 1);
1391+
1392+
match node_0_events[0] {
1393+
MessageSendEvent::SendChannelReestablish { ref node_id, .. } => {
1394+
assert_eq!(*node_id, node_b_id);
1395+
// nodes[0] would send a stale channel reestablish, so there's no need to handle this.
1396+
},
1397+
_ => panic!("Unexpected event"),
1398+
}
1399+
1400+
if let MessageSendEvent::SendPeerStorageRetrieval { node_id, msg } = &node_1_events[0] {
1401+
assert_eq!(*node_id, node_a_id);
1402+
// Should Panic here!
1403+
let res = std::panic::catch_unwind(|| {
1404+
nodes[0].node.handle_peer_storage_retrieval(node_b_id, msg.clone());
1405+
});
1406+
assert!(res.is_err());
1407+
} else {
1408+
panic!("Unexpected event {node_1_events:?}")
1409+
}
1410+
1411+
if let MessageSendEvent::SendChannelReestablish { .. } = &node_1_events[1] {
1412+
// After the `peer_storage_retreival` message would come a `channel_reestablish` (which
1413+
// would also cause nodes[0] to panic) but it already went down due to lost state so
1414+
// there's nothing to deliver.
1415+
} else {
1416+
panic!("Unexpected event {node_1_events:?}")
1417+
}
1418+
// When we panic'd, we expect to panic on `Drop`.
1419+
let res = std::panic::catch_unwind(|| drop(nodes));
1420+
assert!(res.is_err());
1421+
}
1422+

0 commit comments

Comments
 (0)