X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Futil%2Fevents.rs;h=1780483cb8b9e01bcab8d5f0c18e812522d27a7f;hb=69ee4860848d5992b238eca3343141004d9d1572;hp=876dfe6abb551f359a6c67c60fe05c1d104b81ed;hpb=d1e8d9ced595efe1dbcddde480fccc0d3f98184d;p=rust-lightning

diff --git a/lightning/src/util/events.rs b/lightning/src/util/events.rs
index 876dfe6a..1780483c 100644
--- a/lightning/src/util/events.rs
+++ b/lightning/src/util/events.rs
@@ -23,6 +23,7 @@ use bitcoin::blockdata::script::Script;
 
 use bitcoin::secp256k1::key::PublicKey;
 
+use io;
 use prelude::*;
 use core::time::Duration;
 use core::ops::Deref;
@@ -150,10 +151,31 @@ pub enum Event {
 		/// The outputs which you should store as spendable by you.
 		outputs: Vec<SpendableOutputDescriptor>,
 	},
+	/// This event is generated when a payment has been successfully forwarded through us and a
+	/// forwarding fee earned.
+	PaymentForwarded {
+		/// The fee, in milli-satoshis, which was earned as a result of the payment.
+		///
+		/// Note that if we force-closed the channel over which we forwarded an HTLC while the HTLC
+		/// was pending, the amount the next hop claimed will have been rounded down to the nearest
+		/// whole satoshi. Thus, the fee calculated here may be higher than expected as we still
+		/// claimed the full value in millisatoshis from the source. In this case,
+		/// `claim_from_onchain_tx` will be set.
+		///
+		/// If the channel which sent us the payment has been force-closed, we will claim the funds
+		/// via an on-chain transaction. In that case we do not yet know the on-chain transaction
+		/// fees which we will spend and will instead set this to `None`. It is possible duplicate
+		/// `PaymentForwarded` events are generated for the same payment iff `fee_earned_msat` is
+		/// `None`.
+		fee_earned_msat: Option<u64>,
+		/// If this is `true`, the forwarded HTLC was claimed by our counterparty via an on-chain
+		/// transaction.
+		claim_from_onchain_tx: bool,
+	},
 }
 
 impl Writeable for Event {
-	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
+	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
 		match self {
 			&Event::FundingGenerationReady { .. } => {
 				0u8.write(writer)?;
@@ -217,12 +239,19 @@ impl Writeable for Event {
 					(0, VecWriteWrapper(outputs), required),
 				});
 			},
+			&Event::PaymentForwarded { fee_earned_msat, claim_from_onchain_tx } => {
+				7u8.write(writer)?;
+				write_tlv_fields!(writer, {
+					(0, fee_earned_msat, option),
+					(2, claim_from_onchain_tx, required),
+				});
+			},
 		}
 		Ok(())
 	}
 }
 impl MaybeReadable for Event {
-	fn read<R: ::std::io::Read>(reader: &mut R) -> Result<Option<Self>, msgs::DecodeError> {
+	fn read<R: io::Read>(reader: &mut R) -> Result<Option<Self>, msgs::DecodeError> {
 		match Readable::read(reader)? {
 			0u8 => Ok(None),
 			1u8 => {
@@ -312,6 +341,20 @@ impl MaybeReadable for Event {
 				};
 				f()
 			},
+			7u8 => {
+				let f = || {
+					let mut fee_earned_msat = None;
+					let mut claim_from_onchain_tx = false;
+					read_tlv_fields!(reader, {
+						(0, fee_earned_msat, option),
+						(2, claim_from_onchain_tx, required),
+					});
+					Ok(Some(Event::PaymentForwarded { fee_earned_msat, claim_from_onchain_tx }))
+				};
+				f()
+			},
+			// 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)
 		}
 	}