BDR: Linearizing secp256k1 deps

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

diff --git a/lightning/src/ln/channelmonitor.rs b/lightning/src/ln/channelmonitor.rs
index 4987f8f3b381e1f414f479d146f0d716ee19da81..6bddd302ffc64163e2fb76944bc60df7b76f7764 100644 (file)
--- a/lightning/src/ln/channelmonitor.rs
+++ b/lightning/src/ln/channelmonitor.rs
@@ -19,14 +19,14 @@ use bitcoin::blockdata::opcodes;
 use bitcoin::consensus::encode;
 use bitcoin::util::hash::BitcoinHash;
 
-use bitcoin_hashes::Hash;
-use bitcoin_hashes::sha256::Hash as Sha256;
-use bitcoin_hashes::hash160::Hash as Hash160;
-use bitcoin_hashes::sha256d::Hash as Sha256dHash;
+use bitcoin::hashes::Hash;
+use bitcoin::hashes::sha256::Hash as Sha256;
+use bitcoin::hashes::hash160::Hash as Hash160;
+use bitcoin::hashes::sha256d::Hash as Sha256dHash;
 
-use secp256k1::{Secp256k1,Signature};
-use secp256k1::key::{SecretKey,PublicKey};
-use secp256k1;
+use bitcoin::secp256k1::{Secp256k1,Signature};
+use bitcoin::secp256k1::key::{SecretKey,PublicKey};
+use bitcoin::secp256k1;
 
 use ln::msgs::DecodeError;
 use ln::chan_utils;
@@ -1066,8 +1066,8 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
 
                let mut onchain_tx_handler = OnchainTxHandler::new(destination_script.clone(), keys.clone(), their_to_self_delay, logger.clone());
 
-               let local_tx_sequence = initial_local_commitment_tx.without_valid_witness().input[0].sequence as u64;
-               let local_tx_locktime = initial_local_commitment_tx.without_valid_witness().lock_time as u64;
+               let local_tx_sequence = initial_local_commitment_tx.unsigned_tx.input[0].sequence as u64;
+               let local_tx_locktime = initial_local_commitment_tx.unsigned_tx.lock_time as u64;
                let local_commitment_tx = LocalSignedTx {
                        txid: initial_local_commitment_tx.txid(),
                        revocation_key: initial_local_commitment_tx.local_keys.revocation_key,
@@ -1249,8 +1249,8 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
                        return Err(MonitorUpdateError("A local commitment tx has already been signed, no new local commitment txn can be sent to our counterparty"));
                }
                let txid = commitment_tx.txid();
-               let sequence = commitment_tx.without_valid_witness().input[0].sequence as u64;
-               let locktime = commitment_tx.without_valid_witness().lock_time as u64;
+               let sequence = commitment_tx.unsigned_tx.input[0].sequence as u64;
+               let locktime = commitment_tx.unsigned_tx.lock_time as u64;
                let mut new_local_commitment_tx = LocalSignedTx {
                        txid,
                        revocation_key: commitment_tx.local_keys.revocation_key,
@@ -1677,8 +1677,18 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
 
                for &(ref htlc, _, _) in local_tx.htlc_outputs.iter() {
                        if let Some(transaction_output_index) = htlc.transaction_output_index {
-                               let preimage = if let Some(preimage) = self.payment_preimages.get(&htlc.payment_hash) { Some(*preimage) } else { None };
-                               claim_requests.push(ClaimRequest { absolute_timelock: ::std::u32::MAX, aggregable: false, outpoint: BitcoinOutPoint { txid: local_tx.txid, vout: transaction_output_index as u32 }, witness_data: InputMaterial::LocalHTLC { preimage, amount: htlc.amount_msat / 1000 }});
+                               claim_requests.push(ClaimRequest { absolute_timelock: ::std::u32::MAX, aggregable: false, outpoint: BitcoinOutPoint { txid: local_tx.txid, vout: transaction_output_index as u32 },
+                                       witness_data: InputMaterial::LocalHTLC {
+                                               preimage: if !htlc.offered {
+                                                               if let Some(preimage) = self.payment_preimages.get(&htlc.payment_hash) {
+                                                                       Some(preimage.clone())
+                                                               } else {
+                                                                       // We can't build an HTLC-Success transaction without the preimage
+                                                                       continue;
+                                                               }
+                                                       } else { None },
+                                               amount: htlc.amount_msat,
+                               }});
                                watch_outputs.push(commitment_tx.output[transaction_output_index as usize].clone());
                        }
                }
@@ -1780,9 +1790,15 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
                        let txid = commitment_tx.txid();
                        let mut res = vec![commitment_tx];
                        for htlc in self.current_local_commitment_tx.htlc_outputs.iter() {
-                               if let Some(htlc_index) = htlc.0.transaction_output_index {
-                                       let preimage = if let Some(preimage) = self.payment_preimages.get(&htlc.0.payment_hash) { Some(*preimage) } else { None };
-                                       if let Some(htlc_tx) = self.onchain_tx_handler.get_fully_signed_htlc_tx(txid, htlc_index, preimage) {
+                               if let Some(vout) = htlc.0.transaction_output_index {
+                                       let preimage = if !htlc.0.offered {
+                                                       if let Some(preimage) = self.payment_preimages.get(&htlc.0.payment_hash) { Some(preimage.clone()) } else {
+                                                               // We can't build an HTLC-Success transaction without the preimage
+                                                               continue;
+                                                       }
+                                               } else { None };
+                                       if let Some(htlc_tx) = self.onchain_tx_handler.get_fully_signed_htlc_tx(
+                                                       &::bitcoin::OutPoint { txid, vout }, &preimage) {
                                                res.push(htlc_tx);
                                        }
                                }
@@ -1804,9 +1820,15 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
                        let txid = commitment_tx.txid();
                        let mut res = vec![commitment_tx];
                        for htlc in self.current_local_commitment_tx.htlc_outputs.iter() {
-                               if let Some(htlc_index) = htlc.0.transaction_output_index {
-                                       let preimage = if let Some(preimage) = self.payment_preimages.get(&htlc.0.payment_hash) { Some(*preimage) } else { None };
-                                       if let Some(htlc_tx) = self.onchain_tx_handler.get_fully_signed_htlc_tx(txid, htlc_index, preimage) {
+                               if let Some(vout) = htlc.0.transaction_output_index {
+                                       let preimage = if !htlc.0.offered {
+                                                       if let Some(preimage) = self.payment_preimages.get(&htlc.0.payment_hash) { Some(preimage.clone()) } else {
+                                                               // We can't build an HTLC-Success transaction without the preimage
+                                                               continue;
+                                                       }
+                                               } else { None };
+                                       if let Some(htlc_tx) = self.onchain_tx_handler.unsafe_get_fully_signed_htlc_tx(
+                                                       &::bitcoin::OutPoint { txid, vout }, &preimage) {
                                                res.push(htlc_tx);
                                        }
                                }
@@ -2496,10 +2518,10 @@ mod tests {
        use bitcoin::blockdata::transaction::{Transaction, TxIn, TxOut, SigHashType};
        use bitcoin::blockdata::transaction::OutPoint as BitcoinOutPoint;
        use bitcoin::util::bip143;
-       use bitcoin_hashes::Hash;
-       use bitcoin_hashes::sha256::Hash as Sha256;
-       use bitcoin_hashes::sha256d::Hash as Sha256dHash;
-       use bitcoin_hashes::hex::FromHex;
+       use bitcoin::hashes::Hash;
+       use bitcoin::hashes::sha256::Hash as Sha256;
+       use bitcoin::hashes::sha256d::Hash as Sha256dHash;
+       use bitcoin::hashes::hex::FromHex;
        use hex;
        use chain::transaction::OutPoint;
        use ln::channelmanager::{PaymentPreimage, PaymentHash};
@@ -2508,8 +2530,8 @@ mod tests {
        use ln::chan_utils;
        use ln::chan_utils::{HTLCOutputInCommitment, LocalCommitmentTransaction};
        use util::test_utils::TestLogger;
-       use secp256k1::key::{SecretKey,PublicKey};
-       use secp256k1::Secp256k1;
+       use bitcoin::secp256k1::key::{SecretKey,PublicKey};
+       use bitcoin::secp256k1::Secp256k1;
        use rand::{thread_rng,Rng};
        use std::sync::Arc;
        use chain::keysinterface::InMemoryChannelKeys;