X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Futil%2Fevents.rs;h=9f7f4b4e5e00130a3581c5dd397497b3be0ba8ff;hb=79541b11e8b6e62de0fc613f416e30bf1de5f3d9;hp=22b2f40020371e98f022082a6798b961c724ad0f;hpb=6582aaebae7a79a95f4429567c196c4881e39796;p=rust-lightning diff --git a/lightning/src/util/events.rs b/lightning/src/util/events.rs index 22b2f400..9f7f4b4e 100644 --- a/lightning/src/util/events.rs +++ b/lightning/src/util/events.rs @@ -23,13 +23,15 @@ use util::ser::{BigSize, FixedLengthReader, Writeable, Writer, MaybeReadable, Re use routing::router::RouteHop; use bitcoin::blockdata::script::Script; - +use bitcoin::hashes::Hash; +use bitcoin::hashes::sha256::Hash as Sha256; use bitcoin::secp256k1::key::PublicKey; use io; use prelude::*; use core::time::Duration; use core::ops::Deref; +use bitcoin::Transaction; /// Some information provided on receipt of payment depends on whether the payment received is a /// spontaneous payment or a "conventional" lightning payment that's paying an invoice. @@ -177,6 +179,10 @@ pub enum Event { /// Note that this serves as a payment receipt, if you wish to have such a thing, you must /// store it somehow! payment_preimage: PaymentPreimage, + /// The hash which was given to [`ChannelManager::send_payment`]. + /// + /// [`ChannelManager::send_payment`]: crate::ln::channelmanager::ChannelManager::send_payment + payment_hash: PaymentHash, }, /// Indicates an outbound payment we made failed. Probably some intermediary node dropped /// something. You may wish to retry with a different route. @@ -202,6 +208,11 @@ pub enum Event { all_paths_failed: bool, /// The payment path that failed. path: Vec, + /// The channel responsible for the failed payment path. + /// + /// If this is `Some`, then the corresponding channel should be avoided when the payment is + /// retried. May be `None` for older [`Event`] serializations. + short_channel_id: Option, #[cfg(test)] error_code: Option, #[cfg(test)] @@ -253,6 +264,14 @@ pub enum Event { channel_id: [u8; 32], /// The reason the channel was closed. reason: ClosureReason + }, + /// Used to indicate to the user that they can abandon the funding transaction and recycle the + /// inputs for another purpose. + DiscardFunding { + /// The channel_id of the channel which has been closed. + channel_id: [u8; 32], + /// The full transaction received from the user + transaction: Transaction } } @@ -287,14 +306,15 @@ impl Writeable for Event { (8, payment_preimage, option), }); }, - &Event::PaymentSent { ref payment_preimage } => { + &Event::PaymentSent { ref payment_preimage, ref payment_hash} => { 2u8.write(writer)?; write_tlv_fields!(writer, { (0, payment_preimage, required), + (1, payment_hash, required), }); }, &Event::PaymentPathFailed { ref payment_hash, ref rejected_by_dest, ref network_update, - ref all_paths_failed, ref path, + ref all_paths_failed, ref path, ref short_channel_id, #[cfg(test)] ref error_code, #[cfg(test)] @@ -311,6 +331,7 @@ impl Writeable for Event { (2, rejected_by_dest, required), (3, all_paths_failed, required), (5, path, vec_type), + (7, short_channel_id, option), }); }, &Event::PendingHTLCsForwardable { time_forwardable: _ } => { @@ -338,6 +359,13 @@ impl Writeable for Event { (2, reason, required) }); }, + &Event::DiscardFunding { ref channel_id, ref transaction } => { + 11u8.write(writer)?; + write_tlv_fields!(writer, { + (0, channel_id, required), + (2, transaction, required) + }) + }, // Note that, going forward, all new events must only write data inside of // `write_tlv_fields`. Versions 0.0.101+ will ignore odd-numbered events that write // data via `write_tlv_fields`. @@ -387,11 +415,17 @@ impl MaybeReadable for Event { 2u8 => { let f = || { let mut payment_preimage = PaymentPreimage([0; 32]); + let mut payment_hash = None; read_tlv_fields!(reader, { (0, payment_preimage, required), + (1, payment_hash, option), }); + if payment_hash.is_none() { + payment_hash = Some(PaymentHash(Sha256::hash(&payment_preimage.0[..]).into_inner())); + } Ok(Some(Event::PaymentSent { payment_preimage, + payment_hash: payment_hash.unwrap(), })) }; f() @@ -407,12 +441,14 @@ impl MaybeReadable for Event { let mut network_update = None; let mut all_paths_failed = Some(true); let mut path: Option> = Some(vec![]); + let mut short_channel_id = None; read_tlv_fields!(reader, { (0, payment_hash, required), (1, network_update, ignorable), (2, rejected_by_dest, required), (3, all_paths_failed, option), (5, path, vec_type), + (7, short_channel_id, ignorable), }); Ok(Some(Event::PaymentPathFailed { payment_hash, @@ -420,6 +456,7 @@ impl MaybeReadable for Event { network_update, all_paths_failed: all_paths_failed.unwrap(), path: path.unwrap(), + short_channel_id, #[cfg(test)] error_code, #[cfg(test)] @@ -452,14 +489,29 @@ impl MaybeReadable for Event { f() }, 9u8 => { - let mut channel_id = [0; 32]; - let mut reason = None; - read_tlv_fields!(reader, { - (0, channel_id, required), - (2, reason, ignorable), - }); - if reason.is_none() { return Ok(None); } - Ok(Some(Event::ChannelClosed { channel_id, reason: reason.unwrap() })) + let f = || { + let mut channel_id = [0; 32]; + let mut reason = None; + read_tlv_fields!(reader, { + (0, channel_id, required), + (2, reason, ignorable), + }); + if reason.is_none() { return Ok(None); } + Ok(Some(Event::ChannelClosed { channel_id, reason: reason.unwrap() })) + }; + f() + }, + 11u8 => { + let f = || { + let mut channel_id = [0; 32]; + let mut transaction = Transaction{ version: 2, lock_time: 0, input: Vec::new(), output: Vec::new() }; + read_tlv_fields!(reader, { + (0, channel_id, required), + (2, transaction, required), + }); + Ok(Some(Event::DiscardFunding { channel_id, transaction } )) + }; + f() }, // Versions prior to 0.0.100 did not ignore odd types, instead returning InvalidValue. // Version 0.0.100 failed to properly ignore odd types, possibly resulting in corrupt