assert false; return null; // Unreachable without extending the (internal) bindings interface
}
+ /**
+ * Used to indicate that the client should generate a funding transaction with the given
+ * parameters and then call ChannelManager::funding_transaction_generated.
+ * Generated in ChannelManager message handling.
+ * Note that *all inputs* in the funding transaction must spend SegWit outputs or your
+ * counterparty can steal your funds!
+ */
public final static class FundingGenerationReady extends Event {
/**
* The random channel_id we picked which you'll need to pass into
this.user_channel_id = obj.user_channel_id;
}
}
+ /**
+ * Indicates we've received money! Just gotta dig out that payment preimage and feed it to
+ * [`ChannelManager::claim_funds`] to get it....
+ * Note that if the preimage is not known, you should call
+ * [`ChannelManager::fail_htlc_backwards`] to free up resources for this HTLC and avoid
+ * network congestion.
+ * If you fail to call either [`ChannelManager::claim_funds`] or
+ * [`ChannelManager::fail_htlc_backwards`] within the HTLC's timeout, the HTLC will be
+ * automatically failed.
+ *
+ * [`ChannelManager::claim_funds`]: crate::ln::channelmanager::ChannelManager::claim_funds
+ * [`ChannelManager::fail_htlc_backwards`]: crate::ln::channelmanager::ChannelManager::fail_htlc_backwards
+ */
public final static class PaymentReceived extends Event {
/**
* The hash for which the preimage should be handed to the ChannelManager.
this.purpose = purpose_hu_conv;
}
}
+ /**
+ * Indicates an outbound payment we made succeeded (i.e. it made it all the way to its target
+ * and we got back the payment preimage for it).
+ *
+ * Note for MPP payments: in rare cases, this event may be preceded by a `PaymentPathFailed`
+ * event. In this situation, you SHOULD treat this payment as having succeeded.
+ */
public final static class PaymentSent extends Event {
+ /**
+ * The id returned by [`ChannelManager::send_payment`] and used with
+ * [`ChannelManager::retry_payment`].
+ *
+ * [`ChannelManager::send_payment`]: crate::ln::channelmanager::ChannelManager::send_payment
+ * [`ChannelManager::retry_payment`]: crate::ln::channelmanager::ChannelManager::retry_payment
+ *
+ * Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None
+ */
+ @Nullable public final byte[] payment_id;
/**
* The preimage to the hash given to ChannelManager::send_payment.
* Note that this serves as a payment receipt, if you wish to have such a thing, you must
* [`ChannelManager::send_payment`]: crate::ln::channelmanager::ChannelManager::send_payment
*/
public final byte[] payment_hash;
+ /**
+ * The total fee which was spent at intermediate hops in this payment, across all paths.
+ *
+ * Note that, like [`Route::get_total_fees`] this does *not* include any potential
+ * overpayment to the recipient node.
+ *
+ * If the recipient or an intermediate node misbehaves and gives us free money, this may
+ * overstate the amount paid, though this is unlikely.
+ *
+ * [`Route::get_total_fees`]: crate::routing::router::Route::get_total_fees
+ */
+ public final Option_u64Z fee_paid_msat;
private PaymentSent(long ptr, bindings.LDKEvent.PaymentSent obj) {
super(null, ptr);
+ this.payment_id = obj.payment_id;
this.payment_preimage = obj.payment_preimage;
this.payment_hash = obj.payment_hash;
+ long fee_paid_msat = obj.fee_paid_msat;
+ Option_u64Z fee_paid_msat_hu_conv = Option_u64Z.constr_from_ptr(fee_paid_msat);
+ fee_paid_msat_hu_conv.ptrs_to.add(this);
+ this.fee_paid_msat = fee_paid_msat_hu_conv;
}
}
+ /**
+ * Indicates an outbound payment we made failed. Probably some intermediary node dropped
+ * something. You may wish to retry with a different route.
+ */
public final static class PaymentPathFailed extends Event {
+ /**
+ * The id returned by [`ChannelManager::send_payment`] and used with
+ * [`ChannelManager::retry_payment`].
+ *
+ * [`ChannelManager::send_payment`]: crate::ln::channelmanager::ChannelManager::send_payment
+ * [`ChannelManager::retry_payment`]: crate::ln::channelmanager::ChannelManager::retry_payment
+ *
+ * Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None
+ */
+ @Nullable public final byte[] payment_id;
/**
* The hash which was given to ChannelManager::send_payment.
*/
* retried. May be `None` for older [`Event`] serializations.
*/
public final Option_u64Z short_channel_id;
+ /**
+ * Parameters needed to compute a new [`Route`] when retrying the failed payment path.
+ *
+ * See [`find_route`] for details.
+ *
+ * [`Route`]: crate::routing::router::Route
+ * [`find_route`]: crate::routing::router::find_route
+ *
+ * Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None
+ */
+ @Nullable public final RouteParameters retry;
private PaymentPathFailed(long ptr, bindings.LDKEvent.PaymentPathFailed obj) {
super(null, ptr);
+ this.payment_id = obj.payment_id;
this.payment_hash = obj.payment_hash;
this.rejected_by_dest = obj.rejected_by_dest;
long network_update = obj.network_update;
RouteHop[] path_conv_10_arr = new RouteHop[path.length];
for (int k = 0; k < path.length; k++) {
long path_conv_10 = path[k];
- RouteHop path_conv_10_hu_conv = new RouteHop(null, path_conv_10);
+ RouteHop path_conv_10_hu_conv = null; if (path_conv_10 < 0 || path_conv_10 > 4096) { path_conv_10_hu_conv = new RouteHop(null, path_conv_10); }
path_conv_10_hu_conv.ptrs_to.add(this);
path_conv_10_arr[k] = path_conv_10_hu_conv;
}
Option_u64Z short_channel_id_hu_conv = Option_u64Z.constr_from_ptr(short_channel_id);
short_channel_id_hu_conv.ptrs_to.add(this);
this.short_channel_id = short_channel_id_hu_conv;
+ long retry = obj.retry;
+ RouteParameters retry_hu_conv = null; if (retry < 0 || retry > 4096) { retry_hu_conv = new RouteParameters(null, retry); }
+ retry_hu_conv.ptrs_to.add(this);
+ this.retry = retry_hu_conv;
}
}
+ /**
+ * Used to indicate that ChannelManager::process_pending_htlc_forwards should be called at a
+ * time in the future.
+ */
public final static class PendingHTLCsForwardable extends Event {
/**
* The minimum amount of time that should be waited prior to calling
this.time_forwardable = obj.time_forwardable;
}
}
+ /**
+ * Used to indicate that an output which you should know how to spend was confirmed on chain
+ * and is now spendable.
+ * Such an output will *not* ever be spent by rust-lightning, and are not at risk of your
+ * counterparty spending them due to some kind of timeout. Thus, you need to store them
+ * somewhere and spend them when you create on-chain transactions.
+ */
public final static class SpendableOutputs extends Event {
/**
* The outputs which you should store as spendable by you.
this.outputs = outputs_conv_27_arr;
}
}
+ /**
+ * This event is generated when a payment has been successfully forwarded through us and a
+ * forwarding fee earned.
+ */
public final static class PaymentForwarded extends Event {
/**
* The fee, in milli-satoshis, which was earned as a result of the payment.
this.claim_from_onchain_tx = obj.claim_from_onchain_tx;
}
}
+ /**
+ * Used to indicate that a channel with the given `channel_id` is in the process of closure.
+ */
public final static class ChannelClosed extends Event {
/**
* The channel_id of the channel which has been closed. Note that on-chain transactions
this.reason = reason_hu_conv;
}
}
+ /**
+ * Used to indicate to the user that they can abandon the funding transaction and recycle the
+ * inputs for another purpose.
+ */
public final static class DiscardFunding extends Event {
/**
* The channel_id of the channel which has been closed.
this.transaction = obj.transaction;
}
}
+ long clone_ptr() {
+ long ret = bindings.Event_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the Event
*/
public Event clone() {
long ret = bindings.Event_clone(this.ptr);
- if (ret >= 0 && ret < 1024) { return null; }
+ if (ret >= 0 && ret <= 4096) { return null; }
Event ret_hu_conv = Event.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(this);
return ret_hu_conv;
* Utility method to constructs a new FundingGenerationReady-variant Event
*/
public static Event funding_generation_ready(byte[] temporary_channel_id, long channel_value_satoshis, byte[] output_script, long user_channel_id) {
- long ret = bindings.Event_funding_generation_ready(temporary_channel_id, channel_value_satoshis, output_script, user_channel_id);
- if (ret >= 0 && ret < 1024) { return null; }
+ long ret = bindings.Event_funding_generation_ready(InternalUtils.check_arr_len(temporary_channel_id, 32), channel_value_satoshis, output_script, user_channel_id);
+ if (ret >= 0 && ret <= 4096) { return null; }
Event ret_hu_conv = Event.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
* Utility method to constructs a new PaymentReceived-variant Event
*/
public static Event payment_received(byte[] payment_hash, long amt, PaymentPurpose purpose) {
- long ret = bindings.Event_payment_received(payment_hash, amt, purpose.ptr);
- if (ret >= 0 && ret < 1024) { return null; }
+ long ret = bindings.Event_payment_received(InternalUtils.check_arr_len(payment_hash, 32), amt, purpose.ptr);
+ if (ret >= 0 && ret <= 4096) { return null; }
Event ret_hu_conv = Event.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
/**
* Utility method to constructs a new PaymentSent-variant Event
*/
- public static Event payment_sent(byte[] payment_preimage, byte[] payment_hash) {
- long ret = bindings.Event_payment_sent(payment_preimage, payment_hash);
- if (ret >= 0 && ret < 1024) { return null; }
+ public static Event payment_sent(byte[] payment_id, byte[] payment_preimage, byte[] payment_hash, Option_u64Z fee_paid_msat) {
+ long ret = bindings.Event_payment_sent(InternalUtils.check_arr_len(payment_id, 32), InternalUtils.check_arr_len(payment_preimage, 32), InternalUtils.check_arr_len(payment_hash, 32), fee_paid_msat.ptr);
+ if (ret >= 0 && ret <= 4096) { return null; }
Event ret_hu_conv = Event.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
/**
* Utility method to constructs a new PaymentPathFailed-variant Event
*/
- public static Event payment_path_failed(byte[] payment_hash, boolean rejected_by_dest, Option_NetworkUpdateZ network_update, boolean all_paths_failed, RouteHop[] path, Option_u64Z short_channel_id) {
- long ret = bindings.Event_payment_path_failed(payment_hash, rejected_by_dest, network_update.ptr, all_paths_failed, path != null ? Arrays.stream(path).mapToLong(path_conv_10 -> path_conv_10 == null ? 0 : path_conv_10.ptr & ~1).toArray() : null, short_channel_id.ptr);
- if (ret >= 0 && ret < 1024) { return null; }
+ public static Event payment_path_failed(byte[] payment_id, byte[] payment_hash, boolean rejected_by_dest, Option_NetworkUpdateZ network_update, boolean all_paths_failed, RouteHop[] path, Option_u64Z short_channel_id, RouteParameters retry) {
+ long ret = bindings.Event_payment_path_failed(InternalUtils.check_arr_len(payment_id, 32), InternalUtils.check_arr_len(payment_hash, 32), rejected_by_dest, network_update.ptr, all_paths_failed, path != null ? Arrays.stream(path).mapToLong(path_conv_10 -> path_conv_10 == null ? 0 : path_conv_10.ptr & ~1).toArray() : null, short_channel_id.ptr, retry == null ? 0 : retry.ptr & ~1);
+ if (ret >= 0 && ret <= 4096) { return null; }
Event ret_hu_conv = Event.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
*/
public static Event pending_htlcs_forwardable(long time_forwardable) {
long ret = bindings.Event_pending_htlcs_forwardable(time_forwardable);
- if (ret >= 0 && ret < 1024) { return null; }
+ if (ret >= 0 && ret <= 4096) { return null; }
Event ret_hu_conv = Event.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
*/
public static Event spendable_outputs(SpendableOutputDescriptor[] outputs) {
long ret = bindings.Event_spendable_outputs(outputs != null ? Arrays.stream(outputs).mapToLong(outputs_conv_27 -> outputs_conv_27.ptr).toArray() : null);
- if (ret >= 0 && ret < 1024) { return null; }
+ if (ret >= 0 && ret <= 4096) { return null; }
Event ret_hu_conv = Event.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
*/
public static Event payment_forwarded(Option_u64Z fee_earned_msat, boolean claim_from_onchain_tx) {
long ret = bindings.Event_payment_forwarded(fee_earned_msat.ptr, claim_from_onchain_tx);
- if (ret >= 0 && ret < 1024) { return null; }
+ if (ret >= 0 && ret <= 4096) { return null; }
Event ret_hu_conv = Event.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
* Utility method to constructs a new ChannelClosed-variant Event
*/
public static Event channel_closed(byte[] channel_id, long user_channel_id, ClosureReason reason) {
- long ret = bindings.Event_channel_closed(channel_id, user_channel_id, reason.ptr);
- if (ret >= 0 && ret < 1024) { return null; }
+ long ret = bindings.Event_channel_closed(InternalUtils.check_arr_len(channel_id, 32), user_channel_id, reason.ptr);
+ if (ret >= 0 && ret <= 4096) { return null; }
Event ret_hu_conv = Event.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
* Utility method to constructs a new DiscardFunding-variant Event
*/
public static Event discard_funding(byte[] channel_id, byte[] transaction) {
- long ret = bindings.Event_discard_funding(channel_id, transaction);
- if (ret >= 0 && ret < 1024) { return null; }
+ long ret = bindings.Event_discard_funding(InternalUtils.check_arr_len(channel_id, 32), transaction);
+ if (ret >= 0 && ret <= 4096) { return null; }
Event ret_hu_conv = Event.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
projects / ldk-java / blobdiff