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 <jeandudey@hotmail.com>
This commit is contained in:
Jean Pierre Dudey 2018-06-27 09:11:58 -04:00
parent d8474c9d3c
commit d0e9137bc5
9 changed files with 94 additions and 60 deletions

View 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
};

View 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);
}

View file

@ -1 +1,2 @@
pub mod chaininterface;
pub mod transaction;

24
src/chain/transaction.rs Normal file
View file

@ -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()
}
}

View 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]

View 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);

View 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);

View 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,
},

View 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)
}