Fail HTLC backwards on unrevoked remote commitment tx broadcast

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

diff --git a/src/ln/channel.rs b/src/ln/channel.rs
index 5bc5fdf8be126063437f3ffe65dc7f5076a4b882..ddfb809ccdeaf6f7b542c0c08e2850f7646a80cf 100644 (file)
--- a/src/ln/channel.rs
+++ b/src/ln/channel.rs
@@ -2,12 +2,13 @@ use bitcoin::blockdata::block::BlockHeader;
 use bitcoin::blockdata::script::{Script,Builder};
 use bitcoin::blockdata::transaction::{TxIn, TxOut, Transaction, SigHashType};
 use bitcoin::blockdata::opcodes;
-use bitcoin::util::hash::{BitcoinHash, Sha256dHash, Hash160};
+use bitcoin::util::hash::{BitcoinHash, Sha256dHash};
 use bitcoin::util::bip143;
 use bitcoin::consensus::encode::{self, Encodable, Decodable};
 
 use bitcoin_hashes::{Hash, HashEngine};
 use bitcoin_hashes::sha256::Hash as Sha256;
+use bitcoin_hashes::hash160::Hash as Hash160;
 
 use secp256k1::key::{PublicKey,SecretKey};
 use secp256k1::{Secp256k1,Message,Signature};
@@ -314,6 +315,9 @@ pub(super) struct Channel {
        funding_tx_confirmations: u64,
 
        their_dust_limit_satoshis: u64,
+       #[cfg(test)]
+       pub(super) our_dust_limit_satoshis: u64,
+       #[cfg(not(test))]
        our_dust_limit_satoshis: u64,
        their_max_htlc_value_in_flight_msat: u64,
        //get_our_max_htlc_value_in_flight_msat(): u64,
@@ -345,7 +349,7 @@ pub(super) struct Channel {
        logger: Arc<Logger>,
 }
 
-const OUR_MAX_HTLCS: u16 = 5; //TODO
+const OUR_MAX_HTLCS: u16 = 50; //TODO
 /// Confirmation count threshold at which we close a channel. Ideally we'd keep the channel around
 /// on ice until the funding transaction gets more confirmations, but the LN protocol doesn't
 /// really allow for this, so instead we're stuck closing it out at that point.
@@ -906,7 +910,7 @@ impl Channel {
                if value_to_b >= (dust_limit_satoshis as i64) {
                        txouts.push((TxOut {
                                script_pubkey: Builder::new().push_opcode(opcodes::All::OP_PUSHBYTES_0)
-                                                            .push_slice(&Hash160::from_data(&keys.b_payment_key.serialize())[..])
+                                                            .push_slice(&Hash160::hash(&keys.b_payment_key.serialize())[..])
                                                             .into_script(),
                                value: value_to_b as u64
                        }, None));
@@ -939,7 +943,7 @@ impl Channel {
 
        #[inline]
        fn get_closing_scriptpubkey(&self) -> Script {
-               let our_channel_close_key_hash = Hash160::from_data(&self.shutdown_pubkey.serialize());
+               let our_channel_close_key_hash = Hash160::hash(&self.shutdown_pubkey.serialize());
                Builder::new().push_opcode(opcodes::All::OP_PUSHBYTES_0).push_slice(&our_channel_close_key_hash[..]).into_script()
        }
 
@@ -1310,16 +1314,6 @@ impl Channel {
                }))
        }
 
-       pub fn get_update_fail_htlc_and_commit(&mut self, htlc_id: u64, err_packet: msgs::OnionErrorPacket) -> Result<Option<(msgs::UpdateFailHTLC, msgs::CommitmentSigned, ChannelMonitor)>, ChannelError> {
-               match self.get_update_fail_htlc(htlc_id, err_packet)? {
-                       Some(update_fail_htlc) => {
-                               let (commitment, monitor_update) = self.send_commitment_no_status_check()?;
-                               Ok(Some((update_fail_htlc, commitment, monitor_update)))
-                       },
-                       None => Ok(None)
-               }
-       }
-
        // Message handlers:
 
        pub fn accept_channel(&mut self, msg: &msgs::AcceptChannel, config: &UserConfig) -> Result<(), ChannelError> {
@@ -3124,6 +3118,7 @@ impl Channel {
        /// waiting on the remote peer to send us a revoke_and_ack during which time we cannot add new
        /// HTLCs on the wire or we wouldn't be able to determine what they actually ACK'ed.
        /// You MUST call send_commitment prior to any other calls on this Channel
+       /// If an Err is returned, its a ChannelError::Ignore!
        pub fn send_htlc(&mut self, amount_msat: u64, payment_hash: PaymentHash, cltv_expiry: u32, source: HTLCSource, onion_routing_packet: msgs::OnionPacket) -> Result<Option<msgs::UpdateAddHTLC>, ChannelError> {
                if (self.channel_state & (ChannelState::ChannelFunded as u32 | BOTH_SIDES_SHUTDOWN_MASK)) != (ChannelState::ChannelFunded as u32) {
                        return Err(ChannelError::Ignore("Cannot send HTLC until channel is fully established and we haven't started shutting down"));
@@ -3235,6 +3230,12 @@ impl Channel {
                        }
                        if have_updates { break; }
                }
+               for htlc in self.pending_inbound_htlcs.iter() {
+                       if let InboundHTLCState::LocalRemoved(_) = htlc.state {
+                               have_updates = true;
+                       }
+                       if have_updates { break; }
+               }
                if !have_updates {
                        panic!("Cannot create commitment tx until we have some updates to send");
                }