mirrors/rust-lightning
1
0
Fork 0
mirror of https://github.com/lightningdevkit/rust-lightning.git synced 2025-02-24 15:02:20 +01:00
Code Issues Projects Releases Packages Wiki Activity

Merge pull request #64 from TheBlueMatt/master

Browse source 
Expose the script_pubkey being monitored in chain watch (fixes #44)
This commit is contained in:
Matt Corallo 2018-07-19 22:44:42 -04:00 • committed by GitHub
commit 89167164da
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
4 changed files with 35 additions and 60 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

36
README.md
View file

@ -20,42 +20,6 @@ non-optional/non-test/non-library dependencies. Really really do not add
dependencies with dependencies. Do convince Andrew to cut down dependency usage
in rust-bitcoin.
Assorted random TODOs:
* Create a general timer interface - this should be passed around in reference
form to most objects to allow them to register functions which are called on
a timer. By default we should provide an implementation of this which uses
some newfangled rusty promise-y library, but should generally ensure a
client can simply integrate this into whatever existing timer interface
they use. (This is partially complete, but the events stuff needs to also
exist in Channel, which has a few inline TODOs to set up timers).
* Figure out how to expose when-to-connect and who-to-connect-to.
* Implement when-to-connect and who-to-connect-to based on route/node rumoring
and channelmanager state (and some concept of available value in wallet).
* Some kind of serialization format for on-disk storage of things like
channels, channelmonitors, routing db, etc.
* BOLT 10/network bootstrapping implementation.
* Some kind of DoS thing including ban tracking and putting that info in
HandleError (and also rename HandleError) to be propagated up...and then
handled.
* All the random TODOs and unimplemented!()s across the codebase.
* Type-ify our somewhat random usage of Uint256/[u8; 32]. Use Sha256dHash
where appropriate, create our own types for everything else.
* Some kind of logging subsystem/API.
* Migrate all our serialize() -> Vec stuff to serialize(byte_writer) so that we
can avoid allocating a huge buffer for everything we serialize/deserialize.
* Migrate the above TODOs to GitHub issues.
Notes on coding style:
* Use tabs. If you want to align lines, use spaces. Any desired alignment
should display fine at any tab-length display setting.

6
src/chain/chaininterface.rs
View file

@ -16,7 +16,7 @@ pub trait ChainWatchInterface: Sync + Send {
/// Provides an outpoint which must be watched for, providing any transactions which spend the
/// given outpoint.
fn install_watch_outpoint(&self, outpoint: (Sha256dHash, u32));
fn install_watch_outpoint(&self, outpoint: (Sha256dHash, u32), out_script: &Script);
/// Indicates that a listener needs to see all transactions.
fn watch_all_txn(&self);
@ -76,7 +76,7 @@ impl ChainWatchInterface for ChainWatchInterfaceUtil {
self.reentered.fetch_add(1, Ordering::Relaxed);
}
fn install_watch_outpoint(&self, outpoint: (Sha256dHash, u32)) {
fn install_watch_outpoint(&self, outpoint: (Sha256dHash, u32), _out_script: &Script) {
let mut watched = self.watched.lock().unwrap();
watched.1.push(outpoint);
self.reentered.fetch_add(1, Ordering::Relaxed);
@ -158,7 +158,7 @@ impl ChainWatchInterfaceUtil {
self.does_match_tx_unguarded (tx, &watched)
}
fn does_match_tx_unguarded (&self, tx: &Transaction, watched: &MutexGuard<(Vec<Script>, Vec<(Sha256dHash, u32)>, bool)>) -> bool {
fn does_match_tx_unguarded(&self, tx: &Transaction, watched: &MutexGuard<(Vec<Script>, Vec<(Sha256dHash, u32)>, bool)>) -> bool {
if watched.2 {
return true;
}

9
src/ln/channel.rs
View file

@ -1150,7 +1150,8 @@ impl Channel {
}
let funding_txo = OutPoint::new(msg.funding_txid, msg.funding_output_index);
self.channel_monitor.set_funding_info(funding_txo);
let funding_txo_script = self.get_funding_redeemscript().to_v0_p2wsh();
self.channel_monitor.set_funding_info((funding_txo, funding_txo_script));
let (remote_initial_commitment_tx, our_signature) = match self.funding_created_signature(&msg.signature) {
Ok(res) => res,
@ -2053,7 +2054,8 @@ impl Channel {
panic!("Should not have advanced channel commitment tx numbers prior to funding_created");
}
self.channel_monitor.set_funding_info(funding_txo);
let funding_txo_script = self.get_funding_redeemscript().to_v0_p2wsh();
self.channel_monitor.set_funding_info((funding_txo, funding_txo_script));
let (our_signature, commitment_tx) = match self.get_outbound_funding_created_signature() {
Ok(res) => res,
@ -2324,6 +2326,7 @@ mod tests {
use bitcoin::util::hash::Sha256dHash;
use bitcoin::util::bip143;
use bitcoin::network::serialize::serialize;
use bitcoin::blockdata::script::Script;
use bitcoin::blockdata::transaction::Transaction;
use ln::channel::{Channel,ChannelKeys,HTLCOutput,HTLCState,HTLCOutputInCommitment,TxCreationKeys};
use ln::channel::MAX_FUNDING_SATOSHIS;
@ -2376,7 +2379,7 @@ mod tests {
chan.our_dust_limit_satoshis = 546;
let funding_info = OutPoint::new(Sha256dHash::from_hex("8984484a580b825b9972d7adb15050b3ab624ccd731946b3eeddb92f4e7ef6be").unwrap(), 0);
chan.channel_monitor.set_funding_info(funding_info);
chan.channel_monitor.set_funding_info((funding_info, Script::new()));
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()[..],

44
src/ln/channelmonitor.rs
View file

@ -92,9 +92,9 @@ impl<Key : Send + cmp::Eq + hash::Hash + 'static> SimpleManyChannelMonitor<Key>
Some(orig_monitor) => return orig_monitor.insert_combine(monitor),
None => {}
};
match monitor.funding_txo {
None => self.chain_monitor.watch_all_txn(),
Some(outpoint) => self.chain_monitor.install_watch_outpoint((outpoint.txid, outpoint.index as u32)),
match &monitor.funding_txo {
&None => self.chain_monitor.watch_all_txn(),
&Some((ref outpoint, ref script)) => self.chain_monitor.install_watch_outpoint((outpoint.txid, outpoint.index as u32), script),
}
monitors.insert(key, monitor);
Ok(())
@ -147,7 +147,7 @@ const SERIALIZATION_VERSION: u8 = 1;
const MIN_SERIALIZATION_VERSION: u8 = 1;
pub struct ChannelMonitor {
funding_txo: Option<OutPoint>,
funding_txo: Option<(OutPoint, Script)>,
commitment_transaction_number_obscure_factor: u64,
key_storage: KeyStorage,
@ -419,13 +419,12 @@ impl ChannelMonitor {
}
pub fn insert_combine(&mut self, mut other: ChannelMonitor) -> Result<(), HandleError> {
match self.funding_txo {
Some(txo) => if other.funding_txo.is_some() && other.funding_txo.unwrap() != txo {
if self.funding_txo.is_some() {
if other.funding_txo.is_some() && other.funding_txo.as_ref().unwrap() != self.funding_txo.as_ref().unwrap() {
return Err(HandleError{err: "Funding transaction outputs are not identical!", msg: None});
},
None => if other.funding_txo.is_some() {
self.funding_txo = other.funding_txo;
}
} else {
self.funding_txo = other.funding_txo.take();
}
let other_min_secret = other.get_min_seen_secret();
let our_min_secret = self.get_min_seen_secret();
@ -458,7 +457,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(super) fn set_funding_info(&mut self, funding_info: OutPoint) {
pub(super) fn set_funding_info(&mut self, funding_info: (OutPoint, Script)) {
//TODO: Need to register the given script here with a chain_monitor
self.funding_txo = Some(funding_info);
}
@ -475,7 +475,10 @@ impl ChannelMonitor {
}
pub fn get_funding_txo(&self) -> Option<OutPoint> {
self.funding_txo
match self.funding_txo {
Some((outpoint, _)) => Some(outpoint),
None => None
}
}
/// Serializes into a vec, with various modes for the exposed pub fns
@ -484,12 +487,14 @@ impl ChannelMonitor {
res.push(SERIALIZATION_VERSION);
res.push(MIN_SERIALIZATION_VERSION);
match self.funding_txo {
Some(outpoint) => {
match &self.funding_txo {
&Some((ref outpoint, ref script)) => {
res.extend_from_slice(&outpoint.txid[..]);
res.extend_from_slice(&byte_utils::be16_to_array(outpoint.index));
res.extend_from_slice(&byte_utils::be64_to_array(script.len() as u64));
res.extend_from_slice(&script[..]);
},
None => {
&None => {
// We haven't even been initialized...not sure why anyone is serializing us, but
// not much to give them.
return res;
@ -664,10 +669,12 @@ impl ChannelMonitor {
// Technically this can fail and serialize fail a round-trip, but only for serialization of
// barely-init'd ChannelMonitors that we can't do anything with.
let funding_txo = Some(OutPoint {
let outpoint = OutPoint {
txid: Sha256dHash::from(read_bytes!(32)),
index: byte_utils::slice_to_be16(read_bytes!(2)),
});
};
let script_len = byte_utils::slice_to_be64(read_bytes!(8));
let funding_txo = Some((outpoint, Script::from(read_bytes!(script_len).to_vec())));
let commitment_transaction_number_obscure_factor = byte_utils::slice_to_be48(read_bytes!(6));
let key_storage = match read_bytes!(1)[0] {
@ -1026,7 +1033,7 @@ impl ChannelMonitor {
if !inputs.is_empty() || !txn_to_broadcast.is_empty() { // ie we're confident this is actually ours
// We're definitely a remote commitment transaction!
// TODO: Register commitment_txid with the ChainWatchInterface!
// TODO: Register all outputs in commitment_tx with the ChainWatchInterface!
self.remote_commitment_txn_on_chain.lock().unwrap().insert(commitment_txid, commitment_number);
}
if inputs.is_empty() { return txn_to_broadcast; } // Nothing to be done...probably a false positive/local tx
@ -1059,6 +1066,7 @@ impl ChannelMonitor {
// already processed the block, resulting in the remote_commitment_txn_on_chain entry
// not being generated by the above conditional. Thus, to be safe, we go ahead and
// insert it here.
// TODO: Register all outputs in commitment_tx with the ChainWatchInterface!
self.remote_commitment_txn_on_chain.lock().unwrap().insert(commitment_txid, commitment_number);
if let Some(revocation_points) = self.their_cur_revocation_points {
@ -1232,7 +1240,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().txid && txin.prev_index == self.funding_txo.unwrap().index as u32) {
if self.funding_txo.is_none() || (txin.prev_hash == self.funding_txo.as_ref().unwrap().0.txid && txin.prev_index == self.funding_txo.as_ref().unwrap().0.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);