X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Fmain%2Fjava%2Forg%2Fldk%2Fstructs%2FPaymentSendFailure.java;h=5805c66baa48bad25f52e1995d69e855bdcedab7;hb=HEAD;hp=8d9ccef36b75de8db0a6d512ae07538e63daff00;hpb=5e9de82b3a7712a41189756d9d16d946142b2ac5;p=ldk-java diff --git a/src/main/java/org/ldk/structs/PaymentSendFailure.java b/src/main/java/org/ldk/structs/PaymentSendFailure.java index 8d9ccef3..5805c66b 100644 --- a/src/main/java/org/ldk/structs/PaymentSendFailure.java +++ b/src/main/java/org/ldk/structs/PaymentSendFailure.java @@ -9,9 +9,11 @@ import javax.annotation.Nullable; /** - * If a payment fails to send, it can be in one of several states. This enum is returned as the - * Err() type describing which state the payment is in, see the description of individual enum - * states for more. + * If a payment fails to send with [`ChannelManager::send_payment_with_route`], it can be in one + * of several states. This enum is returned as the Err() type describing which state the payment + * is in, see the description of individual enum states for more. + * + * [`ChannelManager::send_payment_with_route`]: crate::ln::channelmanager::ChannelManager::send_payment_with_route */ @SuppressWarnings("unchecked") // We correctly assign various generic arrays public class PaymentSendFailure extends CommonBase { @@ -29,8 +31,11 @@ public class PaymentSendFailure extends CommonBase { if (raw_val.getClass() == bindings.LDKPaymentSendFailure.PathParameterError.class) { return new PathParameterError(ptr, (bindings.LDKPaymentSendFailure.PathParameterError)raw_val); } - if (raw_val.getClass() == bindings.LDKPaymentSendFailure.AllFailedRetrySafe.class) { - return new AllFailedRetrySafe(ptr, (bindings.LDKPaymentSendFailure.AllFailedRetrySafe)raw_val); + if (raw_val.getClass() == bindings.LDKPaymentSendFailure.AllFailedResendSafe.class) { + return new AllFailedResendSafe(ptr, (bindings.LDKPaymentSendFailure.AllFailedResendSafe)raw_val); + } + if (raw_val.getClass() == bindings.LDKPaymentSendFailure.DuplicatePayment.class) { + return new DuplicatePayment(ptr, (bindings.LDKPaymentSendFailure.DuplicatePayment)raw_val); } if (raw_val.getClass() == bindings.LDKPaymentSendFailure.PartialFailure.class) { return new PartialFailure(ptr, (bindings.LDKPaymentSendFailure.PartialFailure)raw_val); @@ -40,8 +45,15 @@ public class PaymentSendFailure extends CommonBase { /** * A parameter which was passed to send_payment was invalid, preventing us from attempting to - * send the payment at all. No channel state has been changed or messages sent to peers, and - * once you've changed the parameter at error, you can freely retry the payment in full. + * send the payment at all. + * + * You can freely resend the payment in full (with the parameter error fixed). + * + * Because the payment failed outright, no payment tracking is done and no + * [`Event::PaymentPathFailed`] or [`Event::PaymentFailed`] events will be generated. + * + * [`Event::PaymentPathFailed`]: crate::events::Event::PaymentPathFailed + * [`Event::PaymentFailed`]: crate::events::Event::PaymentFailed */ public final static class ParameterError extends PaymentSendFailure { public final org.ldk.structs.APIError parameter_error; @@ -55,12 +67,18 @@ public class PaymentSendFailure extends CommonBase { } /** * A parameter in a single path which was passed to send_payment was invalid, preventing us - * from attempting to send the payment at all. No channel state has been changed or messages - * sent to peers, and once you've changed the parameter at error, you can freely retry the - * payment in full. + * from attempting to send the payment at all. + * + * You can freely resend the payment in full (with the parameter error fixed). + * + * Because the payment failed outright, no payment tracking is done and no + * [`Event::PaymentPathFailed`] or [`Event::PaymentFailed`] events will be generated. * * The results here are ordered the same as the paths in the route object which was passed to * send_payment. + * + * [`Event::PaymentPathFailed`]: crate::events::Event::PaymentPathFailed + * [`Event::PaymentFailed`]: crate::events::Event::PaymentFailed */ public final static class PathParameterError extends PaymentSendFailure { public final Result_NoneAPIErrorZ[] path_parameter_error; @@ -79,48 +97,64 @@ public class PaymentSendFailure extends CommonBase { } /** * All paths which were attempted failed to send, with no channel state change taking place. - * You can freely retry the payment in full (though you probably want to do so over different + * You can freely resend the payment in full (though you probably want to do so over different * paths than the ones selected). + * + * Because the payment failed outright, no payment tracking is done and no + * [`Event::PaymentPathFailed`] or [`Event::PaymentFailed`] events will be generated. + * + * [`Event::PaymentPathFailed`]: crate::events::Event::PaymentPathFailed + * [`Event::PaymentFailed`]: crate::events::Event::PaymentFailed */ - public final static class AllFailedRetrySafe extends PaymentSendFailure { - public final APIError[] all_failed_retry_safe; - private AllFailedRetrySafe(long ptr, bindings.LDKPaymentSendFailure.AllFailedRetrySafe obj) { + public final static class AllFailedResendSafe extends PaymentSendFailure { + public final APIError[] all_failed_resend_safe; + private AllFailedResendSafe(long ptr, bindings.LDKPaymentSendFailure.AllFailedResendSafe obj) { super(null, ptr); - long[] all_failed_retry_safe = obj.all_failed_retry_safe; - int all_failed_retry_safe_conv_10_len = all_failed_retry_safe.length; - APIError[] all_failed_retry_safe_conv_10_arr = new APIError[all_failed_retry_safe_conv_10_len]; - for (int k = 0; k < all_failed_retry_safe_conv_10_len; k++) { - long all_failed_retry_safe_conv_10 = all_failed_retry_safe[k]; - org.ldk.structs.APIError all_failed_retry_safe_conv_10_hu_conv = org.ldk.structs.APIError.constr_from_ptr(all_failed_retry_safe_conv_10); - if (all_failed_retry_safe_conv_10_hu_conv != null) { all_failed_retry_safe_conv_10_hu_conv.ptrs_to.add(this); }; - all_failed_retry_safe_conv_10_arr[k] = all_failed_retry_safe_conv_10_hu_conv; + long[] all_failed_resend_safe = obj.all_failed_resend_safe; + int all_failed_resend_safe_conv_10_len = all_failed_resend_safe.length; + APIError[] all_failed_resend_safe_conv_10_arr = new APIError[all_failed_resend_safe_conv_10_len]; + for (int k = 0; k < all_failed_resend_safe_conv_10_len; k++) { + long all_failed_resend_safe_conv_10 = all_failed_resend_safe[k]; + org.ldk.structs.APIError all_failed_resend_safe_conv_10_hu_conv = org.ldk.structs.APIError.constr_from_ptr(all_failed_resend_safe_conv_10); + if (all_failed_resend_safe_conv_10_hu_conv != null) { all_failed_resend_safe_conv_10_hu_conv.ptrs_to.add(this); }; + all_failed_resend_safe_conv_10_arr[k] = all_failed_resend_safe_conv_10_hu_conv; } - this.all_failed_retry_safe = all_failed_retry_safe_conv_10_arr; + this.all_failed_resend_safe = all_failed_resend_safe_conv_10_arr; } } /** - * Some paths which were attempted failed to send, though possibly not all. At least some - * paths have irrevocably committed to the HTLC and retrying the payment in full would result - * in over-/re-payment. + * Indicates that a payment for the provided [`PaymentId`] is already in-flight and has not + * yet completed (i.e. generated an [`Event::PaymentSent`] or [`Event::PaymentFailed`]). * - * The results here are ordered the same as the paths in the route object which was passed to - * send_payment, and any `Err`s which are not [`APIError::MonitorUpdateInProgress`] can be - * safely retried via [`ChannelManager::retry_payment`]. + * [`PaymentId`]: crate::ln::channelmanager::PaymentId + * [`Event::PaymentSent`]: crate::events::Event::PaymentSent + * [`Event::PaymentFailed`]: crate::events::Event::PaymentFailed + */ + public final static class DuplicatePayment extends PaymentSendFailure { + private DuplicatePayment(long ptr, bindings.LDKPaymentSendFailure.DuplicatePayment obj) { + super(null, ptr); + } + } + /** + * Some paths that were attempted failed to send, though some paths may have succeeded. At least + * some paths have irrevocably committed to the HTLC. + * + * The results here are ordered the same as the paths in the route object that was passed to + * send_payment. * - * Any entries which contain `Err(APIError::MonitorUpdateInprogress)` or `Ok(())` MUST NOT be - * retried as they will result in over-/re-payment. These HTLCs all either successfully sent - * (in the case of `Ok(())`) or will send once a [`MonitorEvent::Completed`] is provided for - * the next-hop channel with the latest update_id. + * Any entries that contain `Err(APIError::MonitorUpdateInprogress)` will send once a + * [`MonitorEvent::Completed`] is provided for the next-hop channel with the latest update_id. + * + * [`MonitorEvent::Completed`]: crate::chain::channelmonitor::MonitorEvent::Completed */ public final static class PartialFailure extends PaymentSendFailure { /** - * The errors themselves, in the same order as the route hops. + * The errors themselves, in the same order as the paths from the route. */ public final Result_NoneAPIErrorZ[] results; /** * If some paths failed without irrevocably committing to the new HTLC(s), this will - * contain a [`RouteParameters`] object which can be used to calculate a new route that - * will pay all remaining unpaid balance. + * contain a [`RouteParameters`] object for the failing paths. * * Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None */ @@ -168,12 +202,13 @@ public class PaymentSendFailure extends CommonBase { /** * Utility method to constructs a new ParameterError-variant PaymentSendFailure */ - public static PaymentSendFailure parameter_error(APIError a) { + public static PaymentSendFailure parameter_error(org.ldk.structs.APIError a) { long ret = bindings.PaymentSendFailure_parameter_error(a.ptr); Reference.reachabilityFence(a); if (ret >= 0 && ret <= 4096) { return null; } org.ldk.structs.PaymentSendFailure ret_hu_conv = org.ldk.structs.PaymentSendFailure.constr_from_ptr(ret); if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); }; + if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(a); }; return ret_hu_conv; } @@ -181,7 +216,7 @@ public class PaymentSendFailure extends CommonBase { * Utility method to constructs a new PathParameterError-variant PaymentSendFailure */ public static PaymentSendFailure path_parameter_error(Result_NoneAPIErrorZ[] a) { - long ret = bindings.PaymentSendFailure_path_parameter_error(a != null ? Arrays.stream(a).mapToLong(a_conv_22 -> a_conv_22 != null ? a_conv_22.ptr : 0).toArray() : null); + long ret = bindings.PaymentSendFailure_path_parameter_error(a != null ? Arrays.stream(a).mapToLong(a_conv_22 -> a_conv_22.ptr).toArray() : null); Reference.reachabilityFence(a); if (ret >= 0 && ret <= 4096) { return null; } org.ldk.structs.PaymentSendFailure ret_hu_conv = org.ldk.structs.PaymentSendFailure.constr_from_ptr(ret); @@ -190,22 +225,34 @@ public class PaymentSendFailure extends CommonBase { } /** - * Utility method to constructs a new AllFailedRetrySafe-variant PaymentSendFailure + * Utility method to constructs a new AllFailedResendSafe-variant PaymentSendFailure */ - public static PaymentSendFailure all_failed_retry_safe(APIError[] a) { - long ret = bindings.PaymentSendFailure_all_failed_retry_safe(a != null ? Arrays.stream(a).mapToLong(a_conv_10 -> a_conv_10.ptr).toArray() : null); + public static PaymentSendFailure all_failed_resend_safe(APIError[] a) { + long ret = bindings.PaymentSendFailure_all_failed_resend_safe(a != null ? Arrays.stream(a).mapToLong(a_conv_10 -> a_conv_10.ptr).toArray() : null); Reference.reachabilityFence(a); if (ret >= 0 && ret <= 4096) { return null; } org.ldk.structs.PaymentSendFailure ret_hu_conv = org.ldk.structs.PaymentSendFailure.constr_from_ptr(ret); if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); }; + for (APIError a_conv_10: a) { if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(a_conv_10); }; }; + return ret_hu_conv; + } + + /** + * Utility method to constructs a new DuplicatePayment-variant PaymentSendFailure + */ + public static PaymentSendFailure duplicate_payment() { + long ret = bindings.PaymentSendFailure_duplicate_payment(); + if (ret >= 0 && ret <= 4096) { return null; } + org.ldk.structs.PaymentSendFailure ret_hu_conv = org.ldk.structs.PaymentSendFailure.constr_from_ptr(ret); + if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); }; return ret_hu_conv; } /** * Utility method to constructs a new PartialFailure-variant PaymentSendFailure */ - public static PaymentSendFailure partial_failure(Result_NoneAPIErrorZ[] results, RouteParameters failed_paths_retry, byte[] payment_id) { - long ret = bindings.PaymentSendFailure_partial_failure(results != null ? Arrays.stream(results).mapToLong(results_conv_22 -> results_conv_22 != null ? results_conv_22.ptr : 0).toArray() : null, failed_paths_retry == null ? 0 : failed_paths_retry.ptr, InternalUtils.check_arr_len(payment_id, 32)); + public static PaymentSendFailure partial_failure(Result_NoneAPIErrorZ[] results, org.ldk.structs.RouteParameters failed_paths_retry, byte[] payment_id) { + long ret = bindings.PaymentSendFailure_partial_failure(results != null ? Arrays.stream(results).mapToLong(results_conv_22 -> results_conv_22.ptr).toArray() : null, failed_paths_retry.ptr, InternalUtils.check_arr_len(payment_id, 32)); Reference.reachabilityFence(results); Reference.reachabilityFence(failed_paths_retry); Reference.reachabilityFence(payment_id); @@ -216,4 +263,19 @@ public class PaymentSendFailure extends CommonBase { return ret_hu_conv; } + /** + * Checks if two PaymentSendFailures contain equal inner contents. + * This ignores pointers and is_owned flags and looks at the values in fields. + */ + public boolean eq(org.ldk.structs.PaymentSendFailure b) { + boolean ret = bindings.PaymentSendFailure_eq(this.ptr, b.ptr); + Reference.reachabilityFence(this); + Reference.reachabilityFence(b); + return ret; + } + + @Override public boolean equals(Object o) { + if (!(o instanceof PaymentSendFailure)) return false; + return this.eq((PaymentSendFailure)o); + } }