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};
SpontaneousPayment(PaymentPreimage),
}
+#[derive(Clone, Debug)]
+pub enum ClosureDescriptor {
+ /// Closure generated from ChannelManager::force_close_channel or receiving a peer error
+ /// message by ChannelManager::handle_error
+ ForceClosed {
+ /// If the error is coming from the peer, there should be a human-readable msg
+ peer_msg: Option<String>,
+ },
+ /// 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 for ClosureDescriptor {
+ fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
+ match self {
+ ClosureDescriptor::ForceClosed { peer_msg } => {
+ 0u8.write(writer)?;
+ if let Some(peer_msg) = peer_msg {
+ 0u8.write(writer)?;
+ let bytes = peer_msg.clone().into_bytes();
+ (bytes.len() as u64).write(writer)?;
+ for b in bytes.iter() {
+ b.write(writer)?;
+ }
+ } else {
+ 1u8.write(writer)?;
+ }
+ }
+ ClosureDescriptor::CooperativeClosure => 1u8.write(writer)?,
+ ClosureDescriptor::CommitmentTxBroadcasted => 2u8.write(writer)?,
+ ClosureDescriptor::ProcessingError { err } => {
+ 3u8.write(writer)?;
+ let bytes = err.clone().into_bytes();
+ (bytes.len() as u64).write(writer)?;
+ for b in bytes.iter() {
+ b.write(writer)?;
+ }
+ },
+ ClosureDescriptor::DisconnectedPeer => 4u8.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 => {
+ let peer_msg = match <u8 as Readable>::read(reader)? {
+ 0 => {
+ let bytes_len: u64 = Readable::read(reader)?;
+ let mut bytes: Vec<u8> = Vec::with_capacity(bytes_len as usize);
+ for _ in 0..bytes_len {
+ bytes.push(Readable::read(reader)?);
+ }
+ let err = String::from_utf8(bytes).unwrap();
+ Some(err)
+ },
+ 1 => None,
+ _ => return Err(DecodeError::InvalidValue),
+ };
+ ClosureDescriptor::ForceClosed { peer_msg }
+ },
+ 1 => ClosureDescriptor::CooperativeClosure,
+ 2 => ClosureDescriptor::CommitmentTxBroadcasted,
+ 3 => {
+ let bytes_len: u64 = Readable::read(reader)?;
+ let mut bytes: Vec<u8> = Vec::with_capacity(bytes_len as usize);
+ for _ in 0..bytes_len {
+ bytes.push(Readable::read(reader)?);
+ }
+ let err = String::from_utf8(bytes).unwrap();
+ ClosureDescriptor::ProcessingError { err }
+ },
+ 4 => 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
/// transaction.
claim_from_onchain_tx: bool,
},
+ /// Used to indicate that a channel with the given `channel_id` is in the process of closure.
+ /// Note that if you try to force-close multiple times a channel through
+ /// [`ChannelManager::force_close_channel`] before receiving the corresponding monitor
+ /// event for the broadcast of the commitment transaction, multiple `ChannelClosed` events
+ /// can be generated.
+ 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 {
(2, claim_from_onchain_tx, required),
});
},
+ &Event::ChannelClosed { ref channel_id, ref err } => {
+ 9u8.write(writer)?;
+ channel_id.write(writer)?;
+ err.write(writer)?;
+ write_tlv_fields!(writer, {});
+ },
}
Ok(())
}
};
f()
},
+ 9u8 => {
+ let channel_id = Readable::read(reader)?;
+ let err = Readable::read(reader)?;
+ read_tlv_fields!(reader, {});
+ Ok(Some(Event::ChannelClosed { channel_id, err}))
+ },
// 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)
projects / rust-lightning / blobdiff