- nodes[0].chan_monitor = Arc::new(test_utils::TestChannelMonitor::new(nodes[0].chain_monitor.clone(), nodes[0].tx_broadcaster.clone(), Arc::new(test_utils::TestLogger::new())));
- let mut node_0_monitors = Vec::new();
- for serialized in node_0_monitors_serialized.iter() {
- let mut read = &serialized[..];
- let (_, monitor) = <(Sha256dHash, ChannelMonitor)>::read(&mut read, Arc::new(test_utils::TestLogger::new())).unwrap();
- assert!(read.is_empty());
- node_0_monitors.push(monitor);
- }
-
- let mut nodes_0_read = &nodes_0_serialized[..];
- let keys_manager = Arc::new(keysinterface::KeysManager::new(&nodes[0].node_seed, Network::Testnet, Arc::new(test_utils::TestLogger::new())));
- let (_, nodes_0_deserialized) = <(Sha256dHash, ChannelManager)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
- default_config: UserConfig::new(),
- keys_manager,
- fee_estimator: Arc::new(test_utils::TestFeeEstimator { sat_per_kw: 253 }),
- monitor: nodes[0].chan_monitor.clone(),
- chain_monitor: nodes[0].chain_monitor.clone(),
- tx_broadcaster: nodes[0].tx_broadcaster.clone(),
- logger: Arc::new(test_utils::TestLogger::new()),
- channel_monitors: &node_0_monitors.iter().map(|monitor| { (monitor.get_funding_txo().unwrap(), monitor) }).collect(),
- }).unwrap();
- assert!(nodes_0_read.is_empty());
-
- { // Channel close should result in a commitment tx and an HTLC tx
- let txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
- assert_eq!(txn.len(), 2);
- assert_eq!(txn[0].input[0].previous_output.txid, funding_tx.txid());
- assert_eq!(txn[1].input[0].previous_output.txid, txn[0].txid());
- }
-
- for monitor in node_0_monitors.drain(..) {
- assert!(nodes[0].chan_monitor.add_update_monitor(monitor.get_funding_txo().unwrap(), monitor).is_ok());
- check_added_monitors!(nodes[0], 1);
- }
- nodes[0].node = Arc::new(nodes_0_deserialized);
-
- // nodes[1] and nodes[2] have no lost state with nodes[0]...
- reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
- reconnect_nodes(&nodes[0], &nodes[2], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
- //... and we can even still claim the payment!
- claim_payment(&nodes[2], &[&nodes[0], &nodes[1]], our_payment_preimage);
-
- nodes[3].node.peer_connected(&nodes[0].node.get_our_node_id());
- let reestablish = get_event_msg!(nodes[3], MessageSendEvent::SendChannelReestablish, nodes[0].node.get_our_node_id());
- nodes[0].node.peer_connected(&nodes[3].node.get_our_node_id());
- if let Err(msgs::HandleError { action: Some(msgs::ErrorAction::SendErrorMessage { msg }), .. }) = nodes[0].node.handle_channel_reestablish(&nodes[3].node.get_our_node_id(), &reestablish) {
- assert_eq!(msg.channel_id, channel_id);
- } else { panic!("Unexpected result"); }
-}
-
-macro_rules! check_spendable_outputs {
- ($node: expr, $der_idx: expr) => {
- {
- let events = $node.chan_monitor.simple_monitor.get_and_clear_pending_events();
- let mut txn = Vec::new();
- for event in events {
- match event {
- Event::SpendableOutputs { ref outputs } => {
- for outp in outputs {
- match *outp {
- SpendableOutputDescriptor::DynamicOutputP2WPKH { ref outpoint, ref key, ref output } => {
- let input = TxIn {
- previous_output: outpoint.clone(),
- script_sig: Script::new(),
- sequence: 0,
- witness: Vec::new(),
- };
- let outp = TxOut {
- script_pubkey: Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script(),
- value: output.value,
- };
- let mut spend_tx = Transaction {
- version: 2,
- lock_time: 0,
- input: vec![input],
- output: vec![outp],
- };
- let secp_ctx = Secp256k1::new();
- let remotepubkey = PublicKey::from_secret_key(&secp_ctx, &key);
- let witness_script = Address::p2pkh(&remotepubkey, Network::Testnet).script_pubkey();
- let sighash = Message::from_slice(&bip143::SighashComponents::new(&spend_tx).sighash_all(&spend_tx.input[0], &witness_script, output.value)[..]).unwrap();
- let remotesig = secp_ctx.sign(&sighash, key);
- spend_tx.input[0].witness.push(remotesig.serialize_der().to_vec());
- spend_tx.input[0].witness[0].push(SigHashType::All as u8);
- spend_tx.input[0].witness.push(remotepubkey.serialize().to_vec());
- txn.push(spend_tx);
- },
- SpendableOutputDescriptor::DynamicOutputP2WSH { ref outpoint, ref key, ref witness_script, ref to_self_delay, ref output } => {
- let input = TxIn {
- previous_output: outpoint.clone(),
- script_sig: Script::new(),
- sequence: *to_self_delay as u32,
- witness: Vec::new(),
- };
- let outp = TxOut {
- script_pubkey: Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script(),
- value: output.value,
- };
- let mut spend_tx = Transaction {
- version: 2,
- lock_time: 0,
- input: vec![input],
- output: vec![outp],
- };
- let secp_ctx = Secp256k1::new();
- let sighash = Message::from_slice(&bip143::SighashComponents::new(&spend_tx).sighash_all(&spend_tx.input[0], witness_script, output.value)[..]).unwrap();
- let local_delaysig = secp_ctx.sign(&sighash, key);
- spend_tx.input[0].witness.push(local_delaysig.serialize_der().to_vec());
- spend_tx.input[0].witness[0].push(SigHashType::All as u8);
- spend_tx.input[0].witness.push(vec!(0));
- spend_tx.input[0].witness.push(witness_script.clone().into_bytes());
- txn.push(spend_tx);
- },
- SpendableOutputDescriptor::StaticOutput { ref outpoint, ref output } => {
- let secp_ctx = Secp256k1::new();
- let input = TxIn {
- previous_output: outpoint.clone(),
- script_sig: Script::new(),
- sequence: 0,
- witness: Vec::new(),
- };
- let outp = TxOut {
- script_pubkey: Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script(),
- value: output.value,
- };
- let mut spend_tx = Transaction {
- version: 2,
- lock_time: 0,
- input: vec![input],
- output: vec![outp.clone()],
- };
- let secret = {
- match ExtendedPrivKey::new_master(Network::Testnet, &$node.node_seed) {
- Ok(master_key) => {
- match master_key.ckd_priv(&secp_ctx, ChildNumber::from_hardened_idx($der_idx)) {
- Ok(key) => key,
- Err(_) => panic!("Your RNG is busted"),
- }
- }
- Err(_) => panic!("Your rng is busted"),
- }
- };
- let pubkey = ExtendedPubKey::from_private(&secp_ctx, &secret).public_key;
- let witness_script = Address::p2pkh(&pubkey, Network::Testnet).script_pubkey();
- let sighash = Message::from_slice(&bip143::SighashComponents::new(&spend_tx).sighash_all(&spend_tx.input[0], &witness_script, output.value)[..]).unwrap();
- let sig = secp_ctx.sign(&sighash, &secret.secret_key);
- spend_tx.input[0].witness.push(sig.serialize_der().to_vec());
- spend_tx.input[0].witness[0].push(SigHashType::All as u8);
- spend_tx.input[0].witness.push(pubkey.serialize().to_vec());
- txn.push(spend_tx);
- },
- }
- }
- },
- _ => panic!("Unexpected event"),
- };
- }
- txn
- }
- }
-}
-
-#[test]
-fn test_claim_sizeable_push_msat() {
- // Incidentally test SpendableOutput event generation due to detection of to_local output on commitment tx
- let nodes = create_network(2);
-
- let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 99000000);
- nodes[1].node.force_close_channel(&chan.2);
- check_closed_broadcast!(nodes[1]);
- let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
- assert_eq!(node_txn.len(), 1);
- check_spends!(node_txn[0], chan.3.clone());
- assert_eq!(node_txn[0].output.len(), 2); // We can't force trimming of to_remote output as channel_reserve_satoshis block us to do so at channel opening
-
- let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
- nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![node_txn[0].clone()] }, 0);
- let spend_txn = check_spendable_outputs!(nodes[1], 1);
- assert_eq!(spend_txn.len(), 1);
- check_spends!(spend_txn[0], node_txn[0].clone());
-}
-
-#[test]
-fn test_claim_on_remote_sizeable_push_msat() {
- // Same test as previous, just test on remote commitment tx, as per_commitment_point registration changes following you're funder/fundee and
- // to_remote output is encumbered by a P2WPKH
-
- let nodes = create_network(2);
-
- let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 99000000);
- nodes[0].node.force_close_channel(&chan.2);
- check_closed_broadcast!(nodes[0]);
-
- let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
- assert_eq!(node_txn.len(), 1);
- check_spends!(node_txn[0], chan.3.clone());
- assert_eq!(node_txn[0].output.len(), 2); // We can't force trimming of to_remote output as channel_reserve_satoshis block us to do so at channel opening
-
- let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
- nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![node_txn[0].clone()] }, 0);
- check_closed_broadcast!(nodes[1]);
- let spend_txn = check_spendable_outputs!(nodes[1], 1);
- assert_eq!(spend_txn.len(), 2);
- assert_eq!(spend_txn[0], spend_txn[1]);
- check_spends!(spend_txn[0], node_txn[0].clone());
-}
-
-#[test]
-fn test_claim_on_remote_revoked_sizeable_push_msat() {
- // Same test as previous, just test on remote revoked commitment tx, as per_commitment_point registration changes following you're funder/fundee and
- // to_remote output is encumbered by a P2WPKH
-
- let nodes = create_network(2);
-
- let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 59000000);
- let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
- let revoked_local_txn = nodes[0].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().last_local_commitment_txn.clone();
- assert_eq!(revoked_local_txn[0].input.len(), 1);
- assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan.3.txid());
-
- claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage);
- let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
- nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
- check_closed_broadcast!(nodes[1]);
-
- let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
- let spend_txn = check_spendable_outputs!(nodes[1], 1);
- assert_eq!(spend_txn.len(), 4);
- assert_eq!(spend_txn[0], spend_txn[2]); // to_remote output on revoked remote commitment_tx
- check_spends!(spend_txn[0], revoked_local_txn[0].clone());
- assert_eq!(spend_txn[1], spend_txn[3]); // to_local output on local commitment tx
- check_spends!(spend_txn[1], node_txn[0].clone());
-}
-
-#[test]
-fn test_static_spendable_outputs_preimage_tx() {
- let nodes = create_network(2);
-
- // Create some initial channels
- let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
-
- let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
-
- let commitment_tx = nodes[0].node.channel_state.lock().unwrap().by_id.get(&chan_1.2).unwrap().last_local_commitment_txn.clone();
- assert_eq!(commitment_tx[0].input.len(), 1);
- assert_eq!(commitment_tx[0].input[0].previous_output.txid, chan_1.3.txid());
-
- // Settle A's commitment tx on B's chain
- let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
- assert!(nodes[1].node.claim_funds(payment_preimage));
- check_added_monitors!(nodes[1], 1);
- nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![commitment_tx[0].clone()] }, 1);
- let events = nodes[1].node.get_and_clear_pending_msg_events();
- match events[0] {
- MessageSendEvent::UpdateHTLCs { .. } => {},
- _ => panic!("Unexpected event"),
- }
- match events[1] {
- MessageSendEvent::BroadcastChannelUpdate { .. } => {},
- _ => panic!("Unexepected event"),
- }
-
- // Check B's monitor was able to send back output descriptor event for preimage tx on A's commitment tx
- let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap(); // ChannelManager : 1 (local commitment tx), ChannelMonitor: 2 (1 preimage tx) * 2 (block-rescan)
- check_spends!(node_txn[0], commitment_tx[0].clone());
- assert_eq!(node_txn[0], node_txn[2]);
- assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
- check_spends!(node_txn[1], chan_1.3.clone());
-
- let spend_txn = check_spendable_outputs!(nodes[1], 1); // , 0, 0, 1, 1);
- assert_eq!(spend_txn.len(), 2);
- assert_eq!(spend_txn[0], spend_txn[1]);
- check_spends!(spend_txn[0], node_txn[0].clone());
-}
-
-#[test]
-fn test_static_spendable_outputs_justice_tx_revoked_commitment_tx() {
- let nodes = create_network(2);
-
- // Create some initial channels
- let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
-
- let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
- let revoked_local_txn = nodes[0].node.channel_state.lock().unwrap().by_id.iter().next().unwrap().1.last_local_commitment_txn.clone();
- assert_eq!(revoked_local_txn[0].input.len(), 1);
- assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_1.3.txid());
-
- claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage);
-
- let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
- nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
- check_closed_broadcast!(nodes[1]);
-
- let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
- assert_eq!(node_txn.len(), 3);
- assert_eq!(node_txn.pop().unwrap(), node_txn[0]);
- assert_eq!(node_txn[0].input.len(), 2);
- check_spends!(node_txn[0], revoked_local_txn[0].clone());
-
- let spend_txn = check_spendable_outputs!(nodes[1], 1);
- assert_eq!(spend_txn.len(), 2);
- assert_eq!(spend_txn[0], spend_txn[1]);
- check_spends!(spend_txn[0], node_txn[0].clone());
-}
-
-#[test]
-fn test_static_spendable_outputs_justice_tx_revoked_htlc_timeout_tx() {
- let nodes = create_network(2);
-
- // Create some initial channels
- let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
-
- let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
- let revoked_local_txn = nodes[0].node.channel_state.lock().unwrap().by_id.get(&chan_1.2).unwrap().last_local_commitment_txn.clone();
- assert_eq!(revoked_local_txn[0].input.len(), 1);
- assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_1.3.txid());
-
- claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage);
-
- let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
- // A will generate HTLC-Timeout from revoked commitment tx
- nodes[0].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
- check_closed_broadcast!(nodes[0]);
-
- let revoked_htlc_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
- assert_eq!(revoked_htlc_txn.len(), 3);
- assert_eq!(revoked_htlc_txn[0], revoked_htlc_txn[2]);
- assert_eq!(revoked_htlc_txn[0].input.len(), 1);
- assert_eq!(revoked_htlc_txn[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
- check_spends!(revoked_htlc_txn[0], revoked_local_txn[0].clone());
- check_spends!(revoked_htlc_txn[1], chan_1.3.clone());
-
- // B will generate justice tx from A's revoked commitment/HTLC tx
- nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone(), revoked_htlc_txn[0].clone()] }, 1);
- check_closed_broadcast!(nodes[1]);
-
- let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
- assert_eq!(node_txn.len(), 4);
- assert_eq!(node_txn[3].input.len(), 1);
- check_spends!(node_txn[3], revoked_htlc_txn[0].clone());
-
- // Check B's ChannelMonitor was able to generate the right spendable output descriptor
- let spend_txn = check_spendable_outputs!(nodes[1], 1);
- assert_eq!(spend_txn.len(), 3);
- assert_eq!(spend_txn[0], spend_txn[1]);
- check_spends!(spend_txn[0], node_txn[0].clone());
- check_spends!(spend_txn[2], node_txn[3].clone());
-}
-
-#[test]
-fn test_static_spendable_outputs_justice_tx_revoked_htlc_success_tx() {
- let nodes = create_network(2);
-
- // Create some initial channels
- let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
-
- let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
- let revoked_local_txn = nodes[1].node.channel_state.lock().unwrap().by_id.get(&chan_1.2).unwrap().last_local_commitment_txn.clone();
- assert_eq!(revoked_local_txn[0].input.len(), 1);
- assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_1.3.txid());
-
- claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage);
-
- let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
- // B will generate HTLC-Success from revoked commitment tx
- nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
- check_closed_broadcast!(nodes[1]);
- let revoked_htlc_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
-
- assert_eq!(revoked_htlc_txn.len(), 3);
- assert_eq!(revoked_htlc_txn[0], revoked_htlc_txn[2]);
- assert_eq!(revoked_htlc_txn[0].input.len(), 1);
- assert_eq!(revoked_htlc_txn[0].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
- check_spends!(revoked_htlc_txn[0], revoked_local_txn[0].clone());
-
- // A will generate justice tx from B's revoked commitment/HTLC tx
- nodes[0].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone(), revoked_htlc_txn[0].clone()] }, 1);
- check_closed_broadcast!(nodes[0]);
-
- let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
- assert_eq!(node_txn.len(), 4);
- assert_eq!(node_txn[3].input.len(), 1);
- check_spends!(node_txn[3], revoked_htlc_txn[0].clone());
-
- // Check A's ChannelMonitor was able to generate the right spendable output descriptor
- let spend_txn = check_spendable_outputs!(nodes[0], 1);
- assert_eq!(spend_txn.len(), 5);
- assert_eq!(spend_txn[0], spend_txn[2]);
- assert_eq!(spend_txn[1], spend_txn[3]);
- check_spends!(spend_txn[0], revoked_local_txn[0].clone()); // spending to_remote output from revoked local tx
- check_spends!(spend_txn[1], node_txn[2].clone()); // spending justice tx output from revoked local tx htlc received output
- check_spends!(spend_txn[4], node_txn[3].clone()); // spending justice tx output on htlc success tx
-}
-
-#[test]
-fn test_onchain_to_onchain_claim() {
- // Test that in case of channel closure, we detect the state of output thanks to
- // ChainWatchInterface and claim HTLC on downstream peer's remote commitment tx.
- // First, have C claim an HTLC against its own latest commitment transaction.
- // Then, broadcast these to B, which should update the monitor downstream on the A<->B
- // channel.
- // Finally, check that B will claim the HTLC output if A's latest commitment transaction
- // gets broadcast.
-
- let nodes = create_network(3);
-
- // Create some initial channels
- let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
- let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2);
-
- // Rebalance the network a bit by relaying one payment through all the channels ...
- send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
- send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
-
- let (payment_preimage, _payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
- let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
- let commitment_tx = nodes[2].node.channel_state.lock().unwrap().by_id.get(&chan_2.2).unwrap().last_local_commitment_txn.clone();
- check_spends!(commitment_tx[0], chan_2.3.clone());
- nodes[2].node.claim_funds(payment_preimage);
- check_added_monitors!(nodes[2], 1);
- let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
- assert!(updates.update_add_htlcs.is_empty());
- assert!(updates.update_fail_htlcs.is_empty());
- assert_eq!(updates.update_fulfill_htlcs.len(), 1);
- assert!(updates.update_fail_malformed_htlcs.is_empty());
-
- nodes[2].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![commitment_tx[0].clone()]}, 1);
- check_closed_broadcast!(nodes[2]);
-
- let c_txn = nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap().clone(); // ChannelManager : 2 (commitment tx, HTLC-Success tx), ChannelMonitor : 1 (HTLC-Success tx)
- assert_eq!(c_txn.len(), 3);
- assert_eq!(c_txn[0], c_txn[2]);
- assert_eq!(commitment_tx[0], c_txn[1]);
- check_spends!(c_txn[1], chan_2.3.clone());
- check_spends!(c_txn[2], c_txn[1].clone());
- assert_eq!(c_txn[1].input[0].witness.clone().last().unwrap().len(), 71);
- assert_eq!(c_txn[2].input[0].witness.clone().last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
- assert!(c_txn[0].output[0].script_pubkey.is_v0_p2wsh()); // revokeable output
- assert_eq!(c_txn[0].lock_time, 0); // Success tx
-
- // So we broadcast C's commitment tx and HTLC-Success on B's chain, we should successfully be able to extract preimage and update downstream monitor
- nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![c_txn[1].clone(), c_txn[2].clone()]}, 1);
- {
- let mut b_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
- assert_eq!(b_txn.len(), 4);
- assert_eq!(b_txn[0], b_txn[3]);
- check_spends!(b_txn[1], chan_2.3); // B local commitment tx, issued by ChannelManager
- check_spends!(b_txn[2], b_txn[1].clone()); // HTLC-Timeout on B local commitment tx, issued by ChannelManager
- assert_eq!(b_txn[2].input[0].witness.clone().last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
- assert!(b_txn[2].output[0].script_pubkey.is_v0_p2wsh()); // revokeable output
- assert_ne!(b_txn[2].lock_time, 0); // Timeout tx
- check_spends!(b_txn[0], c_txn[1].clone()); // timeout tx on C remote commitment tx, issued by ChannelMonitor, * 2 due to block rescan
- assert_eq!(b_txn[0].input[0].witness.clone().last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
- assert!(b_txn[0].output[0].script_pubkey.is_v0_p2wpkh()); // direct payment
- assert_ne!(b_txn[2].lock_time, 0); // Timeout tx
- b_txn.clear();
- }
- let msg_events = nodes[1].node.get_and_clear_pending_msg_events();
- check_added_monitors!(nodes[1], 1);
- match msg_events[0] {
- MessageSendEvent::BroadcastChannelUpdate { .. } => {},
- _ => panic!("Unexpected event"),
- }
- match msg_events[1] {
- MessageSendEvent::UpdateHTLCs { ref node_id, updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fulfill_htlcs, ref update_fail_htlcs, ref update_fail_malformed_htlcs, .. } } => {
- assert!(update_add_htlcs.is_empty());
- assert!(update_fail_htlcs.is_empty());
- assert_eq!(update_fulfill_htlcs.len(), 1);
- assert!(update_fail_malformed_htlcs.is_empty());
- assert_eq!(nodes[0].node.get_our_node_id(), *node_id);
- },
- _ => panic!("Unexpected event"),
- };
- // Broadcast A's commitment tx on B's chain to see if we are able to claim inbound HTLC with our HTLC-Success tx
- let commitment_tx = nodes[0].node.channel_state.lock().unwrap().by_id.get(&chan_1.2).unwrap().last_local_commitment_txn.clone();
- nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![commitment_tx[0].clone()]}, 1);
- let b_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
- assert_eq!(b_txn.len(), 3);
- check_spends!(b_txn[1], chan_1.3); // Local commitment tx, issued by ChannelManager
- assert_eq!(b_txn[0], b_txn[2]); // HTLC-Success tx, issued by ChannelMonitor, * 2 due to block rescan
- check_spends!(b_txn[0], commitment_tx[0].clone());
- assert_eq!(b_txn[0].input[0].witness.clone().last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
- assert!(b_txn[0].output[0].script_pubkey.is_v0_p2wpkh()); // direct payment
- assert_eq!(b_txn[2].lock_time, 0); // Success tx
-
- check_closed_broadcast!(nodes[1]);