Add and emit OnchainPaymentSuccessful and OnchainPaymentReceived events

.. two new events that we're emitting when we sent or received an
onchain payment, i.e., the transactions reached ANTI_REORG_DELAY
confirmations.

Author: tnull

bindings/ldk_node.udl

@@ -291,6 +291,8 @@ interface Event {
 	ChannelPending(ChannelId channel_id, UserChannelId user_channel_id, ChannelId former_temporary_channel_id, PublicKey counterparty_node_id, OutPoint funding_txo);
 	ChannelReady(ChannelId channel_id, UserChannelId user_channel_id, PublicKey? counterparty_node_id);
 	ChannelClosed(ChannelId channel_id, UserChannelId user_channel_id, PublicKey? counterparty_node_id, ClosureReason? reason);
+	OnchainPaymentSuccessful(PaymentId payment_id, Txid txid, u64 amount_msat, BlockHash block_hash, u32 block_height);
+	OnchainPaymentReceived(PaymentId payment_id, Txid txid, u64 amount_msat, BlockHash block_hash, u32 block_height);
 };
 
 enum PaymentFailureReason {

src/event.rs

@@ -42,7 +42,7 @@ use lightning_liquidity::lsps2::utils::compute_opening_fee;
 
 use bitcoin::blockdata::locktime::absolute::LockTime;
 use bitcoin::secp256k1::PublicKey;
-use bitcoin::{Amount, OutPoint};
+use bitcoin::{Amount, BlockHash, OutPoint, Txid};
 
 use rand::{thread_rng, Rng};
 
@@ -221,6 +221,41 @@ pub enum Event {
 		/// This will be `None` for events serialized by LDK Node v0.2.1 and prior.
 		reason: Option<ClosureReason>,
 	},
+	/// A sent onchain payment was successful.
+	///
+	/// It's guaranteed to have reached at least [`ANTI_REORG_DELAY`] delay confirmations.
+	///
+	///
+	/// [`ANTI_REORG_DELAY`]: lightning::chain::channelmonitor::ANTI_REORG_DELAY
+	OnchainPaymentSuccessful {
+		/// A local identifier used to track the payment.
+		payment_id: PaymentId,
+		/// The transaction identifier.
+		txid: Txid,
+		/// The value, in thousandths of a satoshi, that has been received.
+		amount_msat: u64,
+		/// The hash of the block in which the transaction was confirmed.
+		block_hash: BlockHash,
+		/// The height under which the block was confirmed.
+		block_height: u32,
+	},
+	/// An onchain payment has been received.
+	///
+	/// It's guaranteed to have reached at least [`ANTI_REORG_DELAY`] delay confirmations.
+	///
+	/// [`ANTI_REORG_DELAY`]: lightning::chain::channelmonitor::ANTI_REORG_DELAY
+	OnchainPaymentReceived {
+		/// A local identifier used to track the payment.
+		payment_id: PaymentId,
+		/// The transaction identifier.
+		txid: Txid,
+		/// The value, in thousandths of a satoshi, that has been received.
+		amount_msat: u64,
+		/// The hash of the block in which the transaction was confirmed.
+		block_hash: BlockHash,
+		/// The height under which the block was confirmed.
+		block_height: u32,
+	},
 }
 
 impl_writeable_tlv_based_enum!(Event,
@@ -277,7 +312,21 @@ impl_writeable_tlv_based_enum!(Event,
 		(10, skimmed_fee_msat, option),
 		(12, claim_from_onchain_tx, required),
 		(14, outbound_amount_forwarded_msat, option),
-	}
+	},
+	(8, OnchainPaymentSuccessful) => {
+		(0, payment_id, required),
+		(2, txid, required),
+		(4, amount_msat, required),
+		(6, block_hash, required),
+		(8, block_height, required),
+	},
+	(9, OnchainPaymentReceived) => {
+		(0, payment_id, required),
+		(2, txid, required),
+		(4, amount_msat, required),
+		(6, block_hash, required),
+		(8, block_height, required),
+	},
 );
 
 pub struct EventQueue<L: Deref>

src/wallet/mod.rs

@@ -9,7 +9,7 @@ use persist::KVStoreWalletPersister;
 
 use crate::logger::{log_debug, log_error, log_info, log_trace, FilesystemLogger, Logger};
 
-use crate::event::EventQueue;
+use crate::event::{Event, EventQueue};
 use crate::fee_estimator::{ConfirmationTarget, FeeEstimator};
 use crate::payment::store::{ConfirmationStatus, PaymentStore};
 use crate::payment::{PaymentDetails, PaymentDirection, PaymentStatus};
@@ -192,24 +192,59 @@ where
 			let (sent, received) = locked_wallet.sent_and_received(&wtx.tx_node.tx);
 			let (direction, amount_msat) = if sent > received {
 				let direction = PaymentDirection::Outbound;
-				let amount_msat = Some(sent.to_sat().saturating_sub(received.to_sat()) * 1000);
+				let amount_msat = sent.to_sat().saturating_sub(received.to_sat()) * 1000;
 				(direction, amount_msat)
 			} else {
 				let direction = PaymentDirection::Inbound;
-				let amount_msat = Some(received.to_sat().saturating_sub(sent.to_sat()) * 1000);
+				let amount_msat = received.to_sat().saturating_sub(sent.to_sat()) * 1000;
 				(direction, amount_msat)
 			};
 
 			let payment = PaymentDetails {
 				id,
 				kind,
-				amount_msat,
+				amount_msat: Some(amount_msat),
 				direction,
 				status: payment_status,
 				latest_update_timestamp,
 			};
 
-			self.payment_store.insert_or_update(&payment)?;
+			let updated = self.payment_store.insert_or_update(&payment)?;
+
+			// If we just updated the entry and we deem the transaction successful (i.e., has seen
+			// at least ANTI_REORG_DELAY confirmations), issue an event.
+			if updated && payment_status == PaymentStatus::Succeeded {
+				match confirmation_status {
+					ConfirmationStatus::Confirmed { block_hash, height, .. } => {
+						let event;
+						if direction == PaymentDirection::Outbound {
+							event = Event::OnchainPaymentSuccessful {
+								payment_id: id,
+								txid,
+								block_hash,
+								block_height: height,
+								amount_msat,
+							};
+						} else {
+							event = Event::OnchainPaymentReceived {
+								payment_id: id,
+								txid,
+								block_hash,
+								block_height: height,
+								amount_msat,
+							};
+						}
+						self.event_queue.add_event(event).map_err(|e| {
+							log_error!(self.logger, "Failed to push to event queue: {}", e);
+							Error::PersistenceFailed
+						})?;
+					},
+					_ => {
+						// We only issue events for transactions that have seen ANTI_REORG_DELAY
+						// confirmations.
+					},
+				}
+			}
 		}
 
 		Ok(())