]> git.bitcoin.ninja Git - rust-lightning/commitdiff
Add the `OutPoint` type for the `ChannelMonitor`'s funding_txo field.
authorJean Pierre Dudey <jeandudey@hotmail.com>
Wed, 27 Jun 2018 13:11:58 +0000 (09:11 -0400)
committerJean Pierre Dudey <jeandudey@hotmail.com>
Fri, 29 Jun 2018 16:12:17 +0000 (12:12 -0400)
This structure replaces the (Sha256dHash, u16) tuple that was being used
for the funding output.

Signed-off-by: Jean Pierre Dudey <jeandudey@hotmail.com>
fuzz/fuzz_targets/channel_target.rs
fuzz/fuzz_targets/full_stack_target.rs
src/chain/mod.rs
src/chain/transaction.rs [new file with mode: 0644]
src/ln/channel.rs
src/ln/channelmanager.rs
src/ln/channelmonitor.rs
src/util/events.rs
src/util/test_utils.rs

index 3f680be4d4ec7541113245c15f5e0d62f9949d53..23c63fee72bd0bb610e3d10acac798969a956889 100644 (file)
@@ -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
        };
index 4ae9be413b81ad83c19d7893fb58254309e5a17a..79bc8581c390a4c4cd9c27d703283fa6d00834f2 100644 (file)
@@ -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);
                                }
index 4f0ac61389b2368b6d837ab2a05afe3e3a0973f2..54b13eaa1a7af1a9c9f8382ca44083e4752b8a80 100644 (file)
@@ -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 (file)
index 0000000..00728b4
--- /dev/null
@@ -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()
+    }
+}
index 86855c1b82f40c5b92b9fe89ccee381db056a674..0b951888e6a796a811ff167f95ba2084256d76c3 100644 (file)
@@ -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<TxIn> = 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<TxIn> = 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<OutPoint> {
                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]
index da93443d6d7ed03378e47c22374fe43ef5ac174d..6aeb7d353222058b11e0a9abc2d43cd2ff6e47ed 100644 (file)
@@ -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);
index c36df8e754044f1295dc284fdfdc32b40cbf7d8a..bcd2ff9723c71415119baa3e8735e8e766a51ac8 100644 (file)
@@ -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<Key> {
        monitors: Mutex<HashMap<Key, ChannelMonitor>>,
        chain_monitor: Arc<ChainWatchInterface>,
@@ -91,15 +92,15 @@ impl<Key : Send + cmp::Eq + hash::Hash + 'static> SimpleManyChannelMonitor<Key>
                };
                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<OutPoint> {
+       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<OutPoint>,
        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<OutPoint> {
                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);
index 7c724243570b25bd5feb1402eb3171eedcfbdbd6..1608d087370bd5fce0a6420a16ba5400a88d95cd 100644 (file)
@@ -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,
        },
index 4502bccec1bd9dc28bff06cf46b838f2c9bf91ff..658758328626cbf18f4b5c4e6c902e1559a6ed25 100644 (file)
@@ -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<Vec<((Sha256dHash, u16), channelmonitor::ChannelMonitor)>>,
-       pub simple_monitor: Arc<channelmonitor::SimpleManyChannelMonitor<(Sha256dHash, u16)>>,
+       pub added_monitors: Mutex<Vec<(OutPoint, channelmonitor::ChannelMonitor)>>,
+       pub simple_monitor: Arc<channelmonitor::SimpleManyChannelMonitor<OutPoint>>,
 }
 impl TestChannelMonitor {
        pub fn new(chain_monitor: Arc<chaininterface::ChainWatchInterface>, broadcaster: Arc<chaininterface::BroadcasterInterface>) -> 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)
        }