Update auto-generated bindings to 0.0.101

Author: TheBlueMatt

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>org.lightningdevkit</groupId>
     <artifactId>ldk-java</artifactId>
-    <version>0.0.100.2</version>
+    <version>0.0.101.0</version>
 
     <name>LDK Java Bindings and Binaries</name>
     <description>LDK Java Bindings and Release Binaries</description>

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

@@ -9,10 +9,12 @@ public enum SemanticError {
 	LDKSemanticError_MultiplePaymentHashes,
 	LDKSemanticError_NoDescription,
 	LDKSemanticError_MultipleDescriptions,
+	LDKSemanticError_NoPaymentSecret,
 	LDKSemanticError_MultiplePaymentSecrets,
 	LDKSemanticError_InvalidFeatures,
 	LDKSemanticError_InvalidRecoveryId,
 	LDKSemanticError_InvalidSignature,
+	LDKSemanticError_ImpreciseAmount,
 	; static native void init();
 	static { init(); }
 }

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

@@ -8,20 +8,28 @@
 
 
 /**
- * BackgroundProcessor takes care of tasks that (1) need to happen periodically to keep
+ * `BackgroundProcessor` takes care of tasks that (1) need to happen periodically to keep
  * Rust-Lightning running properly, and (2) either can or should be run in the background. Its
  * responsibilities are:
- * Monitoring whether the ChannelManager needs to be re-persisted to disk, and if so,
+ * Processing [`Event`]s with a user-provided [`EventHandler`].
+ * 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()` every minute (can be done in the
- * background).
+ * [`ChannelManager`] persistence should be done in the background.
+ * Calling [`ChannelManager::timer_tick_occurred`] and [`PeerManager::timer_tick_occurred`]
+ * at the appropriate intervals.
  * 
- * Note that if ChannelManager persistence fails and the persisted manager becomes out-of-date,
- * then there is a risk of channels force-closing on startup when the manager realizes it's
- * outdated. However, as long as `ChannelMonitor` backups are sound, no funds besides those used
- * for unilateral chain closure fees are at risk.
+ * It will also call [`PeerManager::process_events`] periodically though this shouldn't be relied
+ * upon as doing so may result in high latency.
+ * 
+ * # Note
+ * 
+ * If [`ChannelManager`] persistence fails and the persisted manager becomes out-of-date, then
+ * there is a risk of channels force-closing on startup when the manager realizes it's outdated.
+ * However, as long as [`ChannelMonitor`] backups are sound, no funds besides those used for
+ * unilateral chain closure fees are at risk.
+ * 
+ * [`ChannelMonitor`]: lightning::chain::channelmonitor::ChannelMonitor
+ * [`Event`]: lightning::util::events::Event
  * BackgroundProcessor will immediately stop on drop. It should be stored until shutdown.
  */
 @SuppressWarnings("unchecked") // We correctly assign various generic arrays
@@ -41,31 +49,44 @@ protected void finalize() throws Throwable {
 	 * `persist_manager` returns an error. In case of an error, the error is retrieved by calling
 	 * either [`join`] or [`stop`].
 	 * 
-	 * Typically, users should either implement [`ChannelManagerPersister`] to never return an
-	 * error or call [`join`] and handle any error that may arise. For the latter case, the
-	 * `BackgroundProcessor` must be restarted by calling `start` again after handling the error.
+	 * # Data Persistence
 	 * 
 	 * `persist_manager` is responsible for writing out the [`ChannelManager`] to disk, and/or
 	 * uploading to one or more backup services. See [`ChannelManager::write`] for writing out a
 	 * [`ChannelManager`]. See [`FilesystemPersister::persist_manager`] for Rust-Lightning's
 	 * provided implementation.
 	 * 
+	 * Typically, users should either implement [`ChannelManagerPersister`] to never return an
+	 * error or call [`join`] and handle any error that may arise. For the latter case,
+	 * `BackgroundProcessor` must be restarted by calling `start` again after handling the error.
+	 * 
+	 * # Event Handling
+	 * 
+	 * `event_handler` is responsible for handling events that users should be notified of (e.g.,
+	 * payment failed). [`BackgroundProcessor`] may decorate the given [`EventHandler`] with common
+	 * functionality implemented by other handlers.
+	 * [`NetGraphMsgHandler`] if given will update the [`NetworkGraph`] based on payment failures.
+	 * 
 	 * [top-level documentation]: Self
 	 * [`join`]: Self::join
 	 * [`stop`]: Self::stop
 	 * [`ChannelManager`]: lightning::ln::channelmanager::ChannelManager
 	 * [`ChannelManager::write`]: lightning::ln::channelmanager::ChannelManager#impl-Writeable
 	 * [`FilesystemPersister::persist_manager`]: lightning_persister::FilesystemPersister::persist_manager
+	 * [`NetworkGraph`]: lightning::routing::network_graph::NetworkGraph
+	 * 
+	 * Note that net_graph_msg_handler (or a relevant inner pointer) may be NULL or all-0s to represent None
 	 */
-	public static BackgroundProcessor start(ChannelManagerPersister persister, EventHandler event_handler, ChainMonitor chain_monitor, ChannelManager channel_manager, PeerManager peer_manager, Logger logger) {
-		long ret = bindings.BackgroundProcessor_start(persister == null ? 0 : persister.ptr, event_handler == null ? 0 : event_handler.ptr, chain_monitor == null ? 0 : chain_monitor.ptr & ~1, channel_manager == null ? 0 : channel_manager.ptr & ~1, peer_manager == null ? 0 : peer_manager.ptr & ~1, logger == null ? 0 : logger.ptr);
+	public static BackgroundProcessor start(ChannelManagerPersister persister, EventHandler event_handler, ChainMonitor chain_monitor, ChannelManager channel_manager, NetGraphMsgHandler net_graph_msg_handler, PeerManager peer_manager, Logger logger) {
+		long ret = bindings.BackgroundProcessor_start(persister == null ? 0 : persister.ptr, event_handler == null ? 0 : event_handler.ptr, chain_monitor == null ? 0 : chain_monitor.ptr & ~1, channel_manager == null ? 0 : channel_manager.ptr & ~1, net_graph_msg_handler == null ? 0 : net_graph_msg_handler.ptr & ~1, peer_manager == null ? 0 : peer_manager.ptr & ~1, logger == null ? 0 : logger.ptr);
 		if (ret < 1024) { return null; }
 		BackgroundProcessor ret_hu_conv = new BackgroundProcessor(null, ret);
 		ret_hu_conv.ptrs_to.add(ret_hu_conv);
 		ret_hu_conv.ptrs_to.add(persister);
 		ret_hu_conv.ptrs_to.add(event_handler);
 		ret_hu_conv.ptrs_to.add(chain_monitor);
 		ret_hu_conv.ptrs_to.add(channel_manager);
+		ret_hu_conv.ptrs_to.add(net_graph_msg_handler);
 		ret_hu_conv.ptrs_to.add(peer_manager);
 		ret_hu_conv.ptrs_to.add(logger);
 		return ret_hu_conv;

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

@@ -0,0 +1,168 @@
+package org.ldk.structs;
+
+import org.ldk.impl.bindings;
+import org.ldk.enums.*;
+import org.ldk.util.*;
+import java.util.Arrays;
+import javax.annotation.Nullable;
+
+
+/**
+ * Details about the balance(s) available for spending once the channel appears on chain.
+ * 
+ * See [`ChannelMonitor::get_claimable_balances`] for more details on when these will or will not
+ * be provided.
+ */
+@SuppressWarnings("unchecked") // We correctly assign various generic arrays
+public class Balance extends CommonBase {
+	private Balance(Object _dummy, long ptr) { super(ptr); }
+	@Override @SuppressWarnings("deprecation")
+	protected void finalize() throws Throwable {
+		super.finalize();
+		if (ptr != 0) { bindings.Balance_free(ptr); }
+	}
+	static Balance constr_from_ptr(long ptr) {
+		bindings.LDKBalance raw_val = bindings.LDKBalance_ref_from_ptr(ptr);
+		if (raw_val.getClass() == bindings.LDKBalance.ClaimableOnChannelClose.class) {
+			return new ClaimableOnChannelClose(ptr, (bindings.LDKBalance.ClaimableOnChannelClose)raw_val);
+		}
+		if (raw_val.getClass() == bindings.LDKBalance.ClaimableAwaitingConfirmations.class) {
+			return new ClaimableAwaitingConfirmations(ptr, (bindings.LDKBalance.ClaimableAwaitingConfirmations)raw_val);
+		}
+		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);
+		}
+		assert false; return null; // Unreachable without extending the (internal) bindings interface
+	}
+
+	public final static class ClaimableOnChannelClose extends Balance {
+		/**
+		 * The amount available to claim, in satoshis, excluding the on-chain fees which will be
+		 * required to do so.
+		*/
+		public final long claimable_amount_satoshis;
+		private ClaimableOnChannelClose(long ptr, bindings.LDKBalance.ClaimableOnChannelClose obj) {
+			super(null, ptr);
+			this.claimable_amount_satoshis = obj.claimable_amount_satoshis;
+		}
+	}
+	public final static class ClaimableAwaitingConfirmations extends Balance {
+		/**
+		 * The amount available to claim, in satoshis, possibly excluding the on-chain fees which
+		 * were spent in broadcasting the transaction.
+		*/
+		public final long claimable_amount_satoshis;
+		/**
+		 * The height at which an [`Event::SpendableOutputs`] event will be generated for this
+		 * amount.
+		*/
+		public final int confirmation_height;
+		private ClaimableAwaitingConfirmations(long ptr, bindings.LDKBalance.ClaimableAwaitingConfirmations obj) {
+			super(null, ptr);
+			this.claimable_amount_satoshis = obj.claimable_amount_satoshis;
+			this.confirmation_height = obj.confirmation_height;
+		}
+	}
+	public final static class ContentiousClaimable extends Balance {
+		/**
+		 * The amount 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 the counterparty may be able to claim the balance if we have not
+		 * done so.
+		*/
+		public final int timeout_height;
+		private ContentiousClaimable(long ptr, bindings.LDKBalance.ContentiousClaimable obj) {
+			super(null, ptr);
+			this.claimable_amount_satoshis = obj.claimable_amount_satoshis;
+			this.timeout_height = obj.timeout_height;
+		}
+	}
+	public final static class MaybeClaimableHTLCAwaitingTimeout extends Balance {
+		/**
+		 * The amount 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) {
+			super(null, ptr);
+			this.claimable_amount_satoshis = obj.claimable_amount_satoshis;
+			this.claimable_height = obj.claimable_height;
+		}
+	}
+	/**
+	 * Creates a copy of the Balance
+	 */
+	public Balance clone() {
+		long ret = bindings.Balance_clone(this.ptr);
+		if (ret < 1024) { return null; }
+		Balance ret_hu_conv = Balance.constr_from_ptr(ret);
+		ret_hu_conv.ptrs_to.add(this);
+		return ret_hu_conv;
+	}
+
+	/**
+	 * Utility method to constructs a new ClaimableOnChannelClose-variant Balance
+	 */
+	public static Balance claimable_on_channel_close(long claimable_amount_satoshis) {
+		long ret = bindings.Balance_claimable_on_channel_close(claimable_amount_satoshis);
+		if (ret < 1024) { return null; }
+		Balance ret_hu_conv = Balance.constr_from_ptr(ret);
+		ret_hu_conv.ptrs_to.add(ret_hu_conv);
+		return ret_hu_conv;
+	}
+
+	/**
+	 * Utility method to constructs a new ClaimableAwaitingConfirmations-variant Balance
+	 */
+	public static Balance claimable_awaiting_confirmations(long claimable_amount_satoshis, int confirmation_height) {
+		long ret = bindings.Balance_claimable_awaiting_confirmations(claimable_amount_satoshis, confirmation_height);
+		if (ret < 1024) { return null; }
+		Balance ret_hu_conv = Balance.constr_from_ptr(ret);
+		ret_hu_conv.ptrs_to.add(ret_hu_conv);
+		return ret_hu_conv;
+	}
+
+	/**
+	 * Utility method to constructs a new ContentiousClaimable-variant Balance
+	 */
+	public static Balance contentious_claimable(long claimable_amount_satoshis, int timeout_height) {
+		long ret = bindings.Balance_contentious_claimable(claimable_amount_satoshis, timeout_height);
+		if (ret < 1024) { return null; }
+		Balance ret_hu_conv = Balance.constr_from_ptr(ret);
+		ret_hu_conv.ptrs_to.add(ret_hu_conv);
+		return ret_hu_conv;
+	}
+
+	/**
+	 * Utility method to constructs a new MaybeClaimableHTLCAwaitingTimeout-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);
+		if (ret < 1024) { return null; }
+		Balance ret_hu_conv = Balance.constr_from_ptr(ret);
+		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.
+	 */
+	public boolean eq(Balance b) {
+		boolean ret = bindings.Balance_eq(this.ptr, b == null ? 0 : b.ptr & ~1);
+		this.ptrs_to.add(b);
+		return ret;
+	}
+
+}