X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Fln%2Fchannel.rs;h=f36ce1c506f767e4f1b0821e96bc981813abdd4d;hb=b02176c86bfa991a7c4856e427355d6e034e1eaa;hp=0d4f1c6c57b5ac3c66f832bcecef36f95cc67f0e;hpb=f9ec0a76d4a1bb6a1eee62b8775b2c239b4672e8;p=rust-lightning diff --git a/src/ln/channel.rs b/src/ln/channel.rs index 0d4f1c6c..f36ce1c5 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; @@ -244,6 +245,10 @@ pub struct Channel { local_keys: ChannelKeys, + // Our commitment numbers start at 2^48-1 and count down, whereas the ones used in transaction + // generation start at 0 and count up...this simplifies some parts of implementation at the + // cost of others, but should really just be changed. + cur_local_commitment_transaction_number: u64, cur_remote_commitment_transaction_number: u64, value_to_self_msat: u64, // Excluding all pending_htlcs, excluding fees @@ -315,6 +320,9 @@ const COMMITMENT_TX_BASE_WEIGHT: u64 = 724; const COMMITMENT_TX_WEIGHT_PER_HTLC: u64 = 172; const SPENDING_INPUT_FOR_A_OUTPUT_WEIGHT: u64 = 79; // prevout: 36, nSequence: 4, script len: 1, witness lengths: (3+1)/4, sig: 73/4, if-selector: 1, redeemScript: (6 ops + 2*33 pubkeys + 1*2 delay)/4 const B_OUTPUT_PLUS_SPENDING_INPUT_WEIGHT: u64 = 104; // prevout: 40, nSequence: 4, script len: 1, witness lengths: 3/4, sig: 73/4, pubkey: 33/4, output: 31 (TODO: Wrong? Useless?) +/// Maximmum `funding_satoshis` value, according to the BOLT #2 specification +/// it's 2^24. +pub const MAX_FUNDING_SATOSHIS: u64 = (1 << 24); macro_rules! secp_call { ( $res: expr, $err: expr ) => { @@ -339,7 +347,7 @@ impl Channel { /// Guaranteed to return a value no larger than channel_value_satoshis fn get_our_channel_reserve_satoshis(channel_value_satoshis: u64) -> u64 { - cmp::min(channel_value_satoshis, 10) //TODO + cmp::min(channel_value_satoshis, 1000) //TODO } fn derive_our_dust_limit_satoshis(at_open_background_feerate: u64) -> u64 { @@ -352,9 +360,9 @@ impl Channel { // Constructors: - /// panics if channel_value_satoshis is >= (1 << 24) + /// panics if channel_value_satoshis is >= `MAX_FUNDING_SATOSHIS` pub fn new_outbound(fee_estimator: &FeeEstimator, chan_keys: ChannelKeys, their_node_id: PublicKey, channel_value_satoshis: u64, announce_publicly: bool, user_id: u64) -> Channel { - if channel_value_satoshis >= (1 << 24) { + if channel_value_satoshis >= MAX_FUNDING_SATOSHIS { panic!("funding value > 2^24"); } @@ -440,12 +448,9 @@ impl Channel { /// that we're rejecting the new channel. pub fn new_from_req(fee_estimator: &FeeEstimator, chan_keys: ChannelKeys, their_node_id: PublicKey, msg: &msgs::OpenChannel, user_id: u64, announce_publicly: bool) -> Result { // Check sanity of message fields: - if msg.funding_satoshis >= (1 << 24) { + if msg.funding_satoshis >= MAX_FUNDING_SATOSHIS { return Err(HandleError{err: "funding value > 2^24", msg: Some(msgs::ErrorAction::DisconnectPeer{})}); } - if msg.funding_satoshis > 21000000 * 100000000 { - return Err(HandleError{err: "More funding_satoshis than there are satoshis!", msg: Some(msgs::ErrorAction::DisconnectPeer{})}); - } if msg.channel_reserve_satoshis > msg.funding_satoshis { return Err(HandleError{err: "Bogus channel_reserve_satoshis", msg: Some(msgs::ErrorAction::DisconnectPeer{})}); } @@ -455,9 +460,6 @@ impl Channel { if msg.dust_limit_satoshis > msg.funding_satoshis { return Err(HandleError{err: "Peer never wants payout outputs?", msg: Some(msgs::ErrorAction::DisconnectPeer{})}); } - if msg.max_htlc_value_in_flight_msat > msg.funding_satoshis * 1000 { - return Err(HandleError{err: "Bogus max_htlc_value_in_flight_satoshis", msg: Some(msgs::ErrorAction::DisconnectPeer{})}); - } if msg.htlc_minimum_msat >= (msg.funding_satoshis - msg.channel_reserve_satoshis) * 1000 { return Err(HandleError{err: "Minimum htlc value is full channel value", msg: Some(msgs::ErrorAction::DisconnectPeer{})}); } @@ -482,9 +484,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); @@ -520,7 +522,7 @@ impl Channel { channel_value_satoshis: msg.funding_satoshis, their_dust_limit_satoshis: msg.dust_limit_satoshis, our_dust_limit_satoshis: Channel::derive_our_dust_limit_satoshis(background_feerate), - their_max_htlc_value_in_flight_msat: msg.max_htlc_value_in_flight_msat, + their_max_htlc_value_in_flight_msat: cmp::min(msg.max_htlc_value_in_flight_msat, msg.funding_satoshis * 1000), their_channel_reserve_satoshis: msg.channel_reserve_satoshis, their_htlc_minimum_msat: msg.htlc_minimum_msat, our_htlc_minimum_msat: Channel::derive_our_htlc_minimum_msat(msg.feerate_per_kw as u64), @@ -594,13 +596,13 @@ impl Channel { /// which peer generated this transaction and "to whom" this transaction flows. #[inline] fn build_commitment_transaction(&self, commitment_number: u64, keys: &TxCreationKeys, local: bool, generated_by_local: bool) -> (Transaction, Vec) { - let obscured_commitment_transaction_number = self.get_commitment_transaction_number_obscure_factor() ^ commitment_number; + let obscured_commitment_transaction_number = self.get_commitment_transaction_number_obscure_factor() ^ (0xffffffffffff - commitment_number); 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(), @@ -733,8 +735,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(), @@ -1080,9 +1082,6 @@ impl Channel { if msg.dust_limit_satoshis > 21000000 * 100000000 { return Err(HandleError{err: "Peer never wants payout outputs?", msg: None}); } - if msg.max_htlc_value_in_flight_msat > self.channel_value_satoshis * 1000 { - return Err(HandleError{err: "Bogus max_htlc_value_in_flight_satoshis", msg: None}); - } if msg.channel_reserve_satoshis > self.channel_value_satoshis { return Err(HandleError{err: "Bogus channel_reserve_satoshis", msg: None}); } @@ -1100,7 +1099,7 @@ impl Channel { self.channel_monitor.set_their_htlc_base_key(&msg.htlc_basepoint); self.their_dust_limit_satoshis = msg.dust_limit_satoshis; - self.their_max_htlc_value_in_flight_msat = msg.max_htlc_value_in_flight_msat; + self.their_max_htlc_value_in_flight_msat = cmp::min(msg.max_htlc_value_in_flight_msat, self.channel_value_satoshis * 1000); self.their_channel_reserve_satoshis = msg.channel_reserve_satoshis; self.their_htlc_minimum_msat = msg.htlc_minimum_msat; self.their_to_self_delay = msg.to_self_delay; @@ -1150,7 +1149,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_txo = OutPoint::new(msg.funding_txid, msg.funding_output_index); + self.channel_monitor.set_funding_info(funding_txo); let (remote_initial_commitment_tx, our_signature) = match self.funding_created_signature(&msg.signature) { Ok(res) => res, @@ -1164,8 +1164,7 @@ impl Channel { 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; @@ -1240,11 +1239,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; @@ -1312,7 +1311,7 @@ impl Channel { /// Removes an outbound HTLC which has been commitment_signed by the remote end #[inline] fn mark_outbound_htlc_removed(&mut self, htlc_id: u64, check_preimage: Option<[u8; 32]>, fail_reason: Option) -> Result<[u8; 32], HandleError> { - for mut htlc in self.pending_htlcs.iter_mut() { + for htlc in self.pending_htlcs.iter_mut() { if htlc.outbound && htlc.htlc_id == htlc_id { match check_preimage { None => {}, @@ -1823,7 +1822,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() } @@ -1920,8 +1919,8 @@ 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; @@ -1930,7 +1929,7 @@ impl Channel { self.funding_tx_confirmations = 1; 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))); + ((txo_idx as u64) << (0*8))); } } } @@ -2043,7 +2042,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!"); } @@ -2054,7 +2053,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, @@ -2069,14 +2068,13 @@ impl Channel { // 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.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())) } @@ -2328,8 +2326,10 @@ mod tests { use bitcoin::network::serialize::serialize; use bitcoin::blockdata::transaction::Transaction; use ln::channel::{Channel,ChannelKeys,HTLCOutput,HTLCState,HTLCOutputInCommitment,TxCreationKeys}; + use ln::channel::MAX_FUNDING_SATOSHIS; 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; @@ -2344,6 +2344,12 @@ mod tests { } } + #[test] + fn test_max_funding_satoshis() { + assert!(MAX_FUNDING_SATOSHIS <= 21_000_000 * 100_000_000, + "MAX_FUNDING_SATOSHIS is greater than all satoshis on existence"); + } + #[test] fn outbound_commitment_test() { // Test vectors from BOLT 3 Appendix C: @@ -2369,7 +2375,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()[..], @@ -2398,7 +2405,7 @@ mod tests { macro_rules! test_commitment { ( $their_sig_hex: expr, $our_sig_hex: expr, $tx_hex: expr) => { - unsigned_tx = chan.build_commitment_transaction(42, &keys, true, false); + unsigned_tx = chan.build_commitment_transaction(0xffffffffffff - 42, &keys, true, false); let their_signature = Signature::from_der(&secp_ctx, &hex_bytes($their_sig_hex).unwrap()[..]).unwrap(); let sighash = Message::from_slice(&bip143::SighashComponents::new(&unsigned_tx.0).sighash_all(&unsigned_tx.0.input[0], &chan.get_funding_redeemscript(), chan.channel_value_satoshis)[..]).unwrap(); secp_ctx.verify(&sighash, &their_signature, &chan.their_funding_pubkey).unwrap(); @@ -2864,21 +2871,21 @@ mod tests { let mut seed = [0; 32]; seed[0..32].clone_from_slice(&hex_bytes("0000000000000000000000000000000000000000000000000000000000000000").unwrap()); assert_eq!(chan_utils::build_commitment_secret(seed, 281474976710655), - hex_bytes("02a40c85b6f28da08dfdbe0926c53fab2de6d28c10301f8f7c4073d5e42e3148").unwrap()[..]); + hex_bytes("02a40c85b6f28da08dfdbe0926c53fab2de6d28c10301f8f7c4073d5e42e3148").unwrap()[..]); 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]