Merge pull request #191 from TheBlueMatt/2018-09-chanmon-ser-framework

[rust-lightning] / src / ln / channelmanager.rs

diff --git a/src/ln/channelmanager.rs b/src/ln/channelmanager.rs
index fd156a9ae3166779f05baaed97e9b176bf37a8b3..01faec671c309c5a870ce732bb2bbf2d2316a23d 100644 (file)
--- a/src/ln/channelmanager.rs
+++ b/src/ln/channelmanager.rs
@@ -1,3 +1,11 @@
+//! The top-level channel management and payment tracking stuff lives here.
+//! The ChannelManager is the main chunk of logic implementing the lightning protocol and is
+//! responsible for tracking which channels are open, HTLCs are in flight and reestablishing those
+//! upon reconnect to the relevant peer(s).
+//! It does not manage routing logic (see ln::router for that) nor does it manage constructing
+//! on-chain transactions (it only monitors the chain to watch for any force-closes that might
+//! imply it needs to fail HTLCs/payments/channels it manages).
+
 use bitcoin::blockdata::block::BlockHeader;
 use bitcoin::blockdata::transaction::Transaction;
 use bitcoin::blockdata::constants::genesis_block;
@@ -16,10 +24,10 @@ use ln::channel::{Channel, ChannelKeys};
 use ln::channelmonitor::ManyChannelMonitor;
 use ln::router::{Route,RouteHop};
 use ln::msgs;
-use ln::msgs::{HandleError,ChannelMessageHandler,MsgEncodable};
+use ln::msgs::{HandleError,ChannelMessageHandler};
 use util::{byte_utils, events, internal_traits, rng};
 use util::sha2::Sha256;
-use util::ser::Readable;
+use util::ser::{Readable, Writeable};
 use util::chacha20poly1305rfc::ChaCha20;
 use util::logger::Logger;
 use util::errors::APIError;
@@ -80,23 +88,6 @@ mod channel_held_info {
                Fail(HTLCFailureMsg),
        }
 
-       #[cfg(feature = "fuzztarget")]
-       impl PendingHTLCStatus {
-               pub fn dummy() -> Self {
-                       let secp_ctx = ::secp256k1::Secp256k1::signing_only();
-                       PendingHTLCStatus::Forward(PendingForwardHTLCInfo {
-                               onion_packet: None,
-                               incoming_shared_secret: SharedSecret::new(&secp_ctx,
-                                               &::secp256k1::key::PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &[1; 32]).unwrap()),
-                                               &SecretKey::from_slice(&secp_ctx, &[1; 32]).unwrap()),
-                               payment_hash: [0; 32],
-                               short_channel_id: 0,
-                               amt_to_forward: 0,
-                               outgoing_cltv_value: 0,
-                       })
-               }
-       }
-
        /// Tracks the inbound corresponding to an outbound HTLC
        #[derive(Clone)]
        pub struct HTLCPreviousHopData {
@@ -114,7 +105,7 @@ mod channel_held_info {
                        session_priv: SecretKey,
                },
        }
-       #[cfg(any(test, feature = "fuzztarget"))]
+       #[cfg(test)]
        impl HTLCSource {
                pub fn dummy() -> Self {
                        HTLCSource::OutboundRoute {
@@ -125,7 +116,7 @@ mod channel_held_info {
        }
 
        #[derive(Clone)] // See Channel::revoke_and_ack for why, tl;dr: Rust bug
-       pub enum HTLCFailReason {
+       pub(crate) enum HTLCFailReason {
                ErrorPacket {
                        err: msgs::OnionErrorPacket,
                },
@@ -134,20 +125,8 @@ mod channel_held_info {
                        data: Vec<u8>,
                }
        }
-
-       #[cfg(feature = "fuzztarget")]
-       impl HTLCFailReason {
-               pub fn dummy() -> Self {
-                       HTLCFailReason::Reason {
-                               failure_code: 0, data: Vec::new(),
-                       }
-               }
-       }
 }
-#[cfg(feature = "fuzztarget")]
-pub use self::channel_held_info::*;
-#[cfg(not(feature = "fuzztarget"))]
-pub(crate) use self::channel_held_info::*;
+pub(super) use self::channel_held_info::*;
 
 struct MsgHandleErrInternal {
        err: msgs::HandleError,
@@ -287,6 +266,7 @@ struct OnionKeys {
        mu: [u8; 32],
 }
 
+/// Details of a channel, as returned by ChannelManager::list_channels and ChannelManager::list_usable_channels
 pub struct ChannelDetails {
        /// The channel's ID (prior to funding transaction generation, this is a random 32 bytes,
        /// thereafter this is the txid of the funding transaction xor the funding transaction output).
@@ -296,7 +276,9 @@ pub struct ChannelDetails {
        /// The position of the funding transaction in the chain. None if the funding transaction has
        /// not yet been confirmed and the channel fully opened.
        pub short_channel_id: Option<u64>,
+       /// The node_id of our counterparty
        pub remote_network_id: PublicKey,
+       /// The value, in satoshis, of this channel as appears in the funding output
        pub channel_value_satoshis: u64,
        /// The user_id passed in to create_channel, or 0 if the channel was inbound.
        pub user_id: u64,
@@ -824,7 +806,7 @@ impl ChannelManager {
                        match msgs::OnionHopData::read(&mut Cursor::new(&decoded[..])) {
                                Err(err) => {
                                        let error_code = match err {
-                                               msgs::DecodeError::UnknownRealmByte => 0x4000 | 1,
+                                               msgs::DecodeError::UnknownVersion => 0x4000 | 1, // unknown realm byte
                                                _ => 0x2000 | 2, // Should never happen
                                        };
                                        return_err!("Unable to decode our hop data", error_code, &[0;0]);
@@ -2252,11 +2234,12 @@ mod tests {
        use ln::channelmanager::{ChannelManager,OnionKeys};
        use ln::router::{Route, RouteHop, Router};
        use ln::msgs;
-       use ln::msgs::{MsgEncodable,ChannelMessageHandler,RoutingMessageHandler};
+       use ln::msgs::{ChannelMessageHandler,RoutingMessageHandler};
        use util::test_utils;
        use util::events::{Event, EventsProvider};
-       use util::logger::Logger;
        use util::errors::APIError;
+       use util::logger::Logger;
+       use util::ser::Writeable;
 
        use bitcoin::util::hash::Sha256dHash;
        use bitcoin::blockdata::block::{Block, BlockHeader};