[Java] Update auto-generated Java files

Author: TheBlueMatt

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

@@ -89,11 +89,9 @@ protected void finalize() throws Throwable {
 	 * [`Persister::persist_graph`]: lightning::util::persist::Persister::persist_graph
 	 * [`NetworkGraph`]: lightning::routing::gossip::NetworkGraph
 	 * [`NetworkGraph::write`]: lightning::routing::gossip::NetworkGraph#impl-Writeable
-	 * 
-	 * Note that scorer (or a relevant inner pointer) may be NULL or all-0s to represent None
 	 */
-	public static BackgroundProcessor start(Persister persister, EventHandler event_handler, ChainMonitor chain_monitor, ChannelManager channel_manager, GossipSync gossip_sync, PeerManager peer_manager, Logger logger, @Nullable MultiThreadedLockableScore scorer) {
-		long ret = bindings.BackgroundProcessor_start(persister == null ? 0 : persister.ptr, event_handler == null ? 0 : event_handler.ptr, chain_monitor == null ? 0 : chain_monitor.ptr, channel_manager == null ? 0 : channel_manager.ptr, gossip_sync.ptr, peer_manager == null ? 0 : peer_manager.ptr, logger == null ? 0 : logger.ptr, scorer == null ? 0 : scorer.ptr);
+	public static BackgroundProcessor start(Persister persister, EventHandler event_handler, ChainMonitor chain_monitor, ChannelManager channel_manager, GossipSync gossip_sync, PeerManager peer_manager, Logger logger, Option_WriteableScoreZ scorer) {
+		long ret = bindings.BackgroundProcessor_start(persister == null ? 0 : persister.ptr, event_handler == null ? 0 : event_handler.ptr, chain_monitor == null ? 0 : chain_monitor.ptr, channel_manager == null ? 0 : channel_manager.ptr, gossip_sync.ptr, peer_manager == null ? 0 : peer_manager.ptr, logger == null ? 0 : logger.ptr, scorer.ptr);
 		Reference.reachabilityFence(persister);
 		Reference.reachabilityFence(event_handler);
 		Reference.reachabilityFence(chain_monitor);

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

@@ -33,8 +33,14 @@ static Balance constr_from_ptr(long ptr) {
 		if (raw_val.getClass() == bindings.LDKBalance.ContentiousClaimable.class) {
 			return new ContentiousClaimable(ptr, (bindings.LDKBalance.ContentiousClaimable)raw_val);
 		}
-		if (raw_val.getClass() == bindings.LDKBalance.MaybeClaimableHTLCAwaitingTimeout.class) {
-			return new MaybeClaimableHTLCAwaitingTimeout(ptr, (bindings.LDKBalance.MaybeClaimableHTLCAwaitingTimeout)raw_val);
+		if (raw_val.getClass() == bindings.LDKBalance.MaybeTimeoutClaimableHTLC.class) {
+			return new MaybeTimeoutClaimableHTLC(ptr, (bindings.LDKBalance.MaybeTimeoutClaimableHTLC)raw_val);
+		}
+		if (raw_val.getClass() == bindings.LDKBalance.MaybePreimageClaimableHTLC.class) {
+			return new MaybePreimageClaimableHTLC(ptr, (bindings.LDKBalance.MaybePreimageClaimableHTLC)raw_val);
+		}
+		if (raw_val.getClass() == bindings.LDKBalance.CounterpartyRevokedOutputClaimable.class) {
+			return new CounterpartyRevokedOutputClaimable(ptr, (bindings.LDKBalance.CounterpartyRevokedOutputClaimable)raw_val);
 		}
 		assert false; return null; // Unreachable without extending the (internal) bindings interface
 	}
@@ -107,23 +113,65 @@ private ContentiousClaimable(long ptr, bindings.LDKBalance.ContentiousClaimable
 	 * fees) if the counterparty does not know the preimage for the HTLCs. These are somewhat
 	 * likely to be claimed by our counterparty before we do.
 	 */
-	public final static class MaybeClaimableHTLCAwaitingTimeout extends Balance {
+	public final static class MaybeTimeoutClaimableHTLC extends Balance {
 		/**
-		 * The amount available to claim, in satoshis, excluding the on-chain fees which will be
-		 * required to do so.
+		 * The amount potentially available to claim, in satoshis, excluding the on-chain fees
+		 * which will be required to do so.
 		*/
 		public final long claimable_amount_satoshis;
 		/**
 		 * The height at which we will be able to claim the balance if our counterparty has not
 		 * done so.
 		*/
 		public final int claimable_height;
-		private MaybeClaimableHTLCAwaitingTimeout(long ptr, bindings.LDKBalance.MaybeClaimableHTLCAwaitingTimeout obj) {
+		private MaybeTimeoutClaimableHTLC(long ptr, bindings.LDKBalance.MaybeTimeoutClaimableHTLC obj) {
 			super(null, ptr);
 			this.claimable_amount_satoshis = obj.claimable_amount_satoshis;
 			this.claimable_height = obj.claimable_height;
 		}
 	}
+	/**
+	 * HTLCs which we received from our counterparty which are claimable with a preimage which we
+	 * do not currently have. This will only be claimable if we receive the preimage from the node
+	 * to which we forwarded this HTLC before the timeout.
+	 */
+	public final static class MaybePreimageClaimableHTLC extends Balance {
+		/**
+		 * The amount potentially available to claim, in satoshis, excluding the on-chain fees
+		 * which will be required to do so.
+		*/
+		public final long claimable_amount_satoshis;
+		/**
+		 * The height at which our counterparty will be able to claim the balance if we have not
+		 * yet received the preimage and claimed it ourselves.
+		*/
+		public final int expiry_height;
+		private MaybePreimageClaimableHTLC(long ptr, bindings.LDKBalance.MaybePreimageClaimableHTLC obj) {
+			super(null, ptr);
+			this.claimable_amount_satoshis = obj.claimable_amount_satoshis;
+			this.expiry_height = obj.expiry_height;
+		}
+	}
+	/**
+	 * The channel has been closed, and our counterparty broadcasted a revoked commitment
+	 * transaction.
+	 * 
+	 * Thus, we're able to claim all outputs in the commitment transaction, one of which has the
+	 * following amount.
+	 */
+	public final static class CounterpartyRevokedOutputClaimable extends Balance {
+		/**
+		 * The amount, in satoshis, of the output which we can claim.
+		 * 
+		 * Note that for outputs from HTLC balances this may be excluding some on-chain fees that
+		 * were already spent.
+		*/
+		public final long claimable_amount_satoshis;
+		private CounterpartyRevokedOutputClaimable(long ptr, bindings.LDKBalance.CounterpartyRevokedOutputClaimable obj) {
+			super(null, ptr);
+			this.claimable_amount_satoshis = obj.claimable_amount_satoshis;
+		}
+	}
 	long clone_ptr() {
 		long ret = bindings.Balance_clone_ptr(this.ptr);
 		Reference.reachabilityFence(this);
@@ -181,10 +229,10 @@ public static Balance contentious_claimable(long claimable_amount_satoshis, int
 	}
 
 	/**
-	 * Utility method to constructs a new MaybeClaimableHTLCAwaitingTimeout-variant Balance
+	 * Utility method to constructs a new MaybeTimeoutClaimableHTLC-variant Balance
 	 */
-	public static Balance maybe_claimable_htlcawaiting_timeout(long claimable_amount_satoshis, int claimable_height) {
-		long ret = bindings.Balance_maybe_claimable_htlcawaiting_timeout(claimable_amount_satoshis, claimable_height);
+	public static Balance maybe_timeout_claimable_htlc(long claimable_amount_satoshis, int claimable_height) {
+		long ret = bindings.Balance_maybe_timeout_claimable_htlc(claimable_amount_satoshis, claimable_height);
 		Reference.reachabilityFence(claimable_amount_satoshis);
 		Reference.reachabilityFence(claimable_height);
 		if (ret >= 0 && ret <= 4096) { return null; }
@@ -193,6 +241,31 @@ public static Balance maybe_claimable_htlcawaiting_timeout(long claimable_amount
 		return ret_hu_conv;
 	}
 
+	/**
+	 * Utility method to constructs a new MaybePreimageClaimableHTLC-variant Balance
+	 */
+	public static Balance maybe_preimage_claimable_htlc(long claimable_amount_satoshis, int expiry_height) {
+		long ret = bindings.Balance_maybe_preimage_claimable_htlc(claimable_amount_satoshis, expiry_height);
+		Reference.reachabilityFence(claimable_amount_satoshis);
+		Reference.reachabilityFence(expiry_height);
+		if (ret >= 0 && ret <= 4096) { return null; }
+		org.ldk.structs.Balance ret_hu_conv = org.ldk.structs.Balance.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 CounterpartyRevokedOutputClaimable-variant Balance
+	 */
+	public static Balance counterparty_revoked_output_claimable(long claimable_amount_satoshis) {
+		long ret = bindings.Balance_counterparty_revoked_output_claimable(claimable_amount_satoshis);
+		Reference.reachabilityFence(claimable_amount_satoshis);
+		if (ret >= 0 && ret <= 4096) { return null; }
+		org.ldk.structs.Balance ret_hu_conv = org.ldk.structs.Balance.constr_from_ptr(ret);
+		if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
+		return ret_hu_conv;
+	}
+
 	/**
 	 * Checks if two Balances contain equal inner contents.
 	 * This ignores pointers and is_owned flags and looks at the values in fields.

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

@@ -0,0 +1,28 @@
+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;
+
+public class BigEndianScalar extends CommonBase {
+	/** The bytes of the scalar value, in big endian */
+	public final byte[] scalar_bytes;
+
+	BigEndianScalar(java.lang.Object _dummy, long ptr) {
+		super(ptr);
+		this.scalar_bytes = bindings.BigEndianScalar_get_bytes(ptr);
+	}
+	public BigEndianScalar(byte[] scalar_bytes) {
+		super(bindings.BigEndianScalar_new(scalar_bytes));
+		this.scalar_bytes = bindings.BigEndianScalar_get_bytes(ptr);
+	}
+
+	@Override @SuppressWarnings("deprecation")
+	protected void finalize() throws Throwable {
+		super.finalize();
+		if (ptr != 0) { bindings.BigEndianScalar_free(ptr); }
+	}
+}

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

@@ -0,0 +1,44 @@
+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;
+
+
+/**
+ * Used to construct the blinded hops portion of a blinded route. These hops cannot be identified
+ * by outside observers and thus can be used to hide the identity of the recipient.
+ */
+@SuppressWarnings("unchecked") // We correctly assign various generic arrays
+public class BlindedHop extends CommonBase {
+	BlindedHop(Object _dummy, long ptr) { super(ptr); }
+	@Override @SuppressWarnings("deprecation")
+	protected void finalize() throws Throwable {
+		super.finalize();
+		if (ptr != 0) { bindings.BlindedHop_free(ptr); }
+	}
+
+	/**
+	 * Serialize the BlindedHop object into a byte array which can be read by BlindedHop_read
+	 */
+	public byte[] write() {
+		byte[] ret = bindings.BlindedHop_write(this.ptr);
+		Reference.reachabilityFence(this);
+		return ret;
+	}
+
+	/**
+	 * Read a BlindedHop from a byte array, created by BlindedHop_write
+	 */
+	public static Result_BlindedHopDecodeErrorZ read(byte[] ser) {
+		long ret = bindings.BlindedHop_read(ser);
+		Reference.reachabilityFence(ser);
+		if (ret >= 0 && ret <= 4096) { return null; }
+		Result_BlindedHopDecodeErrorZ ret_hu_conv = Result_BlindedHopDecodeErrorZ.constr_from_ptr(ret);
+		return ret_hu_conv;
+	}
+
+}

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

@@ -0,0 +1,60 @@
+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;
+
+
+/**
+ * Onion messages can be sent and received to blinded routes, which serve to hide the identity of
+ * the recipient.
+ */
+@SuppressWarnings("unchecked") // We correctly assign various generic arrays
+public class BlindedRoute extends CommonBase {
+	BlindedRoute(Object _dummy, long ptr) { super(ptr); }
+	@Override @SuppressWarnings("deprecation")
+	protected void finalize() throws Throwable {
+		super.finalize();
+		if (ptr != 0) { bindings.BlindedRoute_free(ptr); }
+	}
+
+	/**
+	 * Create a blinded route 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_BlindedRouteNoneZ of(byte[][] node_pks, KeysInterface keys_manager) {
+		long ret = bindings.BlindedRoute_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, keys_manager == null ? 0 : keys_manager.ptr);
+		Reference.reachabilityFence(node_pks);
+		Reference.reachabilityFence(keys_manager);
+		if (ret >= 0 && ret <= 4096) { return null; }
+		Result_BlindedRouteNoneZ ret_hu_conv = Result_BlindedRouteNoneZ.constr_from_ptr(ret);
+		if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(keys_manager); };
+		return ret_hu_conv;
+	}
+
+	/**
+	 * Serialize the BlindedRoute object into a byte array which can be read by BlindedRoute_read
+	 */
+	public byte[] write() {
+		byte[] ret = bindings.BlindedRoute_write(this.ptr);
+		Reference.reachabilityFence(this);
+		return ret;
+	}
+
+	/**
+	 * Read a BlindedRoute from a byte array, created by BlindedRoute_write
+	 */
+	public static Result_BlindedRouteDecodeErrorZ read(byte[] ser) {
+		long ret = bindings.BlindedRoute_read(ser);
+		Reference.reachabilityFence(ser);
+		if (ret >= 0 && ret <= 4096) { return null; }
+		Result_BlindedRouteDecodeErrorZ ret_hu_conv = Result_BlindedRouteDecodeErrorZ.constr_from_ptr(ret);
+		return ret_hu_conv;
+	}
+
+}

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

@@ -336,18 +336,79 @@ public void set_commit_upfront_shutdown_pubkey(boolean val) {
 		Reference.reachabilityFence(val);
 	}
 
+	/**
+	 * The Proportion of the channel value to configure as counterparty's channel reserve,
+	 * i.e., `their_channel_reserve_satoshis` for both outbound and inbound channels.
+	 * 
+	 * `their_channel_reserve_satoshis` is the minimum balance that the other node has to maintain
+	 * on their side, at all times.
+	 * This ensures that if our counterparty broadcasts a revoked state, we can punish them by
+	 * claiming at least this value on chain.
+	 * 
+	 * Channel reserve values greater than 30% could be considered highly unreasonable, since that
+	 * amount can never be used for payments.
+	 * Also, if our selected channel reserve for counterparty and counterparty's selected
+	 * channel reserve for us sum up to equal or greater than channel value, channel negotiations
+	 * will fail.
+	 * 
+	 * Note: Versions of LDK earlier than v0.0.104 will fail to read channels with any channel reserve
+	 * other than the default value.
+	 * 
+	 * Default value: 1% of channel value, i.e., configured as 10,000 millionths.
+	 * Minimum value: If the calculated proportional value is less than 1000 sats, it will be treated
+	 * as 1000 sats instead, which is a safe implementation-specific lower bound.
+	 * Maximum value: 1,000,000, any values larger than 1 Million will be treated as 1 Million (or 100%)
+	 * instead, although channel negotiations will fail in that case.
+	 */
+	public int get_their_channel_reserve_proportional_millionths() {
+		int ret = bindings.ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(this.ptr);
+		Reference.reachabilityFence(this);
+		return ret;
+	}
+
+	/**
+	 * The Proportion of the channel value to configure as counterparty's channel reserve,
+	 * i.e., `their_channel_reserve_satoshis` for both outbound and inbound channels.
+	 * 
+	 * `their_channel_reserve_satoshis` is the minimum balance that the other node has to maintain
+	 * on their side, at all times.
+	 * This ensures that if our counterparty broadcasts a revoked state, we can punish them by
+	 * claiming at least this value on chain.
+	 * 
+	 * Channel reserve values greater than 30% could be considered highly unreasonable, since that
+	 * amount can never be used for payments.
+	 * Also, if our selected channel reserve for counterparty and counterparty's selected
+	 * channel reserve for us sum up to equal or greater than channel value, channel negotiations
+	 * will fail.
+	 * 
+	 * Note: Versions of LDK earlier than v0.0.104 will fail to read channels with any channel reserve
+	 * other than the default value.
+	 * 
+	 * Default value: 1% of channel value, i.e., configured as 10,000 millionths.
+	 * Minimum value: If the calculated proportional value is less than 1000 sats, it will be treated
+	 * as 1000 sats instead, which is a safe implementation-specific lower bound.
+	 * Maximum value: 1,000,000, any values larger than 1 Million will be treated as 1 Million (or 100%)
+	 * instead, although channel negotiations will fail in that case.
+	 */
+	public void set_their_channel_reserve_proportional_millionths(int val) {
+		bindings.ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(this.ptr, val);
+		Reference.reachabilityFence(this);
+		Reference.reachabilityFence(val);
+	}
+
 	/**
 	 * Constructs a new ChannelHandshakeConfig given each field
 	 */
-	public static ChannelHandshakeConfig of(int minimum_depth_arg, short our_to_self_delay_arg, long our_htlc_minimum_msat_arg, byte max_inbound_htlc_value_in_flight_percent_of_channel_arg, boolean negotiate_scid_privacy_arg, boolean announced_channel_arg, boolean commit_upfront_shutdown_pubkey_arg) {
-		long ret = bindings.ChannelHandshakeConfig_new(minimum_depth_arg, our_to_self_delay_arg, our_htlc_minimum_msat_arg, max_inbound_htlc_value_in_flight_percent_of_channel_arg, negotiate_scid_privacy_arg, announced_channel_arg, commit_upfront_shutdown_pubkey_arg);
+	public static ChannelHandshakeConfig of(int minimum_depth_arg, short our_to_self_delay_arg, long our_htlc_minimum_msat_arg, byte max_inbound_htlc_value_in_flight_percent_of_channel_arg, boolean negotiate_scid_privacy_arg, boolean announced_channel_arg, boolean commit_upfront_shutdown_pubkey_arg, int their_channel_reserve_proportional_millionths_arg) {
+		long ret = bindings.ChannelHandshakeConfig_new(minimum_depth_arg, our_to_self_delay_arg, our_htlc_minimum_msat_arg, max_inbound_htlc_value_in_flight_percent_of_channel_arg, negotiate_scid_privacy_arg, announced_channel_arg, commit_upfront_shutdown_pubkey_arg, their_channel_reserve_proportional_millionths_arg);
 		Reference.reachabilityFence(minimum_depth_arg);
 		Reference.reachabilityFence(our_to_self_delay_arg);
 		Reference.reachabilityFence(our_htlc_minimum_msat_arg);
 		Reference.reachabilityFence(max_inbound_htlc_value_in_flight_percent_of_channel_arg);
 		Reference.reachabilityFence(negotiate_scid_privacy_arg);
 		Reference.reachabilityFence(announced_channel_arg);
 		Reference.reachabilityFence(commit_upfront_shutdown_pubkey_arg);
+		Reference.reachabilityFence(their_channel_reserve_proportional_millionths_arg);
 		if (ret >= 0 && ret <= 4096) { return null; }
 		org.ldk.structs.ChannelHandshakeConfig ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.ChannelHandshakeConfig(null, ret); }
 		if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };