Add ChannelClosed generation at cooperative/force-close/error processing

[rust-lightning] / lightning / src / util / events.rs

diff --git a/lightning/src/util/events.rs b/lightning/src/util/events.rs
index df4d9037307c30cb20e32c9b36a07ff6c10cd4b5..abd8f6b105fcdda900518efbd3c59ea2c52c14cf 100644 (file)
--- a/lightning/src/util/events.rs
+++ b/lightning/src/util/events.rs
@@ -16,6 +16,7 @@
 
 use chain::keysinterface::SpendableOutputDescriptor;
 use ln::msgs;
+use ln::msgs::DecodeError;
 use ln::{PaymentPreimage, PaymentHash, PaymentSecret};
 use routing::network_graph::NetworkUpdate;
 use util::ser::{Writeable, Writer, MaybeReadable, Readable, VecReadWrapper, VecWriteWrapper};
@@ -68,6 +69,47 @@ pub enum PaymentPurpose {
        SpontaneousPayment(PaymentPreimage),
 }
 
+#[derive(Clone, Debug)]
+pub enum ClosureDescriptor {
+       ForceClosed,
+       UserInitiated,
+       CounterpartyInitiated,
+       CooperativeClosure,
+       UnknownOnchainCommitment,
+       ProcessingError,
+       DisconnectedPeer,
+}
+
+impl Writeable for ClosureDescriptor {
+       fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
+               match self {
+                       ClosureDescriptor::ForceClosed => 0u8.write(writer)?,
+                       ClosureDescriptor::UserInitiated => 1u8.write(writer)?,
+                       ClosureDescriptor::CounterpartyInitiated => 2u8.write(writer)?,
+                       ClosureDescriptor::CooperativeClosure => 3u8.write(writer)?,
+                       ClosureDescriptor::UnknownOnchainCommitment => 4u8.write(writer)?,
+                       ClosureDescriptor::ProcessingError => 5u8.write(writer)?,
+                       ClosureDescriptor::DisconnectedPeer => 6u8.write(writer)?,
+               }
+               Ok(())
+       }
+}
+
+impl Readable for ClosureDescriptor {
+       fn read<R: ::std::io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
+               Ok(match <u8 as Readable>::read(reader)? {
+                       0 => ClosureDescriptor::ForceClosed,
+                       1 => ClosureDescriptor::UserInitiated,
+                       2 => ClosureDescriptor::CounterpartyInitiated,
+                       3 => ClosureDescriptor::CooperativeClosure,
+                       4 => ClosureDescriptor::UnknownOnchainCommitment,
+                       5 => ClosureDescriptor::ProcessingError,
+                       6 => ClosureDescriptor::DisconnectedPeer,
+                       _ => return Err(DecodeError::InvalidValue),
+               })
+       }
+}
+
 /// 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
@@ -189,6 +231,14 @@ pub enum Event {
                /// transaction.
                claim_from_onchain_tx: bool,
        },
+       /// Used to indicate that a channel was closed at the given timestamp.
+       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: ClosureDescriptor
+       }
 }
 
 impl Writeable for Event {
@@ -265,6 +315,12 @@ impl Writeable for Event {
                                        (2, claim_from_onchain_tx, required),
                                });
                        },
+                       &Event::ChannelClosed { ref channel_id, ref err } => {
+                               6u8.write(writer)?;
+                               channel_id.write(writer)?;
+                               err.write(writer)?;
+                               write_tlv_fields!(writer, {});
+                       },
                }
                Ok(())
        }
@@ -380,6 +436,15 @@ impl MaybeReadable for Event {
                        },
                        // Versions prior to 0.0.100 did not ignore odd types, instead returning InvalidValue.
                        x if x % 2 == 1 => Ok(None),
+                       6u8 => {
+                               let f = || {
+                                       let channel_id = Readable::read(reader)?;
+                                       let err = Readable::read(reader)?;
+                                       read_tlv_fields!(reader, {});
+                                       Ok(Some(Event::ChannelClosed { channel_id, err}))
+                               };
+                               f()
+                       },
                        _ => Err(msgs::DecodeError::InvalidValue)
                }
        }