X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fchain%2Fchaininterface.rs;h=295c337e29d905ff8e6e5b28ffb4043b76429148;hb=21d0a955efd016d83ed14dd644f6cbe696e56ad7;hp=814193af0033a21987757b2d1258bd30b988feda;hpb=27079e04d7b542058e48cafaf5c2e7114b3b8e15;p=rust-lightning diff --git a/lightning/src/chain/chaininterface.rs b/lightning/src/chain/chaininterface.rs index 814193af..295c337e 100644 --- a/lightning/src/chain/chaininterface.rs +++ b/lightning/src/chain/chaininterface.rs @@ -1,3 +1,12 @@ +// This file is Copyright its original authors, visible in version control +// history. +// +// This file is licensed under the Apache License, Version 2.0 or the MIT license +// , at your option. +// You may not use this file except in accordance with one or both of these +// licenses. + //! Traits and utility impls which allow other parts of rust-lightning to interact with the //! blockchain. //! @@ -8,12 +17,9 @@ use bitcoin::blockdata::block::{Block, BlockHeader}; use bitcoin::blockdata::transaction::Transaction; use bitcoin::blockdata::script::Script; use bitcoin::blockdata::constants::genesis_block; -use bitcoin::util::hash::BitcoinHash; use bitcoin::network::constants::Network; use bitcoin::hash_types::{Txid, BlockHash}; -use util::logger::Logger; - use std::sync::{Mutex, MutexGuard, Arc}; use std::sync::atomic::{AtomicUsize, Ordering}; use std::collections::HashSet; @@ -55,9 +61,9 @@ pub trait ChainWatchInterface: Sync + Send { /// final two the output within the transaction. fn get_chain_utxo(&self, genesis_hash: BlockHash, unspent_tx_output_identifier: u64) -> Result<(Script, u64), ChainError>; - /// Gets the list of transactions and transaction indices that the ChainWatchInterface is + /// Gets the list of transaction indices within a given block that the ChainWatchInterface is /// watching for. - fn filter_block<'a>(&self, block: &'a Block) -> (Vec<&'a Transaction>, Vec); + fn filter_block(&self, block: &Block) -> Vec; /// Returns a usize that changes when the ChainWatchInterface's watched data is modified. /// Users of `filter_block` should pre-save a copy of `reentered`'s return value and use it to @@ -88,7 +94,7 @@ pub trait ChainListener: Sync + Send { /// /// This also means those counting confirmations using block_connected callbacks should watch /// for duplicate headers and not count them towards confirmations! - fn block_connected(&self, header: &BlockHeader, height: u32, txn_matched: &[&Transaction], indexes_of_txn_matched: &[u32]); + fn block_connected(&self, header: &BlockHeader, height: u32, txn_matched: &[&Transaction], indexes_of_txn_matched: &[usize]); /// Notifies a listener that a block was disconnected. /// Unlike block_connected, this *must* never be called twice for the same disconnect event. /// Height must be the one of the block which was disconnected (not new height of the best chain) @@ -121,7 +127,7 @@ pub trait FeeEstimator: Sync + Send { /// This translates to: /// * satoshis-per-byte * 250 /// * ceil(satoshis-per-kbyte / 4) - fn get_est_sat_per_1000_weight(&self, confirmation_target: ConfirmationTarget) -> u64; + fn get_est_sat_per_1000_weight(&self, confirmation_target: ConfirmationTarget) -> u32; } /// Minimum relay fee as required by bitcoin network mempool policy. @@ -220,7 +226,9 @@ impl ChainWatchedUtil { /// parameters with static lifetimes). Other times you can afford a reference, which is more /// efficient, in which case BlockNotifierRef is a more appropriate type. Defining these type /// aliases prevents issues such as overly long function definitions. -pub type BlockNotifierArc = Arc>>; +/// +/// (C-not exported) as we let clients handle any reference counting they need to do +pub type BlockNotifierArc = Arc, C>>; /// BlockNotifierRef is useful when you want a BlockNotifier that points to ChainListeners /// with nonstatic lifetimes. This is useful for when static lifetimes are not needed. Nonstatic @@ -229,7 +237,7 @@ pub type BlockNotifierArc = Arc>>; /// requires parameters with static lifetimes), in which case BlockNotifierArc is a more /// appropriate type. Defining these type aliases for common usages prevents issues such as /// overly long function definitions. -pub type BlockNotifierRef<'a> = BlockNotifier<'a, &'a ChainListener>; +pub type BlockNotifierRef<'a, C> = BlockNotifier<'a, &'a ChainListener, C>; /// Utility for notifying listeners about new blocks, and handling block rescans if new watch /// data is registered. @@ -238,15 +246,17 @@ pub type BlockNotifierRef<'a> = BlockNotifier<'a, &'a ChainListener>; /// or a BlockNotifierRef for conciseness. See their documentation for more details, but essentially /// you should default to using a BlockNotifierRef, and use a BlockNotifierArc instead when you /// require ChainListeners with static lifetimes, such as when you're using lightning-net-tokio. -pub struct BlockNotifier<'a, CL: Deref + 'a> { +pub struct BlockNotifier<'a, CL: Deref + 'a, C: Deref> + where CL::Target: ChainListener + 'a, C::Target: ChainWatchInterface { listeners: Mutex>, - chain_monitor: Arc, + chain_monitor: C, phantom: PhantomData<&'a ()>, } -impl<'a, CL: Deref + 'a> BlockNotifier<'a, CL> { +impl<'a, CL: Deref + 'a, C: Deref> BlockNotifier<'a, CL, C> + where CL::Target: ChainListener + 'a, C::Target: ChainWatchInterface { /// Constructs a new BlockNotifier without any listeners. - pub fn new(chain_monitor: Arc) -> BlockNotifier<'a, CL> { + pub fn new(chain_monitor: C) -> BlockNotifier<'a, CL, C> { BlockNotifier { listeners: Mutex::new(Vec::new()), chain_monitor, @@ -265,6 +275,8 @@ impl<'a, CL: Deref + 'a> BlockNotifier<'a, CL> { /// If the same listener is registered multiple times, unregistering /// will remove ALL occurrences of that listener. Comparison is done using /// the pointer returned by the Deref trait implementation. + /// + /// (C-not exported) because the equality check would always fail pub fn unregister_listener(&self, listener: CL) { let mut vec = self.listeners.lock().unwrap(); // item is a ref to an abstract thing that dereferences to a ChainListener, @@ -276,11 +288,15 @@ impl<'a, CL: Deref + 'a> BlockNotifier<'a, CL> { /// /// Handles re-scanning the block and calling block_connected again if listeners register new /// watch data during the callbacks for you (see ChainListener::block_connected for more info). - pub fn block_connected<'b>(&self, block: &'b Block, height: u32) { + pub fn block_connected(&self, block: &Block, height: u32) { let mut reentered = true; while reentered { - let (matched, matched_index) = self.chain_monitor.filter_block(block); - reentered = self.block_connected_checked(&block.header, height, matched.as_slice(), matched_index.as_slice()); + let matched_indexes = self.chain_monitor.filter_block(block); + let mut matched_txn = Vec::new(); + for index in matched_indexes.iter() { + matched_txn.push(&block.txdata[*index]); + } + reentered = self.block_connected_checked(&block.header, height, matched_txn.as_slice(), matched_indexes.as_slice()); } } @@ -290,7 +306,7 @@ impl<'a, CL: Deref + 'a> BlockNotifier<'a, CL> { /// Returns true if notified listeners registered additional watch data (implying that the /// block must be re-scanned and this function called again prior to further block_connected /// calls, see ChainListener::block_connected for more info). - pub fn block_connected_checked(&self, header: &BlockHeader, height: u32, txn_matched: &[&Transaction], indexes_of_txn_matched: &[u32]) -> bool { + pub fn block_connected_checked(&self, header: &BlockHeader, height: u32, txn_matched: &[&Transaction], indexes_of_txn_matched: &[usize]) -> bool { let last_seen = self.chain_monitor.reentered(); let listeners = self.listeners.lock().unwrap(); @@ -316,7 +332,6 @@ pub struct ChainWatchInterfaceUtil { network: Network, watched: Mutex, reentered: AtomicUsize, - logger: Arc, } // We only expose PartialEq in test since its somewhat unclear exactly what it should do and we're @@ -354,25 +369,23 @@ impl ChainWatchInterface for ChainWatchInterfaceUtil { } fn get_chain_utxo(&self, genesis_hash: BlockHash, _unspent_tx_output_identifier: u64) -> Result<(Script, u64), ChainError> { - if genesis_hash != genesis_block(self.network).header.bitcoin_hash() { + if genesis_hash != genesis_block(self.network).header.block_hash() { return Err(ChainError::NotWatched); } Err(ChainError::NotSupported) } - fn filter_block<'a>(&self, block: &'a Block) -> (Vec<&'a Transaction>, Vec) { - let mut matched = Vec::new(); + fn filter_block(&self, block: &Block) -> Vec { let mut matched_index = Vec::new(); { let watched = self.watched.lock().unwrap(); for (index, transaction) in block.txdata.iter().enumerate() { if self.does_match_tx_unguarded(transaction, &watched) { - matched.push(transaction); - matched_index.push(index as u32); + matched_index.push(index); } } } - (matched, matched_index) + matched_index } fn reentered(&self) -> usize { @@ -382,12 +395,11 @@ impl ChainWatchInterface for ChainWatchInterfaceUtil { impl ChainWatchInterfaceUtil { /// Creates a new ChainWatchInterfaceUtil for the given network - pub fn new(network: Network, logger: Arc) -> ChainWatchInterfaceUtil { + pub fn new(network: Network) -> ChainWatchInterfaceUtil { ChainWatchInterfaceUtil { - network: network, + network, watched: Mutex::new(ChainWatchedUtil::new()), reentered: AtomicUsize::new(1), - logger: logger, } } @@ -412,7 +424,7 @@ mod tests { fn register_listener_test() { let chanmon_cfgs = create_chanmon_cfgs(1); let node_cfgs = create_node_cfgs(1, &chanmon_cfgs); - let block_notifier = BlockNotifier::new(node_cfgs[0].chain_monitor.clone()); + let block_notifier = BlockNotifier::new(node_cfgs[0].chain_monitor); assert_eq!(block_notifier.listeners.lock().unwrap().len(), 0); let listener = &node_cfgs[0].chan_monitor.simple_monitor as &ChainListener; block_notifier.register_listener(listener); @@ -426,7 +438,7 @@ mod tests { fn unregister_single_listener_test() { let chanmon_cfgs = create_chanmon_cfgs(2); let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); - let block_notifier = BlockNotifier::new(node_cfgs[0].chain_monitor.clone()); + let block_notifier = BlockNotifier::new(node_cfgs[0].chain_monitor); let listener1 = &node_cfgs[0].chan_monitor.simple_monitor as &ChainListener; let listener2 = &node_cfgs[1].chan_monitor.simple_monitor as &ChainListener; block_notifier.register_listener(listener1); @@ -445,7 +457,7 @@ mod tests { fn unregister_single_listener_ref_test() { let chanmon_cfgs = create_chanmon_cfgs(2); let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); - let block_notifier = BlockNotifier::new(node_cfgs[0].chain_monitor.clone()); + let block_notifier = BlockNotifier::new(node_cfgs[0].chain_monitor); block_notifier.register_listener(&node_cfgs[0].chan_monitor.simple_monitor as &ChainListener); block_notifier.register_listener(&node_cfgs[1].chan_monitor.simple_monitor as &ChainListener); let vec = block_notifier.listeners.lock().unwrap(); @@ -462,7 +474,7 @@ mod tests { fn unregister_multiple_of_the_same_listeners_test() { let chanmon_cfgs = create_chanmon_cfgs(2); let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); - let block_notifier = BlockNotifier::new(node_cfgs[0].chain_monitor.clone()); + let block_notifier = BlockNotifier::new(node_cfgs[0].chain_monitor); let listener1 = &node_cfgs[0].chan_monitor.simple_monitor as &ChainListener; let listener2 = &node_cfgs[1].chan_monitor.simple_monitor as &ChainListener; block_notifier.register_listener(listener1);