bool result_ok;
} LDKCResult_NonePaymentSendFailureZ;
-/**
- * The contents of CResult_PaymentHashPaymentSendFailureZ
- */
-typedef union LDKCResult_PaymentHashPaymentSendFailureZPtr {
- /**
- * A pointer to the contents in the success state.
- * Reading from this pointer when `result_ok` is not set is undefined.
- */
- struct LDKThirtyTwoBytes *result;
- /**
- * A pointer to the contents in the error state.
- * Reading from this pointer when `result_ok` is set is undefined.
- */
- struct LDKPaymentSendFailure *err;
-} LDKCResult_PaymentHashPaymentSendFailureZPtr;
-
-/**
- * A CResult_PaymentHashPaymentSendFailureZ represents the result of a fallible operation,
- * containing a crate::c_types::ThirtyTwoBytes on success and a crate::lightning::ln::channelmanager::PaymentSendFailure on failure.
- * `result_ok` indicates the overall state, and the contents are provided via `contents`.
- */
-typedef struct LDKCResult_PaymentHashPaymentSendFailureZ {
- /**
- * The contents of this CResult_PaymentHashPaymentSendFailureZ, accessible via either
- * `err` or `result` depending on the state of `result_ok`.
- */
- union LDKCResult_PaymentHashPaymentSendFailureZPtr contents;
- /**
- * Whether this CResult_PaymentHashPaymentSendFailureZ represents a success state.
- */
- bool result_ok;
-} LDKCResult_PaymentHashPaymentSendFailureZ;
-
/**
* A 4-byte byte array.
*/
uintptr_t datalen;
} LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ;
-/**
- * Some information provided on receipt of payment depends on whether the payment received is a
- * spontaneous payment or a \"conventional\" lightning payment that's paying an invoice.
- */
-typedef enum LDKPaymentPurpose_Tag {
- /**
- * Information for receiving a payment that we generated an invoice for.
- */
- LDKPaymentPurpose_InvoicePayment,
- /**
- * Because this is a spontaneous payment, the payer generated their own preimage rather than us
- * (the payee) providing a preimage.
- */
- LDKPaymentPurpose_SpontaneousPayment,
- /**
- * Must be last for serialization purposes
- */
- LDKPaymentPurpose_Sentinel,
-} LDKPaymentPurpose_Tag;
-
-typedef struct LDKPaymentPurpose_LDKInvoicePayment_Body {
- /**
- * The preimage to the payment_hash, if the payment hash (and secret) were fetched via
- * [`ChannelManager::create_inbound_payment`]. If provided, this can be handed directly to
- * [`ChannelManager::claim_funds`].
- *
- * [`ChannelManager::create_inbound_payment`]: crate::ln::channelmanager::ChannelManager::create_inbound_payment
- * [`ChannelManager::claim_funds`]: crate::ln::channelmanager::ChannelManager::claim_funds
- *
- * Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None
- */
- struct LDKThirtyTwoBytes payment_preimage;
- /**
- * The \"payment secret\". This authenticates the sender to the recipient, preventing a
- * number of deanonymization attacks during the routing process.
- * It is provided here for your reference, however its accuracy is enforced directly by
- * [`ChannelManager`] using the values you previously provided to
- * [`ChannelManager::create_inbound_payment`] or
- * [`ChannelManager::create_inbound_payment_for_hash`].
- *
- * [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
- * [`ChannelManager::create_inbound_payment`]: crate::ln::channelmanager::ChannelManager::create_inbound_payment
- * [`ChannelManager::create_inbound_payment_for_hash`]: crate::ln::channelmanager::ChannelManager::create_inbound_payment_for_hash
- */
- struct LDKThirtyTwoBytes payment_secret;
- /**
- * This is the `user_payment_id` which was provided to
- * [`ChannelManager::create_inbound_payment_for_hash`] or
- * [`ChannelManager::create_inbound_payment`]. It has no meaning inside of LDK and is
- * simply copied here. It may be used to correlate PaymentReceived events with invoice
- * metadata stored elsewhere.
- *
- * [`ChannelManager::create_inbound_payment`]: crate::ln::channelmanager::ChannelManager::create_inbound_payment
- * [`ChannelManager::create_inbound_payment_for_hash`]: crate::ln::channelmanager::ChannelManager::create_inbound_payment_for_hash
- */
- uint64_t user_payment_id;
-} LDKPaymentPurpose_LDKInvoicePayment_Body;
-
-typedef struct MUST_USE_STRUCT LDKPaymentPurpose {
- LDKPaymentPurpose_Tag tag;
- union {
- LDKPaymentPurpose_LDKInvoicePayment_Body invoice_payment;
- struct {
- struct LDKThirtyTwoBytes spontaneous_payment;
- };
- };
-} LDKPaymentPurpose;
-
/**
* An Event which you should probably take some action in response to.
*
* somewhere and spend them when you create on-chain transactions.
*/
LDKEvent_SpendableOutputs,
- /**
- * This event is generated when a payment has been successfully forwarded through us and a
- * forwarding fee earned.
- */
- LDKEvent_PaymentForwarded,
/**
* Must be last for serialization purposes
*/
* The hash for which the preimage should be handed to the ChannelManager.
*/
struct LDKThirtyTwoBytes payment_hash;
+ /**
+ * The preimage to the payment_hash, if the payment hash (and secret) were fetched via
+ * [`ChannelManager::create_inbound_payment`]. If provided, this can be handed directly to
+ * [`ChannelManager::claim_funds`].
+ *
+ * [`ChannelManager::create_inbound_payment`]: crate::ln::channelmanager::ChannelManager::create_inbound_payment
+ * [`ChannelManager::claim_funds`]: crate::ln::channelmanager::ChannelManager::claim_funds
+ *
+ * Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None
+ */
+ struct LDKThirtyTwoBytes payment_preimage;
+ /**
+ * The \"payment secret\". This authenticates the sender to the recipient, preventing a
+ * number of deanonymization attacks during the routing process.
+ * It is provided here for your reference, however its accuracy is enforced directly by
+ * [`ChannelManager`] using the values you previously provided to
+ * [`ChannelManager::create_inbound_payment`] or
+ * [`ChannelManager::create_inbound_payment_for_hash`].
+ *
+ * [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
+ * [`ChannelManager::create_inbound_payment`]: crate::ln::channelmanager::ChannelManager::create_inbound_payment
+ * [`ChannelManager::create_inbound_payment_for_hash`]: crate::ln::channelmanager::ChannelManager::create_inbound_payment_for_hash
+ */
+ struct LDKThirtyTwoBytes payment_secret;
/**
* The value, in thousandths of a satoshi, that this payment is for. Note that you must
* compare this to the expected value before accepting the payment (as otherwise you are
*/
uint64_t amt;
/**
- * Information for claiming this received payment, based on whether the purpose of the
- * payment is to pay an invoice or to send a spontaneous payment.
+ * This is the `user_payment_id` which was provided to
+ * [`ChannelManager::create_inbound_payment_for_hash`] or
+ * [`ChannelManager::create_inbound_payment`]. It has no meaning inside of LDK and is
+ * simply copied here. It may be used to correlate PaymentReceived events with invoice
+ * metadata stored elsewhere.
+ *
+ * [`ChannelManager::create_inbound_payment`]: crate::ln::channelmanager::ChannelManager::create_inbound_payment
+ * [`ChannelManager::create_inbound_payment_for_hash`]: crate::ln::channelmanager::ChannelManager::create_inbound_payment_for_hash
*/
- struct LDKPaymentPurpose purpose;
+ uint64_t user_payment_id;
} LDKEvent_LDKPaymentReceived_Body;
typedef struct LDKEvent_LDKPaymentSent_Body {
struct LDKCVec_SpendableOutputDescriptorZ outputs;
} LDKEvent_LDKSpendableOutputs_Body;
-typedef struct LDKEvent_LDKPaymentForwarded_Body {
- /**
- * The fee, in milli-satoshis, which was earned as a result of the payment.
- *
- * Note that if we force-closed the channel over which we forwarded an HTLC while the HTLC
- * was pending, the amount the next hop claimed will have been rounded down to the nearest
- * whole satoshi. Thus, the fee calculated here may be higher than expected as we still
- * claimed the full value in millisatoshis from the source. In this case,
- * `claim_from_onchain_tx` will be set.
- *
- * If the channel which sent us the payment has been force-closed, we will claim the funds
- * via an on-chain transaction. In that case we do not yet know the on-chain transaction
- * fees which we will spend and will instead set this to `None`. It is possible duplicate
- * `PaymentForwarded` events are generated for the same payment iff `fee_earned_msat` is
- * `None`.
- */
- struct LDKCOption_u64Z fee_earned_msat;
- /**
- * If this is `true`, the forwarded HTLC was claimed by our counterparty via an on-chain
- * transaction.
- */
- bool claim_from_onchain_tx;
-} LDKEvent_LDKPaymentForwarded_Body;
-
typedef struct MUST_USE_STRUCT LDKEvent {
LDKEvent_Tag tag;
union {
LDKEvent_LDKPaymentFailed_Body payment_failed;
LDKEvent_LDKPendingHTLCsForwardable_Body pending_htl_cs_forwardable;
LDKEvent_LDKSpendableOutputs_Body spendable_outputs;
- LDKEvent_LDKPaymentForwarded_Body payment_forwarded;
};
} LDKEvent;
* then there is a risk of channels force-closing on startup when the manager realizes it's
* outdated. However, as long as `ChannelMonitor` backups are sound, no funds besides those used
* for unilateral chain closure fees are at risk.
- *BackgroundProcessor will immediately stop on drop. It should be stored until shutdown.
*/
typedef struct MUST_USE_STRUCT LDKBackgroundProcessor {
/**
*/
struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_clone(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR orig);
-/**
- * Creates a new CResult_PaymentHashPaymentSendFailureZ in the success state.
- */
-struct LDKCResult_PaymentHashPaymentSendFailureZ CResult_PaymentHashPaymentSendFailureZ_ok(struct LDKThirtyTwoBytes o);
-
-/**
- * Creates a new CResult_PaymentHashPaymentSendFailureZ in the error state.
- */
-struct LDKCResult_PaymentHashPaymentSendFailureZ CResult_PaymentHashPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
-
-/**
- * Frees any resources used by the CResult_PaymentHashPaymentSendFailureZ.
- */
-void CResult_PaymentHashPaymentSendFailureZ_free(struct LDKCResult_PaymentHashPaymentSendFailureZ _res);
-
-/**
- * Creates a new CResult_PaymentHashPaymentSendFailureZ which has the same data as `orig`
- * but with all dynamically-allocated buffers duplicated in new buffers.
- */
-struct LDKCResult_PaymentHashPaymentSendFailureZ CResult_PaymentHashPaymentSendFailureZ_clone(const struct LDKCResult_PaymentHashPaymentSendFailureZ *NONNULL_PTR orig);
-
/**
* Frees the buffer pointed to by `data` if `datalen` is non-0.
*/
*/
struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_clone(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR orig);
-/**
- * Frees any resources used by the PaymentPurpose
- */
-void PaymentPurpose_free(struct LDKPaymentPurpose this_ptr);
-
-/**
- * Creates a copy of the PaymentPurpose
- */
-struct LDKPaymentPurpose PaymentPurpose_clone(const struct LDKPaymentPurpose *NONNULL_PTR orig);
-
-/**
- * Utility method to constructs a new InvoicePayment-variant PaymentPurpose
- */
-struct LDKPaymentPurpose PaymentPurpose_invoice_payment(struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_secret, uint64_t user_payment_id);
-
-/**
- * Utility method to constructs a new SpontaneousPayment-variant PaymentPurpose
- */
-struct LDKPaymentPurpose PaymentPurpose_spontaneous_payment(struct LDKThirtyTwoBytes a);
-
/**
* Frees any resources used by the Event
*/
/**
* Utility method to constructs a new PaymentReceived-variant Event
*/
-struct LDKEvent Event_payment_received(struct LDKThirtyTwoBytes payment_hash, uint64_t amt, struct LDKPaymentPurpose purpose);
+struct LDKEvent Event_payment_received(struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_secret, uint64_t amt, uint64_t user_payment_id);
/**
* Utility method to constructs a new PaymentSent-variant Event
*/
struct LDKEvent Event_spendable_outputs(struct LDKCVec_SpendableOutputDescriptorZ outputs);
-/**
- * Utility method to constructs a new PaymentForwarded-variant Event
- */
-struct LDKEvent Event_payment_forwarded(struct LDKCOption_u64Z fee_earned_msat, bool claim_from_onchain_tx);
-
/**
* Serialize the Event object into a byte array which can be read by Event_read
*/
*/
MUST_USE_RES struct LDKCResult_NonePaymentSendFailureZ ChannelManager_send_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret);
-/**
- * Send a spontaneous payment, which is a payment that does not require the recipient to have
- * generated an invoice. Optionally, you may specify the preimage. If you do choose to specify
- * the preimage, it must be a cryptographically secure random value that no intermediate node
- * would be able to guess -- otherwise, an intermediate node may claim the payment and it will
- * never reach the recipient.
- *
- * Similar to regular payments, you MUST NOT reuse a `payment_preimage` value. See
- * [`send_payment`] for more information about the risks of duplicate preimage usage.
- *
- * [`send_payment`]: Self::send_payment
- *
- * Note that payment_preimage (or a relevant inner pointer) may be NULL or all-0s to represent None
- */
-MUST_USE_RES struct LDKCResult_PaymentHashPaymentSendFailureZ ChannelManager_send_spontaneous_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_preimage);
-
/**
* Call this upon creation of a funding transaction for the given channel.
*
* The [`PaymentHash`] (and corresponding [`PaymentPreimage`]) must be globally unique. This
* method may return an Err if another payment with the same payment_hash is still pending.
*
- * `user_payment_id` will be provided back in [`PaymentPurpose::InvoicePayment::user_payment_id`] events to
+ * `user_payment_id` will be provided back in [`PaymentReceived::user_payment_id`] events to
* allow tracking of which events correspond with which calls to this and
* [`create_inbound_payment`]. `user_payment_id` has no meaning inside of LDK, it is simply
* copied to events and otherwise ignored. It may be used to correlate PaymentReceived events
*
* [`create_inbound_payment`]: Self::create_inbound_payment
* [`PaymentReceived`]: events::Event::PaymentReceived
- * [`PaymentPurpose::InvoicePayment::user_payment_id`]: events::PaymentPurpose::InvoicePayment::user_payment_id
+ * [`PaymentReceived::user_payment_id`]: events::Event::PaymentReceived::user_payment_id
*/
MUST_USE_RES struct LDKCResult_PaymentSecretAPIErrorZ ChannelManager_create_inbound_payment_for_hash(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_u64Z min_value_msat, uint32_t invoice_expiry_delta_secs, uint64_t user_payment_id);
*/
struct LDKRouteHintHop RouteHintHop_clone(const struct LDKRouteHintHop *NONNULL_PTR orig);
-/**
- * Gets a keysend route from us (payer) to the given target node (payee). This is needed because
- * keysend payments do not have an invoice from which to pull the payee's supported features, which
- * makes it tricky to otherwise supply the `payee_features` parameter of `get_route`.
- *
- * Note that first_hops (or a relevant inner pointer) may be NULL or all-0s to represent None
- */
-struct LDKCResult_RouteLightningErrorZ get_keysend_route(struct LDKPublicKey our_node_id, const struct LDKNetworkGraph *NONNULL_PTR network, struct LDKPublicKey payee, struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKCVec_RouteHintZ last_hops, uint64_t final_value_msat, uint32_t final_cltv, struct LDKLogger logger);
-
/**
* Gets a route from us (payer) to the given target node (payee).
*
void ChannelManagerPersister_free(struct LDKChannelManagerPersister this_ptr);
/**
- * Start a background thread that takes care of responsibilities enumerated in the [top-level
- * documentation].
- *
- * The thread runs indefinitely unless the object is dropped, [`stop`] is called, or
- * `persist_manager` returns an error. In case of an error, the error is retrieved by calling
- * either [`join`] or [`stop`].
+ * Start a background thread that takes care of responsibilities enumerated in the top-level
+ * documentation.
*
- * Typically, users should either implement [`ChannelManagerPersister`] to never return an
- * error or call [`join`] and handle any error that may arise. For the latter case, the
- * `BackgroundProcessor` must be restarted by calling `start` again after handling the error.
+ * If `persist_manager` returns an error, then this thread will return said error (and
+ * `start()` will need to be called again to restart the `BackgroundProcessor`). Users should
+ * wait on [`thread_handle`]'s `join()` method to be able to tell if and when an error is
+ * returned, or implement `persist_manager` such that an error is never returned to the
+ * `BackgroundProcessor`
*
* `persist_manager` is responsible for writing out the [`ChannelManager`] to disk, and/or
* uploading to one or more backup services. See [`ChannelManager::write`] for writing out a
* [`ChannelManager`]. See [`FilesystemPersister::persist_manager`] for Rust-Lightning's
* provided implementation.
*
- * [top-level documentation]: Self
- * [`join`]: Self::join
- * [`stop`]: Self::stop
+ * [`thread_handle`]: BackgroundProcessor::thread_handle
* [`ChannelManager`]: lightning::ln::channelmanager::ChannelManager
* [`ChannelManager::write`]: lightning::ln::channelmanager::ChannelManager#impl-Writeable
* [`FilesystemPersister::persist_manager`]: lightning_persister::FilesystemPersister::persist_manager
MUST_USE_RES struct LDKBackgroundProcessor BackgroundProcessor_start(struct LDKChannelManagerPersister persister, struct LDKEventHandler event_handler, const struct LDKChainMonitor *NONNULL_PTR chain_monitor, const struct LDKChannelManager *NONNULL_PTR channel_manager, const struct LDKPeerManager *NONNULL_PTR peer_manager, struct LDKLogger logger);
/**
- * Join `BackgroundProcessor`'s thread, returning any error that occurred while persisting
- * [`ChannelManager`].
- *
- * # Panics
- *
- * This function panics if the background thread has panicked such as while persisting or
- * handling events.
- *
- * [`ChannelManager`]: lightning::ln::channelmanager::ChannelManager
- */
-MUST_USE_RES struct LDKCResult_NoneErrorZ BackgroundProcessor_join(struct LDKBackgroundProcessor this_arg);
-
-/**
- * Stop `BackgroundProcessor`'s thread, returning any error that occurred while persisting
- * [`ChannelManager`].
- *
- * # Panics
- *
- * This function panics if the background thread has panicked such as while persisting or
- * handling events.
- *
- * [`ChannelManager`]: lightning::ln::channelmanager::ChannelManager
+ * Stop `BackgroundProcessor`'s thread.
*/
MUST_USE_RES struct LDKCResult_NoneErrorZ BackgroundProcessor_stop(struct LDKBackgroundProcessor this_arg);
class Watch;
class Filter;
class WatchedOutput;
-class PaymentPurpose;
class Event;
class MessageSendEvent;
class MessageSendEventsProvider;
class CVec_MonitorEventZ;
class CVec_C2Tuple_u32ScriptZZ;
class CResult_NoneChannelMonitorUpdateErrZ;
-class CResult_PaymentHashPaymentSendFailureZ;
class CResult_SiPrefixNoneZ;
class CResult_PublicKeyErrorZ;
class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ;
const LDKWatchedOutput* operator &() const { return &self; }
const LDKWatchedOutput* operator ->() const { return &self; }
};
-class PaymentPurpose {
-private:
- LDKPaymentPurpose self;
-public:
- PaymentPurpose(const PaymentPurpose&) = delete;
- PaymentPurpose(PaymentPurpose&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentPurpose)); }
- PaymentPurpose(LDKPaymentPurpose&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentPurpose)); }
- operator LDKPaymentPurpose() && { LDKPaymentPurpose res = self; memset(&self, 0, sizeof(LDKPaymentPurpose)); return res; }
- ~PaymentPurpose() { PaymentPurpose_free(self); }
- PaymentPurpose& operator=(PaymentPurpose&& o) { PaymentPurpose_free(self); self = o.self; memset(&o, 0, sizeof(PaymentPurpose)); return *this; }
- LDKPaymentPurpose* operator &() { return &self; }
- LDKPaymentPurpose* operator ->() { return &self; }
- const LDKPaymentPurpose* operator &() const { return &self; }
- const LDKPaymentPurpose* operator ->() const { return &self; }
-};
class Event {
private:
LDKEvent self;
const LDKCResult_NoneChannelMonitorUpdateErrZ* operator &() const { return &self; }
const LDKCResult_NoneChannelMonitorUpdateErrZ* operator ->() const { return &self; }
};
-class CResult_PaymentHashPaymentSendFailureZ {
-private:
- LDKCResult_PaymentHashPaymentSendFailureZ self;
-public:
- CResult_PaymentHashPaymentSendFailureZ(const CResult_PaymentHashPaymentSendFailureZ&) = delete;
- CResult_PaymentHashPaymentSendFailureZ(CResult_PaymentHashPaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentHashPaymentSendFailureZ)); }
- CResult_PaymentHashPaymentSendFailureZ(LDKCResult_PaymentHashPaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentHashPaymentSendFailureZ)); }
- operator LDKCResult_PaymentHashPaymentSendFailureZ() && { LDKCResult_PaymentHashPaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentHashPaymentSendFailureZ)); return res; }
- ~CResult_PaymentHashPaymentSendFailureZ() { CResult_PaymentHashPaymentSendFailureZ_free(self); }
- CResult_PaymentHashPaymentSendFailureZ& operator=(CResult_PaymentHashPaymentSendFailureZ&& o) { CResult_PaymentHashPaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentHashPaymentSendFailureZ)); return *this; }
- LDKCResult_PaymentHashPaymentSendFailureZ* operator &() { return &self; }
- LDKCResult_PaymentHashPaymentSendFailureZ* operator ->() { return &self; }
- const LDKCResult_PaymentHashPaymentSendFailureZ* operator &() const { return &self; }
- const LDKCResult_PaymentHashPaymentSendFailureZ* operator ->() const { return &self; }
-};
class CResult_SiPrefixNoneZ {
private:
LDKCResult_SiPrefixNoneZ self;
/// but with all dynamically-allocated buffers duplicated in new buffers.
pub extern "C" fn CResult_NonePaymentSendFailureZ_clone(orig: &CResult_NonePaymentSendFailureZ) -> CResult_NonePaymentSendFailureZ { orig.clone() }
#[repr(C)]
-/// The contents of CResult_PaymentHashPaymentSendFailureZ
-pub union CResult_PaymentHashPaymentSendFailureZPtr {
- /// A pointer to the contents in the success state.
- /// Reading from this pointer when `result_ok` is not set is undefined.
- pub result: *mut crate::c_types::ThirtyTwoBytes,
- /// A pointer to the contents in the error state.
- /// Reading from this pointer when `result_ok` is set is undefined.
- pub err: *mut crate::lightning::ln::channelmanager::PaymentSendFailure,
-}
-#[repr(C)]
-/// A CResult_PaymentHashPaymentSendFailureZ represents the result of a fallible operation,
-/// containing a crate::c_types::ThirtyTwoBytes on success and a crate::lightning::ln::channelmanager::PaymentSendFailure on failure.
-/// `result_ok` indicates the overall state, and the contents are provided via `contents`.
-pub struct CResult_PaymentHashPaymentSendFailureZ {
- /// The contents of this CResult_PaymentHashPaymentSendFailureZ, accessible via either
- /// `err` or `result` depending on the state of `result_ok`.
- pub contents: CResult_PaymentHashPaymentSendFailureZPtr,
- /// Whether this CResult_PaymentHashPaymentSendFailureZ represents a success state.
- pub result_ok: bool,
-}
-#[no_mangle]
-/// Creates a new CResult_PaymentHashPaymentSendFailureZ in the success state.
-pub extern "C" fn CResult_PaymentHashPaymentSendFailureZ_ok(o: crate::c_types::ThirtyTwoBytes) -> CResult_PaymentHashPaymentSendFailureZ {
- CResult_PaymentHashPaymentSendFailureZ {
- contents: CResult_PaymentHashPaymentSendFailureZPtr {
- result: Box::into_raw(Box::new(o)),
- },
- result_ok: true,
- }
-}
-#[no_mangle]
-/// Creates a new CResult_PaymentHashPaymentSendFailureZ in the error state.
-pub extern "C" fn CResult_PaymentHashPaymentSendFailureZ_err(e: crate::lightning::ln::channelmanager::PaymentSendFailure) -> CResult_PaymentHashPaymentSendFailureZ {
- CResult_PaymentHashPaymentSendFailureZ {
- contents: CResult_PaymentHashPaymentSendFailureZPtr {
- err: Box::into_raw(Box::new(e)),
- },
- result_ok: false,
- }
-}
-#[no_mangle]
-/// Frees any resources used by the CResult_PaymentHashPaymentSendFailureZ.
-pub extern "C" fn CResult_PaymentHashPaymentSendFailureZ_free(_res: CResult_PaymentHashPaymentSendFailureZ) { }
-impl Drop for CResult_PaymentHashPaymentSendFailureZ {
- fn drop(&mut self) {
- if self.result_ok {
- if unsafe { !(self.contents.result as *mut ()).is_null() } {
- let _ = unsafe { Box::from_raw(self.contents.result) };
- }
- } else {
- if unsafe { !(self.contents.err as *mut ()).is_null() } {
- let _ = unsafe { Box::from_raw(self.contents.err) };
- }
- }
- }
-}
-impl From<crate::c_types::CResultTempl<crate::c_types::ThirtyTwoBytes, crate::lightning::ln::channelmanager::PaymentSendFailure>> for CResult_PaymentHashPaymentSendFailureZ {
- fn from(mut o: crate::c_types::CResultTempl<crate::c_types::ThirtyTwoBytes, crate::lightning::ln::channelmanager::PaymentSendFailure>) -> Self {
- let contents = if o.result_ok {
- let result = unsafe { o.contents.result };
- unsafe { o.contents.result = std::ptr::null_mut() };
- CResult_PaymentHashPaymentSendFailureZPtr { result }
- } else {
- let err = unsafe { o.contents.err };
- unsafe { o.contents.err = std::ptr::null_mut(); }
- CResult_PaymentHashPaymentSendFailureZPtr { err }
- };
- Self {
- contents,
- result_ok: o.result_ok,
- }
- }
-}
-impl Clone for CResult_PaymentHashPaymentSendFailureZ {
- fn clone(&self) -> Self {
- if self.result_ok {
- Self { result_ok: true, contents: CResult_PaymentHashPaymentSendFailureZPtr {
- result: Box::into_raw(Box::new(<crate::c_types::ThirtyTwoBytes>::clone(unsafe { &*self.contents.result })))
- } }
- } else {
- Self { result_ok: false, contents: CResult_PaymentHashPaymentSendFailureZPtr {
- err: Box::into_raw(Box::new(<crate::lightning::ln::channelmanager::PaymentSendFailure>::clone(unsafe { &*self.contents.err })))
- } }
- }
- }
-}
-#[no_mangle]
-/// Creates a new CResult_PaymentHashPaymentSendFailureZ which has the same data as `orig`
-/// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_PaymentHashPaymentSendFailureZ_clone(orig: &CResult_PaymentHashPaymentSendFailureZ) -> CResult_PaymentHashPaymentSendFailureZ { orig.clone() }
-#[repr(C)]
/// A dynamically-allocated array of crate::lightning::ln::msgs::NetAddresss of arbitrary size.
/// This corresponds to std::vector in C++
pub struct CVec_NetAddressZ {
local_ret
}
-/// Send a spontaneous payment, which is a payment that does not require the recipient to have
-/// generated an invoice. Optionally, you may specify the preimage. If you do choose to specify
-/// the preimage, it must be a cryptographically secure random value that no intermediate node
-/// would be able to guess -- otherwise, an intermediate node may claim the payment and it will
-/// never reach the recipient.
-///
-/// Similar to regular payments, you MUST NOT reuse a `payment_preimage` value. See
-/// [`send_payment`] for more information about the risks of duplicate preimage usage.
-///
-/// [`send_payment`]: Self::send_payment
-///
-/// Note that payment_preimage (or a relevant inner pointer) may be NULL or all-0s to represent None
-#[must_use]
-#[no_mangle]
-pub extern "C" fn ChannelManager_send_spontaneous_payment(this_arg: &ChannelManager, route: &crate::lightning::routing::router::Route, mut payment_preimage: crate::c_types::ThirtyTwoBytes) -> crate::c_types::derived::CResult_PaymentHashPaymentSendFailureZ {
- let mut local_payment_preimage = if payment_preimage.data == [0; 32] { None } else { Some( { ::lightning::ln::PaymentPreimage(payment_preimage.data) }) };
- let mut ret = unsafe { &*this_arg.inner }.send_spontaneous_payment(unsafe { &*route.inner }, local_payment_preimage);
- let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::c_types::ThirtyTwoBytes { data: o.0 } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::channelmanager::PaymentSendFailure::native_into(e) }).into() };
- local_ret
-}
-
/// Call this upon creation of a funding transaction for the given channel.
///
/// Returns an [`APIError::APIMisuseError`] if the funding_transaction spent non-SegWit outputs
/// The [`PaymentHash`] (and corresponding [`PaymentPreimage`]) must be globally unique. This
/// method may return an Err if another payment with the same payment_hash is still pending.
///
-/// `user_payment_id` will be provided back in [`PaymentPurpose::InvoicePayment::user_payment_id`] events to
+/// `user_payment_id` will be provided back in [`PaymentReceived::user_payment_id`] events to
/// allow tracking of which events correspond with which calls to this and
/// [`create_inbound_payment`]. `user_payment_id` has no meaning inside of LDK, it is simply
/// copied to events and otherwise ignored. It may be used to correlate PaymentReceived events
///
/// [`create_inbound_payment`]: Self::create_inbound_payment
/// [`PaymentReceived`]: events::Event::PaymentReceived
-/// [`PaymentPurpose::InvoicePayment::user_payment_id`]: events::PaymentPurpose::InvoicePayment::user_payment_id
+/// [`PaymentReceived::user_payment_id`]: events::Event::PaymentReceived::user_payment_id
#[must_use]
#[no_mangle]
pub extern "C" fn ChannelManager_create_inbound_payment_for_hash(this_arg: &ChannelManager, mut payment_hash: crate::c_types::ThirtyTwoBytes, mut min_value_msat: crate::c_types::derived::COption_u64Z, mut invoice_expiry_delta_secs: u32, mut user_payment_id: u64) -> crate::c_types::derived::CResult_PaymentSecretAPIErrorZ {
pub extern "C" fn RouteHintHop_clone(orig: &RouteHintHop) -> RouteHintHop {
orig.clone()
}
-/// Gets a keysend route from us (payer) to the given target node (payee). This is needed because
-/// keysend payments do not have an invoice from which to pull the payee's supported features, which
-/// makes it tricky to otherwise supply the `payee_features` parameter of `get_route`.
-///
-/// Note that first_hops (or a relevant inner pointer) may be NULL or all-0s to represent None
-#[no_mangle]
-pub extern "C" fn get_keysend_route(mut our_node_id: crate::c_types::PublicKey, network: &crate::lightning::routing::network_graph::NetworkGraph, mut payee: crate::c_types::PublicKey, first_hops: *mut crate::c_types::derived::CVec_ChannelDetailsZ, mut last_hops: crate::c_types::derived::CVec_RouteHintZ, mut final_value_msat: u64, mut final_cltv: u32, mut logger: crate::lightning::util::logger::Logger) -> crate::c_types::derived::CResult_RouteLightningErrorZ {
- let mut local_first_hops_base = if first_hops == std::ptr::null_mut() { None } else { Some( { let mut local_first_hops_0 = Vec::new(); for mut item in unsafe { &mut *first_hops }.as_slice().iter() { local_first_hops_0.push( { unsafe { &*item.inner } }); }; local_first_hops_0 }) }; let mut local_first_hops = local_first_hops_base.as_ref().map(|a| &a[..]);
- let mut local_last_hops = Vec::new(); for mut item in last_hops.as_slice().iter() { local_last_hops.push( { unsafe { &*item.inner } }); };
- let mut ret = lightning::routing::router::get_keysend_route(&our_node_id.into_rust(), unsafe { &*network.inner }, &payee.into_rust(), local_first_hops, &local_last_hops[..], final_value_msat, final_cltv, logger);
- let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::routing::router::Route { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::LightningError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
- local_ret
-}
-
/// Gets a route from us (payer) to the given target node (payee).
///
/// If the payee provided features in their invoice, they should be provided via payee_features.
use bitcoin::hashes::Hash;
use crate::c_types::*;
-/// Some information provided on receipt of payment depends on whether the payment received is a
-/// spontaneous payment or a \"conventional\" lightning payment that's paying an invoice.
-#[must_use]
-#[derive(Clone)]
-#[repr(C)]
-pub enum PaymentPurpose {
- /// Information for receiving a payment that we generated an invoice for.
- InvoicePayment {
- /// The preimage to the payment_hash, if the payment hash (and secret) were fetched via
- /// [`ChannelManager::create_inbound_payment`]. If provided, this can be handed directly to
- /// [`ChannelManager::claim_funds`].
- ///
- /// [`ChannelManager::create_inbound_payment`]: crate::ln::channelmanager::ChannelManager::create_inbound_payment
- /// [`ChannelManager::claim_funds`]: crate::ln::channelmanager::ChannelManager::claim_funds
- ///
- /// Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None
- payment_preimage: crate::c_types::ThirtyTwoBytes,
- /// The \"payment secret\". This authenticates the sender to the recipient, preventing a
- /// number of deanonymization attacks during the routing process.
- /// It is provided here for your reference, however its accuracy is enforced directly by
- /// [`ChannelManager`] using the values you previously provided to
- /// [`ChannelManager::create_inbound_payment`] or
- /// [`ChannelManager::create_inbound_payment_for_hash`].
- ///
- /// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
- /// [`ChannelManager::create_inbound_payment`]: crate::ln::channelmanager::ChannelManager::create_inbound_payment
- /// [`ChannelManager::create_inbound_payment_for_hash`]: crate::ln::channelmanager::ChannelManager::create_inbound_payment_for_hash
- payment_secret: crate::c_types::ThirtyTwoBytes,
- /// This is the `user_payment_id` which was provided to
- /// [`ChannelManager::create_inbound_payment_for_hash`] or
- /// [`ChannelManager::create_inbound_payment`]. It has no meaning inside of LDK and is
- /// simply copied here. It may be used to correlate PaymentReceived events with invoice
- /// metadata stored elsewhere.
- ///
- /// [`ChannelManager::create_inbound_payment`]: crate::ln::channelmanager::ChannelManager::create_inbound_payment
- /// [`ChannelManager::create_inbound_payment_for_hash`]: crate::ln::channelmanager::ChannelManager::create_inbound_payment_for_hash
- user_payment_id: u64,
- },
- /// Because this is a spontaneous payment, the payer generated their own preimage rather than us
- /// (the payee) providing a preimage.
- SpontaneousPayment(crate::c_types::ThirtyTwoBytes),
-}
-use lightning::util::events::PaymentPurpose as nativePaymentPurpose;
-impl PaymentPurpose {
- #[allow(unused)]
- pub(crate) fn to_native(&self) -> nativePaymentPurpose {
- match self {
- PaymentPurpose::InvoicePayment {ref payment_preimage, ref payment_secret, ref user_payment_id, } => {
- let mut payment_preimage_nonref = (*payment_preimage).clone();
- let mut local_payment_preimage_nonref = if payment_preimage_nonref.data == [0; 32] { None } else { Some( { ::lightning::ln::PaymentPreimage(payment_preimage_nonref.data) }) };
- let mut payment_secret_nonref = (*payment_secret).clone();
- let mut user_payment_id_nonref = (*user_payment_id).clone();
- nativePaymentPurpose::InvoicePayment {
- payment_preimage: local_payment_preimage_nonref,
- payment_secret: ::lightning::ln::PaymentSecret(payment_secret_nonref.data),
- user_payment_id: user_payment_id_nonref,
- }
- },
- PaymentPurpose::SpontaneousPayment (ref a, ) => {
- let mut a_nonref = (*a).clone();
- nativePaymentPurpose::SpontaneousPayment (
- ::lightning::ln::PaymentPreimage(a_nonref.data),
- )
- },
- }
- }
- #[allow(unused)]
- pub(crate) fn into_native(self) -> nativePaymentPurpose {
- match self {
- PaymentPurpose::InvoicePayment {mut payment_preimage, mut payment_secret, mut user_payment_id, } => {
- let mut local_payment_preimage = if payment_preimage.data == [0; 32] { None } else { Some( { ::lightning::ln::PaymentPreimage(payment_preimage.data) }) };
- nativePaymentPurpose::InvoicePayment {
- payment_preimage: local_payment_preimage,
- payment_secret: ::lightning::ln::PaymentSecret(payment_secret.data),
- user_payment_id: user_payment_id,
- }
- },
- PaymentPurpose::SpontaneousPayment (mut a, ) => {
- nativePaymentPurpose::SpontaneousPayment (
- ::lightning::ln::PaymentPreimage(a.data),
- )
- },
- }
- }
- #[allow(unused)]
- pub(crate) fn from_native(native: &nativePaymentPurpose) -> Self {
- match native {
- nativePaymentPurpose::InvoicePayment {ref payment_preimage, ref payment_secret, ref user_payment_id, } => {
- let mut payment_preimage_nonref = (*payment_preimage).clone();
- let mut local_payment_preimage_nonref = if payment_preimage_nonref.is_none() { crate::c_types::ThirtyTwoBytes::null() } else { { crate::c_types::ThirtyTwoBytes { data: (payment_preimage_nonref.unwrap()).0 } } };
- let mut payment_secret_nonref = (*payment_secret).clone();
- let mut user_payment_id_nonref = (*user_payment_id).clone();
- PaymentPurpose::InvoicePayment {
- payment_preimage: local_payment_preimage_nonref,
- payment_secret: crate::c_types::ThirtyTwoBytes { data: payment_secret_nonref.0 },
- user_payment_id: user_payment_id_nonref,
- }
- },
- nativePaymentPurpose::SpontaneousPayment (ref a, ) => {
- let mut a_nonref = (*a).clone();
- PaymentPurpose::SpontaneousPayment (
- crate::c_types::ThirtyTwoBytes { data: a_nonref.0 },
- )
- },
- }
- }
- #[allow(unused)]
- pub(crate) fn native_into(native: nativePaymentPurpose) -> Self {
- match native {
- nativePaymentPurpose::InvoicePayment {mut payment_preimage, mut payment_secret, mut user_payment_id, } => {
- let mut local_payment_preimage = if payment_preimage.is_none() { crate::c_types::ThirtyTwoBytes::null() } else { { crate::c_types::ThirtyTwoBytes { data: (payment_preimage.unwrap()).0 } } };
- PaymentPurpose::InvoicePayment {
- payment_preimage: local_payment_preimage,
- payment_secret: crate::c_types::ThirtyTwoBytes { data: payment_secret.0 },
- user_payment_id: user_payment_id,
- }
- },
- nativePaymentPurpose::SpontaneousPayment (mut a, ) => {
- PaymentPurpose::SpontaneousPayment (
- crate::c_types::ThirtyTwoBytes { data: a.0 },
- )
- },
- }
- }
-}
-/// Frees any resources used by the PaymentPurpose
-#[no_mangle]
-pub extern "C" fn PaymentPurpose_free(this_ptr: PaymentPurpose) { }
-/// Creates a copy of the PaymentPurpose
-#[no_mangle]
-pub extern "C" fn PaymentPurpose_clone(orig: &PaymentPurpose) -> PaymentPurpose {
- orig.clone()
-}
-#[no_mangle]
-/// Utility method to constructs a new InvoicePayment-variant PaymentPurpose
-pub extern "C" fn PaymentPurpose_invoice_payment(payment_preimage: crate::c_types::ThirtyTwoBytes, payment_secret: crate::c_types::ThirtyTwoBytes, user_payment_id: u64) -> PaymentPurpose {
- PaymentPurpose::InvoicePayment {
- payment_preimage,
- payment_secret,
- user_payment_id,
- }
-}
-#[no_mangle]
-/// Utility method to constructs a new SpontaneousPayment-variant PaymentPurpose
-pub extern "C" fn PaymentPurpose_spontaneous_payment(a: crate::c_types::ThirtyTwoBytes) -> PaymentPurpose {
- PaymentPurpose::SpontaneousPayment(a, )
-}
/// 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
PaymentReceived {
/// The hash for which the preimage should be handed to the ChannelManager.
payment_hash: crate::c_types::ThirtyTwoBytes,
+ /// The preimage to the payment_hash, if the payment hash (and secret) were fetched via
+ /// [`ChannelManager::create_inbound_payment`]. If provided, this can be handed directly to
+ /// [`ChannelManager::claim_funds`].
+ ///
+ /// [`ChannelManager::create_inbound_payment`]: crate::ln::channelmanager::ChannelManager::create_inbound_payment
+ /// [`ChannelManager::claim_funds`]: crate::ln::channelmanager::ChannelManager::claim_funds
+ ///
+ /// Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None
+ payment_preimage: crate::c_types::ThirtyTwoBytes,
+ /// The \"payment secret\". This authenticates the sender to the recipient, preventing a
+ /// number of deanonymization attacks during the routing process.
+ /// It is provided here for your reference, however its accuracy is enforced directly by
+ /// [`ChannelManager`] using the values you previously provided to
+ /// [`ChannelManager::create_inbound_payment`] or
+ /// [`ChannelManager::create_inbound_payment_for_hash`].
+ ///
+ /// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
+ /// [`ChannelManager::create_inbound_payment`]: crate::ln::channelmanager::ChannelManager::create_inbound_payment
+ /// [`ChannelManager::create_inbound_payment_for_hash`]: crate::ln::channelmanager::ChannelManager::create_inbound_payment_for_hash
+ payment_secret: crate::c_types::ThirtyTwoBytes,
/// The value, in thousandths of a satoshi, that this payment is for. Note that you must
/// compare this to the expected value before accepting the payment (as otherwise you are
/// providing proof-of-payment for less than the value you expected!).
amt: u64,
- /// Information for claiming this received payment, based on whether the purpose of the
- /// payment is to pay an invoice or to send a spontaneous payment.
- purpose: crate::lightning::util::events::PaymentPurpose,
+ /// This is the `user_payment_id` which was provided to
+ /// [`ChannelManager::create_inbound_payment_for_hash`] or
+ /// [`ChannelManager::create_inbound_payment`]. It has no meaning inside of LDK and is
+ /// simply copied here. It may be used to correlate PaymentReceived events with invoice
+ /// metadata stored elsewhere.
+ ///
+ /// [`ChannelManager::create_inbound_payment`]: crate::ln::channelmanager::ChannelManager::create_inbound_payment
+ /// [`ChannelManager::create_inbound_payment_for_hash`]: crate::ln::channelmanager::ChannelManager::create_inbound_payment_for_hash
+ user_payment_id: u64,
},
/// Indicates an outbound payment we made succeeded (ie it made it all the way to its target
/// and we got back the payment preimage for it).
/// The outputs which you should store as spendable by you.
outputs: crate::c_types::derived::CVec_SpendableOutputDescriptorZ,
},
- /// This event is generated when a payment has been successfully forwarded through us and a
- /// forwarding fee earned.
- PaymentForwarded {
- /// The fee, in milli-satoshis, which was earned as a result of the payment.
- ///
- /// Note that if we force-closed the channel over which we forwarded an HTLC while the HTLC
- /// was pending, the amount the next hop claimed will have been rounded down to the nearest
- /// whole satoshi. Thus, the fee calculated here may be higher than expected as we still
- /// claimed the full value in millisatoshis from the source. In this case,
- /// `claim_from_onchain_tx` will be set.
- ///
- /// If the channel which sent us the payment has been force-closed, we will claim the funds
- /// via an on-chain transaction. In that case we do not yet know the on-chain transaction
- /// fees which we will spend and will instead set this to `None`. It is possible duplicate
- /// `PaymentForwarded` events are generated for the same payment iff `fee_earned_msat` is
- /// `None`.
- fee_earned_msat: crate::c_types::derived::COption_u64Z,
- /// If this is `true`, the forwarded HTLC was claimed by our counterparty via an on-chain
- /// transaction.
- claim_from_onchain_tx: bool,
- },
}
use lightning::util::events::Event as nativeEvent;
impl Event {
user_channel_id: user_channel_id_nonref,
}
},
- Event::PaymentReceived {ref payment_hash, ref amt, ref purpose, } => {
+ Event::PaymentReceived {ref payment_hash, ref payment_preimage, ref payment_secret, ref amt, ref user_payment_id, } => {
let mut payment_hash_nonref = (*payment_hash).clone();
+ let mut payment_preimage_nonref = (*payment_preimage).clone();
+ let mut local_payment_preimage_nonref = if payment_preimage_nonref.data == [0; 32] { None } else { Some( { ::lightning::ln::PaymentPreimage(payment_preimage_nonref.data) }) };
+ let mut payment_secret_nonref = (*payment_secret).clone();
let mut amt_nonref = (*amt).clone();
- let mut purpose_nonref = (*purpose).clone();
+ let mut user_payment_id_nonref = (*user_payment_id).clone();
nativeEvent::PaymentReceived {
payment_hash: ::lightning::ln::PaymentHash(payment_hash_nonref.data),
+ payment_preimage: local_payment_preimage_nonref,
+ payment_secret: ::lightning::ln::PaymentSecret(payment_secret_nonref.data),
amt: amt_nonref,
- purpose: purpose_nonref.into_native(),
+ user_payment_id: user_payment_id_nonref,
}
},
Event::PaymentSent {ref payment_preimage, } => {
outputs: local_outputs_nonref,
}
},
- Event::PaymentForwarded {ref fee_earned_msat, ref claim_from_onchain_tx, } => {
- let mut fee_earned_msat_nonref = (*fee_earned_msat).clone();
- let mut local_fee_earned_msat_nonref = if fee_earned_msat_nonref.is_some() { Some( { fee_earned_msat_nonref.take() }) } else { None };
- let mut claim_from_onchain_tx_nonref = (*claim_from_onchain_tx).clone();
- nativeEvent::PaymentForwarded {
- fee_earned_msat: local_fee_earned_msat_nonref,
- claim_from_onchain_tx: claim_from_onchain_tx_nonref,
- }
- },
}
}
#[allow(unused)]
user_channel_id: user_channel_id,
}
},
- Event::PaymentReceived {mut payment_hash, mut amt, mut purpose, } => {
+ Event::PaymentReceived {mut payment_hash, mut payment_preimage, mut payment_secret, mut amt, mut user_payment_id, } => {
+ let mut local_payment_preimage = if payment_preimage.data == [0; 32] { None } else { Some( { ::lightning::ln::PaymentPreimage(payment_preimage.data) }) };
nativeEvent::PaymentReceived {
payment_hash: ::lightning::ln::PaymentHash(payment_hash.data),
+ payment_preimage: local_payment_preimage,
+ payment_secret: ::lightning::ln::PaymentSecret(payment_secret.data),
amt: amt,
- purpose: purpose.into_native(),
+ user_payment_id: user_payment_id,
}
},
Event::PaymentSent {mut payment_preimage, } => {
outputs: local_outputs,
}
},
- Event::PaymentForwarded {mut fee_earned_msat, mut claim_from_onchain_tx, } => {
- let mut local_fee_earned_msat = if fee_earned_msat.is_some() { Some( { fee_earned_msat.take() }) } else { None };
- nativeEvent::PaymentForwarded {
- fee_earned_msat: local_fee_earned_msat,
- claim_from_onchain_tx: claim_from_onchain_tx,
- }
- },
}
}
#[allow(unused)]
user_channel_id: user_channel_id_nonref,
}
},
- nativeEvent::PaymentReceived {ref payment_hash, ref amt, ref purpose, } => {
+ nativeEvent::PaymentReceived {ref payment_hash, ref payment_preimage, ref payment_secret, ref amt, ref user_payment_id, } => {
let mut payment_hash_nonref = (*payment_hash).clone();
+ let mut payment_preimage_nonref = (*payment_preimage).clone();
+ let mut local_payment_preimage_nonref = if payment_preimage_nonref.is_none() { crate::c_types::ThirtyTwoBytes::null() } else { { crate::c_types::ThirtyTwoBytes { data: (payment_preimage_nonref.unwrap()).0 } } };
+ let mut payment_secret_nonref = (*payment_secret).clone();
let mut amt_nonref = (*amt).clone();
- let mut purpose_nonref = (*purpose).clone();
+ let mut user_payment_id_nonref = (*user_payment_id).clone();
Event::PaymentReceived {
payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash_nonref.0 },
+ payment_preimage: local_payment_preimage_nonref,
+ payment_secret: crate::c_types::ThirtyTwoBytes { data: payment_secret_nonref.0 },
amt: amt_nonref,
- purpose: crate::lightning::util::events::PaymentPurpose::native_into(purpose_nonref),
+ user_payment_id: user_payment_id_nonref,
}
},
nativeEvent::PaymentSent {ref payment_preimage, } => {
outputs: local_outputs_nonref.into(),
}
},
- nativeEvent::PaymentForwarded {ref fee_earned_msat, ref claim_from_onchain_tx, } => {
- let mut fee_earned_msat_nonref = (*fee_earned_msat).clone();
- let mut local_fee_earned_msat_nonref = if fee_earned_msat_nonref.is_none() { crate::c_types::derived::COption_u64Z::None } else { { crate::c_types::derived::COption_u64Z::Some(fee_earned_msat_nonref.unwrap()) } };
- let mut claim_from_onchain_tx_nonref = (*claim_from_onchain_tx).clone();
- Event::PaymentForwarded {
- fee_earned_msat: local_fee_earned_msat_nonref,
- claim_from_onchain_tx: claim_from_onchain_tx_nonref,
- }
- },
}
}
#[allow(unused)]
user_channel_id: user_channel_id,
}
},
- nativeEvent::PaymentReceived {mut payment_hash, mut amt, mut purpose, } => {
+ nativeEvent::PaymentReceived {mut payment_hash, mut payment_preimage, mut payment_secret, mut amt, mut user_payment_id, } => {
+ let mut local_payment_preimage = if payment_preimage.is_none() { crate::c_types::ThirtyTwoBytes::null() } else { { crate::c_types::ThirtyTwoBytes { data: (payment_preimage.unwrap()).0 } } };
Event::PaymentReceived {
payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash.0 },
+ payment_preimage: local_payment_preimage,
+ payment_secret: crate::c_types::ThirtyTwoBytes { data: payment_secret.0 },
amt: amt,
- purpose: crate::lightning::util::events::PaymentPurpose::native_into(purpose),
+ user_payment_id: user_payment_id,
}
},
nativeEvent::PaymentSent {mut payment_preimage, } => {
outputs: local_outputs.into(),
}
},
- nativeEvent::PaymentForwarded {mut fee_earned_msat, mut claim_from_onchain_tx, } => {
- let mut local_fee_earned_msat = if fee_earned_msat.is_none() { crate::c_types::derived::COption_u64Z::None } else { { crate::c_types::derived::COption_u64Z::Some(fee_earned_msat.unwrap()) } };
- Event::PaymentForwarded {
- fee_earned_msat: local_fee_earned_msat,
- claim_from_onchain_tx: claim_from_onchain_tx,
- }
- },
}
}
}
}
#[no_mangle]
/// Utility method to constructs a new PaymentReceived-variant Event
-pub extern "C" fn Event_payment_received(payment_hash: crate::c_types::ThirtyTwoBytes, amt: u64, purpose: crate::lightning::util::events::PaymentPurpose) -> Event {
+pub extern "C" fn Event_payment_received(payment_hash: crate::c_types::ThirtyTwoBytes, payment_preimage: crate::c_types::ThirtyTwoBytes, payment_secret: crate::c_types::ThirtyTwoBytes, amt: u64, user_payment_id: u64) -> Event {
Event::PaymentReceived {
payment_hash,
+ payment_preimage,
+ payment_secret,
amt,
- purpose,
+ user_payment_id,
}
}
#[no_mangle]
}
}
#[no_mangle]
-/// Utility method to constructs a new PaymentForwarded-variant Event
-pub extern "C" fn Event_payment_forwarded(fee_earned_msat: crate::c_types::derived::COption_u64Z, claim_from_onchain_tx: bool) -> Event {
- Event::PaymentForwarded {
- fee_earned_msat,
- claim_from_onchain_tx,
- }
-}
-#[no_mangle]
/// Serialize the Event object into a byte array which can be read by Event_read
pub extern "C" fn Event_write(obj: &Event) -> crate::c_types::derived::CVec_u8Z {
crate::c_types::serialize_obj(&unsafe { &*obj }.to_native())
/// then there is a risk of channels force-closing on startup when the manager realizes it's
/// outdated. However, as long as `ChannelMonitor` backups are sound, no funds besides those used
/// for unilateral chain closure fees are at risk.
-///BackgroundProcessor will immediately stop on drop. It should be stored until shutdown.
#[must_use]
#[repr(C)]
pub struct BackgroundProcessor {
}
}
}
-/// Start a background thread that takes care of responsibilities enumerated in the [top-level
-/// documentation].
+/// Start a background thread that takes care of responsibilities enumerated in the top-level
+/// documentation.
///
-/// The thread runs indefinitely unless the object is dropped, [`stop`] is called, or
-/// `persist_manager` returns an error. In case of an error, the error is retrieved by calling
-/// either [`join`] or [`stop`].
-///
-/// Typically, users should either implement [`ChannelManagerPersister`] to never return an
-/// error or call [`join`] and handle any error that may arise. For the latter case, the
-/// `BackgroundProcessor` must be restarted by calling `start` again after handling the error.
+/// If `persist_manager` returns an error, then this thread will return said error (and
+/// `start()` will need to be called again to restart the `BackgroundProcessor`). Users should
+/// wait on [`thread_handle`]'s `join()` method to be able to tell if and when an error is
+/// returned, or implement `persist_manager` such that an error is never returned to the
+/// `BackgroundProcessor`
///
/// `persist_manager` is responsible for writing out the [`ChannelManager`] to disk, and/or
/// uploading to one or more backup services. See [`ChannelManager::write`] for writing out a
/// [`ChannelManager`]. See [`FilesystemPersister::persist_manager`] for Rust-Lightning's
/// provided implementation.
///
-/// [top-level documentation]: Self
-/// [`join`]: Self::join
-/// [`stop`]: Self::stop
+/// [`thread_handle`]: BackgroundProcessor::thread_handle
/// [`ChannelManager`]: lightning::ln::channelmanager::ChannelManager
/// [`ChannelManager::write`]: lightning::ln::channelmanager::ChannelManager#impl-Writeable
/// [`FilesystemPersister::persist_manager`]: lightning_persister::FilesystemPersister::persist_manager
BackgroundProcessor { inner: Box::into_raw(Box::new(ret)), is_owned: true }
}
-/// Join `BackgroundProcessor`'s thread, returning any error that occurred while persisting
-/// [`ChannelManager`].
-///
-/// # Panics
-///
-/// This function panics if the background thread has panicked such as while persisting or
-/// handling events.
-///
-/// [`ChannelManager`]: lightning::ln::channelmanager::ChannelManager
-#[must_use]
-#[no_mangle]
-pub extern "C" fn BackgroundProcessor_join(mut this_arg: BackgroundProcessor) -> crate::c_types::derived::CResult_NoneErrorZ {
- let mut ret = (*unsafe { Box::from_raw(this_arg.take_inner()) }).join();
- let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { () /*o*/ }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::c_types::IOError::from_rust(e) }).into() };
- local_ret
-}
-
-/// Stop `BackgroundProcessor`'s thread, returning any error that occurred while persisting
-/// [`ChannelManager`].
-///
-/// # Panics
-///
-/// This function panics if the background thread has panicked such as while persisting or
-/// handling events.
-///
-/// [`ChannelManager`]: lightning::ln::channelmanager::ChannelManager
+/// Stop `BackgroundProcessor`'s thread.
#[must_use]
#[no_mangle]
pub extern "C" fn BackgroundProcessor_stop(mut this_arg: BackgroundProcessor) -> crate::c_types::derived::CResult_NoneErrorZ {
projects / ldk-c-bindings / commitdiff