Merge pull request #29 from TheBlueMatt/main

Update to LDK 0.0.99

Author: TheBlueMatt

src/main/java/org/ldk/batteries/NioPeerHandler.java

@@ -16,13 +16,6 @@
 public class NioPeerHandler {
     private static class Peer {
         SocketDescriptor descriptor;
-        // When we are told by LDK to disconnect, we can't return to LDK until we are sure
-        // won't call any more read/write PeerManager functions with the same connection.
-        // This is set to true if we're in such a condition (with disconnect checked
-        // before with the Peer monitor lock held) and false when we can return.
-        boolean block_disconnect_socket = false;
-        // Indicates LDK told us to disconnect this peer, and thus we should not call socket_disconnected.
-        boolean disconnect_requested = false;
         SelectionKey key;
     }
 
@@ -83,22 +76,12 @@ public long send_data(byte[] data, boolean resume_read) {
 
             @Override
             public void disconnect_socket() {
-                synchronized (peer) {
-                    peer.disconnect_requested = true;
-                }
                 try {
                     do_selector_action(() -> {
                         peer.key.cancel();
                         peer.key.channel().close();
                     });
                 } catch (IOException ignored) { }
-                synchronized (peer) {
-                    while (peer.block_disconnect_socket) {
-                        try {
-                            peer.wait();
-                        } catch (InterruptedException ignored) { }
-                    }
-                }
             }
             @Override public boolean eq(SocketDescriptor other_arg) { return other_arg.hash() == our_id; }
             @Override public long hash() { return our_id; }
@@ -169,11 +152,6 @@ public NioPeerHandler(PeerManager manager) throws IOException {
                             continue; // There is no attachment so the rest of the loop is useless
                         }
                         Peer peer = (Peer) key.attachment();
-                        synchronized (peer) {
-                            if (peer.disconnect_requested)
-                                continue;
-                            peer.block_disconnect_socket = true;
-                        }
                         try {
                             if (key.isValid() && (key.interestOps() & SelectionKey.OP_WRITE) != 0 && key.isWritable()) {
                                 Result_NonePeerHandleErrorZ res = this.peer_manager.write_buffer_space_avail(peer.descriptor);
@@ -208,10 +186,6 @@ public NioPeerHandler(PeerManager manager) throws IOException {
                             key.cancel();
                             peer_manager.socket_disconnected(peer.descriptor);
                         }
-                        synchronized (peer) {
-                            peer.block_disconnect_socket = false;
-                            peer.notifyAll();
-                        }
                     } catch (CancelledKeyException e) {
                         try { key.channel().close(); } catch (IOException ignored) { }
                         // The key is only cancelled when we have notified the PeerManager that the socket is closed, so
@@ -295,4 +269,4 @@ public void interrupt() {
     public void check_events() {
         selector.wakeup();
     }
-}
+}

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

@@ -4,12 +4,11 @@
  * An enum representing the available verbosity levels of the logger.
  */
 public enum Level {
-	LDKLevel_Off,
-	LDKLevel_Error,
-	LDKLevel_Warn,
-	LDKLevel_Info,
-	LDKLevel_Debug,
 	LDKLevel_Trace,
+	LDKLevel_Debug,
+	LDKLevel_Info,
+	LDKLevel_Warn,
+	LDKLevel_Error,
 	; static native void init();
 	static { init(); }
 }

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

@@ -29,7 +29,8 @@ public BestBlock clone() {
 	}
 
 	/**
-	 * Returns the best block from the genesis of the given network.
+	 * Constructs a `BestBlock` that represents the genesis block at height 0 of the given
+	 * network.
 	 */
 	public static BestBlock from_genesis(Network network) {
 		long ret = bindings.BestBlock_from_genesis(network);
@@ -39,7 +40,7 @@ public static BestBlock from_genesis(Network network) {
 	}
 
 	/**
-	 * Returns the best block as identified by the given block hash and height.
+	 * Returns a `BestBlock` as identified by the given block hash and height.
 	 */
 	public static BestBlock of(byte[] block_hash, int height) {
 		long ret = bindings.BestBlock_new(block_hash, height);

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

@@ -20,26 +20,65 @@ protected void finalize() throws Throwable {
 	}
 
 	/**
-	 * Amount (in millionths of a satoshi) the channel will charge per transferred satoshi.
+	 * Amount (in millionths of a satoshi) charged per satoshi for payments forwarded outbound
+	 * over the channel.
 	 * This may be allowed to change at runtime in a later update, however doing so must result in
 	 * update messages sent to notify all nodes of our updated relay fee.
 	 * 
 	 * Default value: 0.
 	 */
-	public int get_fee_proportional_millionths() {
-		int ret = bindings.ChannelConfig_get_fee_proportional_millionths(this.ptr);
+	public int get_forwarding_fee_proportional_millionths() {
+		int ret = bindings.ChannelConfig_get_forwarding_fee_proportional_millionths(this.ptr);
 		return ret;
 	}
 
 	/**
-	 * Amount (in millionths of a satoshi) the channel will charge per transferred satoshi.
+	 * Amount (in millionths of a satoshi) charged per satoshi for payments forwarded outbound
+	 * over the channel.
 	 * This may be allowed to change at runtime in a later update, however doing so must result in
 	 * update messages sent to notify all nodes of our updated relay fee.
 	 * 
 	 * Default value: 0.
 	 */
-	public void set_fee_proportional_millionths(int val) {
-		bindings.ChannelConfig_set_fee_proportional_millionths(this.ptr, val);
+	public void set_forwarding_fee_proportional_millionths(int val) {
+		bindings.ChannelConfig_set_forwarding_fee_proportional_millionths(this.ptr, val);
+	}
+
+	/**
+	 * Amount (in milli-satoshi) charged for payments forwarded outbound over the channel, in
+	 * excess of [`forwarding_fee_proportional_millionths`].
+	 * This may be allowed to change at runtime in a later update, however doing so must result in
+	 * update messages sent to notify all nodes of our updated relay fee.
+	 * 
+	 * The default value of a single satoshi roughly matches the market rate on many routing nodes
+	 * as of July 2021. Adjusting it upwards or downwards may change whether nodes route through
+	 * this node.
+	 * 
+	 * Default value: 1000.
+	 * 
+	 * [`forwarding_fee_proportional_millionths`]: ChannelConfig::forwarding_fee_proportional_millionths
+	 */
+	public int get_forwarding_fee_base_msat() {
+		int ret = bindings.ChannelConfig_get_forwarding_fee_base_msat(this.ptr);
+		return ret;
+	}
+
+	/**
+	 * Amount (in milli-satoshi) charged for payments forwarded outbound over the channel, in
+	 * excess of [`forwarding_fee_proportional_millionths`].
+	 * This may be allowed to change at runtime in a later update, however doing so must result in
+	 * update messages sent to notify all nodes of our updated relay fee.
+	 * 
+	 * The default value of a single satoshi roughly matches the market rate on many routing nodes
+	 * as of July 2021. Adjusting it upwards or downwards may change whether nodes route through
+	 * this node.
+	 * 
+	 * Default value: 1000.
+	 * 
+	 * [`forwarding_fee_proportional_millionths`]: ChannelConfig::forwarding_fee_proportional_millionths
+	 */
+	public void set_forwarding_fee_base_msat(int val) {
+		bindings.ChannelConfig_set_forwarding_fee_base_msat(this.ptr, val);
 	}
 
 	/**
@@ -100,7 +139,7 @@ public void set_cltv_expiry_delta(short val) {
 	 * This should only be set to true for nodes which expect to be online reliably.
 	 * 
 	 * As the node which funds a channel picks this value this will only apply for new outbound
-	 * channels unless ChannelHandshakeLimits::force_announced_channel_preferences is set.
+	 * channels unless [`ChannelHandshakeLimits::force_announced_channel_preference`] is set.
 	 * 
 	 * This cannot be changed after the initial channel handshake.
 	 * 
@@ -118,7 +157,7 @@ public boolean get_announced_channel() {
 	 * This should only be set to true for nodes which expect to be online reliably.
 	 * 
 	 * As the node which funds a channel picks this value this will only apply for new outbound
-	 * channels unless ChannelHandshakeLimits::force_announced_channel_preferences is set.
+	 * channels unless [`ChannelHandshakeLimits::force_announced_channel_preference`] is set.
 	 * 
 	 * This cannot be changed after the initial channel handshake.
 	 * 
@@ -166,8 +205,8 @@ public void set_commit_upfront_shutdown_pubkey(boolean val) {
 	/**
 	 * Constructs a new ChannelConfig given each field
 	 */
-	public static ChannelConfig of(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);
+	public static ChannelConfig of(int forwarding_fee_proportional_millionths_arg, int forwarding_fee_base_msat_arg, short cltv_expiry_delta_arg, boolean announced_channel_arg, boolean commit_upfront_shutdown_pubkey_arg) {
+		long ret = bindings.ChannelConfig_new(forwarding_fee_proportional_millionths_arg, forwarding_fee_base_msat_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/ChannelConfig.java

@@ -0,0 +1,96 @@
+package org.ldk.structs;
+
+import org.ldk.impl.bindings;
+import org.ldk.enums.*;
+import org.ldk.util.*;
+import java.util.Arrays;
+
+
+/**
+ * Channel parameters which apply to our counterparty. These are split out from [`ChannelDetails`]
+ * to better separate parameters.
+ */
+@SuppressWarnings("unchecked") // We correctly assign various generic arrays
+public class ChannelCounterparty extends CommonBase {
+	ChannelCounterparty(Object _dummy, long ptr) { super(ptr); }
+	@Override @SuppressWarnings("deprecation")
+	protected void finalize() throws Throwable {
+		super.finalize();
+		if (ptr != 0) { bindings.ChannelCounterparty_free(ptr); }
+	}
+
+	/**
+	 * The node_id of our counterparty
+	 */
+	public byte[] get_node_id() {
+		byte[] ret = bindings.ChannelCounterparty_get_node_id(this.ptr);
+		return ret;
+	}
+
+	/**
+	 * The node_id of our counterparty
+	 */
+	public void set_node_id(byte[] val) {
+		bindings.ChannelCounterparty_set_node_id(this.ptr, val);
+	}
+
+	/**
+	 * The Features the channel counterparty provided upon last connection.
+	 * Useful for routing as it is the most up-to-date copy of the counterparty's features and
+	 * many routing-relevant features are present in the init context.
+	 */
+	public InitFeatures get_features() {
+		long ret = bindings.ChannelCounterparty_get_features(this.ptr);
+		InitFeatures ret_hu_conv = new InitFeatures(null, ret);
+		ret_hu_conv.ptrs_to.add(this);
+		return ret_hu_conv;
+	}
+
+	/**
+	 * The Features the channel counterparty provided upon last connection.
+	 * Useful for routing as it is the most up-to-date copy of the counterparty's features and
+	 * many routing-relevant features are present in the init context.
+	 */
+	public void set_features(InitFeatures val) {
+		bindings.ChannelCounterparty_set_features(this.ptr, val == null ? 0 : val.ptr & ~1);
+		this.ptrs_to.add(val);
+	}
+
+	/**
+	 * The value, in satoshis, that must always be held in the channel for our counterparty. This
+	 * value ensures that if our counterparty broadcasts a revoked state, we can punish them by
+	 * claiming at least this value on chain.
+	 * 
+	 * This value is not included in [`inbound_capacity_msat`] as it can never be spent.
+	 * 
+	 * [`inbound_capacity_msat`]: ChannelDetails::inbound_capacity_msat
+	 */
+	public long get_unspendable_punishment_reserve() {
+		long ret = bindings.ChannelCounterparty_get_unspendable_punishment_reserve(this.ptr);
+		return ret;
+	}
+
+	/**
+	 * The value, in satoshis, that must always be held in the channel for our counterparty. This
+	 * value ensures that if our counterparty broadcasts a revoked state, we can punish them by
+	 * claiming at least this value on chain.
+	 * 
+	 * This value is not included in [`inbound_capacity_msat`] as it can never be spent.
+	 * 
+	 * [`inbound_capacity_msat`]: ChannelDetails::inbound_capacity_msat
+	 */
+	public void set_unspendable_punishment_reserve(long val) {
+		bindings.ChannelCounterparty_set_unspendable_punishment_reserve(this.ptr, val);
+	}
+
+	/**
+	 * Creates a copy of the ChannelCounterparty
+	 */
+	public ChannelCounterparty clone() {
+		long ret = bindings.ChannelCounterparty_clone(this.ptr);
+		ChannelCounterparty ret_hu_conv = new ChannelCounterparty(null, ret);
+		ret_hu_conv.ptrs_to.add(this);
+		return ret_hu_conv;
+	}
+
+}