X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Futil%2Fevents.rs;h=2e54e2f3f15b7a6f0162dcd3ac0492a466024b27;hb=eab9b3452657cef788eb54e3f46eda4fb06f9197;hp=d4288164cd972e23230ac86af64d42c6bf254952;hpb=a6e650630d7696a0f4de4776d8543d4cfd1a1ed0;p=rust-lightning diff --git a/lightning/src/util/events.rs b/lightning/src/util/events.rs index d4288164..2e54e2f3 100644 --- a/lightning/src/util/events.rs +++ b/lightning/src/util/events.rs @@ -14,9 +14,11 @@ //! future, as well as generate and broadcast funding transactions handle payment preimages and a //! few other things. +use chain::keysinterface::SpendableOutputDescriptor; use ln::msgs; +use ln::msgs::DecodeError; use ln::{PaymentPreimage, PaymentHash, PaymentSecret}; -use chain::keysinterface::SpendableOutputDescriptor; +use routing::network_graph::NetworkUpdate; use util::ser::{Writeable, Writer, MaybeReadable, Readable, VecReadWrapper, VecWriteWrapper}; use bitcoin::blockdata::script::Script; @@ -67,6 +69,38 @@ pub enum PaymentPurpose { SpontaneousPayment(PaymentPreimage), } +#[derive(Clone, Debug)] +/// Some information provided on the closure source of the channel halting. +pub enum ClosureReason { + /// Closure generated from receiving a peer error message by ChannelManager::handle_error + CounterpartyForceClosed { + /// The error is coming from the peer, there *might* be a human-readable msg + peer_msg: Option, + }, + /// Closure generated from ChannelManager::force_close_channel + HolderForceClosed, + /// Closure generated from receiving a peer's ClosingSigned message. Note the shutdown + /// sequence might have been initially initiated by us. + CooperativeClosure, + /// Closure generated from receiving chain::Watch's CommitmentTxBroadcast event. + CommitmentTxBroadcasted, + /// Closure generated from processing an event, likely a HTLC forward/relay/reception. + ProcessingError { + err: String, + }, + /// Closure generated from ChannelManager::peer_disconnected. + DisconnectedPeer, +} + +impl_writeable_tlv_based_enum_upgradable!(ClosureReason, + (0, CounterpartyForceClosed) => { (1, peer_msg, option) }, + (2, HolderForceClosed) => {}, + (6, CommitmentTxBroadcasted) => {}, + (4, CooperativeClosure) => {}, + (8, ProcessingError) => { (1, err, required) }, + (10, DisconnectedPeer) => {}, +); + /// An Event which you should probably take some action in response to. /// /// Note that while Writeable and Readable are implemented for Event, you probably shouldn't use @@ -111,8 +145,11 @@ pub enum Event { /// payment is to pay an invoice or to send a spontaneous payment. purpose: PaymentPurpose, }, - /// Indicates an outbound payment we made succeeded (ie it made it all the way to its target + /// Indicates an outbound payment we made succeeded (i.e. it made it all the way to its target /// and we got back the payment preimage for it). + /// + /// Note for MPP payments: in rare cases, this event may be preceded by a `PaymentFailed` event. + /// In this situation, you SHOULD treat this payment as having succeeded. PaymentSent { /// The preimage to the hash given to ChannelManager::send_payment. /// Note that this serves as a payment receipt, if you wish to have such a thing, you must @@ -128,6 +165,19 @@ pub enum Event { /// the payment has failed, not just the route in question. If this is not set, you may /// retry the payment via a different route. rejected_by_dest: bool, + /// Any failure information conveyed via the Onion return packet by a node along the failed + /// payment route. + /// + /// Should be applied to the [`NetworkGraph`] so that routing decisions can take into + /// account the update. [`NetGraphMsgHandler`] is capable of doing this. + /// + /// [`NetworkGraph`]: crate::routing::network_graph::NetworkGraph + /// [`NetGraphMsgHandler`]: crate::routing::network_graph::NetGraphMsgHandler + network_update: Option, + /// For both single-path and multi-path payments, this is set if all paths of the payment have + /// failed. This will be set to false if (1) this is an MPP payment and (2) other parts of the + /// larger MPP payment were still in flight when this event was generated. + all_paths_failed: bool, #[cfg(test)] error_code: Option, #[cfg(test)] @@ -172,6 +222,14 @@ pub enum Event { /// transaction. claim_from_onchain_tx: bool, }, + /// Used to indicate that a channel with the given `channel_id` is in the process of closure. + ChannelClosed { + /// The channel_id which has been barren from further off-chain updates but + /// funding output might still be not resolved yet. + channel_id: [u8; 32], + /// A machine-readable error message + err: ClosureReason + } } impl Writeable for Event { @@ -211,7 +269,7 @@ impl Writeable for Event { (0, payment_preimage, required), }); }, - &Event::PaymentFailed { ref payment_hash, ref rejected_by_dest, + &Event::PaymentFailed { ref payment_hash, ref rejected_by_dest, ref network_update, ref all_paths_failed, #[cfg(test)] ref error_code, #[cfg(test)] @@ -224,7 +282,9 @@ impl Writeable for Event { error_data.write(writer)?; write_tlv_fields!(writer, { (0, payment_hash, required), + (1, network_update, option), (2, rejected_by_dest, required), + (3, all_paths_failed, required), }); }, &Event::PendingHTLCsForwardable { time_forwardable: _ } => { @@ -246,6 +306,12 @@ impl Writeable for Event { (2, claim_from_onchain_tx, required), }); }, + &Event::ChannelClosed { ref channel_id, ref err } => { + 8u8.write(writer)?; + channel_id.write(writer)?; + err.write(writer)?; + write_tlv_fields!(writer, {}); + }, } Ok(()) } @@ -307,13 +373,19 @@ impl MaybeReadable for Event { let error_data = Readable::read(reader)?; let mut payment_hash = PaymentHash([0; 32]); let mut rejected_by_dest = false; + let mut network_update = None; + let mut all_paths_failed = Some(true); read_tlv_fields!(reader, { (0, payment_hash, required), + (1, network_update, ignorable), (2, rejected_by_dest, required), + (3, all_paths_failed, option), }); Ok(Some(Event::PaymentFailed { payment_hash, rejected_by_dest, + network_update, + all_paths_failed: all_paths_failed.unwrap(), #[cfg(test)] error_code, #[cfg(test)] @@ -353,6 +425,13 @@ impl MaybeReadable for Event { }; f() }, + 8u8 => { + let channel_id = Readable::read(reader)?; + let err = MaybeReadable::read(reader)?; + read_tlv_fields!(reader, {}); + if err.is_none() { return Ok(None); } + Ok(Some(Event::ChannelClosed { channel_id, err: err.unwrap() })) + }, // Versions prior to 0.0.100 did not ignore odd types, instead returning InvalidValue. x if x % 2 == 1 => Ok(None), _ => Err(msgs::DecodeError::InvalidValue) @@ -485,12 +564,6 @@ pub enum MessageSendEvent { /// The action which should be taken. action: msgs::ErrorAction }, - /// When a payment fails we may receive updates back from the hop where it failed. In such - /// cases this event is generated so that we can inform the network graph of this information. - PaymentFailureNetworkUpdate { - /// The channel/node update which should be sent to NetGraphMsgHandler - update: msgs::HTLCFailChannelUpdate, - }, /// Query a peer for channels with funding transaction UTXOs in a block range. SendChannelRangeQuery { /// The node_id of this message recipient