Batch-sign local HTLC txn with a well-doc'd API, returning sigs

[rust-lightning] / lightning / src / ln / channel.rs

diff --git a/lightning/src/ln/channel.rs b/lightning/src/ln/channel.rs
index 35f10ef2a912a6039f57e784ef122397c9731223..c5908906a076b7251f7f918d815626a5f5b32fb4 100644 (file)
--- a/lightning/src/ln/channel.rs
+++ b/lightning/src/ln/channel.rs
@@ -4495,7 +4495,7 @@ mod tests {
                macro_rules! test_commitment {
                        ( $their_sig_hex: expr, $our_sig_hex: expr, $tx_hex: expr, {
                                $( { $htlc_idx: expr, $their_htlc_sig_hex: expr, $our_htlc_sig_hex: expr, $htlc_tx_hex: expr } ), *
-                       } ) => {
+                       } ) => { {
                                unsigned_tx = {
                                        let mut res = chan.build_commitment_transaction(0xffffffffffff - 42, &keys, true, false, chan.feerate_per_kw);
                                        let htlcs = res.2.drain(..)
@@ -4517,11 +4517,15 @@ mod tests {
                                assert_eq!(unsigned_tx.1.len(), per_htlc.len());
 
                                localtx = LocalCommitmentTransaction::new_missing_local_sig(unsigned_tx.0.clone(), &their_signature, &PublicKey::from_secret_key(&secp_ctx, chan.local_keys.funding_key()), chan.their_funding_pubkey(), keys.clone(), chan.feerate_per_kw, per_htlc);
-                               chan_keys.sign_local_commitment(&mut localtx, &chan.secp_ctx);
+                               let local_sig = chan_keys.sign_local_commitment(&localtx, &chan.secp_ctx).unwrap();
+                               localtx.add_local_sig(&redeemscript, local_sig);
 
                                assert_eq!(serialize(localtx.with_valid_witness())[..],
                                                hex::decode($tx_hex).unwrap()[..]);
 
+                               let htlc_sigs = chan_keys.sign_local_commitment_htlc_transactions(&localtx, chan.their_to_self_delay, &chan.secp_ctx).unwrap();
+                               let mut htlc_sig_iter = localtx.per_htlc.iter().zip(htlc_sigs.iter().enumerate());
+
                                $({
                                        let remote_signature = Signature::from_der(&hex::decode($their_htlc_sig_hex).unwrap()[..]).unwrap();
 
@@ -4543,12 +4547,19 @@ mod tests {
                                                assert!(preimage.is_some());
                                        }
 
-                                       chan_keys.sign_htlc_transaction(&mut localtx, $htlc_idx, preimage, chan.their_to_self_delay, &chan.secp_ctx);
+                                       let mut htlc_sig = htlc_sig_iter.next().unwrap();
+                                       while (htlc_sig.1).1.is_none() { htlc_sig = htlc_sig_iter.next().unwrap(); }
+                                       assert_eq!((htlc_sig.0).0.transaction_output_index, Some($htlc_idx));
 
-                                       assert_eq!(serialize(localtx.htlc_with_valid_witness($htlc_idx).as_ref().unwrap())[..],
+                                       assert_eq!(serialize(&localtx.get_signed_htlc_tx((htlc_sig.1).0, &(htlc_sig.1).1.unwrap(), &preimage, chan.their_to_self_delay))[..],
                                                        hex::decode($htlc_tx_hex).unwrap()[..]);
                                })*
-                       }
+                               loop {
+                                       let htlc_sig = htlc_sig_iter.next();
+                                       if htlc_sig.is_none() { break; }
+                                       assert!((htlc_sig.unwrap().1).1.is_none());
+                               }
+                       } }
                }
 
                {