+
+#[test]
+fn test_override_0msat_htlc_minimum() {
+ let mut zero_config = UserConfig::default();
+ zero_config.own_channel_config.our_htlc_minimum_msat = 0;
+ 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(zero_config.clone())]);
+ let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
+
+ nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 16_000_000, 12_000_000, 42, Some(zero_config)).unwrap();
+ let res = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
+ assert_eq!(res.htlc_minimum_msat, 1);
+
+ nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::known(), &res);
+ let res = get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id());
+ assert_eq!(res.htlc_minimum_msat, 1);
+}
+
+#[test]
+fn test_simple_payment_secret() {
+ // Simple test of sending a payment with a payment_secret present. This does not use any AMP
+ // features, however.
+ let chanmon_cfgs = create_chanmon_cfgs(3);
+ 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);
+
+ create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
+ create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
+ let logger = test_utils::TestLogger::new();
+
+ let (payment_preimage, payment_hash) = get_payment_preimage_hash!(&nodes[0]);
+ let payment_secret = PaymentSecret([0xdb; 32]);
+ let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
+ let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
+ send_along_route_with_secret(&nodes[0], route, &[&[&nodes[1], &nodes[2]]], 100000, payment_hash, Some(payment_secret.clone()));
+ // Claiming with all the correct values but the wrong secret should result in nothing...
+ assert_eq!(nodes[2].node.claim_funds(payment_preimage, &None, 100_000), false);
+ assert_eq!(nodes[2].node.claim_funds(payment_preimage, &Some(PaymentSecret([42; 32])), 100_000), false);
+ // ...but with the right secret we should be able to claim all the way back
+ claim_payment_along_route_with_secret(&nodes[0], &[&[&nodes[1], &nodes[2]]], false, payment_preimage, Some(payment_secret.clone()), 100_000);
+}
+
+#[test]
+fn test_simple_mpp() {
+ // Simple test of sending a multi-path payment.
+ let chanmon_cfgs = create_chanmon_cfgs(4);
+ let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
+ let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
+ let nodes = create_network(4, &node_cfgs, &node_chanmgrs);
+
+ let chan_1_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
+ let chan_2_id = create_announced_chan_between_nodes(&nodes, 0, 2, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
+ let chan_3_id = create_announced_chan_between_nodes(&nodes, 1, 3, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
+ let chan_4_id = create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
+ let logger = test_utils::TestLogger::new();
+
+ let (payment_preimage, payment_hash) = get_payment_preimage_hash!(&nodes[0]);
+ let payment_secret = PaymentSecret([0xdb; 32]);
+ let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
+ let mut route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[3].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
+ let path = route.paths[0].clone();
+ route.paths.push(path);
+ route.paths[0][0].pubkey = nodes[1].node.get_our_node_id();
+ route.paths[0][0].short_channel_id = chan_1_id;
+ route.paths[0][1].short_channel_id = chan_3_id;
+ route.paths[1][0].pubkey = nodes[2].node.get_our_node_id();
+ route.paths[1][0].short_channel_id = chan_2_id;
+ route.paths[1][1].short_channel_id = chan_4_id;
+ send_along_route_with_secret(&nodes[0], route, &[&[&nodes[1], &nodes[3]], &[&nodes[2], &nodes[3]]], 200_000, payment_hash, Some(payment_secret.clone()));
+ // Claiming with all the correct values but the wrong secret should result in nothing...
+ assert_eq!(nodes[3].node.claim_funds(payment_preimage, &None, 200_000), false);
+ assert_eq!(nodes[3].node.claim_funds(payment_preimage, &Some(PaymentSecret([42; 32])), 200_000), false);
+ // ...but with the right secret we should be able to claim all the way back
+ claim_payment_along_route_with_secret(&nodes[0], &[&[&nodes[1], &nodes[3]], &[&nodes[2], &nodes[3]]], false, payment_preimage, Some(payment_secret), 200_000);
+}
+
+#[test]
+fn test_update_err_monitor_lockdown() {
+ // Our monitor will lock update of local commitment transaction if a broadcastion condition
+ // has been fulfilled (either force-close from Channel or block height requiring a HTLC-
+ // timeout). Trying to update monitor after lockdown should return a ChannelMonitorUpdateErr.
+ //
+ // This scenario may happen in a watchtower setup, where watchtower process a block height
+ // triggering a timeout while a slow-block-processing ChannelManager receives a local signed
+ // commitment at same time.
+
+ 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]);
+ let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
+
+ // Create some initial channel
+ let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
+ let outpoint = OutPoint { txid: chan_1.3.txid(), index: 0 };
+
+ // Rebalance the network to generate htlc in the two directions
+ send_payment(&nodes[0], &vec!(&nodes[1])[..], 10_000_000, 10_000_000);
+
+ // Route a HTLC from node 0 to node 1 (but don't settle)
+ let preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 9_000_000).0;
+
+ // Copy ChainMonitor to simulate a watchtower and update block height of node 0 until its ChannelMonitor timeout HTLC onchain
+ let chain_source = test_utils::TestChainSource::new(Network::Testnet);
+ let logger = test_utils::TestLogger::with_id(format!("node {}", 0));
+ let persister = test_utils::TestPersister::new();
+ let watchtower = {
+ let monitors = nodes[0].chain_monitor.chain_monitor.monitors.read().unwrap();
+ let monitor = monitors.get(&outpoint).unwrap();
+ let mut w = test_utils::TestVecWriter(Vec::new());
+ monitor.write(&mut w).unwrap();
+ let new_monitor = <(BlockHash, channelmonitor::ChannelMonitor<EnforcingSigner>)>::read(
+ &mut ::std::io::Cursor::new(&w.0), &test_utils::OnlyReadsKeysInterface {}).unwrap().1;
+ assert!(new_monitor == *monitor);
+ let watchtower = test_utils::TestChainMonitor::new(Some(&chain_source), &chanmon_cfgs[0].tx_broadcaster, &logger, &chanmon_cfgs[0].fee_estimator, &persister, &node_cfgs[0].keys_manager);
+ assert!(watchtower.watch_channel(outpoint, new_monitor).is_ok());
+ watchtower
+ };
+ let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
+ watchtower.chain_monitor.block_connected(&header, &[], 200);
+
+ // Try to update ChannelMonitor
+ assert!(nodes[1].node.claim_funds(preimage, &None, 9_000_000));
+ check_added_monitors!(nodes[1], 1);
+ let updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
+ assert_eq!(updates.update_fulfill_htlcs.len(), 1);
+ nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]);
+ if let Some(ref mut channel) = nodes[0].node.channel_state.lock().unwrap().by_id.get_mut(&chan_1.2) {
+ if let Ok((_, _, _, update)) = channel.commitment_signed(&updates.commitment_signed, &node_cfgs[0].fee_estimator, &node_cfgs[0].logger) {
+ if let Err(_) = watchtower.chain_monitor.update_channel(outpoint, update.clone()) {} else { assert!(false); }
+ if let Ok(_) = nodes[0].chain_monitor.update_channel(outpoint, update) {} else { assert!(false); }
+ } else { assert!(false); }
+ } else { assert!(false); };
+ // Our local monitor is in-sync and hasn't processed yet timeout
+ check_added_monitors!(nodes[0], 1);
+ let events = nodes[0].node.get_and_clear_pending_events();
+ assert_eq!(events.len(), 1);
+}
+
+#[test]
+fn test_concurrent_monitor_claim() {
+ // Watchtower A receives block, broadcasts state N, then channel receives new state N+1,
+ // sending it to both watchtowers, Bob accepts N+1, then receives block and broadcasts
+ // the latest state N+1, Alice rejects state N+1, but Bob has already broadcast it,
+ // state N+1 confirms. Alice claims output from state N+1.
+
+ 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]);
+ let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
+
+ // Create some initial channel
+ let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
+ let outpoint = OutPoint { txid: chan_1.3.txid(), index: 0 };
+
+ // Rebalance the network to generate htlc in the two directions
+ send_payment(&nodes[0], &vec!(&nodes[1])[..], 10_000_000, 10_000_000);
+
+ // Route a HTLC from node 0 to node 1 (but don't settle)
+ route_payment(&nodes[0], &vec!(&nodes[1])[..], 9_000_000).0;
+
+ // Copy ChainMonitor to simulate watchtower Alice and update block height her ChannelMonitor timeout HTLC onchain
+ let chain_source = test_utils::TestChainSource::new(Network::Testnet);
+ let logger = test_utils::TestLogger::with_id(format!("node {}", "Alice"));
+ let persister = test_utils::TestPersister::new();
+ let watchtower_alice = {
+ let monitors = nodes[0].chain_monitor.chain_monitor.monitors.read().unwrap();
+ let monitor = monitors.get(&outpoint).unwrap();
+ let mut w = test_utils::TestVecWriter(Vec::new());
+ monitor.write(&mut w).unwrap();
+ let new_monitor = <(BlockHash, channelmonitor::ChannelMonitor<EnforcingSigner>)>::read(
+ &mut ::std::io::Cursor::new(&w.0), &test_utils::OnlyReadsKeysInterface {}).unwrap().1;
+ assert!(new_monitor == *monitor);
+ let watchtower = test_utils::TestChainMonitor::new(Some(&chain_source), &chanmon_cfgs[0].tx_broadcaster, &logger, &chanmon_cfgs[0].fee_estimator, &persister, &node_cfgs[0].keys_manager);
+ assert!(watchtower.watch_channel(outpoint, new_monitor).is_ok());
+ watchtower
+ };
+ let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
+ watchtower_alice.chain_monitor.block_connected(&header, &vec![], 135);
+
+ // Watchtower Alice should have broadcast a commitment/HTLC-timeout
+ {
+ let mut txn = chanmon_cfgs[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
+ assert_eq!(txn.len(), 2);
+ txn.clear();
+ }
+
+ // Copy ChainMonitor to simulate watchtower Bob and make it receive a commitment update first.
+ let chain_source = test_utils::TestChainSource::new(Network::Testnet);
+ let logger = test_utils::TestLogger::with_id(format!("node {}", "Bob"));
+ let persister = test_utils::TestPersister::new();
+ let watchtower_bob = {
+ let monitors = nodes[0].chain_monitor.chain_monitor.monitors.read().unwrap();
+ let monitor = monitors.get(&outpoint).unwrap();
+ let mut w = test_utils::TestVecWriter(Vec::new());
+ monitor.write(&mut w).unwrap();
+ let new_monitor = <(BlockHash, channelmonitor::ChannelMonitor<EnforcingSigner>)>::read(
+ &mut ::std::io::Cursor::new(&w.0), &test_utils::OnlyReadsKeysInterface {}).unwrap().1;
+ assert!(new_monitor == *monitor);
+ let watchtower = test_utils::TestChainMonitor::new(Some(&chain_source), &chanmon_cfgs[0].tx_broadcaster, &logger, &chanmon_cfgs[0].fee_estimator, &persister, &node_cfgs[0].keys_manager);
+ assert!(watchtower.watch_channel(outpoint, new_monitor).is_ok());
+ watchtower
+ };
+ let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
+ watchtower_bob.chain_monitor.block_connected(&header, &vec![], 134);
+
+ // Route another payment to generate another update with still previous HTLC pending
+ let (_, payment_hash) = get_payment_preimage_hash!(nodes[0]);
+ {
+ let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
+ let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[0].node.get_our_node_id(), None, &Vec::new(), 3000000 , TEST_FINAL_CLTV, &logger).unwrap();
+ nodes[1].node.send_payment(&route, payment_hash, &None).unwrap();
+ }
+ check_added_monitors!(nodes[1], 1);
+
+ let updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
+ assert_eq!(updates.update_add_htlcs.len(), 1);
+ nodes[0].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &updates.update_add_htlcs[0]);
+ if let Some(ref mut channel) = nodes[0].node.channel_state.lock().unwrap().by_id.get_mut(&chan_1.2) {
+ if let Ok((_, _, _, update)) = channel.commitment_signed(&updates.commitment_signed, &node_cfgs[0].fee_estimator, &node_cfgs[0].logger) {
+ // Watchtower Alice should already have seen the block and reject the update
+ if let Err(_) = watchtower_alice.chain_monitor.update_channel(outpoint, update.clone()) {} else { assert!(false); }
+ if let Ok(_) = watchtower_bob.chain_monitor.update_channel(outpoint, update.clone()) {} else { assert!(false); }
+ if let Ok(_) = nodes[0].chain_monitor.update_channel(outpoint, update) {} else { assert!(false); }
+ } else { assert!(false); }
+ } else { assert!(false); };
+ // Our local monitor is in-sync and hasn't processed yet timeout
+ check_added_monitors!(nodes[0], 1);
+
+ //// Provide one more block to watchtower Bob, expect broadcast of commitment and HTLC-Timeout
+ watchtower_bob.chain_monitor.block_connected(&header, &vec![], 135);
+
+ // Watchtower Bob should have broadcast a commitment/HTLC-timeout
+ let bob_state_y;
+ {
+ let mut txn = chanmon_cfgs[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
+ assert_eq!(txn.len(), 2);
+ bob_state_y = txn[0].clone();
+ txn.clear();
+ };
+
+ // We confirm Bob's state Y on Alice, she should broadcast a HTLC-timeout
+ watchtower_alice.chain_monitor.block_connected(&header, &vec![(0, &bob_state_y)], 136);
+ {
+ let htlc_txn = chanmon_cfgs[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
+ // We broadcast twice the transaction, once due to the HTLC-timeout, once due
+ // the onchain detection of the HTLC output
+ assert_eq!(htlc_txn.len(), 2);
+ check_spends!(htlc_txn[0], bob_state_y);
+ check_spends!(htlc_txn[1], bob_state_y);
+ }
+}
+
+#[test]
+fn test_pre_lockin_no_chan_closed_update() {
+ // Test that if a peer closes a channel in response to a funding_created message we don't
+ // generate a channel update (as the channel cannot appear on chain without a funding_signed
+ // message).
+ //
+ // Doing so would imply a channel monitor update before the initial channel monitor
+ // registration, violating our API guarantees.
+ //
+ // Previously, full_stack_target managed to hit this case by opening then closing a channel,
+ // then opening a second channel with the same funding output as the first (which is not
+ // rejected because the first channel does not exist in the ChannelManager) and closing it
+ // before receiving funding_signed.
+ 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]);
+ let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
+
+ // Create an initial channel
+ nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None).unwrap();
+ 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(), InitFeatures::known(), &open_chan_msg);
+ let accept_chan_msg = get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id());
+ nodes[0].node.handle_accept_channel(&nodes[1].node.get_our_node_id(), InitFeatures::known(), &accept_chan_msg);
+
+ // Move the first channel through the funding flow...
+ let (temporary_channel_id, _tx, funding_output) = create_funding_transaction(&nodes[0], 100000, 42);
+
+ nodes[0].node.funding_transaction_generated(&temporary_channel_id, funding_output);
+ check_added_monitors!(nodes[0], 0);
+
+ let funding_created_msg = get_event_msg!(nodes[0], MessageSendEvent::SendFundingCreated, nodes[1].node.get_our_node_id());
+ let channel_id = ::chain::transaction::OutPoint { txid: funding_created_msg.funding_txid, index: funding_created_msg.funding_output_index }.to_channel_id();
+ nodes[0].node.handle_error(&nodes[1].node.get_our_node_id(), &msgs::ErrorMessage { channel_id, data: "Hi".to_owned() });
+ assert!(nodes[0].chain_monitor.added_monitors.lock().unwrap().is_empty());
+}
+
+#[test]
+fn test_htlc_no_detection() {
+ // This test is a mutation to underscore the detection logic bug we had
+ // before #653. HTLC value routed is above the remaining balance, thus
+ // inverting HTLC and `to_remote` output. HTLC will come second and
+ // it wouldn't be seen by pre-#653 detection as we were enumerate()'ing
+ // on a watched outputs vector (Vec<TxOut>) thus implicitly relying on
+ // outputs order detection for correct spending children filtring.
+
+ 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]);
+ let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
+
+ // Create some initial channels
+ let chan_1 = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 10001, InitFeatures::known(), InitFeatures::known());
+
+ send_payment(&nodes[0], &vec!(&nodes[1])[..], 1_000_000, 1_000_000);
+ let (_, our_payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1])[..], 2_000_000);
+ let local_txn = get_local_commitment_txn!(nodes[0], chan_1.2);
+ assert_eq!(local_txn[0].input.len(), 1);
+ assert_eq!(local_txn[0].output.len(), 3);
+ check_spends!(local_txn[0], chan_1.3);
+
+ // Timeout HTLC on A's chain and so it can generate a HTLC-Timeout tx
+ let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
+ connect_block(&nodes[0], &Block { header, txdata: vec![local_txn[0].clone()] }, 200);
+ // We deliberately connect the local tx twice as this should provoke a failure calling
+ // this test before #653 fix.
+ connect_block(&nodes[0], &Block { header, txdata: vec![local_txn[0].clone()] }, 200);
+ check_closed_broadcast!(nodes[0], false);
+ check_added_monitors!(nodes[0], 1);
+
+ let htlc_timeout = {
+ let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
+ assert_eq!(node_txn[0].input.len(), 1);
+ assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
+ check_spends!(node_txn[0], local_txn[0]);
+ node_txn[0].clone()
+ };
+
+ let header_201 = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
+ connect_block(&nodes[0], &Block { header: header_201, txdata: vec![htlc_timeout.clone()] }, 201);
+ connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1, 201, true, header_201.block_hash());
+ expect_payment_failed!(nodes[0], our_payment_hash, true);
+}
+
+fn do_test_onchain_htlc_settlement_after_close(broadcast_alice: bool, go_onchain_before_fulfill: bool) {
+ // If we route an HTLC, then learn the HTLC's preimage after the upstream channel has been
+ // force-closed, we must claim that HTLC on-chain. (Given an HTLC forwarded from Alice --> Bob -->
+ // Carol, Alice would be the upstream node, and Carol the downstream.)
+ //
+ // Steps of the test:
+ // 1) Alice sends a HTLC to Carol through Bob.
+ // 2) Carol doesn't settle the HTLC.
+ // 3) If broadcast_alice is true, Alice force-closes her channel with Bob. Else Bob force closes.
+ // Steps 4 and 5 may be reordered depending on go_onchain_before_fulfill.
+ // 4) Bob sees the Alice's commitment on his chain or vice versa. An offered output is present
+ // but can't be claimed as Bob doesn't have yet knowledge of the preimage.
+ // 5) Carol release the preimage to Bob off-chain.
+ // 6) Bob claims the offered output on the broadcasted commitment.
+ let chanmon_cfgs = create_chanmon_cfgs(3);
+ 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);
+
+ // Create some initial channels
+ let chan_ab = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 10001, InitFeatures::known(), InitFeatures::known());
+ create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 100000, 10001, InitFeatures::known(), InitFeatures::known());
+
+ // Steps (1) and (2):
+ // Send an HTLC Alice --> Bob --> Carol, but Carol doesn't settle the HTLC back.
+ let (payment_preimage, _payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3_000_000);
+
+ // Check that Alice's commitment transaction now contains an output for this HTLC.
+ let alice_txn = get_local_commitment_txn!(nodes[0], chan_ab.2);
+ check_spends!(alice_txn[0], chan_ab.3);
+ assert_eq!(alice_txn[0].output.len(), 2);
+ check_spends!(alice_txn[1], alice_txn[0]); // 2nd transaction is a non-final HTLC-timeout
+ assert_eq!(alice_txn[1].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
+ assert_eq!(alice_txn.len(), 2);
+
+ // Steps (3) and (4):
+ // If `go_onchain_before_fufill`, broadcast the relevant commitment transaction and check that Bob
+ // responds by (1) broadcasting a channel update and (2) adding a new ChannelMonitor.
+ let mut force_closing_node = 0; // Alice force-closes
+ if !broadcast_alice { force_closing_node = 1; } // Bob force-closes
+ nodes[force_closing_node].node.force_close_channel(&chan_ab.2).unwrap();
+ check_closed_broadcast!(nodes[force_closing_node], false);
+ check_added_monitors!(nodes[force_closing_node], 1);
+ if go_onchain_before_fulfill {
+ let txn_to_broadcast = match broadcast_alice {
+ true => alice_txn.clone(),
+ false => get_local_commitment_txn!(nodes[1], chan_ab.2)
+ };
+ let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
+ connect_block(&nodes[1], &Block { header, txdata: vec![txn_to_broadcast[0].clone()]}, 1);
+ let mut bob_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
+ if broadcast_alice {
+ check_closed_broadcast!(nodes[1], false);
+ check_added_monitors!(nodes[1], 1);
+ }
+ assert_eq!(bob_txn.len(), 1);
+ check_spends!(bob_txn[0], chan_ab.3);
+ }
+
+ // Step (5):
+ // Carol then claims the funds and sends an update_fulfill message to Bob, and they go through the
+ // process of removing the HTLC from their commitment transactions.
+ assert!(nodes[2].node.claim_funds(payment_preimage, &None, 3_000_000));
+ check_added_monitors!(nodes[2], 1);
+ let carol_updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
+ assert!(carol_updates.update_add_htlcs.is_empty());
+ assert!(carol_updates.update_fail_htlcs.is_empty());
+ assert!(carol_updates.update_fail_malformed_htlcs.is_empty());
+ assert!(carol_updates.update_fee.is_none());
+ assert_eq!(carol_updates.update_fulfill_htlcs.len(), 1);
+
+ nodes[1].node.handle_update_fulfill_htlc(&nodes[2].node.get_our_node_id(), &carol_updates.update_fulfill_htlcs[0]);
+ // If Alice broadcasted but Bob doesn't know yet, here he prepares to tell her about the preimage.
+ if !go_onchain_before_fulfill && broadcast_alice {
+ let events = nodes[1].node.get_and_clear_pending_msg_events();
+ assert_eq!(events.len(), 1);
+ match events[0] {
+ MessageSendEvent::UpdateHTLCs { ref node_id, .. } => {
+ assert_eq!(*node_id, nodes[0].node.get_our_node_id());
+ },
+ _ => panic!("Unexpected event"),
+ };
+ }
+ nodes[1].node.handle_commitment_signed(&nodes[2].node.get_our_node_id(), &carol_updates.commitment_signed);
+ // One monitor update for the preimage to update the Bob<->Alice channel, one monitor update
+ // Carol<->Bob's updated commitment transaction info.
+ check_added_monitors!(nodes[1], 2);
+
+ let events = nodes[1].node.get_and_clear_pending_msg_events();
+ assert_eq!(events.len(), 2);
+ let bob_revocation = match events[0] {
+ MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => {
+ assert_eq!(*node_id, nodes[2].node.get_our_node_id());
+ (*msg).clone()
+ },
+ _ => panic!("Unexpected event"),
+ };
+ let bob_updates = match events[1] {
+ MessageSendEvent::UpdateHTLCs { ref node_id, ref updates } => {
+ assert_eq!(*node_id, nodes[2].node.get_our_node_id());
+ (*updates).clone()
+ },
+ _ => panic!("Unexpected event"),
+ };
+
+ nodes[2].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bob_revocation);
+ check_added_monitors!(nodes[2], 1);
+ nodes[2].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bob_updates.commitment_signed);
+ check_added_monitors!(nodes[2], 1);
+
+ let events = nodes[2].node.get_and_clear_pending_msg_events();
+ assert_eq!(events.len(), 1);
+ let carol_revocation = match events[0] {
+ MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => {
+ assert_eq!(*node_id, nodes[1].node.get_our_node_id());
+ (*msg).clone()
+ },
+ _ => panic!("Unexpected event"),
+ };
+ nodes[1].node.handle_revoke_and_ack(&nodes[2].node.get_our_node_id(), &carol_revocation);
+ check_added_monitors!(nodes[1], 1);
+
+ // If this test requires the force-closed channel to not be on-chain until after the fulfill,
+ // here's where we put said channel's commitment tx on-chain.
+ let mut txn_to_broadcast = alice_txn.clone();
+ if !broadcast_alice { txn_to_broadcast = get_local_commitment_txn!(nodes[1], chan_ab.2); }
+ if !go_onchain_before_fulfill {
+ let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
+ connect_block(&nodes[1], &Block { header, txdata: vec![txn_to_broadcast[0].clone()]}, 1);
+ // If Bob was the one to force-close, he will have already passed these checks earlier.
+ if broadcast_alice {
+ check_closed_broadcast!(nodes[1], false);
+ check_added_monitors!(nodes[1], 1);
+ }
+ let mut bob_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
+ if broadcast_alice {
+ // In `connect_block()`, the ChainMonitor and ChannelManager are separately notified about a
+ // new block being connected. The ChannelManager being notified triggers a monitor update,
+ // which triggers broadcasting our commitment tx and an HTLC-claiming tx. The ChainMonitor
+ // being notified triggers the HTLC-claiming tx redundantly, resulting in 3 total txs being
+ // broadcasted.
+ assert_eq!(bob_txn.len(), 3);
+ check_spends!(bob_txn[1], chan_ab.3);
+ } else {
+ assert_eq!(bob_txn.len(), 2);
+ check_spends!(bob_txn[0], chan_ab.3);
+ }
+ }
+
+ // Step (6):
+ // Finally, check that Bob broadcasted a preimage-claiming transaction for the HTLC output on the
+ // broadcasted commitment transaction.
+ {
+ let bob_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
+ if go_onchain_before_fulfill {
+ // Bob should now have an extra broadcasted tx, for the preimage-claiming transaction.
+ assert_eq!(bob_txn.len(), 2);
+ }
+ let script_weight = match broadcast_alice {
+ true => OFFERED_HTLC_SCRIPT_WEIGHT,
+ false => ACCEPTED_HTLC_SCRIPT_WEIGHT
+ };
+ // If Alice force-closed and Bob didn't receive her commitment transaction until after he
+ // received Carol's fulfill, he broadcasts the HTLC-output-claiming transaction first. Else if
+ // Bob force closed or if he found out about Alice's commitment tx before receiving Carol's
+ // fulfill, then he broadcasts the HTLC-output-claiming transaction second.
+ if broadcast_alice && !go_onchain_before_fulfill {
+ check_spends!(bob_txn[0], txn_to_broadcast[0]);
+ assert_eq!(bob_txn[0].input[0].witness.last().unwrap().len(), script_weight);
+ } else {
+ check_spends!(bob_txn[1], txn_to_broadcast[0]);
+ assert_eq!(bob_txn[1].input[0].witness.last().unwrap().len(), script_weight);
+ }
+ }
+}
+
+#[test]
+fn test_onchain_htlc_settlement_after_close() {
+ do_test_onchain_htlc_settlement_after_close(true, true);
+ do_test_onchain_htlc_settlement_after_close(false, true); // Technically redundant, but may as well
+ do_test_onchain_htlc_settlement_after_close(true, false);
+ do_test_onchain_htlc_settlement_after_close(false, false);
+}
+
+#[test]
+fn test_duplicate_chan_id() {
+ // Test that if a given peer tries to open a channel with the same channel_id as one that is
+ // already open we reject it and keep the old channel.
+ //
+ // Previously, full_stack_target managed to figure out that if you tried to open two channels
+ // with the same funding output (ie post-funding channel_id), we'd create a monitor update for
+ // the existing channel when we detect the duplicate new channel, screwing up our monitor
+ // updating logic for the existing channel.
+ 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]);
+ let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
+
+ // Create an initial channel
+ nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None).unwrap();
+ 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(), InitFeatures::known(), &open_chan_msg);
+ nodes[0].node.handle_accept_channel(&nodes[1].node.get_our_node_id(), InitFeatures::known(), &get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id()));
+
+ // Try to create a second channel with the same temporary_channel_id as the first and check
+ // that it is rejected.
+ nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::known(), &open_chan_msg);
+ {
+ 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 } => {
+ // Technically, at this point, nodes[1] would be justified in thinking both the
+ // first (valid) and second (invalid) channels are closed, given they both have
+ // the same non-temporary channel_id. However, currently we do not, so we just
+ // move forward with it.
+ assert_eq!(msg.channel_id, open_chan_msg.temporary_channel_id);
+ assert_eq!(node_id, nodes[0].node.get_our_node_id());
+ },
+ _ => panic!("Unexpected event"),
+ }
+ }
+
+ // Move the first channel through the funding flow...
+ let (temporary_channel_id, tx, funding_output) = create_funding_transaction(&nodes[0], 100000, 42);
+
+ nodes[0].node.funding_transaction_generated(&temporary_channel_id, funding_output);
+ 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());
+ nodes[1].node.handle_funding_created(&nodes[0].node.get_our_node_id(), &funding_created_msg);
+ {
+ let mut added_monitors = nodes[1].chain_monitor.added_monitors.lock().unwrap();
+ assert_eq!(added_monitors.len(), 1);
+ assert_eq!(added_monitors[0].0, funding_output);
+ added_monitors.clear();
+ }
+ let funding_signed_msg = get_event_msg!(nodes[1], MessageSendEvent::SendFundingSigned, nodes[0].node.get_our_node_id());
+
+ let funding_outpoint = ::chain::transaction::OutPoint { txid: funding_created_msg.funding_txid, index: funding_created_msg.funding_output_index };
+ let channel_id = funding_outpoint.to_channel_id();
+
+ // Now we have the first channel past funding_created (ie it has a txid-based channel_id, not a
+ // temporary one).
+
+ // First try to open a second channel with a temporary channel id equal to the txid-based one.
+ // Technically this is allowed by the spec, but we don't support it and there's little reason
+ // to. Still, it shouldn't cause any other issues.
+ open_chan_msg.temporary_channel_id = channel_id;
+ nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::known(), &open_chan_msg);
+ {
+ 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 } => {
+ // Technically, at this point, nodes[1] would be justified in thinking both
+ // channels are closed, but currently we do not, so we just move forward with it.
+ assert_eq!(msg.channel_id, open_chan_msg.temporary_channel_id);
+ assert_eq!(node_id, nodes[0].node.get_our_node_id());
+ },
+ _ => panic!("Unexpected event"),
+ }
+ }
+
+ // Now try to create a second channel which has a duplicate funding output.
+ nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None).unwrap();
+ let open_chan_2_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(), InitFeatures::known(), &open_chan_2_msg);
+ nodes[0].node.handle_accept_channel(&nodes[1].node.get_our_node_id(), InitFeatures::known(), &get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id()));
+ create_funding_transaction(&nodes[0], 100000, 42); // Get and check the FundingGenerationReady event
+
+ let funding_created = {
+ let mut a_channel_lock = nodes[0].node.channel_state.lock().unwrap();
+ let mut as_chan = a_channel_lock.by_id.get_mut(&open_chan_2_msg.temporary_channel_id).unwrap();
+ let logger = test_utils::TestLogger::new();
+ as_chan.get_outbound_funding_created(funding_outpoint, &&logger).unwrap()
+ };
+ check_added_monitors!(nodes[0], 0);
+ nodes[1].node.handle_funding_created(&nodes[0].node.get_our_node_id(), &funding_created);
+ // At this point we'll try to add a duplicate channel monitor, which will be rejected, but
+ // still needs to be cleared here.
+ check_added_monitors!(nodes[1], 1);
+
+ // ...still, nodes[1] will reject the duplicate 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 } => {
+ // Technically, at this point, nodes[1] would be justified in thinking both
+ // channels are closed, but currently we do not, so we just move forward with it.
+ assert_eq!(msg.channel_id, channel_id);
+ assert_eq!(node_id, nodes[0].node.get_our_node_id());
+ },
+ _ => panic!("Unexpected event"),
+ }
+ }
+
+ // finally, finish creating the original channel and send a payment over it to make sure
+ // everything is functional.
+ nodes[0].node.handle_funding_signed(&nodes[1].node.get_our_node_id(), &funding_signed_msg);
+ {
+ let mut added_monitors = nodes[0].chain_monitor.added_monitors.lock().unwrap();
+ assert_eq!(added_monitors.len(), 1);
+ assert_eq!(added_monitors[0].0, funding_output);
+ added_monitors.clear();
+ }
+
+ let events_4 = nodes[0].node.get_and_clear_pending_events();
+ assert_eq!(events_4.len(), 1);
+ match events_4[0] {
+ Event::FundingBroadcastSafe { ref funding_txo, user_channel_id } => {
+ assert_eq!(user_channel_id, 42);
+ assert_eq!(*funding_txo, funding_output);
+ },
+ _ => panic!("Unexpected event"),
+ };
+
+ let (funding_locked, _) = create_chan_between_nodes_with_value_confirm(&nodes[0], &nodes[1], &tx);
+ let (announcement, as_update, bs_update) = create_chan_between_nodes_with_value_b(&nodes[0], &nodes[1], &funding_locked);
+ update_nodes_with_chan_announce(&nodes, 0, 1, &announcement, &as_update, &bs_update);
+ send_payment(&nodes[0], &[&nodes[1]], 8000000, 8_000_000);
+}
+
+#[test]
+fn test_error_chans_closed() {
+ // Test that we properly handle error messages, closing appropriate channels.
+ //
+ // Prior to #787 we'd allow a peer to make us force-close a channel we had with a different
+ // peer. The "real" fix for that is to index channels with peers_ids, however in the mean time
+ // we can test various edge cases around it to ensure we don't regress.
+ let chanmon_cfgs = create_chanmon_cfgs(3);
+ 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);
+
+ // Create some initial channels
+ let chan_1 = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 10001, InitFeatures::known(), InitFeatures::known());
+ let chan_2 = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 10001, InitFeatures::known(), InitFeatures::known());
+ let chan_3 = create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 100000, 10001, InitFeatures::known(), InitFeatures::known());
+
+ assert_eq!(nodes[0].node.list_usable_channels().len(), 3);
+ assert_eq!(nodes[1].node.list_usable_channels().len(), 2);
+ assert_eq!(nodes[2].node.list_usable_channels().len(), 1);
+
+ // Closing a channel from a different peer has no effect
+ nodes[0].node.handle_error(&nodes[1].node.get_our_node_id(), &msgs::ErrorMessage { channel_id: chan_3.2, data: "ERR".to_owned() });
+ assert_eq!(nodes[0].node.list_usable_channels().len(), 3);
+
+ // Closing one channel doesn't impact others
+ nodes[0].node.handle_error(&nodes[1].node.get_our_node_id(), &msgs::ErrorMessage { channel_id: chan_2.2, data: "ERR".to_owned() });
+ check_added_monitors!(nodes[0], 1);
+ check_closed_broadcast!(nodes[0], false);
+ assert_eq!(nodes[0].node.list_usable_channels().len(), 2);
+ assert!(nodes[0].node.list_usable_channels()[0].channel_id == chan_1.2 || nodes[0].node.list_usable_channels()[1].channel_id == chan_1.2);
+ assert!(nodes[0].node.list_usable_channels()[0].channel_id == chan_3.2 || nodes[0].node.list_usable_channels()[1].channel_id == chan_3.2);
+
+ // A null channel ID should close all channels
+ let _chan_4 = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 10001, InitFeatures::known(), InitFeatures::known());
+ nodes[0].node.handle_error(&nodes[1].node.get_our_node_id(), &msgs::ErrorMessage { channel_id: [0; 32], data: "ERR".to_owned() });
+ check_added_monitors!(nodes[0], 2);
+ let events = nodes[0].node.get_and_clear_pending_msg_events();
+ assert_eq!(events.len(), 2);
+ match events[0] {
+ MessageSendEvent::BroadcastChannelUpdate { ref msg } => {
+ assert_eq!(msg.contents.flags & 2, 2);
+ },
+ _ => panic!("Unexpected event"),
+ }
+ match events[1] {
+ MessageSendEvent::BroadcastChannelUpdate { ref msg } => {
+ assert_eq!(msg.contents.flags & 2, 2);
+ },
+ _ => panic!("Unexpected event"),
+ }
+ // Note that at this point users of a standard PeerHandler will end up calling
+ // peer_disconnected with no_connection_possible set to false, duplicating the
+ // close-all-channels logic. That's OK, we don't want to end up not force-closing channels for
+ // users with their own peer handling logic. We duplicate the call here, however.
+ assert_eq!(nodes[0].node.list_usable_channels().len(), 1);
+ assert!(nodes[0].node.list_usable_channels()[0].channel_id == chan_3.2);
+
+ nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), true);
+ assert_eq!(nodes[0].node.list_usable_channels().len(), 1);
+ assert!(nodes[0].node.list_usable_channels()[0].channel_id == chan_3.2);
+}