Update auto-generated bindings

Author: TheBlueMatt

liblightningjni_debug.so

@@ -2,8 +2,6 @@
 
 /**
  * An error when accessing the chain via [`Access`].
- * 
- * [`Access`]: trait.Access.html
  */
 public enum LDKAccessError {
 	LDKAccessError_UnknownChain,

liblightningjni_release.so

@@ -202,6 +202,11 @@ public final static class SendShortIdsQuery extends LDKMessageSendEvent {
 			public long msg;
 			SendShortIdsQuery(byte[] node_id, long msg) { this.node_id = node_id; this.msg = msg; }
 		}
+		public final static class SendReplyChannelRange extends LDKMessageSendEvent {
+			public byte[] node_id;
+			public long msg;
+			SendReplyChannelRange(byte[] node_id, long msg) { this.node_id = node_id; this.msg = msg; }
+		}
 		static native void init();
 	}
 	static { LDKMessageSendEvent.init(); }
@@ -758,6 +763,7 @@ public interface LDKChannelMessageHandler {
 		 void peer_disconnected(byte[] their_node_id, boolean no_connection_possible);
 		 void peer_connected(byte[] their_node_id, long msg);
 		 void handle_channel_reestablish(byte[] their_node_id, long msg);
+		 void handle_channel_update(byte[] their_node_id, long msg);
 		 void handle_error(byte[] their_node_id, long msg);
 	}
 	public static native long LDKChannelMessageHandler_new(LDKChannelMessageHandler impl, LDKMessageSendEventsProvider MessageSendEventsProvider);
@@ -797,6 +803,8 @@ public interface LDKChannelMessageHandler {
 	public static native void ChannelMessageHandler_peer_connected(long this_arg, byte[] their_node_id, long msg);
 	// void ChannelMessageHandler_handle_channel_reestablish LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg
 	public static native void ChannelMessageHandler_handle_channel_reestablish(long this_arg, byte[] their_node_id, long msg);
+	// void ChannelMessageHandler_handle_channel_update LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg
+	public static native void ChannelMessageHandler_handle_channel_update(long this_arg, byte[] their_node_id, long msg);
 	// void ChannelMessageHandler_handle_error LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg
 	public static native void ChannelMessageHandler_handle_error(long this_arg, byte[] their_node_id, long msg);
 	public interface LDKRoutingMessageHandler {
@@ -1688,6 +1696,10 @@ public interface LDKSocketDescriptor {
 	public static native int ChannelConfig_get_fee_proportional_millionths(long this_ptr);
 	// void ChannelConfig_set_fee_proportional_millionths(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
 	public static native void ChannelConfig_set_fee_proportional_millionths(long this_ptr, int val);
+	// uint16_t ChannelConfig_get_cltv_expiry_delta(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
+	public static native short ChannelConfig_get_cltv_expiry_delta(long this_ptr);
+	// void ChannelConfig_set_cltv_expiry_delta(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint16_t val);
+	public static native void ChannelConfig_set_cltv_expiry_delta(long this_ptr, short val);
 	// bool ChannelConfig_get_announced_channel(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
 	public static native boolean ChannelConfig_get_announced_channel(long this_ptr);
 	// void ChannelConfig_set_announced_channel(struct LDKChannelConfig *NONNULL_PTR this_ptr, bool val);
@@ -1696,8 +1708,8 @@ public interface LDKSocketDescriptor {
 	public static native boolean ChannelConfig_get_commit_upfront_shutdown_pubkey(long this_ptr);
 	// void ChannelConfig_set_commit_upfront_shutdown_pubkey(struct LDKChannelConfig *NONNULL_PTR this_ptr, bool val);
 	public static native void ChannelConfig_set_commit_upfront_shutdown_pubkey(long this_ptr, boolean val);
-	// MUST_USE_RES struct LDKChannelConfig ChannelConfig_new(uint32_t fee_proportional_millionths_arg, bool announced_channel_arg, bool commit_upfront_shutdown_pubkey_arg);
-	public static native long ChannelConfig_new(int fee_proportional_millionths_arg, boolean announced_channel_arg, boolean commit_upfront_shutdown_pubkey_arg);
+	// MUST_USE_RES struct LDKChannelConfig ChannelConfig_new(uint32_t fee_proportional_millionths_arg, uint16_t cltv_expiry_delta_arg, bool announced_channel_arg, bool commit_upfront_shutdown_pubkey_arg);
+	public static native long ChannelConfig_new(int fee_proportional_millionths_arg, short cltv_expiry_delta_arg, boolean announced_channel_arg, boolean commit_upfront_shutdown_pubkey_arg);
 	// struct LDKChannelConfig ChannelConfig_clone(const struct LDKChannelConfig *NONNULL_PTR orig);
 	public static native long ChannelConfig_clone(long orig);
 	// MUST_USE_RES struct LDKChannelConfig ChannelConfig_default(void);
@@ -2940,6 +2952,8 @@ public interface LDKSocketDescriptor {
 	public static native long ReplyShortChannelIdsEnd_read(byte[] ser);
 	// struct LDKCVec_u8Z ReplyShortChannelIdsEnd_write(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR obj);
 	public static native byte[] ReplyShortChannelIdsEnd_write(long obj);
+	// MUST_USE_RES uint32_t QueryChannelRange_end_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_arg);
+	public static native int QueryChannelRange_end_blocknum(long this_arg);
 	// struct LDKCResult_QueryChannelRangeDecodeErrorZ QueryChannelRange_read(struct LDKu8slice ser);
 	public static native long QueryChannelRange_read(byte[] ser);
 	// struct LDKCVec_u8Z QueryChannelRange_write(const struct LDKQueryChannelRange *NONNULL_PTR obj);

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

@@ -14,9 +14,8 @@
  * or used independently to monitor channels remotely. See the [module-level documentation] for
  * details.
  * 
- * [`chain::Watch`]: ../trait.Watch.html
- * [`ChannelManager`]: ../../ln/channelmanager/struct.ChannelManager.html
- * [module-level documentation]: index.html
+ * [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
+ * [module-level documentation]: crate::chain::chainmonitor
  */
 @SuppressWarnings("unchecked") // We correctly assign various generic arrays
 public class ChainMonitor extends CommonBase {
@@ -37,10 +36,6 @@ protected void finalize() throws Throwable {
 	 * calls must not exclude any transactions matching the new outputs nor any in-block
 	 * descendants of such transactions. It is not necessary to re-fetch the block to obtain
 	 * updated `txdata`.
-	 * 
-	 * [`ChannelMonitor::block_connected`]: ../channelmonitor/struct.ChannelMonitor.html#method.block_connected
-	 * [`chain::Watch::release_pending_monitor_events`]: ../trait.Watch.html#tymethod.release_pending_monitor_events
-	 * [`chain::Filter`]: ../trait.Filter.html
 	 */
 	public void block_connected(byte[] header, TwoTuple<Long, byte[]>[] txdata, int height) {
 		bindings.ChainMonitor_block_connected(this.ptr, header, Arrays.stream(txdata).mapToLong(txdata_conv_24 -> bindings.C2Tuple_usizeTransactionZ_new(txdata_conv_24.a, txdata_conv_24.b)).toArray(), height);
@@ -51,8 +46,6 @@ public void block_connected(byte[] header, TwoTuple<Long, byte[]>[] txdata, int
 	 * Dispatches to per-channel monitors, which are responsible for updating their on-chain view
 	 * of a channel based on the disconnected block. See [`ChannelMonitor::block_disconnected`] for
 	 * details.
-	 * 
-	 * [`ChannelMonitor::block_disconnected`]: ../channelmonitor/struct.ChannelMonitor.html#method.block_disconnected
 	 */
 	public void block_disconnected(byte[] header, int disconnected_height) {
 		bindings.ChainMonitor_block_disconnected(this.ptr, header, disconnected_height);
@@ -66,8 +59,6 @@ public void block_disconnected(byte[] header, int disconnected_height) {
 	 * pre-filter blocks or only fetch blocks matching a compact filter. Otherwise, clients may
 	 * always need to fetch full blocks absent another means for determining which blocks contain
 	 * transactions relevant to the watched channels.
-	 * 
-	 * [`chain::Filter`]: ../trait.Filter.html
 	 */
 	public static ChainMonitor constructor_new(Filter chain_source, BroadcasterInterface broadcaster, Logger logger, FeeEstimator feeest, Persist persister) {
 		long ret = bindings.ChainMonitor_new(chain_source == null ? 0 : chain_source.ptr, broadcaster == null ? 0 : broadcaster.ptr, logger == null ? 0 : logger.ptr, feeest == null ? 0 : feeest.ptr, persister == null ? 0 : persister.ptr);

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

@@ -42,6 +42,57 @@ public void set_fee_proportional_millionths(int val) {
 		bindings.ChannelConfig_set_fee_proportional_millionths(this.ptr, val);
 	}
 
+	/**
+	 * The difference in the CLTV value between incoming HTLCs and an outbound HTLC forwarded over
+	 * the channel this config applies to.
+	 * 
+	 * This is analogous to [`ChannelHandshakeConfig::our_to_self_delay`] but applies to in-flight
+	 * HTLC balance when a channel appears on-chain whereas
+	 * [`ChannelHandshakeConfig::our_to_self_delay`] applies to the remaining
+	 * (non-HTLC-encumbered) balance.
+	 * 
+	 * Thus, for HTLC-encumbered balances to be enforced on-chain when a channel is force-closed,
+	 * we (or one of our watchtowers) MUST be online to check for broadcast of the current
+	 * commitment transaction at least once per this many blocks (minus some margin to allow us
+	 * enough time to broadcast and confirm a transaction, possibly with time in between to RBF
+	 * the spending transaction).
+	 * 
+	 * Default value: 72 (12 hours at an average of 6 blocks/hour).
+	 * Minimum value: [`MIN_CLTV_EXPIRY_DELTA`], any values less than this will be treated as
+	 * [`MIN_CLTV_EXPIRY_DELTA`] instead.
+	 * 
+	 * [`MIN_CLTV_EXPIRY_DELTA`]: crate::ln::channelmanager::MIN_CLTV_EXPIRY_DELTA
+	 */
+	public short get_cltv_expiry_delta() {
+		short ret = bindings.ChannelConfig_get_cltv_expiry_delta(this.ptr);
+		return ret;
+	}
+
+	/**
+	 * The difference in the CLTV value between incoming HTLCs and an outbound HTLC forwarded over
+	 * the channel this config applies to.
+	 * 
+	 * This is analogous to [`ChannelHandshakeConfig::our_to_self_delay`] but applies to in-flight
+	 * HTLC balance when a channel appears on-chain whereas
+	 * [`ChannelHandshakeConfig::our_to_self_delay`] applies to the remaining
+	 * (non-HTLC-encumbered) balance.
+	 * 
+	 * Thus, for HTLC-encumbered balances to be enforced on-chain when a channel is force-closed,
+	 * we (or one of our watchtowers) MUST be online to check for broadcast of the current
+	 * commitment transaction at least once per this many blocks (minus some margin to allow us
+	 * enough time to broadcast and confirm a transaction, possibly with time in between to RBF
+	 * the spending transaction).
+	 * 
+	 * Default value: 72 (12 hours at an average of 6 blocks/hour).
+	 * Minimum value: [`MIN_CLTV_EXPIRY_DELTA`], any values less than this will be treated as
+	 * [`MIN_CLTV_EXPIRY_DELTA`] instead.
+	 * 
+	 * [`MIN_CLTV_EXPIRY_DELTA`]: crate::ln::channelmanager::MIN_CLTV_EXPIRY_DELTA
+	 */
+	public void set_cltv_expiry_delta(short val) {
+		bindings.ChannelConfig_set_cltv_expiry_delta(this.ptr, val);
+	}
+
 	/**
 	 * Set to announce the channel publicly and notify all nodes that they can route via this
 	 * channel.
@@ -115,8 +166,8 @@ public void set_commit_upfront_shutdown_pubkey(boolean val) {
 	/**
 	 * Constructs a new ChannelConfig given each field
 	 */
-	public static ChannelConfig constructor_new(int fee_proportional_millionths_arg, boolean announced_channel_arg, boolean commit_upfront_shutdown_pubkey_arg) {
-		long ret = bindings.ChannelConfig_new(fee_proportional_millionths_arg, announced_channel_arg, commit_upfront_shutdown_pubkey_arg);
+	public static ChannelConfig constructor_new(int fee_proportional_millionths_arg, short cltv_expiry_delta_arg, boolean announced_channel_arg, boolean commit_upfront_shutdown_pubkey_arg) {
+		long ret = bindings.ChannelConfig_new(fee_proportional_millionths_arg, cltv_expiry_delta_arg, announced_channel_arg, commit_upfront_shutdown_pubkey_arg);
 		ChannelConfig ret_hu_conv = new ChannelConfig(null, ret);
 		ret_hu_conv.ptrs_to.add(ret_hu_conv);
 		return ret_hu_conv;

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

@@ -39,9 +39,7 @@ public static ChannelFeatures constructor_empty() {
 	}
 
 	/**
-	 * Creates features known by the implementation as defined by [`T::KNOWN_FEATURE_FLAGS`].
-	 * 
-	 * [`T::KNOWN_FEATURE_FLAGS`]: sealed/trait.Context.html#associatedconstant.KNOWN_FEATURE_FLAGS
+	 * Creates a Features with the bits set which are known by the implementation
 	 */
 	public static ChannelFeatures constructor_known() {
 		long ret = bindings.ChannelFeatures_known();

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

@@ -44,37 +44,43 @@ public void set_minimum_depth(int val) {
 	}
 
 	/**
-	 * Set to the amount of time we require our counterparty to wait to claim their money.
+	 * Set to the number of blocks we require our counterparty to wait to claim their money (ie
+	 * the number of blocks we have to punish our counterparty if they broadcast a revoked
+	 * transaction).
 	 * 
-	 * It's one of the main parameter of our security model. We (or one of our watchtowers) MUST
-	 * be online to check for peer having broadcast a revoked transaction to steal our funds
-	 * at least once every our_to_self_delay blocks.
+	 * This is one of the main parameters of our security model. We (or one of our watchtowers) MUST
+	 * be online to check for revoked transactions on-chain at least once every our_to_self_delay
+	 * blocks (minus some margin to allow us enough time to broadcast and confirm a transaction,
+	 * possibly with time in between to RBF the spending transaction).
 	 * 
 	 * Meanwhile, asking for a too high delay, we bother peer to freeze funds for nothing in
 	 * case of an honest unilateral channel close, which implicitly decrease the economic value of
 	 * our channel.
 	 * 
-	 * Default value: BREAKDOWN_TIMEOUT (currently 144), we enforce it as a minimum at channel
-	 * opening so you can tweak config to ask for more security, not less.
+	 * Default value: [`BREAKDOWN_TIMEOUT`], we enforce it as a minimum at channel opening so you
+	 * can tweak config to ask for more security, not less.
 	 */
 	public short get_our_to_self_delay() {
 		short ret = bindings.ChannelHandshakeConfig_get_our_to_self_delay(this.ptr);
 		return ret;
 	}
 
 	/**
-	 * Set to the amount of time we require our counterparty to wait to claim their money.
+	 * Set to the number of blocks we require our counterparty to wait to claim their money (ie
+	 * the number of blocks we have to punish our counterparty if they broadcast a revoked
+	 * transaction).
 	 * 
-	 * It's one of the main parameter of our security model. We (or one of our watchtowers) MUST
-	 * be online to check for peer having broadcast a revoked transaction to steal our funds
-	 * at least once every our_to_self_delay blocks.
+	 * This is one of the main parameters of our security model. We (or one of our watchtowers) MUST
+	 * be online to check for revoked transactions on-chain at least once every our_to_self_delay
+	 * blocks (minus some margin to allow us enough time to broadcast and confirm a transaction,
+	 * possibly with time in between to RBF the spending transaction).
 	 * 
 	 * Meanwhile, asking for a too high delay, we bother peer to freeze funds for nothing in
 	 * case of an honest unilateral channel close, which implicitly decrease the economic value of
 	 * our channel.
 	 * 
-	 * Default value: BREAKDOWN_TIMEOUT (currently 144), we enforce it as a minimum at channel
-	 * opening so you can tweak config to ask for more security, not less.
+	 * Default value: [`BREAKDOWN_TIMEOUT`], we enforce it as a minimum at channel opening so you
+	 * can tweak config to ask for more security, not less.
 	 */
 	public void set_our_to_self_delay(short val) {
 		bindings.ChannelHandshakeConfig_set_our_to_self_delay(this.ptr, val);

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

@@ -102,6 +102,10 @@ public static interface ChannelMessageHandlerInterface {
 		 * Handle an incoming channel_reestablish message from the given peer.
 		 */
 		void handle_channel_reestablish(byte[] their_node_id, ChannelReestablish msg);
+		/**
+		 * Handle an incoming channel update from the given peer.
+		 */
+		void handle_channel_update(byte[] their_node_id, ChannelUpdate msg);
 		/**
 		 * Handle an incoming error message from the given peer.
 		 */
@@ -187,6 +191,10 @@ public static ChannelMessageHandler new_impl(ChannelMessageHandlerInterface arg,
 				ChannelReestablish msg_hu_conv = new ChannelReestablish(null, msg);
 				arg.handle_channel_reestablish(their_node_id, msg_hu_conv);
 			}
+			@Override public void handle_channel_update(byte[] their_node_id, long msg) {
+				ChannelUpdate msg_hu_conv = new ChannelUpdate(null, msg);
+				arg.handle_channel_update(their_node_id, msg_hu_conv);
+			}
 			@Override public void handle_error(byte[] their_node_id, long msg) {
 				ErrorMessage msg_hu_conv = new ErrorMessage(null, msg);
 				arg.handle_error(their_node_id, msg_hu_conv);
@@ -343,6 +351,14 @@ public void handle_channel_reestablish(byte[] their_node_id, ChannelReestablish
 		this.ptrs_to.add(msg);
 	}
 
+	/**
+	 * Handle an incoming channel update from the given peer.
+	 */
+	public void handle_channel_update(byte[] their_node_id, ChannelUpdate msg) {
+		bindings.ChannelMessageHandler_handle_channel_update(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+		this.ptrs_to.add(msg);
+	}
+
 	/**
 	 * Handle an incoming error message from the given peer.
 	 */

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

@@ -133,8 +133,6 @@ public void load_outputs_to_watch(Filter filter) {
 	/**
 	 * Get the list of HTLCs who's status has been updated on chain. This should be called by
 	 * ChannelManager via [`chain::Watch::release_pending_monitor_events`].
-	 * 
-	 * [`chain::Watch::release_pending_monitor_events`]: ../trait.Watch.html#tymethod.release_pending_monitor_events
 	 */
 	public MonitorEvent[] get_and_clear_pending_monitor_events() {
 		long[] ret = bindings.ChannelMonitor_get_and_clear_pending_monitor_events(this.ptr);