Merge pull request #110 from TheBlueMatt/main

Update to LDK 0.0.110

Author: TheBlueMatt

.github/workflows/build.yml

@@ -39,11 +39,11 @@ jobs:
           # Note this is a different endpoint, as we need one non-upstream commit!
           git clone https://git.bitcoin.ninja/rust-lightning
           cd rust-lightning
-          git checkout origin/2022-07-109-java-bindings
+          git checkout origin/2022-07-110-java-bindings
           cd ..
           git clone https://github.com/lightningdevkit/ldk-c-bindings
           cd ldk-c-bindings
-          git checkout 0.0.109
+          git checkout 0.0.110
       - name: Rebuild C bindings without STD
         run: |
           cd ldk-c-bindings
@@ -130,11 +130,11 @@ jobs:
           # Note this is a different endpoint, as we need one non-upstream commit!
           git clone https://git.bitcoin.ninja/rust-lightning
           cd rust-lightning
-          git checkout origin/2022-07-109-java-bindings
+          git checkout origin/2022-07-110-java-bindings
           cd ..
           git clone https://github.com/lightningdevkit/ldk-c-bindings
           cd ldk-c-bindings
-          git checkout 0.0.109
+          git checkout 0.0.110
       - name: Rebuild C bindings, and check the sample app builds + links
         run: |
           cd ldk-c-bindings
@@ -185,11 +185,11 @@ jobs:
           # Note this is a different endpoint, as we need one non-upstream commit!
           git clone https://git.bitcoin.ninja/rust-lightning
           cd rust-lightning
-          git checkout origin/2022-07-109-java-bindings
+          git checkout origin/2022-07-110-java-bindings
           cd ..
           git clone https://github.com/lightningdevkit/ldk-c-bindings
           cd ldk-c-bindings
-          git checkout 0.0.109
+          git checkout 0.0.110
       - name: Rebuild C bindings, and check the sample app builds + links
         run: |
           cd ldk-c-bindings
@@ -288,11 +288,11 @@ jobs:
           # Note this is a different endpoint, as we need one non-upstream commit!
           git clone https://git.bitcoin.ninja/rust-lightning
           cd rust-lightning
-          git checkout origin/2022-07-109-java-bindings
+          git checkout origin/2022-07-110-java-bindings
           cd ..
           git clone https://github.com/lightningdevkit/ldk-c-bindings
           cd ldk-c-bindings
-          git checkout 0.0.109
+          git checkout 0.0.110
       - name: Checkout Android AAR binaries and artifacts
         run: |
           # Gitweb only allows snapshots of folders by providing the object hash, which we have to extract:
@@ -368,11 +368,11 @@ jobs:
           # Note this is a different endpoint, as we need one non-upstream commit!
           git clone https://git.bitcoin.ninja/rust-lightning
           cd rust-lightning
-          git checkout origin/2022-07-109-java-bindings
+          git checkout origin/2022-07-110-java-bindings
           cd ..
           git clone https://github.com/lightningdevkit/ldk-c-bindings
           cd ldk-c-bindings
-          git checkout 0.0.109
+          git checkout 0.0.110
       - name: Rebuild C bindings with upstream clang, and check the sample app builds + links
         run: |
           export PATH=`pwd`/clang+llvm-14.0.5-x86_64-apple-darwin/bin:$PATH

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

@@ -426,6 +426,20 @@ public Result_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ send_spontaneous_
 		return ret_hu_conv;
 	}
 
+	/**
+	 * Send a payment that is probing the given route for liquidity. We calculate the
+	 * [`PaymentHash`] of probes based on a static secret and a random [`PaymentId`], which allows
+	 * us to easily discern them from real payments.
+	 */
+	public Result_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ send_probe(RouteHop[] hops) {
+		long ret = bindings.ChannelManager_send_probe(this.ptr, hops != null ? Arrays.stream(hops).mapToLong(hops_conv_10 -> hops_conv_10 == null ? 0 : hops_conv_10.ptr & ~1).toArray() : null);
+		Reference.reachabilityFence(this);
+		Reference.reachabilityFence(hops);
+		if (ret >= 0 && ret <= 4096) { return null; }
+		Result_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ ret_hu_conv = Result_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ.constr_from_ptr(ret);
+		return ret_hu_conv;
+	}
+
 	/**
 	 * Call this upon creation of a funding transaction for the given channel.
 	 * 
@@ -485,7 +499,7 @@ public Result_NoneAPIErrorZ funding_transaction_generated(byte[] temporary_chann
 	 * tying these addresses together and to this node. If you wish to preserve user privacy,
 	 * addresses should likely contain only Tor Onion addresses.
 	 * 
-	 * Panics if `addresses` is absurdly large (more than 500).
+	 * Panics if `addresses` is absurdly large (more than 100).
 	 * 
 	 * [`get_and_clear_pending_msg_events`]: MessageSendEventsProvider::get_and_clear_pending_msg_events
 	 */

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

@@ -176,6 +176,21 @@ public Event[] get_and_clear_pending_events() {
 		return ret_conv_7_arr;
 	}
 
+	/**
+	 * Gets the `node_id` of the counterparty for this channel.
+	 * 
+	 * Will be `None` for channels constructed on LDK versions prior to 0.0.110 and always `Some`
+	 * otherwise.
+	 * 
+	 * Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
+	 */
+	@Nullable
+	public byte[] get_counterparty_node_id() {
+		byte[] ret = bindings.ChannelMonitor_get_counterparty_node_id(this.ptr);
+		Reference.reachabilityFence(this);
+		return ret;
+	}
+
 	/**
 	 * Used by ChannelManager deserialization to broadcast the latest holder state if its copy of
 	 * the Channel was out-of-date. You may use it to get a broadcastable holder toxic tx in case of

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

@@ -97,20 +97,17 @@ public void set_htlc_minimum_msat(long val) {
 	/**
 	 * The maximum value which may be relayed to the next hop via the channel.
 	 */
-	public Option_u64Z get_htlc_maximum_msat() {
+	public long get_htlc_maximum_msat() {
 		long ret = bindings.ChannelUpdateInfo_get_htlc_maximum_msat(this.ptr);
 		Reference.reachabilityFence(this);
-		if (ret >= 0 && ret <= 4096) { return null; }
-		org.ldk.structs.Option_u64Z ret_hu_conv = org.ldk.structs.Option_u64Z.constr_from_ptr(ret);
-		ret_hu_conv.ptrs_to.add(this);
-		return ret_hu_conv;
+		return ret;
 	}
 
 	/**
 	 * The maximum value which may be relayed to the next hop via the channel.
 	 */
-	public void set_htlc_maximum_msat(Option_u64Z val) {
-		bindings.ChannelUpdateInfo_set_htlc_maximum_msat(this.ptr, val.ptr);
+	public void set_htlc_maximum_msat(long val) {
+		bindings.ChannelUpdateInfo_set_htlc_maximum_msat(this.ptr, val);
 		Reference.reachabilityFence(this);
 		Reference.reachabilityFence(val);
 	}
@@ -171,8 +168,8 @@ public void set_last_update_message(@Nullable ChannelUpdate val) {
 	/**
 	 * Constructs a new ChannelUpdateInfo given each field
 	 */
-	public static ChannelUpdateInfo of(int last_update_arg, boolean enabled_arg, short cltv_expiry_delta_arg, long htlc_minimum_msat_arg, Option_u64Z htlc_maximum_msat_arg, RoutingFees fees_arg, ChannelUpdate last_update_message_arg) {
-		long ret = bindings.ChannelUpdateInfo_new(last_update_arg, enabled_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg, htlc_maximum_msat_arg.ptr, fees_arg == null ? 0 : fees_arg.ptr & ~1, last_update_message_arg == null ? 0 : last_update_message_arg.ptr & ~1);
+	public static ChannelUpdateInfo of(int last_update_arg, boolean enabled_arg, short cltv_expiry_delta_arg, long htlc_minimum_msat_arg, long htlc_maximum_msat_arg, RoutingFees fees_arg, ChannelUpdate last_update_message_arg) {
+		long ret = bindings.ChannelUpdateInfo_new(last_update_arg, enabled_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg, htlc_maximum_msat_arg, fees_arg == null ? 0 : fees_arg.ptr & ~1, last_update_message_arg == null ? 0 : last_update_message_arg.ptr & ~1);
 		Reference.reachabilityFence(last_update_arg);
 		Reference.reachabilityFence(enabled_arg);
 		Reference.reachabilityFence(cltv_expiry_delta_arg);

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

@@ -46,6 +46,12 @@ static Event constr_from_ptr(long ptr) {
 		if (raw_val.getClass() == bindings.LDKEvent.PaymentPathFailed.class) {
 			return new PaymentPathFailed(ptr, (bindings.LDKEvent.PaymentPathFailed)raw_val);
 		}
+		if (raw_val.getClass() == bindings.LDKEvent.ProbeSuccessful.class) {
+			return new ProbeSuccessful(ptr, (bindings.LDKEvent.ProbeSuccessful)raw_val);
+		}
+		if (raw_val.getClass() == bindings.LDKEvent.ProbeFailed.class) {
+			return new ProbeFailed(ptr, (bindings.LDKEvent.ProbeFailed)raw_val);
+		}
 		if (raw_val.getClass() == bindings.LDKEvent.PendingHTLCsForwardable.class) {
 			return new PendingHTLCsForwardable(ptr, (bindings.LDKEvent.PendingHTLCsForwardable)raw_val);
 		}
@@ -64,6 +70,9 @@ static Event constr_from_ptr(long ptr) {
 		if (raw_val.getClass() == bindings.LDKEvent.OpenChannelRequest.class) {
 			return new OpenChannelRequest(ptr, (bindings.LDKEvent.OpenChannelRequest)raw_val);
 		}
+		if (raw_val.getClass() == bindings.LDKEvent.HTLCHandlingFailed.class) {
+			return new HTLCHandlingFailed(ptr, (bindings.LDKEvent.HTLCHandlingFailed)raw_val);
+		}
 		assert false; return null; // Unreachable without extending the (internal) bindings interface
 	}
 
@@ -449,6 +458,90 @@ private PaymentPathFailed(long ptr, bindings.LDKEvent.PaymentPathFailed obj) {
 			this.retry = retry_hu_conv;
 		}
 	}
+	/**
+	 * Indicates that a probe payment we sent returned successful, i.e., only failed at the destination.
+	 */
+	public final static class ProbeSuccessful extends Event {
+		/**
+		 * The id returned by [`ChannelManager::send_probe`].
+		 * 
+		 * [`ChannelManager::send_probe`]: crate::ln::channelmanager::ChannelManager::send_probe
+		*/
+		public final byte[] payment_id;
+		/**
+		 * The hash generated by [`ChannelManager::send_probe`].
+		 * 
+		 * [`ChannelManager::send_probe`]: crate::ln::channelmanager::ChannelManager::send_probe
+		*/
+		public final byte[] payment_hash;
+		/**
+		 * The payment path that was successful.
+		*/
+		public final RouteHop[] path;
+		private ProbeSuccessful(long ptr, bindings.LDKEvent.ProbeSuccessful obj) {
+			super(null, ptr);
+			this.payment_id = obj.payment_id;
+			this.payment_hash = obj.payment_hash;
+			long[] path = obj.path;
+			int path_conv_10_len = path.length;
+			RouteHop[] path_conv_10_arr = new RouteHop[path_conv_10_len];
+			for (int k = 0; k < path_conv_10_len; k++) {
+				long path_conv_10 = path[k];
+				org.ldk.structs.RouteHop path_conv_10_hu_conv = null; if (path_conv_10 < 0 || path_conv_10 > 4096) { path_conv_10_hu_conv = new org.ldk.structs.RouteHop(null, path_conv_10); }
+				path_conv_10_hu_conv.ptrs_to.add(this);
+				path_conv_10_arr[k] = path_conv_10_hu_conv;
+			}
+			this.path = path_conv_10_arr;
+		}
+	}
+	/**
+	 * Indicates that a probe payment we sent failed at an intermediary node on the path.
+	 */
+	public final static class ProbeFailed extends Event {
+		/**
+		 * The id returned by [`ChannelManager::send_probe`].
+		 * 
+		 * [`ChannelManager::send_probe`]: crate::ln::channelmanager::ChannelManager::send_probe
+		*/
+		public final byte[] payment_id;
+		/**
+		 * The hash generated by [`ChannelManager::send_probe`].
+		 * 
+		 * [`ChannelManager::send_probe`]: crate::ln::channelmanager::ChannelManager::send_probe
+		*/
+		public final byte[] payment_hash;
+		/**
+		 * The payment path that failed.
+		*/
+		public final RouteHop[] path;
+		/**
+		 * The channel responsible for the failed probe.
+		 * 
+		 * Note that for route hints or for the first hop in a path this may be an SCID alias and
+		 * may not refer to a channel in the public network graph. These aliases may also collide
+		 * with channels in the public network graph.
+		*/
+		public final org.ldk.structs.Option_u64Z short_channel_id;
+		private ProbeFailed(long ptr, bindings.LDKEvent.ProbeFailed obj) {
+			super(null, ptr);
+			this.payment_id = obj.payment_id;
+			this.payment_hash = obj.payment_hash;
+			long[] path = obj.path;
+			int path_conv_10_len = path.length;
+			RouteHop[] path_conv_10_arr = new RouteHop[path_conv_10_len];
+			for (int k = 0; k < path_conv_10_len; k++) {
+				long path_conv_10 = path[k];
+				org.ldk.structs.RouteHop path_conv_10_hu_conv = null; if (path_conv_10 < 0 || path_conv_10 > 4096) { path_conv_10_hu_conv = new org.ldk.structs.RouteHop(null, path_conv_10); }
+				path_conv_10_hu_conv.ptrs_to.add(this);
+				path_conv_10_arr[k] = path_conv_10_hu_conv;
+			}
+			this.path = path_conv_10_arr;
+			long short_channel_id = obj.short_channel_id;
+			org.ldk.structs.Option_u64Z short_channel_id_hu_conv = org.ldk.structs.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;
+		}
+	}
 	/**
 	 * Used to indicate that [`ChannelManager::process_pending_htlc_forwards`] should be called at
 	 * a time in the future.
@@ -675,6 +768,38 @@ private OpenChannelRequest(long ptr, bindings.LDKEvent.OpenChannelRequest obj) {
 			this.channel_type = channel_type_hu_conv;
 		}
 	}
+	/**
+	 * Indicates that the HTLC was accepted, but could not be processed when or after attempting to
+	 * forward it.
+	 * 
+	 * Some scenarios where this event may be sent include:
+	 * Insufficient capacity in the outbound channel
+	 * While waiting to forward the HTLC, the channel it is meant to be forwarded through closes
+	 * When an unknown SCID is requested for forwarding a payment.
+	 * Claiming an amount for an MPP payment that exceeds the HTLC total
+	 * The HTLC has timed out
+	 * 
+	 * This event, however, does not get generated if an HTLC fails to meet the forwarding
+	 * requirements (i.e. insufficient fees paid, or a CLTV that is too soon).
+	 */
+	public final static class HTLCHandlingFailed extends Event {
+		/**
+		 * The channel over which the HTLC was received.
+		*/
+		public final byte[] prev_channel_id;
+		/**
+		 * Destination of the HTLC that failed to be processed.
+		*/
+		public final org.ldk.structs.HTLCDestination failed_next_destination;
+		private HTLCHandlingFailed(long ptr, bindings.LDKEvent.HTLCHandlingFailed obj) {
+			super(null, ptr);
+			this.prev_channel_id = obj.prev_channel_id;
+			long failed_next_destination = obj.failed_next_destination;
+			org.ldk.structs.HTLCDestination failed_next_destination_hu_conv = org.ldk.structs.HTLCDestination.constr_from_ptr(failed_next_destination);
+			failed_next_destination_hu_conv.ptrs_to.add(this);
+			this.failed_next_destination = failed_next_destination_hu_conv;
+		}
+	}
 	long clone_ptr() {
 		long ret = bindings.Event_clone_ptr(this.ptr);
 		Reference.reachabilityFence(this);
@@ -798,6 +923,35 @@ public static Event payment_path_failed(byte[] payment_id, byte[] payment_hash,
 		return ret_hu_conv;
 	}
 
+	/**
+	 * Utility method to constructs a new ProbeSuccessful-variant Event
+	 */
+	public static Event probe_successful(byte[] payment_id, byte[] payment_hash, RouteHop[] path) {
+		long ret = bindings.Event_probe_successful(InternalUtils.check_arr_len(payment_id, 32), InternalUtils.check_arr_len(payment_hash, 32), path != null ? Arrays.stream(path).mapToLong(path_conv_10 -> path_conv_10 == null ? 0 : path_conv_10.ptr & ~1).toArray() : null);
+		Reference.reachabilityFence(payment_id);
+		Reference.reachabilityFence(payment_hash);
+		Reference.reachabilityFence(path);
+		if (ret >= 0 && ret <= 4096) { return null; }
+		org.ldk.structs.Event ret_hu_conv = org.ldk.structs.Event.constr_from_ptr(ret);
+		ret_hu_conv.ptrs_to.add(ret_hu_conv);
+		return ret_hu_conv;
+	}
+
+	/**
+	 * Utility method to constructs a new ProbeFailed-variant Event
+	 */
+	public static Event probe_failed(byte[] payment_id, byte[] payment_hash, RouteHop[] path, Option_u64Z short_channel_id) {
+		long ret = bindings.Event_probe_failed(InternalUtils.check_arr_len(payment_id, 32), InternalUtils.check_arr_len(payment_hash, 32), 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);
+		Reference.reachabilityFence(payment_id);
+		Reference.reachabilityFence(payment_hash);
+		Reference.reachabilityFence(path);
+		Reference.reachabilityFence(short_channel_id);
+		if (ret >= 0 && ret <= 4096) { return null; }
+		org.ldk.structs.Event ret_hu_conv = org.ldk.structs.Event.constr_from_ptr(ret);
+		ret_hu_conv.ptrs_to.add(ret_hu_conv);
+		return ret_hu_conv;
+	}
+
 	/**
 	 * Utility method to constructs a new PendingHTLCsForwardable-variant Event
 	 */
@@ -880,6 +1034,19 @@ public static Event open_channel_request(byte[] temporary_channel_id, byte[] cou
 		return ret_hu_conv;
 	}
 
+	/**
+	 * Utility method to constructs a new HTLCHandlingFailed-variant Event
+	 */
+	public static Event htlchandling_failed(byte[] prev_channel_id, HTLCDestination failed_next_destination) {
+		long ret = bindings.Event_htlchandling_failed(InternalUtils.check_arr_len(prev_channel_id, 32), failed_next_destination.ptr);
+		Reference.reachabilityFence(prev_channel_id);
+		Reference.reachabilityFence(failed_next_destination);
+		if (ret >= 0 && ret <= 4096) { return null; }
+		org.ldk.structs.Event ret_hu_conv = org.ldk.structs.Event.constr_from_ptr(ret);
+		ret_hu_conv.ptrs_to.add(ret_hu_conv);
+		return ret_hu_conv;
+	}
+
 	/**
 	 * Serialize the Event object into a byte array which can be read by Event_read
 	 */