X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Futil%2Ftest_utils.rs;h=295636e33a222555f8aa273ced12718dac2131e5;hb=801b775a7d17eff165ea5e8a4d11a966e0ef29d0;hp=4f4ddc23f480348f37ac26c883ecd535496f65b5;hpb=87398be29354ea0e844a13c6e6988c8152d31a18;p=rust-lightning

diff --git a/lightning/src/util/test_utils.rs b/lightning/src/util/test_utils.rs
index 4f4ddc23..295636e3 100644
--- a/lightning/src/util/test_utils.rs
+++ b/lightning/src/util/test_utils.rs
@@ -7,8 +7,9 @@
 // You may not use this file except in accordance with one or both of these
 // licenses.
 
+use chain;
 use chain::chaininterface;
-use chain::chaininterface::{ConfirmationTarget, ChainError, ChainWatchInterface};
+use chain::chaininterface::ConfirmationTarget;
 use chain::transaction::OutPoint;
 use chain::keysinterface;
 use ln::channelmonitor;
@@ -22,12 +23,11 @@ use util::logger::{Logger, Level, Record};
 use util::ser::{Readable, Writer, Writeable};
 
 use bitcoin::blockdata::constants::genesis_block;
-use bitcoin::blockdata::transaction::Transaction;
+use bitcoin::blockdata::transaction::{Transaction, TxOut};
 use bitcoin::blockdata::script::{Builder, Script};
-use bitcoin::blockdata::block::BlockHeader;
 use bitcoin::blockdata::opcodes;
 use bitcoin::network::constants::Network;
-use bitcoin::hash_types::{Txid, BlockHash};
+use bitcoin::hash_types::BlockHash;
 
 use bitcoin::secp256k1::{SecretKey, PublicKey, Secp256k1, Signature};
 
@@ -79,10 +79,10 @@ impl<'a> TestChannelMonitor<'a> {
 		}
 	}
 }
-impl<'a> channelmonitor::ManyChannelMonitor for TestChannelMonitor<'a> {
+impl<'a> chain::Watch for TestChannelMonitor<'a> {
 	type Keys = EnforcingChannelKeys;
 
-	fn add_monitor(&self, funding_txo: OutPoint, monitor: channelmonitor::ChannelMonitor<EnforcingChannelKeys>) -> Result<(), channelmonitor::ChannelMonitorUpdateErr> {
+	fn watch_channel(&self, funding_txo: OutPoint, monitor: channelmonitor::ChannelMonitor<EnforcingChannelKeys>) -> Result<(), channelmonitor::ChannelMonitorUpdateErr> {
 		// At every point where we get a monitor update, we should be able to send a useful monitor
 		// to a watchtower and disk...
 		let mut w = TestVecWriter(Vec::new());
@@ -92,7 +92,7 @@ impl<'a> channelmonitor::ManyChannelMonitor for TestChannelMonitor<'a> {
 		assert!(new_monitor == monitor);
 		self.latest_monitor_update_id.lock().unwrap().insert(funding_txo.to_channel_id(), (funding_txo, monitor.get_latest_update_id()));
 		self.added_monitors.lock().unwrap().push((funding_txo, monitor));
-		assert!(self.simple_monitor.add_monitor(funding_txo, new_monitor).is_ok());
+		assert!(self.simple_monitor.watch_channel(funding_txo, new_monitor).is_ok());
 
 		let ret = self.update_ret.lock().unwrap().clone();
 		if let Some(next_ret) = self.next_update_ret.lock().unwrap().take() {
@@ -101,7 +101,7 @@ impl<'a> channelmonitor::ManyChannelMonitor for TestChannelMonitor<'a> {
 		ret
 	}
 
-	fn update_monitor(&self, funding_txo: OutPoint, update: channelmonitor::ChannelMonitorUpdate) -> Result<(), channelmonitor::ChannelMonitorUpdateErr> {
+	fn update_channel(&self, funding_txo: OutPoint, update: channelmonitor::ChannelMonitorUpdate) -> Result<(), channelmonitor::ChannelMonitorUpdateErr> {
 		// Every monitor update should survive roundtrip
 		let mut w = TestVecWriter(Vec::new());
 		update.write(&mut w).unwrap();
@@ -109,7 +109,7 @@ impl<'a> channelmonitor::ManyChannelMonitor for TestChannelMonitor<'a> {
 				&mut ::std::io::Cursor::new(&w.0)).unwrap() == update);
 
 		self.latest_monitor_update_id.lock().unwrap().insert(funding_txo.to_channel_id(), (funding_txo, update.update_id));
-		assert!(self.simple_monitor.update_monitor(funding_txo, update).is_ok());
+		assert!(self.simple_monitor.update_channel(funding_txo, update).is_ok());
 		// At every point where we get a monitor update, we should be able to send a useful monitor
 		// to a watchtower and disk...
 		let monitors = self.simple_monitor.monitors.lock().unwrap();
@@ -128,8 +128,8 @@ impl<'a> channelmonitor::ManyChannelMonitor for TestChannelMonitor<'a> {
 		ret
 	}
 
-	fn get_and_clear_pending_monitor_events(&self) -> Vec<MonitorEvent> {
-		return self.simple_monitor.get_and_clear_pending_monitor_events();
+	fn release_pending_monitor_events(&self) -> Vec<MonitorEvent> {
+		return self.simple_monitor.release_pending_monitor_events();
 	}
 }
 
@@ -393,27 +393,27 @@ impl TestKeysInterface {
 	}
 }
 
-pub struct TestChainWatcher {
-	pub utxo_ret: Mutex<Result<(Script, u64), ChainError>>,
+pub struct TestChainSource {
+	pub genesis_hash: BlockHash,
+	pub utxo_ret: Mutex<Result<TxOut, chain::AccessError>>,
 }
 
-impl TestChainWatcher {
-	pub fn new() -> Self {
-		let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
-		Self { utxo_ret: Mutex::new(Ok((script, u64::max_value()))) }
+impl TestChainSource {
+	pub fn new(network: Network) -> Self {
+		let script_pubkey = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
+		Self {
+			genesis_hash: genesis_block(network).block_hash(),
+			utxo_ret: Mutex::new(Ok(TxOut { value: u64::max_value(), script_pubkey })),
+		}
 	}
 }
 
-impl ChainWatchInterface for TestChainWatcher {
-	fn install_watch_tx(&self, _txid: &Txid, _script_pub_key: &Script) { }
-	fn install_watch_outpoint(&self, _outpoint: (Txid, u32), _out_script: &Script) { }
-	fn watch_all_txn(&self) { }
-	fn filter_block(&self, _header: &BlockHeader, _txdata: &[(usize, &Transaction)]) -> Vec<usize> {
-		Vec::new()
-	}
-	fn reentered(&self) -> usize { 0 }
+impl chain::Access for TestChainSource {
+	fn get_utxo(&self, genesis_hash: &BlockHash, _short_channel_id: u64) -> Result<TxOut, chain::AccessError> {
+		if self.genesis_hash != *genesis_hash {
+			return Err(chain::AccessError::UnknownChain);
+		}
 
-	fn get_chain_utxo(&self, _genesis_hash: BlockHash, _unspent_tx_output_identifier: u64) -> Result<(Script, u64), ChainError> {
 		self.utxo_ret.lock().unwrap().clone()
 	}
 }