Skip to content

Commit

Permalink
f Use individual event structs
Browse files Browse the repository at this point in the history
  • Loading branch information
@tnull
tnull committed Sep 30, 2022
1 parent 77940d9 commit 8312428
Showing 1 changed file with 175 additions and 81 deletions.
256 changes: 175 additions & 81 deletions src/event.rs
View file
Original file line number Diff line number Diff line change
@@ -1,3 +1,7 @@
//! The events emitted by [`LdkLite`] live here.
//!
//! [`LdkLite`]: [`crate::LdkLite`]

use crate::{
hex_utils, ChannelManager, Error, FilesystemPersister, LdkLiteChainAccess, LdkLiteConfig,
NetworkGraph, PaymentInfo, PaymentInfoStorage, PaymentStatus,
Expand Down Expand Up @@ -27,79 +31,45 @@ use std::time::Duration;
/// The event queue will be persisted under this key.
pub(crate) const EVENTS_PERSISTENCE_KEY: &str = "events";

/// An event emitted by [`LdkLite`] that should be handled by the user. This will more often than
/// not wrap a LDK event accessible via the `inner` field.
/// An event emitted by [`LdkLite`] that should be handled by the user.
///
/// This wraps an event of a specific type and will more often than not wrap a LDK event accessible
/// via the `inner` field.
///
/// [`LdkLite`]: [`crate::LdkLite`]
#[derive(Debug, Clone)]
pub enum LdkLiteEvent {
/// A payment we sent was successful.
PaymentSuccessful {
/// The hash of the payment.
payment_hash: PaymentHash,
/// The wrapped LDK event.
inner: ldk_events::Event,
},
PaymentSuccessful(PaymentSuccessfulEvent),
/// A payment we sent has failed.
PaymentFailed {
/// The hash of the payment.
payment_hash: PaymentHash,
/// The wrapped LDK event.
inner: ldk_events::Event,
},
PaymentFailed(PaymentFailedEvent),
/// A payment has been received.
PaymentReceived {
/// The hash of the payment.
payment_hash: PaymentHash,
/// The value, in thousandths of a satoshi that has been received.
amount_msat: u64,
/// The wrapped LDK event.
inner: ldk_events::Event,
},
PaymentReceived(PaymentReceivedEvent),
// TODO: Implement after a corresponding LDK event is added.
//ChannelOpened {
//},
//ChannelOpened(ChannelOpenedEvent),
/// A channel has been closed.
ChannelClosed {
/// The channel_id of the channel which has been closed.
channel_id: [u8; 32],
/// The wrapped LDK event.
inner: ldk_events::Event,
},
ChannelClosed(ChannelClosedEvent),
// TODO: Implement on-chain events when better integrating with BDK wallet sync.
//OnChainPaymentSent {
//},
//OnChainPaymentReceived {
//}
//OnChainPaymentSent(OnChainPaymentSentEvent),
//OnChainPaymentReceived(OnChainPaymentReceivedEvent),
}

trait EventType {
const TYPE: u8;
}

impl Readable for LdkLiteEvent {
fn read<R: lightning::io::Read>(
reader: &mut R,
) -> Result<Self, lightning::ln::msgs::DecodeError> {
match Readable::read(reader)? {
0u8 => {
let payment_hash: PaymentHash = Readable::read(reader)?;
let inner: ldk_events::Event = MaybeReadable::read(reader)?.unwrap();
Ok(Self::PaymentSuccessful { payment_hash, inner })
}
1u8 => {
let payment_hash: PaymentHash = Readable::read(reader)?;
let inner: ldk_events::Event = MaybeReadable::read(reader)?.unwrap();
Ok(Self::PaymentFailed { payment_hash, inner })
}
2u8 => {
let payment_hash: PaymentHash = Readable::read(reader)?;
let amount_msat: u64 = Readable::read(reader)?;
let inner: ldk_events::Event = MaybeReadable::read(reader)?.unwrap();
Ok(Self::PaymentReceived { payment_hash, amount_msat, inner })
}
//3u8 => {
PaymentSuccessfulEvent::TYPE => Ok(Self::PaymentSuccessful(Readable::read(reader)?)),
PaymentFailedEvent::TYPE => Ok(Self::PaymentFailed(Readable::read(reader)?)),
PaymentReceivedEvent::TYPE => Ok(Self::PaymentReceived(Readable::read(reader)?)),
// ChannelOpenedEvent::TYPE => {
// TODO ChannelOpened
//}
4u8 => {
let channel_id: [u8; 32] = Readable::read(reader)?;
let inner: ldk_events::Event = MaybeReadable::read(reader)?.unwrap();
Ok(Self::ChannelClosed { channel_id, inner })
}
ChannelClosedEvent::TYPE => Ok(Self::ChannelClosed(Readable::read(reader)?)),
//5u8 => {
// TODO OnChainPaymentSent
//}
Expand All @@ -114,32 +84,24 @@ impl Readable for LdkLiteEvent {
impl Writeable for LdkLiteEvent {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), lightning::io::Error> {
match self {
Self::PaymentSuccessful { payment_hash, inner } => {
0u8.write(writer)?;
payment_hash.write(writer)?;
inner.write(writer)?;
Self::PaymentSuccessful(event) => {
event.write(writer)?;
Ok(())
}
Self::PaymentFailed { payment_hash, inner } => {
1u8.write(writer)?;
payment_hash.write(writer)?;
inner.write(writer)?;
Self::PaymentFailed(event) => {
PaymentFailedEvent::TYPE.write(writer)?;
event.write(writer)?;
Ok(())
}
Self::PaymentReceived { payment_hash, amount_msat, inner } => {
2u8.write(writer)?;
payment_hash.write(writer)?;
amount_msat.write(writer)?;
inner.write(writer)?;
Self::PaymentReceived(event) => {
event.write(writer)?;
Ok(())
}
//Self::ChannelOpened { .. } => {
//TODO
//}
Self::ChannelClosed { channel_id, inner } => {
4u8.write(writer)?;
channel_id.write(writer)?;
inner.write(writer)?;
Self::ChannelClosed(event) => {
event.write(writer)?;
Ok(())
} //Self::OnChainPaymentSent { .. } => {
//TODO
Expand All @@ -151,6 +113,138 @@ impl Writeable for LdkLiteEvent {
}
}

/// A payment we sent was successful.
#[derive(Debug, Clone)]
pub struct PaymentSuccessfulEvent {
/// The hash of the payment.
pub payment_hash: PaymentHash,
/// The wrapped LDK event.
pub inner: ldk_events::Event,
}

impl EventType for PaymentSuccessfulEvent {
const TYPE: u8 = 0u8;
}

impl Readable for PaymentSuccessfulEvent {
fn read<R: lightning::io::Read>(
reader: &mut R,
) -> Result<Self, lightning::ln::msgs::DecodeError> {
let payment_hash: PaymentHash = Readable::read(reader)?;
let inner: ldk_events::Event = MaybeReadable::read(reader)?.unwrap();
Ok(Self { payment_hash, inner })
}
}

impl Writeable for PaymentSuccessfulEvent {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), lightning::io::Error> {
Self::TYPE.write(writer)?;
self.payment_hash.write(writer)?;
self.inner.write(writer)?;
Ok(())
}
}

/// A payment we sent has failed.
#[derive(Debug, Clone)]
pub struct PaymentFailedEvent {
/// The hash of the payment.
pub payment_hash: PaymentHash,
/// The wrapped LDK event.
pub inner: ldk_events::Event,
}

impl EventType for PaymentFailedEvent {
const TYPE: u8 = 1u8;
}

impl Readable for PaymentFailedEvent {
fn read<R: lightning::io::Read>(
reader: &mut R,
) -> Result<Self, lightning::ln::msgs::DecodeError> {
let payment_hash: PaymentHash = Readable::read(reader)?;
let inner: ldk_events::Event = MaybeReadable::read(reader)?.unwrap();
Ok(Self { payment_hash, inner })
}
}

impl Writeable for PaymentFailedEvent {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), lightning::io::Error> {
Self::TYPE.write(writer)?;
self.payment_hash.write(writer)?;
self.inner.write(writer)?;
Ok(())
}
}

/// A payment has been received.
#[derive(Debug, Clone)]
pub struct PaymentReceivedEvent {
/// The hash of the payment.
pub payment_hash: PaymentHash,
/// The value, in thousandths of a satoshi that has been received.
pub amount_msat: u64,
/// The wrapped LDK event.
pub inner: ldk_events::Event,
}

impl EventType for PaymentReceivedEvent {
const TYPE: u8 = 2u8;
}

impl Readable for PaymentReceivedEvent {
fn read<R: lightning::io::Read>(
reader: &mut R,
) -> Result<Self, lightning::ln::msgs::DecodeError> {
let payment_hash: PaymentHash = Readable::read(reader)?;
let amount_msat: u64 = Readable::read(reader)?;
let inner: ldk_events::Event = MaybeReadable::read(reader)?.unwrap();
Ok(Self { payment_hash, amount_msat, inner })
}
}

impl Writeable for PaymentReceivedEvent {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), lightning::io::Error> {
Self::TYPE.write(writer)?;
self.payment_hash.write(writer)?;
self.amount_msat.write(writer)?;
self.inner.write(writer)?;
Ok(())
}
}

/// A channel has been closed.
#[derive(Debug, Clone)]
pub struct ChannelClosedEvent {
/// The channel_id of the channel which has been closed.
pub channel_id: [u8; 32],
/// The wrapped LDK event.
pub inner: ldk_events::Event,
}

impl EventType for ChannelClosedEvent {
const TYPE: u8 = 4u8;
}

impl Readable for ChannelClosedEvent {
fn read<R: lightning::io::Read>(
reader: &mut R,
) -> Result<Self, lightning::ln::msgs::DecodeError> {
let channel_id: [u8; 32] = Readable::read(reader)?;
let inner: ldk_events::Event = MaybeReadable::read(reader)?.unwrap();
Ok(Self { channel_id, inner })
}
}

impl Writeable for ChannelClosedEvent {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), lightning::io::Error> {
Self::TYPE.write(writer)?;
self.channel_id.write(writer)?;
self.inner.write(writer)?;
Ok(())
}
}

pub(crate) struct LdkLiteEventQueue<K: KVStorePersister> {
queue: Mutex<EventQueueSerWrapper>,
notifier: Condvar,
Expand Down Expand Up @@ -315,11 +409,11 @@ impl ldk_events::EventHandler for LdkLiteEventHandler {
};
self.channel_manager.claim_funds(payment_preimage.unwrap());
self.event_queue
.add_event(LdkLiteEvent::PaymentReceived {
.add_event(LdkLiteEvent::PaymentReceived(PaymentReceivedEvent {
payment_hash: *payment_hash,
amount_msat: *amount_msat,
inner: event.clone(),
})
}))
.unwrap();
}
ldk_events::Event::PaymentClaimed { payment_hash, purpose, amount_msat } => {
Expand Down Expand Up @@ -384,10 +478,10 @@ impl ldk_events::EventHandler for LdkLiteEventHandler {
}
}
self.event_queue
.add_event(LdkLiteEvent::PaymentSuccessful {
.add_event(LdkLiteEvent::PaymentSuccessful(PaymentSuccessfulEvent {
payment_hash: *payment_hash,
inner: event.clone(),
})
}))
.unwrap();
}
ldk_events::Event::PaymentFailed { payment_hash, .. } => {
Expand All @@ -403,10 +497,10 @@ impl ldk_events::EventHandler for LdkLiteEventHandler {
payment.status = PaymentStatus::Failed;
}
self.event_queue
.add_event(LdkLiteEvent::PaymentFailed {
.add_event(LdkLiteEvent::PaymentFailed(PaymentFailedEvent {
payment_hash: *payment_hash,
inner: event.clone(),
})
}))
.unwrap();
}

Expand Down Expand Up @@ -518,10 +612,10 @@ impl ldk_events::EventHandler for LdkLiteEventHandler {
reason
);
self.event_queue
.add_event(LdkLiteEvent::ChannelClosed {
.add_event(LdkLiteEvent::ChannelClosed(ChannelClosedEvent {
channel_id: *channel_id,
inner: event.clone(),
})
}))
.unwrap();
}
ldk_events::Event::DiscardFunding { .. } => {}
Expand Down

0 comments on commit 8312428

Please sign in to comment.