[Java] Update auto-generated bindings to 0.0.115

Author: TheBlueMatt

src/main/java/org/ldk/enums/CreationError.java

@@ -1,11 +1,11 @@
 package org.ldk.enums;
 
 /**
- * Errors that may occur when constructing a new `RawInvoice` or `Invoice`
+ * Errors that may occur when constructing a new [`RawInvoice`] or [`Invoice`]
  */
 public enum CreationError {
 	/**
-	 * The supplied description string was longer than 639 __bytes__ (see [`Description::new(...)`](./struct.Description.html#method.new))
+	 * The supplied description string was longer than 639 __bytes__ (see [`Description::new`])
 	 */
 	LDKCreationError_DescriptionTooLong,
 	/**

src/main/java/org/ldk/enums/PaymentFailureReason.java

@@ -0,0 +1,44 @@
+package org.ldk.enums;
+
+/**
+ * The reason the payment failed. Used in [`Event::PaymentFailed`].
+ */
+public enum PaymentFailureReason {
+	/**
+	 * The intended recipient rejected our payment.
+	 */
+	LDKPaymentFailureReason_RecipientRejected,
+	/**
+	 * The user chose to abandon this payment by calling [`ChannelManager::abandon_payment`].
+	 * 
+	 * [`ChannelManager::abandon_payment`]: crate::ln::channelmanager::ChannelManager::abandon_payment
+	 */
+	LDKPaymentFailureReason_UserAbandoned,
+	/**
+	 * We exhausted all of our retry attempts while trying to send the payment, or we
+	 * exhausted the [`Retry::Timeout`] if the user set one. If at any point a retry
+	 * attempt failed while being forwarded along the path, an [`Event::PaymentPathFailed`] will
+	 * have come before this.
+	 * 
+	 * [`Retry::Timeout`]: crate::ln::channelmanager::Retry::Timeout
+	 */
+	LDKPaymentFailureReason_RetriesExhausted,
+	/**
+	 * The payment expired while retrying, based on the provided
+	 * [`PaymentParameters::expiry_time`].
+	 * 
+	 * [`PaymentParameters::expiry_time`]: crate::routing::router::PaymentParameters::expiry_time
+	 */
+	LDKPaymentFailureReason_PaymentExpired,
+	/**
+	 * We failed to find a route while retrying the payment.
+	 */
+	LDKPaymentFailureReason_RouteNotFound,
+	/**
+	 * This error should generally never happen. This likely means that there is a problem with
+	 * your router.
+	 */
+	LDKPaymentFailureReason_UnexpectedError,
+	; static native void init();
+	static { init(); }
+}

src/main/java/org/ldk/enums/RetryableSendFailure.java

@@ -1,12 +1,12 @@
 package org.ldk.enums;
 
 /**
- * Indicates an immediate error on [`ChannelManager::send_payment_with_retry`]. Further errors
- * may be surfaced later via [`Event::PaymentPathFailed`] and [`Event::PaymentFailed`].
+ * Indicates an immediate error on [`ChannelManager::send_payment`]. Further errors may be
+ * surfaced later via [`Event::PaymentPathFailed`] and [`Event::PaymentFailed`].
  * 
- * [`ChannelManager::send_payment_with_retry`]: crate::ln::channelmanager::ChannelManager::send_payment_with_retry
- * [`Event::PaymentPathFailed`]: crate::util::events::Event::PaymentPathFailed
- * [`Event::PaymentFailed`]: crate::util::events::Event::PaymentFailed
+ * [`ChannelManager::send_payment`]: crate::ln::channelmanager::ChannelManager::send_payment
+ * [`Event::PaymentPathFailed`]: crate::events::Event::PaymentPathFailed
+ * [`Event::PaymentFailed`]: crate::events::Event::PaymentFailed
  */
 public enum RetryableSendFailure {
 	/**
@@ -25,8 +25,8 @@ public enum RetryableSendFailure {
 	 * yet completed (i.e. generated an [`Event::PaymentSent`] or [`Event::PaymentFailed`]).
 	 * 
 	 * [`PaymentId`]: crate::ln::channelmanager::PaymentId
-	 * [`Event::PaymentSent`]: crate::util::events::Event::PaymentSent
-	 * [`Event::PaymentFailed`]: crate::util::events::Event::PaymentFailed
+	 * [`Event::PaymentSent`]: crate::events::Event::PaymentSent
+	 * [`Event::PaymentFailed`]: crate::events::Event::PaymentFailed
 	 */
 	LDKRetryableSendFailure_DuplicatePayment,
 	; static native void init();

src/main/java/org/ldk/enums/SemanticError.java

@@ -1,7 +1,7 @@
 package org.ldk.enums;
 
 /**
- * Errors that may occur when converting a `RawInvoice` to an `Invoice`. They relate to the
+ * Errors that may occur when converting a [`RawInvoice`] to an [`Invoice`]. They relate to the
  * requirements sections in BOLT #11
  */
 public enum SemanticError {

src/main/java/org/ldk/impl/bindings.java

@@ -0,0 +1,42 @@
+package org.ldk.structs;
+
+import org.ldk.impl.bindings;
+import org.ldk.enums.*;
+import org.ldk.util.*;
+import java.util.Arrays;
+import java.lang.ref.Reference;
+import javax.annotation.Nullable;
+
+
+/**
+ * The minimum amount required for an item in an [`Offer`], denominated in either bitcoin or
+ * another currency.
+ */
+@SuppressWarnings("unchecked") // We correctly assign various generic arrays
+public class Amount extends CommonBase {
+	Amount(Object _dummy, long ptr) { super(ptr); }
+	@Override @SuppressWarnings("deprecation")
+	protected void finalize() throws Throwable {
+		super.finalize();
+		if (ptr != 0) { bindings.Amount_free(ptr); }
+	}
+
+	long clone_ptr() {
+		long ret = bindings.Amount_clone_ptr(this.ptr);
+		Reference.reachabilityFence(this);
+		return ret;
+	}
+
+	/**
+	 * Creates a copy of the Amount
+	 */
+	public Amount clone() {
+		long ret = bindings.Amount_clone(this.ptr);
+		Reference.reachabilityFence(this);
+		if (ret >= 0 && ret <= 4096) { return null; }
+		org.ldk.structs.Amount ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.Amount(null, ret); }
+		if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); };
+		return ret_hu_conv;
+	}
+
+}

src/main/java/org/ldk/structs/Amount.java

@@ -16,8 +16,8 @@
  * Monitoring whether the [`ChannelManager`] needs to be re-persisted to disk, and if so,
  * writing it to disk/backups by invoking the callback given to it at startup.
  * [`ChannelManager`] persistence should be done in the background.
- * Calling [`ChannelManager::timer_tick_occurred`] and [`PeerManager::timer_tick_occurred`]
- * at the appropriate intervals.
+ * Calling [`ChannelManager::timer_tick_occurred`], [`ChainMonitor::rebroadcast_pending_claims`]
+ * and [`PeerManager::timer_tick_occurred`] at the appropriate intervals.
  * Calling [`NetworkGraph::remove_stale_channels_and_tracking`] (if a [`GossipSync`] with a
  * [`NetworkGraph`] is provided to [`BackgroundProcessor::start`]).
  * 
@@ -32,7 +32,7 @@
  * unilateral chain closure fees are at risk.
  * 
  * [`ChannelMonitor`]: lightning::chain::channelmonitor::ChannelMonitor
- * [`Event`]: lightning::util::events::Event
+ * [`Event`]: lightning::events::Event
  * BackgroundProcessor will immediately stop on drop. It should be stored until shutdown.
  */
 @SuppressWarnings("unchecked") // We correctly assign various generic arrays

src/main/java/org/ldk/structs/BackgroundProcessor.java

@@ -39,6 +39,35 @@ public BlindedHop clone() {
 		return ret_hu_conv;
 	}
 
+	/**
+	 * Generates a non-cryptographic 64-bit hash of the BlindedHop.
+	 */
+	public long hash() {
+		long ret = bindings.BlindedHop_hash(this.ptr);
+		Reference.reachabilityFence(this);
+		return ret;
+	}
+
+	@Override public int hashCode() {
+		return (int)this.hash();
+	}
+	/**
+	 * Checks if two BlindedHops contain equal inner contents.
+	 * This ignores pointers and is_owned flags and looks at the values in fields.
+	 * Two objects with NULL inner values will be considered "equal" here.
+	 */
+	public boolean eq(org.ldk.structs.BlindedHop b) {
+		boolean ret = bindings.BlindedHop_eq(this.ptr, b == null ? 0 : b.ptr);
+		Reference.reachabilityFence(this);
+		Reference.reachabilityFence(b);
+		if (this != null) { this.ptrs_to.add(b); };
+		return ret;
+	}
+
+	@Override public boolean equals(Object o) {
+		if (!(o instanceof BlindedHop)) return false;
+		return this.eq((BlindedHop)o);
+	}
 	/**
 	 * Serialize the BlindedHop object into a byte array which can be read by BlindedHop_read
 	 */

src/main/java/org/ldk/structs/BlindedHop.java

@@ -9,8 +9,8 @@
 
 
 /**
- * Onion messages can be sent and received to blinded paths, which serve to hide the identity of
- * the recipient.
+ * Onion messages and payments can be sent and received to blinded paths, which serve to hide the
+ * identity of the recipient.
  */
 @SuppressWarnings("unchecked") // We correctly assign various generic arrays
 public class BlindedPath extends CommonBase {
@@ -40,13 +40,42 @@ public BlindedPath clone() {
 	}
 
 	/**
-	 * Create a blinded path to be forwarded along `node_pks`. The last node pubkey in `node_pks`
-	 * will be the destination node.
+	 * Generates a non-cryptographic 64-bit hash of the BlindedPath.
+	 */
+	public long hash() {
+		long ret = bindings.BlindedPath_hash(this.ptr);
+		Reference.reachabilityFence(this);
+		return ret;
+	}
+
+	@Override public int hashCode() {
+		return (int)this.hash();
+	}
+	/**
+	 * Checks if two BlindedPaths contain equal inner contents.
+	 * This ignores pointers and is_owned flags and looks at the values in fields.
+	 * Two objects with NULL inner values will be considered "equal" here.
+	 */
+	public boolean eq(org.ldk.structs.BlindedPath b) {
+		boolean ret = bindings.BlindedPath_eq(this.ptr, b == null ? 0 : b.ptr);
+		Reference.reachabilityFence(this);
+		Reference.reachabilityFence(b);
+		if (this != null) { this.ptrs_to.add(b); };
+		return ret;
+	}
+
+	@Override public boolean equals(Object o) {
+		if (!(o instanceof BlindedPath)) return false;
+		return this.eq((BlindedPath)o);
+	}
+	/**
+	 * Create a blinded path for an onion message, to be forwarded along `node_pks`. The last node
+	 * pubkey in `node_pks` will be the destination node.
 	 * 
 	 * Errors if less than two hops are provided or if `node_pk`(s) are invalid.
 	 */
-	public static Result_BlindedPathNoneZ of(byte[][] node_pks, org.ldk.structs.EntropySource entropy_source) {
-		long ret = bindings.BlindedPath_new(node_pks != null ? Arrays.stream(node_pks).map(node_pks_conv_8 -> InternalUtils.check_arr_len(node_pks_conv_8, 33)).toArray(byte[][]::new) : null, entropy_source == null ? 0 : entropy_source.ptr);
+	public static Result_BlindedPathNoneZ new_for_message(byte[][] node_pks, org.ldk.structs.EntropySource entropy_source) {
+		long ret = bindings.BlindedPath_new_for_message(node_pks != null ? Arrays.stream(node_pks).map(node_pks_conv_8 -> InternalUtils.check_arr_len(node_pks_conv_8, 33)).toArray(byte[][]::new) : null, entropy_source == null ? 0 : entropy_source.ptr);
 		Reference.reachabilityFence(node_pks);
 		Reference.reachabilityFence(entropy_source);
 		if (ret >= 0 && ret <= 4096) { return null; }