Surface outbound payment events via next_event() (#34)

Previously, PaymentSuccessful events from LDK were silently ACKed
and discarded by next_event()'s catch-all arm. This meant callers
using the event-polling model (as opposed to the blocking
wait_for_payment_outcome path) could never learn when an outbound
payment completed or obtain its preimage.

This is a prerequisite for making agent-wallet payments
non-blocking: instead of calling payWhileRunning with a 30-second
timeout that blocks the Node.js thread and risks losing the
preimage on timeout, the agent-wallet will fire-and-forget the
payment and pick up the result through the event loop.

Add a Sent variant (discriminant 3) to PaymentEventType and map
Event::PaymentSuccessful to it in next_event(), carrying the
payment_id and preimage. Also extend PaymentEvent with payment_id
and preimage fields, and expose the previously-discarded payment_id
on PaymentFailed events so callers can correlate failures to
specific outbound payments.

All new fields are Option and set to None on Claimable/Received
events, so this is backwards-compatible for existing consumers
that only match on the first three variants.

Author: amackillop

index.d.ts

@@ -53,11 +53,16 @@ export interface PaymentEvent {
   amountMsat?: number
   reason?: string
   payerNote?: string
+  /** Opaque payment identifier. Present for Sent and Failed (outbound) events. */
+  paymentId?: string
+  /** Payment preimage (proof of payment). Present for Sent events. */
+  preimage?: string
 }
 export const enum PaymentEventType {
   Claimable = 0,
   Received = 1,
   Failed = 2,
+  Sent = 3
 }
 export interface NodeChannel {
   channelId: string

src/lib.rs

@@ -307,13 +307,18 @@ pub struct PaymentEvent {
   pub amount_msat: Option<i64>,
   pub reason: Option<String>,
   pub payer_note: Option<String>,
+  /// Opaque payment identifier. Present for Sent and Failed (outbound) events.
+  pub payment_id: Option<String>,
+  /// Payment preimage (proof of payment). Present for Sent events.
+  pub preimage: Option<String>,
 }
 
 #[napi]
 pub enum PaymentEventType {
   Claimable,
   Received,
   Failed,
+  Sent,
 }
 
 #[napi(object)]
@@ -463,6 +468,8 @@ impl MdkNode {
               amount_msat: Some(*claimable_amount_msat as i64),
               reason: None,
               payer_note: None,
+              payment_id: None,
+              preimage: None,
             }),
             Event::PaymentReceived {
               payment_id,
@@ -490,9 +497,12 @@ impl MdkNode {
                 amount_msat: Some(*amount_msat as i64),
                 reason: None,
                 payer_note,
+                payment_id: None,
+                preimage: None,
               })
             }
             Event::PaymentFailed {
+              payment_id: event_pid,
               payment_hash,
               reason,
               ..
@@ -502,6 +512,22 @@ impl MdkNode {
               amount_msat: None,
               reason: reason.map(|r| format!("{r:?}")),
               payer_note: None,
+              payment_id: event_pid.map(|id| bytes_to_hex(&id.0)),
+              preimage: None,
+            }),
+            Event::PaymentSuccessful {
+              payment_id: event_pid,
+              payment_hash,
+              payment_preimage,
+              ..
+            } => Some(PaymentEvent {
+              event_type: PaymentEventType::Sent,
+              payment_hash: bytes_to_hex(&payment_hash.0),
+              amount_msat: None,
+              reason: None,
+              payer_note: None,
+              payment_id: event_pid.map(|id| bytes_to_hex(&id.0)),
+              preimage: payment_preimage.map(|p| bytes_to_hex(&p.0)),
             }),
             _ => None,
           };