Add test_static_spendable_outputs_preimage_tx

Aims to covered both keysinterace preimage tx case and
detection of second remote commitment tx

Add AddressType to describe DynamicOutput

Author: Antoine Riard

src/chain/keysinterface.rs

@@ -25,6 +25,17 @@ use std::time::{SystemTime, UNIX_EPOCH};
 use std::sync::Arc;
 use std::sync::atomic::{AtomicUsize, Ordering};
 
+/// Used to describe the type of address to which a DynamicOutput commits
+pub enum AddressType {
+	/// Output commits to P2WSH
+	P2WSH {
+		/// witness_script needed to redeem it
+		witness_script: Script,
+	},
+	/// Output commits to a P2WPKH
+	P2WPKH,
+}
+
 /// When on-chain outputs are created by rust-lightning an event is generated which informs the
 /// user thereof. This enum describes the format of the output and provides the OutPoint.
 pub enum SpendableOutputDescriptor {
@@ -37,17 +48,21 @@ pub enum SpendableOutputDescriptor {
 		/// The output which is referenced by the given outpoint
 		output: TxOut,
 	},
-	/// Outpoint commits to a P2WSH, should be spend by the following witness :
+	/// Outpoint commits to a P2WSH if witness_script is Some or P2WPKH if it's None.
+	/// P2WSH should be spend by the following witness :
 	/// <local_delayedsig> 0 <witnessScript>
 	/// With input nSequence set to_self_delay.
-	/// Outputs from a HTLC-Success/Timeout tx
+	/// P2WPKH should be spend by the following witness :
+	/// <local_sig> <local_pubkey>
+	/// Outputs from a HTLC-Success/Timeout tx/commitment tx
 	DynamicOutput {
 		/// Outpoint spendable by user wallet
 		outpoint: OutPoint,
-		/// local_delayedkey = delayed_payment_basepoint_secret + SHA256(per_commitment_point || delayed_payment_basepoint)
-		local_delayedkey: SecretKey,
-		/// witness redeemScript encumbering output
-		witness_script: Script,
+		/// local_delayedkey = delayed_payment_basepoint_secret + SHA256(per_commitment_point || delayed_payment_basepoint) OR
+		/// localkey = payment_basepoint_secret + SHA256(per_commitment_point || payment_basepoint
+		key: SecretKey,
+		/// witness redeemScript encumbering output. If None script is a P2WPKH to build from key.
+		address: AddressType,
 		/// nSequence input must commit to self_delay to satisfy script's OP_CSV
 		to_self_delay: u16,
 		/// The output which is referenced by the given outpoint

src/ln/channel.rs

@@ -436,7 +436,7 @@ impl Channel {
 
 		let secp_ctx = Secp256k1::new();
 		let channel_monitor = ChannelMonitor::new(&chan_keys.revocation_base_key, &chan_keys.delayed_payment_base_key,
-		                                          &chan_keys.htlc_base_key, BREAKDOWN_TIMEOUT,
+		                                          &chan_keys.htlc_base_key, &chan_keys.payment_base_key, BREAKDOWN_TIMEOUT,
 		                                          keys_provider.get_destination_script(), logger.clone());
 
 		Ok(Channel {
@@ -624,7 +624,7 @@ impl Channel {
 
 		let secp_ctx = Secp256k1::new();
 		let mut channel_monitor = ChannelMonitor::new(&chan_keys.revocation_base_key, &chan_keys.delayed_payment_base_key,
-		                                              &chan_keys.htlc_base_key, BREAKDOWN_TIMEOUT,
+		                                              &chan_keys.htlc_base_key, &chan_keys.payment_base_key, BREAKDOWN_TIMEOUT,
 		                                              keys_provider.get_destination_script(), logger.clone());
 		channel_monitor.set_their_base_keys(&msg.htlc_basepoint, &msg.delayed_payment_basepoint);
 		channel_monitor.provide_their_next_revocation_point(Some((INITIAL_COMMITMENT_NUMBER, msg.first_per_commitment_point)));

src/ln/channelmanager.rs

@@ -3209,7 +3209,7 @@ mod tests {
 	use chain::chaininterface;
 	use chain::transaction::OutPoint;
 	use chain::chaininterface::{ChainListener, ChainWatchInterface};
-	use chain::keysinterface::{KeysInterface, SpendableOutputDescriptor};
+	use chain::keysinterface::{KeysInterface, SpendableOutputDescriptor, AddressType};
 	use chain::keysinterface;
 	use ln::channelmanager::{ChannelManager,ChannelManagerReadArgs,OnionKeys,PaymentFailReason,RAACommitmentOrder};
 	use ln::channelmonitor::{ChannelMonitor, ChannelMonitorUpdateErr, CLTV_CLAIM_BUFFER, HTLC_FAIL_TIMEOUT_BLOCKS, ManyChannelMonitor};
@@ -3225,6 +3225,8 @@ mod tests {
 
 	use bitcoin::util::hash::{BitcoinHash, Sha256dHash};
 	use bitcoin::util::bip143;
+	use bitcoin::util::address::Address;
+	use bitcoin::util::bip32::{ChildNumber, ExtendedPubKey, ExtendedPrivKey};
 	use bitcoin::blockdata::block::{Block, BlockHeader};
 	use bitcoin::blockdata::transaction::{Transaction, TxOut, TxIn, SigHashType};
 	use bitcoin::blockdata::script::{Builder, Script};
@@ -7546,7 +7548,7 @@ mod tests {
 						Event::SpendableOutputs { ref outputs } => {
 							for outp in outputs {
 								match *outp {
-									SpendableOutputDescriptor::DynamicOutput { ref outpoint, ref local_delayedkey, ref witness_script, ref to_self_delay, ref output } => {
+									SpendableOutputDescriptor::DynamicOutput { ref outpoint, ref key, ref address, ref to_self_delay, ref output } => {
 										let input = TxIn {
 											previous_output: outpoint.clone(),
 											script_sig: Script::new(),
@@ -7563,14 +7565,28 @@ mod tests {
 											input: vec![input],
 											output: vec![outp],
 										};
-										let sighash = Message::from_slice(&bip143::SighashComponents::new(&spend_tx).sighash_all(&spend_tx.input[0], witness_script, output.value)[..]).unwrap();
 										let secp_ctx = Secp256k1::new();
-										let local_delaysig = secp_ctx.sign(&sighash, local_delayedkey);
-										spend_tx.input[0].witness.push(local_delaysig.serialize_der(&secp_ctx).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);
+										match *address {
+											AddressType::P2WSH { ref witness_script } => {
+												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(&secp_ctx).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);
+											},
+											AddressType::P2WPKH => {
+												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(&secp_ctx).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);
+											},
+										}
 									},
 									_ => panic!("Unexpected event"),
 								}
@@ -7584,6 +7600,57 @@ mod tests {
 		}
 	}
 
+	macro_rules! check_static_output {
+		($event: expr, $node: expr, $event_idx: expr, $output_idx: expr, $der_idx: expr, $idx_node: expr) => {
+			match $event[$event_idx] {
+				Event::SpendableOutputs { ref outputs } => {
+					match outputs[$output_idx] {
+						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(&secp_ctx, Network::Testnet, &$node[$idx_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(&secp_ctx).to_vec());
+							spend_tx.input[0].witness[0].push(SigHashType::All as u8);
+							spend_tx.input[0].witness.push(pubkey.serialize().to_vec());
+							spend_tx
+						},
+						_ => panic!("Unexpected event !"),
+					}
+				},
+				_ => panic!("Unexpected event !"),
+			};
+		}
+	}
+
 	#[test]
 	fn test_claim_sizeable_push_msat() {
 		// Incidentally test SpendableOutput event generation due to detection of to_local output on commitment tx
@@ -7607,4 +7674,44 @@ mod tests {
 		assert_eq!(spend_txn.len(), 1);
 		check_spends!(spend_txn[0], 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(), 133);
+		check_spends!(node_txn[1], chan_1.3.clone());
+
+		let events = nodes[1].chan_monitor.simple_monitor.get_and_clear_pending_events();
+		let spend_tx = check_static_output!(events, nodes, 0, 0, 1, 1);
+		check_spends!(spend_tx, node_txn[0].clone());
+	}
 }