From: Jean Pierre Dudey Date: Wed, 27 Jun 2018 13:11:58 +0000 (-0400) Subject: Add the `OutPoint` type for the `ChannelMonitor`'s funding_txo field. X-Git-Tag: v0.0.12~400^2 X-Git-Url: http://git.bitcoin.ninja/?a=commitdiff_plain;h=d0e9137bc5f8f31cc5e9c63b94f1450bdb18b524;p=rust-lightning Add the `OutPoint` type for the `ChannelMonitor`'s funding_txo field. This structure replaces the (Sha256dHash, u16) tuple that was being used for the funding output. Signed-off-by: Jean Pierre Dudey --- diff --git a/fuzz/fuzz_targets/channel_target.rs b/fuzz/fuzz_targets/channel_target.rs index 3f680be4d..23c63fee7 100644 --- a/fuzz/fuzz_targets/channel_target.rs +++ b/fuzz/fuzz_targets/channel_target.rs @@ -12,6 +12,7 @@ use lightning::ln::channelmanager::{HTLCFailReason, PendingForwardHTLCInfo}; use lightning::ln::msgs; use lightning::ln::msgs::MsgDecodable; use lightning::chain::chaininterface::{FeeEstimator, ConfirmationTarget}; +use lightning::chain::transaction::OutPoint; use lightning::util::reset_rng_state; use secp256k1::key::{PublicKey, SecretKey}; @@ -196,9 +197,9 @@ pub fn do_test(data: &[u8]) { return_err!(chan.accept_channel(&accept_chan)); tx.output.push(TxOut{ value: chan_value, script_pubkey: chan.get_funding_redeemscript().to_v0_p2wsh() }); - let funding_output = (Sha256dHash::from_data(&serialize(&tx).unwrap()[..]), 0); + let funding_output = OutPoint::new(Sha256dHash::from_data(&serialize(&tx).unwrap()[..]), 0); - chan.get_outbound_funding_created(funding_output.0.clone(), funding_output.1).unwrap(); + chan.get_outbound_funding_created(funding_output).unwrap(); let funding_signed = decode_msg!(msgs::FundingSigned, 32+64); return_err!(chan.funding_signed(&funding_signed)); chan @@ -215,11 +216,11 @@ pub fn do_test(data: &[u8]) { chan.get_accept_channel().unwrap(); tx.output.push(TxOut{ value: open_chan.funding_satoshis, script_pubkey: chan.get_funding_redeemscript().to_v0_p2wsh() }); - let funding_output = (Sha256dHash::from_data(&serialize(&tx).unwrap()[..]), 0); + let funding_output = OutPoint::new(Sha256dHash::from_data(&serialize(&tx).unwrap()[..]), 0); let mut funding_created = decode_msg!(msgs::FundingCreated, 32+32+2+64); - funding_created.funding_txid = funding_output.0.clone(); - funding_created.funding_output_index = funding_output.1; + funding_created.funding_txid = funding_output.txid.clone(); + funding_created.funding_output_index = funding_output.index; return_err!(chan.funding_created(&funding_created)); chan }; diff --git a/fuzz/fuzz_targets/full_stack_target.rs b/fuzz/fuzz_targets/full_stack_target.rs index 4ae9be413..79bc8581c 100644 --- a/fuzz/fuzz_targets/full_stack_target.rs +++ b/fuzz/fuzz_targets/full_stack_target.rs @@ -15,6 +15,7 @@ use crypto::sha2::Sha256; use crypto::digest::Digest; use lightning::chain::chaininterface::{BroadcasterInterface,ConfirmationTarget,ChainListener,FeeEstimator,ChainWatchInterfaceUtil}; +use lightning::chain::transaction::OutPoint; use lightning::ln::channelmonitor; use lightning::ln::channelmanager::ChannelManager; use lightning::ln::peer_handler::{MessageHandler,PeerManager,SocketDescriptor}; @@ -93,7 +94,7 @@ impl FeeEstimator for FuzzEstimator { struct TestChannelMonitor {} impl channelmonitor::ManyChannelMonitor for TestChannelMonitor { - fn add_update_monitor(&self, _funding_txo: (Sha256dHash, u16), _monitor: channelmonitor::ChannelMonitor) -> Result<(), channelmonitor::ChannelMonitorUpdateErr> { + fn add_update_monitor(&self, _funding_txo: OutPoint, _monitor: channelmonitor::ChannelMonitor) -> Result<(), channelmonitor::ChannelMonitorUpdateErr> { //TODO! Ok(()) } @@ -280,7 +281,7 @@ pub fn do_test(data: &[u8]) { let mut tx = Transaction { version: 0, lock_time: 0, input: Vec::new(), output: vec![TxOut { value: funding_generation.1, script_pubkey: funding_generation.2, }] }; - let funding_output = (Sha256dHash::from_data(&serialize(&tx).unwrap()[..]), 0); + let funding_output = OutPoint::new(Sha256dHash::from_data(&serialize(&tx).unwrap()[..]), 0); channelmanager.funding_transaction_generated(&funding_generation.0, funding_output.clone()); pending_funding_signatures.insert(funding_output, tx); } diff --git a/src/chain/mod.rs b/src/chain/mod.rs index 4f0ac6138..54b13eaa1 100644 --- a/src/chain/mod.rs +++ b/src/chain/mod.rs @@ -1 +1,2 @@ pub mod chaininterface; +pub mod transaction; diff --git a/src/chain/transaction.rs b/src/chain/transaction.rs new file mode 100644 index 000000000..00728b450 --- /dev/null +++ b/src/chain/transaction.rs @@ -0,0 +1,24 @@ +use bitcoin::util::hash::Sha256dHash; +use bitcoin::util::uint::Uint256; + +/// A reference to a transaction output. +#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)] +pub struct OutPoint { + /// The referenced transaction's txid. + pub txid: Sha256dHash, + /// The index of the referenced output in its transaction's vout. + pub index: u16, +} + +impl OutPoint { + /// Creates a new `OutPoint` from the txid an the index. + pub fn new(txid: Sha256dHash, index: u16) -> OutPoint { + OutPoint { txid, index } + } + + /// Convert an `OutPoint` to a lightning channel id. + pub fn to_channel_id(&self) -> Uint256 { + // TODO: or le? + self.txid.into_be() ^ Uint256::from_u64(self.index as u64).unwrap() + } +} diff --git a/src/ln/channel.rs b/src/ln/channel.rs index 86855c1b8..0b951888e 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; @@ -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); @@ -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(), @@ -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, @@ -1165,7 +1167,7 @@ impl Channel { self.channel_monitor.provide_latest_remote_commitment_tx_info(&remote_initial_commitment_tx, Vec::new()); 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 +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; @@ -1823,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() } @@ -1920,17 +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))); } } } @@ -2043,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!"); } @@ -2054,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, @@ -2070,13 +2072,13 @@ impl Channel { self.channel_monitor.provide_latest_remote_commitment_tx_info(&commitment_tx, Vec::new()); 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())) } @@ -2330,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; @@ -2369,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()[..], @@ -2868,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] diff --git a/src/ln/channelmanager.rs b/src/ln/channelmanager.rs index da93443d6..6aeb7d353 100644 --- a/src/ln/channelmanager.rs +++ b/src/ln/channelmanager.rs @@ -1,4 +1,4 @@ -use bitcoin::blockdata::block::BlockHeader; + use bitcoin::blockdata::block::BlockHeader; use bitcoin::blockdata::transaction::Transaction; use bitcoin::blockdata::constants::genesis_block; use bitcoin::network::constants::Network; @@ -12,6 +12,7 @@ use secp256k1::ecdh::SharedSecret; use secp256k1; use chain::chaininterface::{BroadcasterInterface,ChainListener,ChainWatchInterface,FeeEstimator}; +use chain::transaction::OutPoint; use ln::channel::{Channel, ChannelKeys}; use ln::channelmonitor::ManyChannelMonitor; use ln::router::{Route,RouteHop}; @@ -661,12 +662,12 @@ impl ChannelManager { /// Call this upon creation of a funding transaction for the given channel. /// Panics if a funding transaction has already been provided for this channel. - pub fn funding_transaction_generated(&self, temporary_channel_id: &Uint256, funding_txo: (Sha256dHash, u16)) { + pub fn funding_transaction_generated(&self, temporary_channel_id: &Uint256, funding_txo: OutPoint) { let (chan, msg, chan_monitor) = { let mut channel_state = self.channel_state.lock().unwrap(); match channel_state.by_id.remove(&temporary_channel_id) { Some(mut chan) => { - match chan.get_outbound_funding_created(funding_txo.0, funding_txo.1) { + match chan.get_outbound_funding_created(funding_txo) { Ok(funding_msg) => { (chan, funding_msg.0, funding_msg.1) }, @@ -1029,7 +1030,7 @@ impl ChainListener for ChannelManager { if let Some(funding_txo) = channel.get_funding_txo() { for tx in txn_matched { for inp in tx.input.iter() { - if inp.prev_hash == funding_txo.0 && inp.prev_index == funding_txo.1 as u32 { + if inp.prev_hash == funding_txo.txid && inp.prev_index == funding_txo.index as u32 { if let Some(short_id) = channel.get_short_channel_id() { short_to_ids_to_remove.push(short_id); } @@ -1578,7 +1579,7 @@ impl ChannelMessageHandler for ChannelManager { let mut hmac = Hmac::new(Sha256::new(), &um); hmac.input(&err_packet.encode()[32..]); - let mut calc_tag = [0u8; 32]; + let mut calc_tag = [0u8; 32]; hmac.raw_result(&mut calc_tag); if crypto::util::fixed_time_eq(&calc_tag, &err_packet.hmac) { const UNKNOWN_CHAN: u16 = 0x4000|10; @@ -1801,6 +1802,7 @@ impl ChannelMessageHandler for ChannelManager { #[cfg(test)] mod tests { use chain::chaininterface; + use chain::transaction::OutPoint; use ln::channelmanager::{ChannelManager,OnionKeys}; use ln::router::{Route, RouteHop, Router}; use ln::msgs; @@ -2020,9 +2022,9 @@ mod tests { tx = Transaction { version: chan_id as u32, lock_time: 0, input: Vec::new(), output: vec![TxOut { value: *channel_value_satoshis, script_pubkey: output_script.clone(), }]}; - funding_output = (Sha256dHash::from_data(&serialize(&tx).unwrap()[..]), 0); + funding_output = OutPoint::new(Sha256dHash::from_data(&serialize(&tx).unwrap()[..]), 0); - node_a.node.funding_transaction_generated(&temporary_channel_id, funding_output.clone()); + node_a.node.funding_transaction_generated(&temporary_channel_id, funding_output); let mut added_monitors = node_a.chan_monitor.added_monitors.lock().unwrap(); assert_eq!(added_monitors.len(), 1); assert_eq!(added_monitors[0].0, funding_output); diff --git a/src/ln/channelmonitor.rs b/src/ln/channelmonitor.rs index c36df8e75..bcd2ff972 100644 --- a/src/ln/channelmonitor.rs +++ b/src/ln/channelmonitor.rs @@ -13,6 +13,7 @@ use ln::msgs::HandleError; use ln::chan_utils; use ln::chan_utils::HTLCOutputInCommitment; use chain::chaininterface::{ChainListener, ChainWatchInterface, BroadcasterInterface}; +use chain::transaction::OutPoint; use util::sha2::Sha256; use std::collections::HashMap; @@ -42,8 +43,8 @@ pub enum ChannelMonitorUpdateErr { /// an update occurs and a remote watchtower is left with old state, it may broadcast transactions /// which we have revoked, allowing our counterparty to claim all funds in the channel! pub trait ManyChannelMonitor: Send + Sync { - /// Adds or updates a monitor for the given funding_txid+funding_output_index. - fn add_update_monitor(&self, funding_txo: (Sha256dHash, u16), monitor: ChannelMonitor) -> Result<(), ChannelMonitorUpdateErr>; + /// Adds or updates a monitor for the given `funding_txo`. + fn add_update_monitor(&self, funding_txo: OutPoint, monitor: ChannelMonitor) -> Result<(), ChannelMonitorUpdateErr>; } /// A simple implementation of a ManyChannelMonitor and ChainListener. Can be used to create a @@ -53,7 +54,7 @@ pub trait ManyChannelMonitor: Send + Sync { /// users cannot overwrite a given channel by providing a duplicate key. ie you should probably /// index by a PublicKey which is required to sign any updates. /// If you're using this for local monitoring of your own channels, you probably want to use -/// (Sha256dHash, u16) as the key, which will give you a ManyChannelMonitor implementation. +/// `OutPoint` as the key, which will give you a ManyChannelMonitor implementation. pub struct SimpleManyChannelMonitor { monitors: Mutex>, chain_monitor: Arc, @@ -91,15 +92,15 @@ impl SimpleManyChannelMonitor }; match monitor.funding_txo { None => self.chain_monitor.watch_all_txn(), - Some((funding_txid, funding_output_index)) => self.chain_monitor.install_watch_outpoint((funding_txid, funding_output_index as u32)), + Some(outpoint) => self.chain_monitor.install_watch_outpoint((outpoint.txid, outpoint.index as u32)), } monitors.insert(key, monitor); Ok(()) } } -impl ManyChannelMonitor for SimpleManyChannelMonitor<(Sha256dHash, u16)> { - fn add_update_monitor(&self, funding_txo: (Sha256dHash, u16), monitor: ChannelMonitor) -> Result<(), ChannelMonitorUpdateErr> { +impl ManyChannelMonitor for SimpleManyChannelMonitor { + fn add_update_monitor(&self, funding_txo: OutPoint, monitor: ChannelMonitor) -> Result<(), ChannelMonitorUpdateErr> { match self.add_update_monitor_by_key(funding_txo, monitor) { Ok(_) => Ok(()), Err(_) => Err(ChannelMonitorUpdateErr::PermanentFailure), @@ -140,7 +141,7 @@ struct LocalSignedTx { } pub struct ChannelMonitor { - funding_txo: Option<(Sha256dHash, u16)>, + funding_txo: Option, commitment_transaction_number_obscure_factor: u64, key_storage: KeyStorage, @@ -369,8 +370,8 @@ impl ChannelMonitor { /// optional, without it this monitor cannot be used in an SPV client, but you may wish to /// avoid this (or call unset_funding_info) on a monitor you wish to send to a watchtower as it /// provides slightly better privacy. - pub fn set_funding_info(&mut self, funding_txid: Sha256dHash, funding_output_index: u16) { - self.funding_txo = Some((funding_txid, funding_output_index)); + pub fn set_funding_info(&mut self, funding_info: OutPoint) { + self.funding_txo = Some(funding_info); } pub fn set_their_htlc_base_key(&mut self, their_htlc_base_key: &PublicKey) { @@ -385,7 +386,7 @@ impl ChannelMonitor { self.funding_txo = None; } - pub fn get_funding_txo(&self) -> Option<(Sha256dHash, u16)> { + pub fn get_funding_txo(&self) -> Option { self.funding_txo } @@ -748,7 +749,7 @@ impl ChannelMonitor { fn block_connected(&self, txn_matched: &[&Transaction], height: u32, broadcaster: &BroadcasterInterface) { for tx in txn_matched { for txin in tx.input.iter() { - if self.funding_txo.is_none() || (txin.prev_hash == self.funding_txo.unwrap().0 && txin.prev_index == self.funding_txo.unwrap().1 as u32) { + if self.funding_txo.is_none() || (txin.prev_hash == self.funding_txo.unwrap().txid && txin.prev_index == self.funding_txo.unwrap().index as u32) { let mut txn = self.check_spend_remote_transaction(tx, height); if txn.is_empty() { txn = self.check_spend_local_transaction(tx, height); diff --git a/src/util/events.rs b/src/util/events.rs index 7c7242435..1608d0873 100644 --- a/src/util/events.rs +++ b/src/util/events.rs @@ -1,8 +1,8 @@ use ln::msgs; +use chain::transaction::OutPoint; use bitcoin::blockdata::script::Script; use bitcoin::util::uint::Uint256; -use bitcoin::util::hash::Sha256dHash; use secp256k1::key::PublicKey; @@ -24,7 +24,7 @@ pub enum Event { /// channel. Broadcasting such a transaction prior to this event may lead to our counterparty /// trivially stealing all funds in the funding transaction! FundingBroadcastSafe { - funding_txo: (Sha256dHash, u16), + funding_txo: OutPoint, /// The value passed in to ChannelManager::create_channel user_channel_id: u64, }, diff --git a/src/util/test_utils.rs b/src/util/test_utils.rs index 4502bccec..658758328 100644 --- a/src/util/test_utils.rs +++ b/src/util/test_utils.rs @@ -1,9 +1,9 @@ use chain::chaininterface; use chain::chaininterface::ConfirmationTarget; +use chain::transaction::OutPoint; use ln::channelmonitor; use bitcoin::blockdata::transaction::Transaction; -use bitcoin::util::hash::Sha256dHash; use std::sync::{Arc,Mutex}; @@ -17,8 +17,8 @@ impl chaininterface::FeeEstimator for TestFeeEstimator { } pub struct TestChannelMonitor { - pub added_monitors: Mutex>, - pub simple_monitor: Arc>, + pub added_monitors: Mutex>, + pub simple_monitor: Arc>, } impl TestChannelMonitor { pub fn new(chain_monitor: Arc, broadcaster: Arc) -> Self { @@ -29,7 +29,7 @@ impl TestChannelMonitor { } } impl channelmonitor::ManyChannelMonitor for TestChannelMonitor { - fn add_update_monitor(&self, funding_txo: (Sha256dHash, u16), monitor: channelmonitor::ChannelMonitor) -> Result<(), channelmonitor::ChannelMonitorUpdateErr> { + fn add_update_monitor(&self, funding_txo: OutPoint, monitor: channelmonitor::ChannelMonitor) -> Result<(), channelmonitor::ChannelMonitorUpdateErr> { self.added_monitors.lock().unwrap().push((funding_txo, monitor.clone())); self.simple_monitor.add_update_monitor(funding_txo, monitor) }