// 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;
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};
}
}
}
-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());
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() {
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();
&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();
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();
}
}
}
}
-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()
}
}