X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Fln%2Fchannel.rs;h=1c17cb1f9c1f18613a7fe1625119a9c4a91a26ba;hb=b65aa86ea077fd9d5e0aa46c3d3a0f09ae9bf451;hp=f16de61a836cf8c3552840af3a2b5c0c272134af;hpb=2d8afeccdb4f5aa6232e6d87c6096e980b836072;p=rust-lightning diff --git a/src/ln/channel.rs b/src/ln/channel.rs index f16de61a..1c17cb1f 100644 --- a/src/ln/channel.rs +++ b/src/ln/channel.rs @@ -21,6 +21,7 @@ use ln::channelmanager::{PendingForwardHTLCInfo, HTLCFailReason}; use ln::chan_utils::{TxCreationKeys,HTLCOutputInCommitment,HTLC_SUCCESS_TX_WEIGHT,HTLC_TIMEOUT_TX_WEIGHT}; use ln::chan_utils; use chain::chaininterface::{FeeEstimator,ConfirmationTarget}; +use chain::transaction::OutPoint; use util::{transaction_utils,rng}; use util::sha2::Sha256; @@ -387,7 +388,7 @@ impl Channel { holding_cell_htlc_updates: Vec::new(), next_local_htlc_id: 0, next_remote_htlc_id: 0, - channel_update_count: 0, + channel_update_count: 1, last_local_commitment_txn: Vec::new(), @@ -482,9 +483,9 @@ impl Channel { let our_channel_monitor_claim_key_hash = Hash160::from_data(&PublicKey::from_secret_key(&secp_ctx, &chan_keys.channel_monitor_claim_key).unwrap().serialize()); let our_channel_monitor_claim_script = Builder::new().push_opcode(opcodes::All::OP_PUSHBYTES_0).push_slice(&our_channel_monitor_claim_key_hash[..]).into_script(); let mut channel_monitor = ChannelMonitor::new(&chan_keys.revocation_base_key, - &PublicKey::from_secret_key(&secp_ctx, &chan_keys.delayed_payment_base_key).unwrap(), - &chan_keys.htlc_base_key, - BREAKDOWN_TIMEOUT, our_channel_monitor_claim_script); + &PublicKey::from_secret_key(&secp_ctx, &chan_keys.delayed_payment_base_key).unwrap(), + &chan_keys.htlc_base_key, + BREAKDOWN_TIMEOUT, our_channel_monitor_claim_script); channel_monitor.set_their_htlc_base_key(&msg.htlc_basepoint); channel_monitor.set_their_to_self_delay(msg.to_self_delay); @@ -505,7 +506,7 @@ impl Channel { holding_cell_htlc_updates: Vec::new(), next_local_htlc_id: 0, next_remote_htlc_id: 0, - channel_update_count: 0, + channel_update_count: 1, last_local_commitment_txn: Vec::new(), @@ -599,8 +600,8 @@ impl Channel { let txins = { let mut ins: Vec = Vec::new(); ins.push(TxIn { - prev_hash: self.channel_monitor.get_funding_txo().unwrap().0, - prev_index: self.channel_monitor.get_funding_txo().unwrap().1 as u32, + prev_hash: self.channel_monitor.get_funding_txo().unwrap().txid, + prev_index: self.channel_monitor.get_funding_txo().unwrap().index as u32, script_sig: Script::new(), sequence: ((0x80 as u32) << 8*3) | ((obscured_commitment_transaction_number >> 3*8) as u32), witness: Vec::new(), @@ -608,7 +609,7 @@ impl Channel { ins }; - let mut txouts: Vec<(TxOut, Option)> = Vec::new(); + let mut txouts: Vec<(TxOut, Option)> = Vec::with_capacity(self.pending_htlcs.len() + 2); let dust_limit_satoshis = if local { self.our_dust_limit_satoshis } else { self.their_dust_limit_satoshis }; let mut remote_htlc_total_msat = 0; @@ -699,8 +700,8 @@ impl Channel { transaction_utils::sort_outputs(&mut txouts); - let mut outputs: Vec = Vec::new(); - let mut htlcs_used: Vec = Vec::new(); + let mut outputs: Vec = Vec::with_capacity(txouts.len()); + let mut htlcs_used: Vec = Vec::with_capacity(txouts.len()); for (idx, out) in txouts.drain(..).enumerate() { outputs.push(out.0); if let Some(out_htlc) = out.1 { @@ -733,8 +734,8 @@ impl Channel { let txins = { let mut ins: Vec = Vec::new(); ins.push(TxIn { - prev_hash: self.channel_monitor.get_funding_txo().unwrap().0, - prev_index: self.channel_monitor.get_funding_txo().unwrap().1 as u32, + prev_hash: self.channel_monitor.get_funding_txo().unwrap().txid, + prev_index: self.channel_monitor.get_funding_txo().unwrap().index as u32, script_sig: Script::new(), sequence: 0xffffffff, witness: Vec::new(), @@ -1150,7 +1151,8 @@ impl Channel { panic!("Should not have advanced channel commitment tx numbers prior to funding_created"); } - self.channel_monitor.set_funding_info(msg.funding_txid, msg.funding_output_index); + let funding_info = OutPoint::new(msg.funding_txid, msg.funding_output_index); + self.channel_monitor.set_funding_info(funding_info); let (remote_initial_commitment_tx, our_signature) = match self.funding_created_signature(&msg.signature) { Ok(res) => res, @@ -1162,10 +1164,10 @@ impl Channel { // Now that we're past error-generating stuff, update our local state: - self.channel_monitor.provide_latest_remote_commitment_tx_info(&remote_initial_commitment_tx, Vec::new()); + self.channel_monitor.provide_latest_remote_commitment_tx_info(&remote_initial_commitment_tx, Vec::new(), self.cur_remote_commitment_transaction_number); self.channel_state = ChannelState::FundingSent as u32; let funding_txo = self.channel_monitor.get_funding_txo().unwrap(); - self.channel_id = funding_txo.0.into_be() ^ Uint256::from_u64(funding_txo.1 as u64).unwrap(); //TODO: or le? + self.channel_id = funding_txo.to_channel_id(); self.cur_remote_commitment_transaction_number -= 1; self.cur_local_commitment_transaction_number -= 1; @@ -1212,6 +1214,7 @@ impl Channel { self.channel_state |= ChannelState::TheirFundingLocked as u32; } else if non_shutdown_state == (ChannelState::FundingSent as u32 | ChannelState::OurFundingLocked as u32) { self.channel_state = ChannelState::ChannelFunded as u32 | (self.channel_state & BOTH_SIDES_SHUTDOWN_MASK); + self.channel_update_count += 1; } else { return Err(HandleError{err: "Peer sent a funding_locked at a strange time", msg: None}); } @@ -1239,11 +1242,11 @@ impl Channel { HTLCState::AwaitingAnnouncedRemoteRevoke => {}, HTLCState::LocalAnnounced => { if for_remote_update_check { continue; } }, HTLCState::Committed => {}, - HTLCState::RemoteRemoved => { if for_remote_update_check { continue; } }, - HTLCState::AwaitingRemoteRevokeToRemove => { if for_remote_update_check { continue; } }, - HTLCState::AwaitingRemovedRemoteRevoke => { if for_remote_update_check { continue; } }, - HTLCState::LocalRemoved => {}, - HTLCState::LocalRemovedAwaitingCommitment => { if for_remote_update_check { continue; } }, + HTLCState::RemoteRemoved => { if for_remote_update_check { continue; } }, + HTLCState::AwaitingRemoteRevokeToRemove => { if for_remote_update_check { continue; } }, + HTLCState::AwaitingRemovedRemoteRevoke => { if for_remote_update_check { continue; } }, + HTLCState::LocalRemoved => {}, + HTLCState::LocalRemovedAwaitingCommitment => { if for_remote_update_check { continue; } }, } if !htlc.outbound { inbound_htlc_count += 1; @@ -1606,6 +1609,7 @@ impl Channel { return Err(HandleError{err: "Non-funding remote tried to update channel fee", msg: None}); } Channel::check_remote_fee(fee_estimator, msg.feerate_per_kw)?; + self.channel_update_count += 1; self.feerate_per_kw = msg.feerate_per_kw as u64; Ok(()) } @@ -1613,6 +1617,7 @@ impl Channel { pub fn shutdown(&mut self, fee_estimator: &FeeEstimator, msg: &msgs::Shutdown) -> Result<(Option, Option, Vec<[u8; 32]>), HandleError> { if self.channel_state < ChannelState::FundingSent as u32 { self.channel_state = ChannelState::ShutdownComplete as u32; + self.channel_update_count += 1; return Ok((None, None, Vec::new())); } for htlc in self.pending_htlcs.iter() { @@ -1660,6 +1665,7 @@ impl Channel { // From here on out, we may not fail! self.channel_state |= ChannelState::RemoteShutdownSent as u32; + self.channel_update_count += 1; // We can't send our shutdown until we've committed all of our pending HTLCs, but the // remote side is unlikely to accept any new HTLCs, so we go ahead and "free" any holding @@ -1690,6 +1696,7 @@ impl Channel { }; self.channel_state |= ChannelState::LocalShutdownSent as u32; + self.channel_update_count += 1; if self.pending_htlcs.is_empty() && self.channel_outbound { // There are no more HTLCs and we're the funder, this means we start the closing_signed // dance with an initial fee proposal! @@ -1737,6 +1744,7 @@ impl Channel { if last_fee == msg.fee_satoshis { self.sign_commitment_transaction(&mut closing_tx, &msg.signature); self.channel_state = ChannelState::ShutdownComplete as u32; + self.channel_update_count += 1; return Ok((None, Some(closing_tx))); } } @@ -1781,6 +1789,7 @@ impl Channel { let our_sig = self.sign_commitment_transaction(&mut closing_tx, &msg.signature); self.channel_state = ChannelState::ShutdownComplete as u32; + self.channel_update_count += 1; Ok((Some(msgs::ClosingSigned { channel_id: self.channel_id, @@ -1816,7 +1825,7 @@ impl Channel { /// Returns the funding_txo we either got from our peer, or were given by /// get_outbound_funding_created. - pub fn get_funding_txo(&self) -> Option<(Sha256dHash, u16)> { + pub fn get_funding_txo(&self) -> Option { self.channel_monitor.get_funding_txo() } @@ -1832,8 +1841,7 @@ impl Channel { self.channel_value_satoshis } - pub fn get_channel_update_count(&mut self) -> u32 { - self.channel_update_count += 1; //TODO: This should be base on updates, not updates *sent* + pub fn get_channel_update_count(&self) -> u32 { self.channel_update_count } @@ -1892,6 +1900,7 @@ impl Channel { self.channel_state |= ChannelState::OurFundingLocked as u32; } else if non_shutdown_state == (ChannelState::FundingSent as u32 | ChannelState::TheirFundingLocked as u32) { self.channel_state = ChannelState::ChannelFunded as u32 | (self.channel_state & BOTH_SIDES_SHUTDOWN_MASK); + self.channel_update_count += 1; //TODO: Something about a state where we "lost confirmation" } else if self.channel_state < ChannelState::ChannelFunded as u32 { panic!("Started confirming a channel in a state pre-FundingSent?"); @@ -1913,16 +1922,17 @@ impl Channel { } if non_shutdown_state & !(ChannelState::TheirFundingLocked as u32) == ChannelState::FundingSent as u32 { for (ref tx, index_in_block) in txn_matched.iter().zip(indexes_of_txn_matched) { - if tx.txid() == self.channel_monitor.get_funding_txo().unwrap().0 { - let txo_idx = self.channel_monitor.get_funding_txo().unwrap().1 as usize; + if tx.txid() == self.channel_monitor.get_funding_txo().unwrap().txid { + let txo_idx = self.channel_monitor.get_funding_txo().unwrap().index as usize; if txo_idx >= tx.output.len() || tx.output[txo_idx].script_pubkey != self.get_funding_redeemscript().to_v0_p2wsh() || tx.output[txo_idx].value != self.channel_value_satoshis { self.channel_state = ChannelState::ShutdownComplete as u32; + self.channel_update_count += 1; } else { self.funding_tx_confirmations = 1; - self.short_channel_id = Some(((height as u64) << (5*8)) | + self.short_channel_id = Some(((height as u64) << (5*8)) | ((*index_in_block as u64) << (2*8)) | - ((self.channel_monitor.get_funding_txo().unwrap().1 as u64) << (2*8))); + ((self.channel_monitor.get_funding_txo().unwrap().index as u64) << (2*8))); } } } @@ -2035,7 +2045,7 @@ impl Channel { /// or if called on an inbound channel. /// Note that channel_id changes during this call! /// Do NOT broadcast the funding transaction until after a successful funding_signed call! - pub fn get_outbound_funding_created(&mut self, funding_txid: Sha256dHash, funding_output_index: u16) -> Result<(msgs::FundingCreated, ChannelMonitor), HandleError> { + pub fn get_outbound_funding_created(&mut self, funding_txo: OutPoint) -> Result<(msgs::FundingCreated, ChannelMonitor), HandleError> { if !self.channel_outbound { panic!("Tried to create outbound funding_created message on an inbound channel!"); } @@ -2046,7 +2056,7 @@ impl Channel { panic!("Should not have advanced channel commitment tx numbers prior to funding_created"); } - self.channel_monitor.set_funding_info(funding_txid, funding_output_index); + self.channel_monitor.set_funding_info(funding_txo); let (our_signature, commitment_tx) = match self.get_outbound_funding_created_signature() { Ok(res) => res, @@ -2059,16 +2069,16 @@ impl Channel { let temporary_channel_id = self.channel_id; // Now that we're past error-generating stuff, update our local state: - self.channel_monitor.provide_latest_remote_commitment_tx_info(&commitment_tx, Vec::new()); + self.channel_monitor.provide_latest_remote_commitment_tx_info(&commitment_tx, Vec::new(), self.cur_remote_commitment_transaction_number); self.channel_state = ChannelState::FundingCreated as u32; let funding_txo = self.channel_monitor.get_funding_txo().unwrap(); - self.channel_id = funding_txo.0.into_be() ^ Uint256::from_u64(funding_txo.1 as u64).unwrap(); //TODO: or le? + self.channel_id = funding_txo.to_channel_id(); self.cur_remote_commitment_transaction_number -= 1; Ok((msgs::FundingCreated { temporary_channel_id: temporary_channel_id, - funding_txid: funding_txid, - funding_output_index: funding_output_index, + funding_txid: funding_txo.txid, + funding_output_index: funding_txo.index, signature: our_signature }, self.channel_monitor.clone())) } @@ -2233,7 +2243,7 @@ impl Channel { } // Update state now that we've passed all the can-fail calls... - self.channel_monitor.provide_latest_remote_commitment_tx_info(&remote_commitment_tx.0, remote_commitment_tx.1); + self.channel_monitor.provide_latest_remote_commitment_tx_info(&remote_commitment_tx.0, remote_commitment_tx.1, self.cur_remote_commitment_transaction_number); self.channel_state |= ChannelState::AwaitingRemoteRevoke as u32; Ok((msgs::CommitmentSigned { @@ -2278,6 +2288,7 @@ impl Channel { } else { self.channel_state |= ChannelState::LocalShutdownSent as u32; } + self.channel_update_count += 1; // We can't send our shutdown until we've committed all of our pending HTLCs, but the // remote side is unlikely to accept any new HTLCs, so we go ahead and "free" any holding @@ -2304,6 +2315,7 @@ impl Channel { pub fn force_shutdown(&mut self) -> Vec { assert!(self.channel_state != ChannelState::ShutdownComplete as u32); self.channel_state = ChannelState::ShutdownComplete as u32; + self.channel_update_count += 1; let mut res = Vec::new(); mem::swap(&mut res, &mut self.last_local_commitment_txn); res @@ -2320,6 +2332,7 @@ mod tests { use ln::channel::{Channel,ChannelKeys,HTLCOutput,HTLCState,HTLCOutputInCommitment,TxCreationKeys}; use ln::chan_utils; use chain::chaininterface::{FeeEstimator,ConfirmationTarget}; + use chain::transaction::OutPoint; use secp256k1::{Secp256k1,Message,Signature}; use secp256k1::key::{SecretKey,PublicKey}; use crypto::sha2::Sha256; @@ -2359,7 +2372,8 @@ mod tests { chan.their_to_self_delay = 144; chan.our_dust_limit_satoshis = 546; - chan.channel_monitor.set_funding_info(Sha256dHash::from_hex("8984484a580b825b9972d7adb15050b3ab624ccd731946b3eeddb92f4e7ef6be").unwrap(), 0); + let funding_info = OutPoint::new(Sha256dHash::from_hex("8984484a580b825b9972d7adb15050b3ab624ccd731946b3eeddb92f4e7ef6be").unwrap(), 0); + chan.channel_monitor.set_funding_info(funding_info); chan.their_payment_basepoint = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex_bytes("4444444444444444444444444444444444444444444444444444444444444444").unwrap()[..]).unwrap()).unwrap(); assert_eq!(chan.their_payment_basepoint.serialize()[..], @@ -2858,17 +2872,17 @@ mod tests { seed[0..32].clone_from_slice(&hex_bytes("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF").unwrap()); assert_eq!(chan_utils::build_commitment_secret(seed, 281474976710655), - hex_bytes("7cc854b54e3e0dcdb010d7a3fee464a9687be6e8db3be6854c475621e007a5dc").unwrap()[..]); + hex_bytes("7cc854b54e3e0dcdb010d7a3fee464a9687be6e8db3be6854c475621e007a5dc").unwrap()[..]); assert_eq!(chan_utils::build_commitment_secret(seed, 0xaaaaaaaaaaa), - hex_bytes("56f4008fb007ca9acf0e15b054d5c9fd12ee06cea347914ddbaed70d1c13a528").unwrap()[..]); + hex_bytes("56f4008fb007ca9acf0e15b054d5c9fd12ee06cea347914ddbaed70d1c13a528").unwrap()[..]); assert_eq!(chan_utils::build_commitment_secret(seed, 0x555555555555), - hex_bytes("9015daaeb06dba4ccc05b91b2f73bd54405f2be9f217fbacd3c5ac2e62327d31").unwrap()[..]); + hex_bytes("9015daaeb06dba4ccc05b91b2f73bd54405f2be9f217fbacd3c5ac2e62327d31").unwrap()[..]); seed[0..32].clone_from_slice(&hex_bytes("0101010101010101010101010101010101010101010101010101010101010101").unwrap()); assert_eq!(chan_utils::build_commitment_secret(seed, 1), - hex_bytes("915c75942a26bb3a433a8ce2cb0427c29ec6c1775cfc78328b57f6ba7bfeaa9c").unwrap()[..]); + hex_bytes("915c75942a26bb3a433a8ce2cb0427c29ec6c1775cfc78328b57f6ba7bfeaa9c").unwrap()[..]); } #[test]