]> git.bitcoin.ninja Git - ldk-java/commitdiff
Update auto-generated bindings
authorMatt Corallo <git@bluematt.me>
Sat, 20 Mar 2021 21:54:47 +0000 (17:54 -0400)
committerMatt Corallo <git@bluematt.me>
Mon, 22 Mar 2021 00:01:01 +0000 (20:01 -0400)
32 files changed:
liblightningjni_debug.so
liblightningjni_release.so
src/main/java/org/ldk/enums/LDKAccessError.java
src/main/java/org/ldk/impl/bindings.java
src/main/java/org/ldk/structs/ChainMonitor.java
src/main/java/org/ldk/structs/ChannelConfig.java
src/main/java/org/ldk/structs/ChannelFeatures.java
src/main/java/org/ldk/structs/ChannelHandshakeConfig.java
src/main/java/org/ldk/structs/ChannelMessageHandler.java
src/main/java/org/ldk/structs/ChannelMonitor.java
src/main/java/org/ldk/structs/ChannelMonitorUpdate.java
src/main/java/org/ldk/structs/Filter.java
src/main/java/org/ldk/structs/HTLCUpdate.java
src/main/java/org/ldk/structs/InitFeatures.java
src/main/java/org/ldk/structs/InvoiceFeatures.java [new file with mode: 0644]
src/main/java/org/ldk/structs/MessageSendEvent.java
src/main/java/org/ldk/structs/NodeFeatures.java
src/main/java/org/ldk/structs/Persist.java
src/main/java/org/ldk/structs/QueryChannelRange.java
src/main/java/org/ldk/structs/Result_InvoiceFeaturesDecodeErrorZ.java [new file with mode: 0644]
src/main/java/org/ldk/structs/UnsignedChannelUpdate.java
src/main/java/org/ldk/structs/Watch.java
src/main/jni/bindings.c
src/main/jni/org_ldk_impl_bindings.h
ts/bindings.c
ts/bindings.ts
ts/structs/ChannelConfig.ts
ts/structs/ChannelMessageHandler.ts
ts/structs/InvoiceFeatures.ts [new file with mode: 0644]
ts/structs/MessageSendEvent.ts
ts/structs/QueryChannelRange.ts
ts/structs/Result_InvoiceFeaturesDecodeErrorZ.ts [new file with mode: 0644]

index 57752d516d63c166381ee6d5b2067aa1a892d782..e25a23d0b37bbd2476b1f8d8350187f1efd0e020 100755 (executable)
Binary files a/liblightningjni_debug.so and b/liblightningjni_debug.so differ
index 5fec76cc3b03d8170321065b4017314a0826223e..ebfbf2f3609d4befd4b734375764cbe617ce458a 100755 (executable)
Binary files a/liblightningjni_release.so and b/liblightningjni_release.so differ
index 2a4c57ffc45c5009cdade58c807bae1645fcdcb3..c8e604c16308d54bd9ba8d94ef8b2409a117f28c 100644 (file)
@@ -2,8 +2,6 @@ package org.ldk.enums;
 
 /**
  * An error when accessing the chain via [`Access`].
- * 
- * [`Access`]: trait.Access.html
  */
 public enum LDKAccessError {
        LDKAccessError_UnknownChain,
index 99196cc49864297734bbf46e371f0c16a890201c..a414060c69c23bc54c82f55443952204aeba8f9e 100644 (file)
@@ -202,6 +202,11 @@ public class bindings {
                        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 class bindings {
                 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 class bindings {
        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 class bindings {
        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 class bindings {
        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 class bindings {
        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);
index a32ef2d3fad316b3a78f8d9129954534cc10772e..1cfc04d36bff5835d4f75123f5d76ff2ab746855 100644 (file)
@@ -14,9 +14,8 @@ import java.util.Arrays;
  * 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 @@ public class ChainMonitor extends CommonBase {
         * 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 class ChainMonitor extends CommonBase {
         * 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 class ChainMonitor extends CommonBase {
         * 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);
index c7a095bbdc9a9c43d9330e9b7cf62c3f15b3da6d..7f5f6d2e63bd1e8e469b6d850fa2c0d927bdf3ac 100644 (file)
@@ -42,6 +42,57 @@ public class ChannelConfig extends CommonBase {
                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 class ChannelConfig extends CommonBase {
        /**
         * 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;
index bac024ad142aed562747554b8cd604d86d6aadd7..9d445f4f954dd9584c6879b093d0d68e2e8d8e73 100644 (file)
@@ -39,9 +39,7 @@ public class ChannelFeatures extends CommonBase {
        }
 
        /**
-        * 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();
index 2b1a7eeedc1fd065e80c1f0770e830cf95ed413b..bf53b65c972409d66b33d207d19cc81ffd18c208 100644 (file)
@@ -44,18 +44,21 @@ public class ChannelHandshakeConfig extends CommonBase {
        }
 
        /**
-        * 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);
@@ -63,18 +66,21 @@ public class ChannelHandshakeConfig extends CommonBase {
        }
 
        /**
-        * 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);
index 5eaedc1652e4e16ed601ee33e25a5e8c177c1d45..c5bb627289593e065d271538cb4d413451edf62d 100644 (file)
@@ -102,6 +102,10 @@ public class ChannelMessageHandler extends CommonBase {
                 * 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 class ChannelMessageHandler extends CommonBase {
                                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 class ChannelMessageHandler extends CommonBase {
                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.
         */
index 1ab69bc7f5a0f368fa2bf0dc1fb2a31dba89a08d..e16b37978945913aca2d08b3ffd11f9bdad6485d 100644 (file)
@@ -133,8 +133,6 @@ public class ChannelMonitor extends CommonBase {
        /**
         * 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);
index 4373180aedc6190f2a6e20195122ad80d7d2d15f..248ee9af68df14569962de1931b0f8bd43988834 100644 (file)
@@ -31,8 +31,6 @@ public class ChannelMonitorUpdate extends CommonBase {
         * The only instance where update_id values are not strictly increasing is the case where we
         * allow post-force-close updates with a special update ID of [`CLOSED_CHANNEL_UPDATE_ID`]. See
         * its docs for more details.
-        * 
-        * [`CLOSED_CHANNEL_UPDATE_ID`]: constant.CLOSED_CHANNEL_UPDATE_ID.html
         */
        public long get_update_id() {
                long ret = bindings.ChannelMonitorUpdate_get_update_id(this.ptr);
@@ -51,8 +49,6 @@ public class ChannelMonitorUpdate extends CommonBase {
         * The only instance where update_id values are not strictly increasing is the case where we
         * allow post-force-close updates with a special update ID of [`CLOSED_CHANNEL_UPDATE_ID`]. See
         * its docs for more details.
-        * 
-        * [`CLOSED_CHANNEL_UPDATE_ID`]: constant.CLOSED_CHANNEL_UPDATE_ID.html
         */
        public void set_update_id(long val) {
                bindings.ChannelMonitorUpdate_set_update_id(this.ptr, val);
index 092c65614100a5045588eb204eac935026cba488..776d95ede643a5a88fcd065d2bbc1b431a766dd7 100644 (file)
@@ -20,11 +20,10 @@ import java.util.Arrays;
  * 
  * Note that use as part of a [`Watch`] implementation involves reentrancy. Therefore, the `Filter`
  * should not block on I/O. Implementations should instead queue the newly monitored data to be
- * processed later. Then, in order to block until the data has been processed, any `Watch`
+ * processed later. Then, in order to block until the data has been processed, any [`Watch`]
  * invocation that has called the `Filter` must return [`TemporaryFailure`].
  * 
- * [`Watch`]: trait.Watch.html
- * [`TemporaryFailure`]: channelmonitor/enum.ChannelMonitorUpdateErr.html#variant.TemporaryFailure
+ * [`TemporaryFailure`]: channelmonitor::ChannelMonitorUpdateErr::TemporaryFailure
  * [BIP 157]: https://github.com/bitcoin/bips/blob/master/bip-0157.mediawiki
  * [BIP 158]: https://github.com/bitcoin/bips/blob/master/bip-0158.mediawiki
  */
index 5951ab2e22a28fd485b1bb8f978a4ac7cd5b92df..e951269a10aeeab9dc12967ade5add046884070a 100644 (file)
@@ -10,8 +10,6 @@ import java.util.Arrays;
  * Simple structure sent back by `chain::Watch` when an HTLC from a forward channel is detected on
  * chain. Used to update the corresponding HTLC in the backward channel. Failing to pass the
  * preimage claim backward will lead to loss of funds.
- * 
- * [`chain::Watch`]: ../trait.Watch.html
  */
 @SuppressWarnings("unchecked") // We correctly assign various generic arrays
 public class HTLCUpdate extends CommonBase {
index 38195c910e168bb0ef21ed16ce95afd24d65e261..cf4e0b3d9f3ba3d1cfe178cadc97389a4851a53e 100644 (file)
@@ -39,9 +39,7 @@ public class InitFeatures extends CommonBase {
        }
 
        /**
-        * 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 InitFeatures constructor_known() {
                long ret = bindings.InitFeatures_known();
diff --git a/src/main/java/org/ldk/structs/InvoiceFeatures.java b/src/main/java/org/ldk/structs/InvoiceFeatures.java
new file mode 100644 (file)
index 0000000..b5d8133
--- /dev/null
@@ -0,0 +1,68 @@
+package org.ldk.structs;
+
+import org.ldk.impl.bindings;
+import org.ldk.enums.*;
+import org.ldk.util.*;
+import java.util.Arrays;
+
+
+/**
+ * Features used within an invoice.
+ */
+@SuppressWarnings("unchecked") // We correctly assign various generic arrays
+public class InvoiceFeatures extends CommonBase {
+       InvoiceFeatures(Object _dummy, long ptr) { super(ptr); }
+       @Override @SuppressWarnings("deprecation")
+       protected void finalize() throws Throwable {
+               super.finalize();
+               if (ptr != 0) { bindings.InvoiceFeatures_free(ptr); }
+       }
+
+       /**
+        * Creates a copy of the InvoiceFeatures
+        */
+       public InvoiceFeatures clone() {
+               long ret = bindings.InvoiceFeatures_clone(this.ptr);
+               InvoiceFeatures ret_hu_conv = new InvoiceFeatures(null, ret);
+               ret_hu_conv.ptrs_to.add(this);
+               return ret_hu_conv;
+       }
+
+       /**
+        * Create a blank Features with no features set
+        */
+       public static InvoiceFeatures constructor_empty() {
+               long ret = bindings.InvoiceFeatures_empty();
+               InvoiceFeatures ret_hu_conv = new InvoiceFeatures(null, ret);
+               ret_hu_conv.ptrs_to.add(ret_hu_conv);
+               return ret_hu_conv;
+       }
+
+       /**
+        * Creates a Features with the bits set which are known by the implementation
+        */
+       public static InvoiceFeatures constructor_known() {
+               long ret = bindings.InvoiceFeatures_known();
+               InvoiceFeatures ret_hu_conv = new InvoiceFeatures(null, ret);
+               ret_hu_conv.ptrs_to.add(ret_hu_conv);
+               return ret_hu_conv;
+       }
+
+       /**
+        * Serialize the InvoiceFeatures object into a byte array which can be read by InvoiceFeatures_read
+        */
+       public byte[] write() {
+               byte[] ret = bindings.InvoiceFeatures_write(this.ptr);
+               return ret;
+       }
+
+       /**
+        * Read a InvoiceFeatures from a byte array, created by InvoiceFeatures_write
+        */
+       public static Result_InvoiceFeaturesDecodeErrorZ constructor_read(byte[] ser) {
+               long ret = bindings.InvoiceFeatures_read(ser);
+               Result_InvoiceFeaturesDecodeErrorZ ret_hu_conv = Result_InvoiceFeaturesDecodeErrorZ.constr_from_ptr(ret);
+               return ret_hu_conv;
+       }
+
+}
index 8327eae792fe32c3157c6d9d3c97a031843f6f0a..36e816f8acf257b99440cb6433464cb8cc720d21 100644 (file)
@@ -75,6 +75,9 @@ public class MessageSendEvent extends CommonBase {
                if (raw_val.getClass() == bindings.LDKMessageSendEvent.SendShortIdsQuery.class) {
                        return new SendShortIdsQuery(ptr, (bindings.LDKMessageSendEvent.SendShortIdsQuery)raw_val);
                }
+               if (raw_val.getClass() == bindings.LDKMessageSendEvent.SendReplyChannelRange.class) {
+                       return new SendReplyChannelRange(ptr, (bindings.LDKMessageSendEvent.SendReplyChannelRange)raw_val);
+               }
                assert false; return null; // Unreachable without extending the (internal) bindings interface
        }
 
@@ -291,4 +294,16 @@ public class MessageSendEvent extends CommonBase {
                        this.msg = msg_hu_conv;
                }
        }
+       public final static class SendReplyChannelRange extends MessageSendEvent {
+               public final byte[] node_id;
+               public final ReplyChannelRange msg;
+               private SendReplyChannelRange(long ptr, bindings.LDKMessageSendEvent.SendReplyChannelRange obj) {
+                       super(null, ptr);
+                       this.node_id = obj.node_id;
+                       long msg = obj.msg;
+                       ReplyChannelRange msg_hu_conv = new ReplyChannelRange(null, msg);
+                       msg_hu_conv.ptrs_to.add(this);
+                       this.msg = msg_hu_conv;
+               }
+       }
 }
index b4d09e7188bf6b9382710e485b7a5ede11aaf068..022a46f68e4d4721b260996cde63beb249bb7426 100644 (file)
@@ -39,9 +39,7 @@ public class NodeFeatures extends CommonBase {
        }
 
        /**
-        * 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 NodeFeatures constructor_known() {
                long ret = bindings.NodeFeatures_known();
index ebb48ed949b9376c752cad1126a915a82c7e299e..ef36c4259811cfa2d9e0f1ed8dd67fc5e9373950 100644 (file)
@@ -40,11 +40,8 @@ public class Persist extends CommonBase {
                 * stored channel data). Note that you **must** persist every new monitor to
                 * disk. See the `Persist` trait documentation for more details.
                 * 
-                * See [`ChannelMonitor::serialize_for_disk`] for writing out a `ChannelMonitor`,
+                * See [`ChannelMonitor::write`] for writing out a `ChannelMonitor`,
                 * and [`ChannelMonitorUpdateErr`] for requirements when returning errors.
-                * 
-                * [`ChannelMonitor::serialize_for_disk`]: struct.ChannelMonitor.html#method.serialize_for_disk
-                * [`ChannelMonitorUpdateErr`]: enum.ChannelMonitorUpdateErr.html
                 */
                Result_NoneChannelMonitorUpdateErrZ persist_new_channel(OutPoint id, ChannelMonitor data);
                /**
@@ -67,14 +64,9 @@ public class Persist extends CommonBase {
                 * them in batches. The size of each monitor grows `O(number of state updates)`
                 * whereas updates are small and `O(1)`.
                 * 
-                * See [`ChannelMonitor::serialize_for_disk`] for writing out a `ChannelMonitor`,
+                * See [`ChannelMonitor::write`] for writing out a `ChannelMonitor`,
                 * [`ChannelMonitorUpdate::write`] for writing out an update, and
                 * [`ChannelMonitorUpdateErr`] for requirements when returning errors.
-                * 
-                * [`ChannelMonitor::update_monitor`]: struct.ChannelMonitor.html#impl-1
-                * [`ChannelMonitor::serialize_for_disk`]: struct.ChannelMonitor.html#method.serialize_for_disk
-                * [`ChannelMonitorUpdate::write`]: struct.ChannelMonitorUpdate.html#method.write
-                * [`ChannelMonitorUpdateErr`]: enum.ChannelMonitorUpdateErr.html
                 */
                Result_NoneChannelMonitorUpdateErrZ update_persisted_channel(OutPoint id, ChannelMonitorUpdate update, ChannelMonitor data);
        }
@@ -109,11 +101,8 @@ public class Persist extends CommonBase {
         * stored channel data). Note that you **must** persist every new monitor to
         * disk. See the `Persist` trait documentation for more details.
         * 
-        * See [`ChannelMonitor::serialize_for_disk`] for writing out a `ChannelMonitor`,
+        * See [`ChannelMonitor::write`] for writing out a `ChannelMonitor`,
         * and [`ChannelMonitorUpdateErr`] for requirements when returning errors.
-        * 
-        * [`ChannelMonitor::serialize_for_disk`]: struct.ChannelMonitor.html#method.serialize_for_disk
-        * [`ChannelMonitorUpdateErr`]: enum.ChannelMonitorUpdateErr.html
         */
        public Result_NoneChannelMonitorUpdateErrZ persist_new_channel(OutPoint id, ChannelMonitor data) {
                long ret = bindings.Persist_persist_new_channel(this.ptr, id == null ? 0 : id.ptr & ~1, data == null ? 0 : data.ptr & ~1);
@@ -143,14 +132,9 @@ public class Persist extends CommonBase {
         * them in batches. The size of each monitor grows `O(number of state updates)`
         * whereas updates are small and `O(1)`.
         * 
-        * See [`ChannelMonitor::serialize_for_disk`] for writing out a `ChannelMonitor`,
+        * See [`ChannelMonitor::write`] for writing out a `ChannelMonitor`,
         * [`ChannelMonitorUpdate::write`] for writing out an update, and
         * [`ChannelMonitorUpdateErr`] for requirements when returning errors.
-        * 
-        * [`ChannelMonitor::update_monitor`]: struct.ChannelMonitor.html#impl-1
-        * [`ChannelMonitor::serialize_for_disk`]: struct.ChannelMonitor.html#method.serialize_for_disk
-        * [`ChannelMonitorUpdate::write`]: struct.ChannelMonitorUpdate.html#method.write
-        * [`ChannelMonitorUpdateErr`]: enum.ChannelMonitorUpdateErr.html
         */
        public Result_NoneChannelMonitorUpdateErrZ update_persisted_channel(OutPoint id, ChannelMonitorUpdate update, ChannelMonitor data) {
                long ret = bindings.Persist_update_persisted_channel(this.ptr, id == null ? 0 : id.ptr & ~1, update == null ? 0 : update.ptr & ~1, data == null ? 0 : data.ptr & ~1);
index 97d856ea41e3c47b293088d9ad3949b91c488467..6b07c91f5c96f75484277eeeb3126d762e0822e5 100644 (file)
@@ -86,6 +86,14 @@ public class QueryChannelRange extends CommonBase {
                return ret_hu_conv;
        }
 
+       /**
+        * \n\t * Calculates the overflow safe ending block height for the query.\n\t * Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`\n\t
+        */
+       public int end_blocknum() {
+               int ret = bindings.QueryChannelRange_end_blocknum(this.ptr);
+               return ret;
+       }
+
        /**
         * Read a QueryChannelRange from a byte array, created by QueryChannelRange_write
         */
diff --git a/src/main/java/org/ldk/structs/Result_InvoiceFeaturesDecodeErrorZ.java b/src/main/java/org/ldk/structs/Result_InvoiceFeaturesDecodeErrorZ.java
new file mode 100644 (file)
index 0000000..0ea0787
--- /dev/null
@@ -0,0 +1,50 @@
+package org.ldk.structs;
+
+import org.ldk.impl.bindings;
+import org.ldk.enums.*;
+import org.ldk.util.*;
+import java.util.Arrays;
+
+public class Result_InvoiceFeaturesDecodeErrorZ extends CommonBase {
+       private Result_InvoiceFeaturesDecodeErrorZ(Object _dummy, long ptr) { super(ptr); }
+       protected void finalize() throws Throwable {
+               if (ptr != 0) { bindings.CResult_InvoiceFeaturesDecodeErrorZ_free(ptr); } super.finalize();
+       }
+
+       static Result_InvoiceFeaturesDecodeErrorZ constr_from_ptr(long ptr) {
+               if (bindings.LDKCResult_InvoiceFeaturesDecodeErrorZ_result_ok(ptr)) {
+                       return new Result_InvoiceFeaturesDecodeErrorZ_OK(null, ptr);
+               } else {
+                       return new Result_InvoiceFeaturesDecodeErrorZ_Err(null, ptr);
+               }
+       }
+       public static final class Result_InvoiceFeaturesDecodeErrorZ_OK extends Result_InvoiceFeaturesDecodeErrorZ {
+               public final InvoiceFeatures res;
+               private Result_InvoiceFeaturesDecodeErrorZ_OK(Object _dummy, long ptr) {
+                       super(_dummy, ptr);
+                       long res = bindings.LDKCResult_InvoiceFeaturesDecodeErrorZ_get_ok(ptr);
+                       InvoiceFeatures res_hu_conv = new InvoiceFeatures(null, res);
+                       res_hu_conv.ptrs_to.add(this);
+                       this.res = res_hu_conv;
+               }
+               public Result_InvoiceFeaturesDecodeErrorZ_OK(InvoiceFeatures res) {
+                       this(null, bindings.CResult_InvoiceFeaturesDecodeErrorZ_ok(res == null ? 0 : res.ptr & ~1));
+                       this.ptrs_to.add(res);
+               }
+       }
+
+       public static final class Result_InvoiceFeaturesDecodeErrorZ_Err extends Result_InvoiceFeaturesDecodeErrorZ {
+               public final DecodeError err;
+               private Result_InvoiceFeaturesDecodeErrorZ_Err(Object _dummy, long ptr) {
+                       super(_dummy, ptr);
+                       long err = bindings.LDKCResult_InvoiceFeaturesDecodeErrorZ_get_err(ptr);
+                       DecodeError err_hu_conv = new DecodeError(null, err);
+                       err_hu_conv.ptrs_to.add(this);
+                       this.err = err_hu_conv;
+               }
+               public Result_InvoiceFeaturesDecodeErrorZ_Err(DecodeError err) {
+                       this(null, bindings.CResult_InvoiceFeaturesDecodeErrorZ_err(err == null ? 0 : err.ptr & ~1));
+                       this.ptrs_to.add(err);
+               }
+       }
+}
index 9f50b5c6f25be35534125c17e72610f6d4b4b754..294ca4b36522af4de74cdde043f83026ed26b14b 100644 (file)
@@ -79,7 +79,14 @@ public class UnsignedChannelUpdate extends CommonBase {
        }
 
        /**
-        * The number of blocks to subtract from incoming HTLC cltv_expiry values
+        * The number of blocks such that if:
+        * `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
+        * then we need to fail the HTLC backwards. When forwarding an HTLC, cltv_expiry_delta determines
+        * the outgoing HTLC's minimum cltv_expiry value -- so, if an incoming HTLC comes in with a
+        * cltv_expiry of 100000, and the node we're forwarding to has a cltv_expiry_delta value of 10,
+        * then we'll check that the outgoing HTLC's cltv_expiry value is at least 100010 before
+        * forwarding. Note that the HTLC sender is the one who originally sets this value when
+        * constructing the route.
         */
        public short get_cltv_expiry_delta() {
                short ret = bindings.UnsignedChannelUpdate_get_cltv_expiry_delta(this.ptr);
@@ -87,7 +94,14 @@ public class UnsignedChannelUpdate extends CommonBase {
        }
 
        /**
-        * The number of blocks to subtract from incoming HTLC cltv_expiry values
+        * The number of blocks such that if:
+        * `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
+        * then we need to fail the HTLC backwards. When forwarding an HTLC, cltv_expiry_delta determines
+        * the outgoing HTLC's minimum cltv_expiry value -- so, if an incoming HTLC comes in with a
+        * cltv_expiry of 100000, and the node we're forwarding to has a cltv_expiry_delta value of 10,
+        * then we'll check that the outgoing HTLC's cltv_expiry value is at least 100010 before
+        * forwarding. Note that the HTLC sender is the one who originally sets this value when
+        * constructing the route.
         */
        public void set_cltv_expiry_delta(short val) {
                bindings.UnsignedChannelUpdate_set_cltv_expiry_delta(this.ptr, val);
index 85602ac83a4135f09079c490791dcf1242224bc9..d560838a914125396516e731fe3eb86440667af5 100644 (file)
@@ -24,9 +24,9 @@ import java.util.Arrays;
  * funds in the channel. See [`ChannelMonitorUpdateErr`] for more details about how to handle
  * multiple instances.
  * 
- * [`ChannelMonitor`]: channelmonitor/struct.ChannelMonitor.html
- * [`ChannelMonitorUpdateErr`]: channelmonitor/enum.ChannelMonitorUpdateErr.html
- * [`PermanentFailure`]: channelmonitor/enum.ChannelMonitorUpdateErr.html#variant.PermanentFailure
+ * [`ChannelMonitor`]: channelmonitor::ChannelMonitor
+ * [`ChannelMonitorUpdateErr`]: channelmonitor::ChannelMonitorUpdateErr
+ * [`PermanentFailure`]: channelmonitor::ChannelMonitorUpdateErr::PermanentFailure
  */
 @SuppressWarnings("unchecked") // We correctly assign various generic arrays
 public class Watch extends CommonBase {
@@ -50,9 +50,9 @@ public class Watch extends CommonBase {
                 * with any spends of outputs returned by [`get_outputs_to_watch`]. In practice, this means
                 * calling [`block_connected`] and [`block_disconnected`] on the monitor.
                 * 
-                * [`get_outputs_to_watch`]: channelmonitor/struct.ChannelMonitor.html#method.get_outputs_to_watch
-                * [`block_connected`]: channelmonitor/struct.ChannelMonitor.html#method.block_connected
-                * [`block_disconnected`]: channelmonitor/struct.ChannelMonitor.html#method.block_disconnected
+                * [`get_outputs_to_watch`]: channelmonitor::ChannelMonitor::get_outputs_to_watch
+                * [`block_connected`]: channelmonitor::ChannelMonitor::block_connected
+                * [`block_disconnected`]: channelmonitor::ChannelMonitor::block_disconnected
                 */
                Result_NoneChannelMonitorUpdateErrZ watch_channel(OutPoint funding_txo, ChannelMonitor monitor);
                /**
@@ -61,8 +61,8 @@ public class Watch extends CommonBase {
                 * Implementations must call [`update_monitor`] with the given update. See
                 * [`ChannelMonitorUpdateErr`] for invariants around returning an error.
                 * 
-                * [`update_monitor`]: channelmonitor/struct.ChannelMonitor.html#method.update_monitor
-                * [`ChannelMonitorUpdateErr`]: channelmonitor/enum.ChannelMonitorUpdateErr.html
+                * [`update_monitor`]: channelmonitor::ChannelMonitor::update_monitor
+                * [`ChannelMonitorUpdateErr`]: channelmonitor::ChannelMonitorUpdateErr
                 */
                Result_NoneChannelMonitorUpdateErrZ update_channel(OutPoint funding_txo, ChannelMonitorUpdate update);
                /**
@@ -109,9 +109,9 @@ public class Watch extends CommonBase {
         * with any spends of outputs returned by [`get_outputs_to_watch`]. In practice, this means
         * calling [`block_connected`] and [`block_disconnected`] on the monitor.
         * 
-        * [`get_outputs_to_watch`]: channelmonitor/struct.ChannelMonitor.html#method.get_outputs_to_watch
-        * [`block_connected`]: channelmonitor/struct.ChannelMonitor.html#method.block_connected
-        * [`block_disconnected`]: channelmonitor/struct.ChannelMonitor.html#method.block_disconnected
+        * [`get_outputs_to_watch`]: channelmonitor::ChannelMonitor::get_outputs_to_watch
+        * [`block_connected`]: channelmonitor::ChannelMonitor::block_connected
+        * [`block_disconnected`]: channelmonitor::ChannelMonitor::block_disconnected
         */
        public Result_NoneChannelMonitorUpdateErrZ watch_channel(OutPoint funding_txo, ChannelMonitor monitor) {
                long ret = bindings.Watch_watch_channel(this.ptr, funding_txo == null ? 0 : funding_txo.ptr & ~1, monitor == null ? 0 : monitor.ptr & ~1);
@@ -127,8 +127,8 @@ public class Watch extends CommonBase {
         * Implementations must call [`update_monitor`] with the given update. See
         * [`ChannelMonitorUpdateErr`] for invariants around returning an error.
         * 
-        * [`update_monitor`]: channelmonitor/struct.ChannelMonitor.html#method.update_monitor
-        * [`ChannelMonitorUpdateErr`]: channelmonitor/enum.ChannelMonitorUpdateErr.html
+        * [`update_monitor`]: channelmonitor::ChannelMonitor::update_monitor
+        * [`ChannelMonitorUpdateErr`]: channelmonitor::ChannelMonitorUpdateErr
         */
        public Result_NoneChannelMonitorUpdateErrZ update_channel(OutPoint funding_txo, ChannelMonitorUpdate update) {
                long ret = bindings.Watch_update_channel(this.ptr, funding_txo == null ? 0 : funding_txo.ptr & ~1, update == null ? 0 : update.ptr & ~1);
index b36f9c344d15706b7cf0d3f4b4b07ea7cba00647..0e201da0621e2e9aa1fcab949c48e52ae37af930 100644 (file)
@@ -777,6 +777,8 @@ static jclass LDKMessageSendEvent_SendChannelRangeQuery_class = NULL;
 static jmethodID LDKMessageSendEvent_SendChannelRangeQuery_meth = NULL;
 static jclass LDKMessageSendEvent_SendShortIdsQuery_class = NULL;
 static jmethodID LDKMessageSendEvent_SendShortIdsQuery_meth = NULL;
+static jclass LDKMessageSendEvent_SendReplyChannelRange_class = NULL;
+static jmethodID LDKMessageSendEvent_SendReplyChannelRange_meth = NULL;
 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKMessageSendEvent_init (JNIEnv *env, jclass clz) {
        LDKMessageSendEvent_SendAcceptChannel_class =
                (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendAcceptChannel;"));
@@ -868,6 +870,11 @@ JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKMessageSendEvent_init
        CHECK(LDKMessageSendEvent_SendShortIdsQuery_class != NULL);
        LDKMessageSendEvent_SendShortIdsQuery_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendShortIdsQuery_class, "<init>", "([BJ)V");
        CHECK(LDKMessageSendEvent_SendShortIdsQuery_meth != NULL);
+       LDKMessageSendEvent_SendReplyChannelRange_class =
+               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendReplyChannelRange;"));
+       CHECK(LDKMessageSendEvent_SendReplyChannelRange_class != NULL);
+       LDKMessageSendEvent_SendReplyChannelRange_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendReplyChannelRange_class, "<init>", "([BJ)V");
+       CHECK(LDKMessageSendEvent_SendReplyChannelRange_meth != NULL);
 }
 JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKMessageSendEvent_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
        LDKMessageSendEvent *obj = (LDKMessageSendEvent*)ptr;
@@ -1024,6 +1031,15 @@ JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKMessageSendEvent_1ref_1f
                        long msg_ref = (long)msg_var.inner & ~1;
                        return (*env)->NewObject(env, LDKMessageSendEvent_SendShortIdsQuery_class, LDKMessageSendEvent_SendShortIdsQuery_meth, node_id_arr, msg_ref);
                }
+               case LDKMessageSendEvent_SendReplyChannelRange: {
+                       int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
+                       (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->send_reply_channel_range.node_id.compressed_form);
+                       LDKReplyChannelRange msg_var = obj->send_reply_channel_range.msg;
+                       CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+                       CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+                       long msg_ref = (long)msg_var.inner & ~1;
+                       return (*env)->NewObject(env, LDKMessageSendEvent_SendReplyChannelRange_class, LDKMessageSendEvent_SendReplyChannelRange_meth, node_id_arr, msg_ref);
+               }
                default: abort();
        }
 }
@@ -2279,7 +2295,7 @@ static void LDKSign_JCalls_free(void* this_arg) {
                FREE(j_calls);
        }
 }
-LDKPublicKey get_per_commitment_point_jcall(const void* this_arg, uint64_t idx) {
+LDKPublicKey get_per_commitment_point_LDKSign_jcall(const void* this_arg, uint64_t idx) {
        LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -2291,7 +2307,7 @@ LDKPublicKey get_per_commitment_point_jcall(const void* this_arg, uint64_t idx)
        (*env)->GetByteArrayRegion(env, ret, 0, 33, ret_ref.compressed_form);
        return ret_ref;
 }
-LDKThirtyTwoBytes release_commitment_secret_jcall(const void* this_arg, uint64_t idx) {
+LDKThirtyTwoBytes release_commitment_secret_LDKSign_jcall(const void* this_arg, uint64_t idx) {
        LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -2303,7 +2319,7 @@ LDKThirtyTwoBytes release_commitment_secret_jcall(const void* this_arg, uint64_t
        (*env)->GetByteArrayRegion(env, ret, 0, 32, ret_ref.data);
        return ret_ref;
 }
-LDKThirtyTwoBytes channel_keys_id_jcall(const void* this_arg) {
+LDKThirtyTwoBytes channel_keys_id_LDKSign_jcall(const void* this_arg) {
        LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -2315,7 +2331,7 @@ LDKThirtyTwoBytes channel_keys_id_jcall(const void* this_arg) {
        (*env)->GetByteArrayRegion(env, ret, 0, 32, ret_ref.data);
        return ret_ref;
 }
-LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_counterparty_commitment_jcall(const void* this_arg, const LDKCommitmentTransaction * commitment_tx) {
+LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_counterparty_commitment_LDKSign_jcall(const void* this_arg, const LDKCommitmentTransaction * commitment_tx) {
        LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -2334,7 +2350,7 @@ LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_counterparty_commitment_j
        ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone((LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)ret);
        return ret_conv;
 }
-LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_holder_commitment_and_htlcs_jcall(const void* this_arg, const LDKHolderCommitmentTransaction * commitment_tx) {
+LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_holder_commitment_and_htlcs_LDKSign_jcall(const void* this_arg, const LDKHolderCommitmentTransaction * commitment_tx) {
        LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -2353,7 +2369,7 @@ LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_holder_commitment_and_htl
        ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone((LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)ret);
        return ret_conv;
 }
-LDKCResult_SignatureNoneZ sign_justice_transaction_jcall(const void* this_arg, LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (* per_commitment_key)[32], const LDKHTLCOutputInCommitment * htlc) {
+LDKCResult_SignatureNoneZ sign_justice_transaction_LDKSign_jcall(const void* this_arg, LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (* per_commitment_key)[32], const LDKHTLCOutputInCommitment * htlc) {
        LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -2378,7 +2394,7 @@ LDKCResult_SignatureNoneZ sign_justice_transaction_jcall(const void* this_arg, L
        ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)ret);
        return ret_conv;
 }
-LDKCResult_SignatureNoneZ sign_counterparty_htlc_transaction_jcall(const void* this_arg, LDKTransaction htlc_tx, uintptr_t input, uint64_t amount, LDKPublicKey per_commitment_point, const LDKHTLCOutputInCommitment * htlc) {
+LDKCResult_SignatureNoneZ sign_counterparty_htlc_transaction_LDKSign_jcall(const void* this_arg, LDKTransaction htlc_tx, uintptr_t input, uint64_t amount, LDKPublicKey per_commitment_point, const LDKHTLCOutputInCommitment * htlc) {
        LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -2403,7 +2419,7 @@ LDKCResult_SignatureNoneZ sign_counterparty_htlc_transaction_jcall(const void* t
        ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)ret);
        return ret_conv;
 }
-LDKCResult_SignatureNoneZ sign_closing_transaction_jcall(const void* this_arg, LDKTransaction closing_tx) {
+LDKCResult_SignatureNoneZ sign_closing_transaction_LDKSign_jcall(const void* this_arg, LDKTransaction closing_tx) {
        LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -2418,7 +2434,7 @@ LDKCResult_SignatureNoneZ sign_closing_transaction_jcall(const void* this_arg, L
        ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)ret);
        return ret_conv;
 }
-LDKCResult_SignatureNoneZ sign_channel_announcement_jcall(const void* this_arg, const LDKUnsignedChannelAnnouncement * msg) {
+LDKCResult_SignatureNoneZ sign_channel_announcement_LDKSign_jcall(const void* this_arg, const LDKUnsignedChannelAnnouncement * msg) {
        LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -2437,7 +2453,7 @@ LDKCResult_SignatureNoneZ sign_channel_announcement_jcall(const void* this_arg,
        ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)ret);
        return ret_conv;
 }
-void ready_channel_jcall(void* this_arg, const LDKChannelTransactionParameters * channel_parameters) {
+void ready_channel_LDKSign_jcall(void* this_arg, const LDKChannelTransactionParameters * channel_parameters) {
        LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -2453,7 +2469,7 @@ void ready_channel_jcall(void* this_arg, const LDKChannelTransactionParameters *
        CHECK(obj != NULL);
        return (*env)->CallVoidMethod(env, obj, j_calls->ready_channel_meth, channel_parameters_ref);
 }
-LDKCVec_u8Z write_jcall(const void* this_arg) {
+LDKCVec_u8Z write_LDKSign_jcall(const void* this_arg) {
        LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -2508,18 +2524,18 @@ static inline LDKSign LDKSign_init (JNIEnv *env, jclass clz, jobject o, int64_t
 
        LDKSign ret = {
                .this_arg = (void*) calls,
-               .get_per_commitment_point = get_per_commitment_point_jcall,
-               .release_commitment_secret = release_commitment_secret_jcall,
-               .channel_keys_id = channel_keys_id_jcall,
-               .sign_counterparty_commitment = sign_counterparty_commitment_jcall,
-               .sign_holder_commitment_and_htlcs = sign_holder_commitment_and_htlcs_jcall,
-               .sign_justice_transaction = sign_justice_transaction_jcall,
-               .sign_counterparty_htlc_transaction = sign_counterparty_htlc_transaction_jcall,
-               .sign_closing_transaction = sign_closing_transaction_jcall,
-               .sign_channel_announcement = sign_channel_announcement_jcall,
-               .ready_channel = ready_channel_jcall,
+               .get_per_commitment_point = get_per_commitment_point_LDKSign_jcall,
+               .release_commitment_secret = release_commitment_secret_LDKSign_jcall,
+               .channel_keys_id = channel_keys_id_LDKSign_jcall,
+               .sign_counterparty_commitment = sign_counterparty_commitment_LDKSign_jcall,
+               .sign_holder_commitment_and_htlcs = sign_holder_commitment_and_htlcs_LDKSign_jcall,
+               .sign_justice_transaction = sign_justice_transaction_LDKSign_jcall,
+               .sign_counterparty_htlc_transaction = sign_counterparty_htlc_transaction_LDKSign_jcall,
+               .sign_closing_transaction = sign_closing_transaction_LDKSign_jcall,
+               .sign_channel_announcement = sign_channel_announcement_LDKSign_jcall,
+               .ready_channel = ready_channel_LDKSign_jcall,
                .clone = LDKSign_JCalls_clone,
-               .write = write_jcall,
+               .write = write_LDKSign_jcall,
                .free = LDKSign_JCalls_free,
                .pubkeys = pubkeys_conv,
                .set_pubkeys = NULL,
@@ -2991,7 +3007,7 @@ static void LDKWatch_JCalls_free(void* this_arg) {
                FREE(j_calls);
        }
 }
-LDKCResult_NoneChannelMonitorUpdateErrZ watch_channel_jcall(const void* this_arg, LDKOutPoint funding_txo, LDKChannelMonitor monitor) {
+LDKCResult_NoneChannelMonitorUpdateErrZ watch_channel_LDKWatch_jcall(const void* this_arg, LDKOutPoint funding_txo, LDKChannelMonitor monitor) {
        LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -3016,7 +3032,7 @@ LDKCResult_NoneChannelMonitorUpdateErrZ watch_channel_jcall(const void* this_arg
        ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)ret);
        return ret_conv;
 }
-LDKCResult_NoneChannelMonitorUpdateErrZ update_channel_jcall(const void* this_arg, LDKOutPoint funding_txo, LDKChannelMonitorUpdate update) {
+LDKCResult_NoneChannelMonitorUpdateErrZ update_channel_LDKWatch_jcall(const void* this_arg, LDKOutPoint funding_txo, LDKChannelMonitorUpdate update) {
        LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -3041,7 +3057,7 @@ LDKCResult_NoneChannelMonitorUpdateErrZ update_channel_jcall(const void* this_ar
        ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)ret);
        return ret_conv;
 }
-LDKCVec_MonitorEventZ release_pending_monitor_events_jcall(const void* this_arg) {
+LDKCVec_MonitorEventZ release_pending_monitor_events_LDKWatch_jcall(const void* this_arg) {
        LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -3085,9 +3101,9 @@ static inline LDKWatch LDKWatch_init (JNIEnv *env, jclass clz, jobject o) {
 
        LDKWatch ret = {
                .this_arg = (void*) calls,
-               .watch_channel = watch_channel_jcall,
-               .update_channel = update_channel_jcall,
-               .release_pending_monitor_events = release_pending_monitor_events_jcall,
+               .watch_channel = watch_channel_LDKWatch_jcall,
+               .update_channel = update_channel_LDKWatch_jcall,
+               .release_pending_monitor_events = release_pending_monitor_events_LDKWatch_jcall,
                .free = LDKWatch_JCalls_free,
        };
        return ret;
@@ -3158,7 +3174,7 @@ static void LDKBroadcasterInterface_JCalls_free(void* this_arg) {
                FREE(j_calls);
        }
 }
-void broadcast_transaction_jcall(const void* this_arg, LDKTransaction tx) {
+void broadcast_transaction_LDKBroadcasterInterface_jcall(const void* this_arg, LDKTransaction tx) {
        LDKBroadcasterInterface_JCalls *j_calls = (LDKBroadcasterInterface_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -3187,7 +3203,7 @@ static inline LDKBroadcasterInterface LDKBroadcasterInterface_init (JNIEnv *env,
 
        LDKBroadcasterInterface ret = {
                .this_arg = (void*) calls,
-               .broadcast_transaction = broadcast_transaction_jcall,
+               .broadcast_transaction = broadcast_transaction_LDKBroadcasterInterface_jcall,
                .free = LDKBroadcasterInterface_JCalls_free,
        };
        return ret;
@@ -3246,7 +3262,7 @@ static void LDKKeysInterface_JCalls_free(void* this_arg) {
                FREE(j_calls);
        }
 }
-LDKSecretKey get_node_secret_jcall(const void* this_arg) {
+LDKSecretKey get_node_secret_LDKKeysInterface_jcall(const void* this_arg) {
        LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -3258,7 +3274,7 @@ LDKSecretKey get_node_secret_jcall(const void* this_arg) {
        (*env)->GetByteArrayRegion(env, ret, 0, 32, ret_ref.bytes);
        return ret_ref;
 }
-LDKCVec_u8Z get_destination_script_jcall(const void* this_arg) {
+LDKCVec_u8Z get_destination_script_LDKKeysInterface_jcall(const void* this_arg) {
        LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -3271,7 +3287,7 @@ LDKCVec_u8Z get_destination_script_jcall(const void* this_arg) {
        (*env)->GetByteArrayRegion(env, ret, 0, ret_ref.datalen, ret_ref.data);
        return ret_ref;
 }
-LDKPublicKey get_shutdown_pubkey_jcall(const void* this_arg) {
+LDKPublicKey get_shutdown_pubkey_LDKKeysInterface_jcall(const void* this_arg) {
        LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -3283,7 +3299,7 @@ LDKPublicKey get_shutdown_pubkey_jcall(const void* this_arg) {
        (*env)->GetByteArrayRegion(env, ret, 0, 33, ret_ref.compressed_form);
        return ret_ref;
 }
-LDKSign get_channel_signer_jcall(const void* this_arg, bool inbound, uint64_t channel_value_satoshis) {
+LDKSign get_channel_signer_LDKKeysInterface_jcall(const void* this_arg, bool inbound, uint64_t channel_value_satoshis) {
        LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -3294,7 +3310,7 @@ LDKSign get_channel_signer_jcall(const void* this_arg, bool inbound, uint64_t ch
        ret_conv = Sign_clone(ret);
        return ret_conv;
 }
-LDKThirtyTwoBytes get_secure_random_bytes_jcall(const void* this_arg) {
+LDKThirtyTwoBytes get_secure_random_bytes_LDKKeysInterface_jcall(const void* this_arg) {
        LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -3306,7 +3322,7 @@ LDKThirtyTwoBytes get_secure_random_bytes_jcall(const void* this_arg) {
        (*env)->GetByteArrayRegion(env, ret, 0, 32, ret_ref.data);
        return ret_ref;
 }
-LDKCResult_SignDecodeErrorZ read_chan_signer_jcall(const void* this_arg, LDKu8slice reader) {
+LDKCResult_SignDecodeErrorZ read_chan_signer_LDKKeysInterface_jcall(const void* this_arg, LDKu8slice reader) {
        LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -3347,12 +3363,12 @@ static inline LDKKeysInterface LDKKeysInterface_init (JNIEnv *env, jclass clz, j
 
        LDKKeysInterface ret = {
                .this_arg = (void*) calls,
-               .get_node_secret = get_node_secret_jcall,
-               .get_destination_script = get_destination_script_jcall,
-               .get_shutdown_pubkey = get_shutdown_pubkey_jcall,
-               .get_channel_signer = get_channel_signer_jcall,
-               .get_secure_random_bytes = get_secure_random_bytes_jcall,
-               .read_chan_signer = read_chan_signer_jcall,
+               .get_node_secret = get_node_secret_LDKKeysInterface_jcall,
+               .get_destination_script = get_destination_script_LDKKeysInterface_jcall,
+               .get_shutdown_pubkey = get_shutdown_pubkey_LDKKeysInterface_jcall,
+               .get_channel_signer = get_channel_signer_LDKKeysInterface_jcall,
+               .get_secure_random_bytes = get_secure_random_bytes_LDKKeysInterface_jcall,
+               .read_chan_signer = read_chan_signer_LDKKeysInterface_jcall,
                .free = LDKKeysInterface_JCalls_free,
        };
        return ret;
@@ -3425,7 +3441,7 @@ static void LDKFeeEstimator_JCalls_free(void* this_arg) {
                FREE(j_calls);
        }
 }
-uint32_t get_est_sat_per_1000_weight_jcall(const void* this_arg, LDKConfirmationTarget confirmation_target) {
+uint32_t get_est_sat_per_1000_weight_LDKFeeEstimator_jcall(const void* this_arg, LDKConfirmationTarget confirmation_target) {
        LDKFeeEstimator_JCalls *j_calls = (LDKFeeEstimator_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -3451,7 +3467,7 @@ static inline LDKFeeEstimator LDKFeeEstimator_init (JNIEnv *env, jclass clz, job
 
        LDKFeeEstimator ret = {
                .this_arg = (void*) calls,
-               .get_est_sat_per_1000_weight = get_est_sat_per_1000_weight_jcall,
+               .get_est_sat_per_1000_weight = get_est_sat_per_1000_weight_LDKFeeEstimator_jcall,
                .free = LDKFeeEstimator_JCalls_free,
        };
        return ret;
@@ -3483,7 +3499,7 @@ static void LDKLogger_JCalls_free(void* this_arg) {
                FREE(j_calls);
        }
 }
-void log_jcall(const void* this_arg, const char* record) {
+void log_LDKLogger_jcall(const void* this_arg, const char* record) {
        LDKLogger_JCalls *j_calls = (LDKLogger_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -3510,7 +3526,7 @@ static inline LDKLogger LDKLogger_init (JNIEnv *env, jclass clz, jobject o) {
 
        LDKLogger ret = {
                .this_arg = (void*) calls,
-               .log = log_jcall,
+               .log = log_LDKLogger_jcall,
                .free = LDKLogger_JCalls_free,
        };
        return ret;
@@ -4585,7 +4601,7 @@ static void LDKMessageSendEventsProvider_JCalls_free(void* this_arg) {
                FREE(j_calls);
        }
 }
-LDKCVec_MessageSendEventZ get_and_clear_pending_msg_events_jcall(const void* this_arg) {
+LDKCVec_MessageSendEventZ get_and_clear_pending_msg_events_LDKMessageSendEventsProvider_jcall(const void* this_arg) {
        LDKMessageSendEventsProvider_JCalls *j_calls = (LDKMessageSendEventsProvider_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -4625,7 +4641,7 @@ static inline LDKMessageSendEventsProvider LDKMessageSendEventsProvider_init (JN
 
        LDKMessageSendEventsProvider ret = {
                .this_arg = (void*) calls,
-               .get_and_clear_pending_msg_events = get_and_clear_pending_msg_events_jcall,
+               .get_and_clear_pending_msg_events = get_and_clear_pending_msg_events_LDKMessageSendEventsProvider_jcall,
                .free = LDKMessageSendEventsProvider_JCalls_free,
        };
        return ret;
@@ -4666,7 +4682,7 @@ static void LDKEventsProvider_JCalls_free(void* this_arg) {
                FREE(j_calls);
        }
 }
-LDKCVec_EventZ get_and_clear_pending_events_jcall(const void* this_arg) {
+LDKCVec_EventZ get_and_clear_pending_events_LDKEventsProvider_jcall(const void* this_arg) {
        LDKEventsProvider_JCalls *j_calls = (LDKEventsProvider_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -4706,7 +4722,7 @@ static inline LDKEventsProvider LDKEventsProvider_init (JNIEnv *env, jclass clz,
 
        LDKEventsProvider ret = {
                .this_arg = (void*) calls,
-               .get_and_clear_pending_events = get_and_clear_pending_events_jcall,
+               .get_and_clear_pending_events = get_and_clear_pending_events_LDKEventsProvider_jcall,
                .free = LDKEventsProvider_JCalls_free,
        };
        return ret;
@@ -4747,7 +4763,7 @@ static void LDKAccess_JCalls_free(void* this_arg) {
                FREE(j_calls);
        }
 }
-LDKCResult_TxOutAccessErrorZ get_utxo_jcall(const void* this_arg, const uint8_t (* genesis_hash)[32], uint64_t short_channel_id) {
+LDKCResult_TxOutAccessErrorZ get_utxo_LDKAccess_jcall(const void* this_arg, const uint8_t (* genesis_hash)[32], uint64_t short_channel_id) {
        LDKAccess_JCalls *j_calls = (LDKAccess_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -4777,7 +4793,7 @@ static inline LDKAccess LDKAccess_init (JNIEnv *env, jclass clz, jobject o) {
 
        LDKAccess ret = {
                .this_arg = (void*) calls,
-               .get_utxo = get_utxo_jcall,
+               .get_utxo = get_utxo_LDKAccess_jcall,
                .free = LDKAccess_JCalls_free,
        };
        return ret;
@@ -4814,7 +4830,7 @@ static void LDKListen_JCalls_free(void* this_arg) {
                FREE(j_calls);
        }
 }
-void block_connected_jcall(const void* this_arg, LDKu8slice block, uint32_t height) {
+void block_connected_LDKListen_jcall(const void* this_arg, LDKu8slice block, uint32_t height) {
        LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -4825,7 +4841,7 @@ void block_connected_jcall(const void* this_arg, LDKu8slice block, uint32_t heig
        CHECK(obj != NULL);
        return (*env)->CallVoidMethod(env, obj, j_calls->block_connected_meth, block_arr, height);
 }
-void block_disconnected_jcall(const void* this_arg, const uint8_t (* header)[80], uint32_t height) {
+void block_disconnected_LDKListen_jcall(const void* this_arg, const uint8_t (* header)[80], uint32_t height) {
        LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -4854,8 +4870,8 @@ static inline LDKListen LDKListen_init (JNIEnv *env, jclass clz, jobject o) {
 
        LDKListen ret = {
                .this_arg = (void*) calls,
-               .block_connected = block_connected_jcall,
-               .block_disconnected = block_disconnected_jcall,
+               .block_connected = block_connected_LDKListen_jcall,
+               .block_disconnected = block_disconnected_LDKListen_jcall,
                .free = LDKListen_JCalls_free,
        };
        return ret;
@@ -4899,7 +4915,7 @@ static void LDKFilter_JCalls_free(void* this_arg) {
                FREE(j_calls);
        }
 }
-void register_tx_jcall(const void* this_arg, const uint8_t (* txid)[32], LDKu8slice script_pubkey) {
+void register_tx_LDKFilter_jcall(const void* this_arg, const uint8_t (* txid)[32], LDKu8slice script_pubkey) {
        LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -4912,7 +4928,7 @@ void register_tx_jcall(const void* this_arg, const uint8_t (* txid)[32], LDKu8sl
        CHECK(obj != NULL);
        return (*env)->CallVoidMethod(env, obj, j_calls->register_tx_meth, txid_arr, script_pubkey_arr);
 }
-void register_output_jcall(const void* this_arg, const LDKOutPoint * outpoint, LDKu8slice script_pubkey) {
+void register_output_LDKFilter_jcall(const void* this_arg, const LDKOutPoint * outpoint, LDKu8slice script_pubkey) {
        LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -4950,8 +4966,8 @@ static inline LDKFilter LDKFilter_init (JNIEnv *env, jclass clz, jobject o) {
 
        LDKFilter ret = {
                .this_arg = (void*) calls,
-               .register_tx = register_tx_jcall,
-               .register_output = register_output_jcall,
+               .register_tx = register_tx_LDKFilter_jcall,
+               .register_output = register_output_LDKFilter_jcall,
                .free = LDKFilter_JCalls_free,
        };
        return ret;
@@ -5002,7 +5018,7 @@ static void LDKPersist_JCalls_free(void* this_arg) {
                FREE(j_calls);
        }
 }
-LDKCResult_NoneChannelMonitorUpdateErrZ persist_new_channel_jcall(const void* this_arg, LDKOutPoint id, const LDKChannelMonitor * data) {
+LDKCResult_NoneChannelMonitorUpdateErrZ persist_new_channel_LDKPersist_jcall(const void* this_arg, LDKOutPoint id, const LDKChannelMonitor * data) {
        LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -5028,7 +5044,7 @@ LDKCResult_NoneChannelMonitorUpdateErrZ persist_new_channel_jcall(const void* th
        ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)ret);
        return ret_conv;
 }
-LDKCResult_NoneChannelMonitorUpdateErrZ update_persisted_channel_jcall(const void* this_arg, LDKOutPoint id, const LDKChannelMonitorUpdate * update, const LDKChannelMonitor * data) {
+LDKCResult_NoneChannelMonitorUpdateErrZ update_persisted_channel_LDKPersist_jcall(const void* this_arg, LDKOutPoint id, const LDKChannelMonitorUpdate * update, const LDKChannelMonitor * data) {
        LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -5081,8 +5097,8 @@ static inline LDKPersist LDKPersist_init (JNIEnv *env, jclass clz, jobject o) {
 
        LDKPersist ret = {
                .this_arg = (void*) calls,
-               .persist_new_channel = persist_new_channel_jcall,
-               .update_persisted_channel = update_persisted_channel_jcall,
+               .persist_new_channel = persist_new_channel_LDKPersist_jcall,
+               .update_persisted_channel = update_persisted_channel_LDKPersist_jcall,
                .free = LDKPersist_JCalls_free,
        };
        return ret;
@@ -5146,6 +5162,7 @@ typedef struct LDKChannelMessageHandler_JCalls {
        jmethodID peer_disconnected_meth;
        jmethodID peer_connected_meth;
        jmethodID handle_channel_reestablish_meth;
+       jmethodID handle_channel_update_meth;
        jmethodID handle_error_meth;
 } LDKChannelMessageHandler_JCalls;
 static void LDKChannelMessageHandler_JCalls_free(void* this_arg) {
@@ -5157,7 +5174,7 @@ static void LDKChannelMessageHandler_JCalls_free(void* this_arg) {
                FREE(j_calls);
        }
 }
-void handle_open_channel_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKInitFeatures their_features, const LDKOpenChannel * msg) {
+void handle_open_channel_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKInitFeatures their_features, const LDKOpenChannel * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -5182,7 +5199,7 @@ void handle_open_channel_jcall(const void* this_arg, LDKPublicKey their_node_id,
        CHECK(obj != NULL);
        return (*env)->CallVoidMethod(env, obj, j_calls->handle_open_channel_meth, their_node_id_arr, their_features_ref, msg_ref);
 }
-void handle_accept_channel_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKInitFeatures their_features, const LDKAcceptChannel * msg) {
+void handle_accept_channel_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKInitFeatures their_features, const LDKAcceptChannel * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -5207,7 +5224,7 @@ void handle_accept_channel_jcall(const void* this_arg, LDKPublicKey their_node_i
        CHECK(obj != NULL);
        return (*env)->CallVoidMethod(env, obj, j_calls->handle_accept_channel_meth, their_node_id_arr, their_features_ref, msg_ref);
 }
-void handle_funding_created_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKFundingCreated * msg) {
+void handle_funding_created_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKFundingCreated * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -5225,7 +5242,7 @@ void handle_funding_created_jcall(const void* this_arg, LDKPublicKey their_node_
        CHECK(obj != NULL);
        return (*env)->CallVoidMethod(env, obj, j_calls->handle_funding_created_meth, their_node_id_arr, msg_ref);
 }
-void handle_funding_signed_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKFundingSigned * msg) {
+void handle_funding_signed_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKFundingSigned * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -5243,7 +5260,7 @@ void handle_funding_signed_jcall(const void* this_arg, LDKPublicKey their_node_i
        CHECK(obj != NULL);
        return (*env)->CallVoidMethod(env, obj, j_calls->handle_funding_signed_meth, their_node_id_arr, msg_ref);
 }
-void handle_funding_locked_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKFundingLocked * msg) {
+void handle_funding_locked_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKFundingLocked * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -5261,7 +5278,7 @@ void handle_funding_locked_jcall(const void* this_arg, LDKPublicKey their_node_i
        CHECK(obj != NULL);
        return (*env)->CallVoidMethod(env, obj, j_calls->handle_funding_locked_meth, their_node_id_arr, msg_ref);
 }
-void handle_shutdown_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInitFeatures * their_features, const LDKShutdown * msg) {
+void handle_shutdown_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInitFeatures * their_features, const LDKShutdown * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -5287,7 +5304,7 @@ void handle_shutdown_jcall(const void* this_arg, LDKPublicKey their_node_id, con
        CHECK(obj != NULL);
        return (*env)->CallVoidMethod(env, obj, j_calls->handle_shutdown_meth, their_node_id_arr, their_features_ref, msg_ref);
 }
-void handle_closing_signed_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKClosingSigned * msg) {
+void handle_closing_signed_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKClosingSigned * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -5305,7 +5322,7 @@ void handle_closing_signed_jcall(const void* this_arg, LDKPublicKey their_node_i
        CHECK(obj != NULL);
        return (*env)->CallVoidMethod(env, obj, j_calls->handle_closing_signed_meth, their_node_id_arr, msg_ref);
 }
-void handle_update_add_htlc_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateAddHTLC * msg) {
+void handle_update_add_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateAddHTLC * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -5323,7 +5340,7 @@ void handle_update_add_htlc_jcall(const void* this_arg, LDKPublicKey their_node_
        CHECK(obj != NULL);
        return (*env)->CallVoidMethod(env, obj, j_calls->handle_update_add_htlc_meth, their_node_id_arr, msg_ref);
 }
-void handle_update_fulfill_htlc_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFulfillHTLC * msg) {
+void handle_update_fulfill_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFulfillHTLC * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -5341,7 +5358,7 @@ void handle_update_fulfill_htlc_jcall(const void* this_arg, LDKPublicKey their_n
        CHECK(obj != NULL);
        return (*env)->CallVoidMethod(env, obj, j_calls->handle_update_fulfill_htlc_meth, their_node_id_arr, msg_ref);
 }
-void handle_update_fail_htlc_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFailHTLC * msg) {
+void handle_update_fail_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFailHTLC * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -5359,7 +5376,7 @@ void handle_update_fail_htlc_jcall(const void* this_arg, LDKPublicKey their_node
        CHECK(obj != NULL);
        return (*env)->CallVoidMethod(env, obj, j_calls->handle_update_fail_htlc_meth, their_node_id_arr, msg_ref);
 }
-void handle_update_fail_malformed_htlc_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFailMalformedHTLC * msg) {
+void handle_update_fail_malformed_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFailMalformedHTLC * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -5377,7 +5394,7 @@ void handle_update_fail_malformed_htlc_jcall(const void* this_arg, LDKPublicKey
        CHECK(obj != NULL);
        return (*env)->CallVoidMethod(env, obj, j_calls->handle_update_fail_malformed_htlc_meth, their_node_id_arr, msg_ref);
 }
-void handle_commitment_signed_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKCommitmentSigned * msg) {
+void handle_commitment_signed_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKCommitmentSigned * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -5395,7 +5412,7 @@ void handle_commitment_signed_jcall(const void* this_arg, LDKPublicKey their_nod
        CHECK(obj != NULL);
        return (*env)->CallVoidMethod(env, obj, j_calls->handle_commitment_signed_meth, their_node_id_arr, msg_ref);
 }
-void handle_revoke_and_ack_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKRevokeAndACK * msg) {
+void handle_revoke_and_ack_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKRevokeAndACK * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -5413,7 +5430,7 @@ void handle_revoke_and_ack_jcall(const void* this_arg, LDKPublicKey their_node_i
        CHECK(obj != NULL);
        return (*env)->CallVoidMethod(env, obj, j_calls->handle_revoke_and_ack_meth, their_node_id_arr, msg_ref);
 }
-void handle_update_fee_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFee * msg) {
+void handle_update_fee_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFee * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -5431,7 +5448,7 @@ void handle_update_fee_jcall(const void* this_arg, LDKPublicKey their_node_id, c
        CHECK(obj != NULL);
        return (*env)->CallVoidMethod(env, obj, j_calls->handle_update_fee_meth, their_node_id_arr, msg_ref);
 }
-void handle_announcement_signatures_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKAnnouncementSignatures * msg) {
+void handle_announcement_signatures_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKAnnouncementSignatures * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -5449,7 +5466,7 @@ void handle_announcement_signatures_jcall(const void* this_arg, LDKPublicKey the
        CHECK(obj != NULL);
        return (*env)->CallVoidMethod(env, obj, j_calls->handle_announcement_signatures_meth, their_node_id_arr, msg_ref);
 }
-void peer_disconnected_jcall(const void* this_arg, LDKPublicKey their_node_id, bool no_connection_possible) {
+void peer_disconnected_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, bool no_connection_possible) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -5459,7 +5476,7 @@ void peer_disconnected_jcall(const void* this_arg, LDKPublicKey their_node_id, b
        CHECK(obj != NULL);
        return (*env)->CallVoidMethod(env, obj, j_calls->peer_disconnected_meth, their_node_id_arr, no_connection_possible);
 }
-void peer_connected_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInit * msg) {
+void peer_connected_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInit * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -5477,7 +5494,7 @@ void peer_connected_jcall(const void* this_arg, LDKPublicKey their_node_id, cons
        CHECK(obj != NULL);
        return (*env)->CallVoidMethod(env, obj, j_calls->peer_connected_meth, their_node_id_arr, msg_ref);
 }
-void handle_channel_reestablish_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKChannelReestablish * msg) {
+void handle_channel_reestablish_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKChannelReestablish * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -5495,7 +5512,25 @@ void handle_channel_reestablish_jcall(const void* this_arg, LDKPublicKey their_n
        CHECK(obj != NULL);
        return (*env)->CallVoidMethod(env, obj, j_calls->handle_channel_reestablish_meth, their_node_id_arr, msg_ref);
 }
-void handle_error_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKErrorMessage * msg) {
+void handle_channel_update_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKChannelUpdate * msg) {
+       LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
+       JNIEnv *env;
+       DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
+       int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
+       (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
+       LDKChannelUpdate msg_var = *msg;
+       msg_var = ChannelUpdate_clone(msg);
+       CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+       CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+       long msg_ref = (long)msg_var.inner;
+       if (msg_var.is_owned) {
+               msg_ref |= 1;
+       }
+       jobject obj = (*env)->NewLocalRef(env, j_calls->o);
+       CHECK(obj != NULL);
+       return (*env)->CallVoidMethod(env, obj, j_calls->handle_channel_update_meth, their_node_id_arr, msg_ref);
+}
+void handle_error_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKErrorMessage * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -5562,30 +5597,33 @@ static inline LDKChannelMessageHandler LDKChannelMessageHandler_init (JNIEnv *en
        CHECK(calls->peer_connected_meth != NULL);
        calls->handle_channel_reestablish_meth = (*env)->GetMethodID(env, c, "handle_channel_reestablish", "([BJ)V");
        CHECK(calls->handle_channel_reestablish_meth != NULL);
+       calls->handle_channel_update_meth = (*env)->GetMethodID(env, c, "handle_channel_update", "([BJ)V");
+       CHECK(calls->handle_channel_update_meth != NULL);
        calls->handle_error_meth = (*env)->GetMethodID(env, c, "handle_error", "([BJ)V");
        CHECK(calls->handle_error_meth != NULL);
 
        LDKChannelMessageHandler ret = {
                .this_arg = (void*) calls,
-               .handle_open_channel = handle_open_channel_jcall,
-               .handle_accept_channel = handle_accept_channel_jcall,
-               .handle_funding_created = handle_funding_created_jcall,
-               .handle_funding_signed = handle_funding_signed_jcall,
-               .handle_funding_locked = handle_funding_locked_jcall,
-               .handle_shutdown = handle_shutdown_jcall,
-               .handle_closing_signed = handle_closing_signed_jcall,
-               .handle_update_add_htlc = handle_update_add_htlc_jcall,
-               .handle_update_fulfill_htlc = handle_update_fulfill_htlc_jcall,
-               .handle_update_fail_htlc = handle_update_fail_htlc_jcall,
-               .handle_update_fail_malformed_htlc = handle_update_fail_malformed_htlc_jcall,
-               .handle_commitment_signed = handle_commitment_signed_jcall,
-               .handle_revoke_and_ack = handle_revoke_and_ack_jcall,
-               .handle_update_fee = handle_update_fee_jcall,
-               .handle_announcement_signatures = handle_announcement_signatures_jcall,
-               .peer_disconnected = peer_disconnected_jcall,
-               .peer_connected = peer_connected_jcall,
-               .handle_channel_reestablish = handle_channel_reestablish_jcall,
-               .handle_error = handle_error_jcall,
+               .handle_open_channel = handle_open_channel_LDKChannelMessageHandler_jcall,
+               .handle_accept_channel = handle_accept_channel_LDKChannelMessageHandler_jcall,
+               .handle_funding_created = handle_funding_created_LDKChannelMessageHandler_jcall,
+               .handle_funding_signed = handle_funding_signed_LDKChannelMessageHandler_jcall,
+               .handle_funding_locked = handle_funding_locked_LDKChannelMessageHandler_jcall,
+               .handle_shutdown = handle_shutdown_LDKChannelMessageHandler_jcall,
+               .handle_closing_signed = handle_closing_signed_LDKChannelMessageHandler_jcall,
+               .handle_update_add_htlc = handle_update_add_htlc_LDKChannelMessageHandler_jcall,
+               .handle_update_fulfill_htlc = handle_update_fulfill_htlc_LDKChannelMessageHandler_jcall,
+               .handle_update_fail_htlc = handle_update_fail_htlc_LDKChannelMessageHandler_jcall,
+               .handle_update_fail_malformed_htlc = handle_update_fail_malformed_htlc_LDKChannelMessageHandler_jcall,
+               .handle_commitment_signed = handle_commitment_signed_LDKChannelMessageHandler_jcall,
+               .handle_revoke_and_ack = handle_revoke_and_ack_LDKChannelMessageHandler_jcall,
+               .handle_update_fee = handle_update_fee_LDKChannelMessageHandler_jcall,
+               .handle_announcement_signatures = handle_announcement_signatures_LDKChannelMessageHandler_jcall,
+               .peer_disconnected = peer_disconnected_LDKChannelMessageHandler_jcall,
+               .peer_connected = peer_connected_LDKChannelMessageHandler_jcall,
+               .handle_channel_reestablish = handle_channel_reestablish_LDKChannelMessageHandler_jcall,
+               .handle_channel_update = handle_channel_update_LDKChannelMessageHandler_jcall,
+               .handle_error = handle_error_LDKChannelMessageHandler_jcall,
                .free = LDKChannelMessageHandler_JCalls_free,
                .MessageSendEventsProvider = LDKMessageSendEventsProvider_init(env, clz, MessageSendEventsProvider),
        };
@@ -5803,6 +5841,17 @@ JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMessageHandler_1handle_
        (this_arg_conv->handle_channel_reestablish)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
 }
 
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMessageHandler_1handle_1channel_1update(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id, int64_t msg) {
+       LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
+       LDKPublicKey their_node_id_ref;
+       CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
+       (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
+       LDKChannelUpdate msg_conv;
+       msg_conv.inner = (void*)(msg & (~1));
+       msg_conv.is_owned = false;
+       (this_arg_conv->handle_channel_update)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
+}
+
 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMessageHandler_1handle_1error(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id, int64_t msg) {
        LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
        LDKPublicKey their_node_id_ref;
@@ -5840,7 +5889,7 @@ static void LDKRoutingMessageHandler_JCalls_free(void* this_arg) {
                FREE(j_calls);
        }
 }
-LDKCResult_boolLightningErrorZ handle_node_announcement_jcall(const void* this_arg, const LDKNodeAnnouncement * msg) {
+LDKCResult_boolLightningErrorZ handle_node_announcement_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKNodeAnnouncement * msg) {
        LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -5859,7 +5908,7 @@ LDKCResult_boolLightningErrorZ handle_node_announcement_jcall(const void* this_a
        ret_conv = CResult_boolLightningErrorZ_clone((LDKCResult_boolLightningErrorZ*)ret);
        return ret_conv;
 }
-LDKCResult_boolLightningErrorZ handle_channel_announcement_jcall(const void* this_arg, const LDKChannelAnnouncement * msg) {
+LDKCResult_boolLightningErrorZ handle_channel_announcement_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKChannelAnnouncement * msg) {
        LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -5878,7 +5927,7 @@ LDKCResult_boolLightningErrorZ handle_channel_announcement_jcall(const void* thi
        ret_conv = CResult_boolLightningErrorZ_clone((LDKCResult_boolLightningErrorZ*)ret);
        return ret_conv;
 }
-LDKCResult_boolLightningErrorZ handle_channel_update_jcall(const void* this_arg, const LDKChannelUpdate * msg) {
+LDKCResult_boolLightningErrorZ handle_channel_update_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKChannelUpdate * msg) {
        LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -5897,7 +5946,7 @@ LDKCResult_boolLightningErrorZ handle_channel_update_jcall(const void* this_arg,
        ret_conv = CResult_boolLightningErrorZ_clone((LDKCResult_boolLightningErrorZ*)ret);
        return ret_conv;
 }
-void handle_htlc_fail_channel_update_jcall(const void* this_arg, const LDKHTLCFailChannelUpdate * update) {
+void handle_htlc_fail_channel_update_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKHTLCFailChannelUpdate * update) {
        LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -5906,7 +5955,7 @@ void handle_htlc_fail_channel_update_jcall(const void* this_arg, const LDKHTLCFa
        CHECK(obj != NULL);
        return (*env)->CallVoidMethod(env, obj, j_calls->handle_htlc_fail_channel_update_meth, ret_update);
 }
-LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ get_next_channel_announcements_jcall(const void* this_arg, uint64_t starting_point, uint8_t batch_amount) {
+LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ get_next_channel_announcements_LDKRoutingMessageHandler_jcall(const void* this_arg, uint64_t starting_point, uint8_t batch_amount) {
        LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -5929,7 +5978,7 @@ LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ get_next_channel
        (*env)->ReleaseLongArrayElements(env, ret, ret_vals, 0);
        return ret_constr;
 }
-LDKCVec_NodeAnnouncementZ get_next_node_announcements_jcall(const void* this_arg, LDKPublicKey starting_point, uint8_t batch_amount) {
+LDKCVec_NodeAnnouncementZ get_next_node_announcements_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey starting_point, uint8_t batch_amount) {
        LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -5956,7 +6005,7 @@ LDKCVec_NodeAnnouncementZ get_next_node_announcements_jcall(const void* this_arg
        (*env)->ReleaseLongArrayElements(env, ret, ret_vals, 0);
        return ret_constr;
 }
-void sync_routing_table_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInit * init) {
+void sync_routing_table_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInit * init) {
        LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -5974,7 +6023,7 @@ void sync_routing_table_jcall(const void* this_arg, LDKPublicKey their_node_id,
        CHECK(obj != NULL);
        return (*env)->CallVoidMethod(env, obj, j_calls->sync_routing_table_meth, their_node_id_arr, init_ref);
 }
-LDKCResult_NoneLightningErrorZ handle_reply_channel_range_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKReplyChannelRange msg) {
+LDKCResult_NoneLightningErrorZ handle_reply_channel_range_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKReplyChannelRange msg) {
        LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -5994,7 +6043,7 @@ LDKCResult_NoneLightningErrorZ handle_reply_channel_range_jcall(const void* this
        ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)ret);
        return ret_conv;
 }
-LDKCResult_NoneLightningErrorZ handle_reply_short_channel_ids_end_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKReplyShortChannelIdsEnd msg) {
+LDKCResult_NoneLightningErrorZ handle_reply_short_channel_ids_end_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKReplyShortChannelIdsEnd msg) {
        LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -6014,7 +6063,7 @@ LDKCResult_NoneLightningErrorZ handle_reply_short_channel_ids_end_jcall(const vo
        ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)ret);
        return ret_conv;
 }
-LDKCResult_NoneLightningErrorZ handle_query_channel_range_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKQueryChannelRange msg) {
+LDKCResult_NoneLightningErrorZ handle_query_channel_range_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKQueryChannelRange msg) {
        LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -6034,7 +6083,7 @@ LDKCResult_NoneLightningErrorZ handle_query_channel_range_jcall(const void* this
        ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)ret);
        return ret_conv;
 }
-LDKCResult_NoneLightningErrorZ handle_query_short_channel_ids_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKQueryShortChannelIds msg) {
+LDKCResult_NoneLightningErrorZ handle_query_short_channel_ids_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKQueryShortChannelIds msg) {
        LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -6092,17 +6141,17 @@ static inline LDKRoutingMessageHandler LDKRoutingMessageHandler_init (JNIEnv *en
 
        LDKRoutingMessageHandler ret = {
                .this_arg = (void*) calls,
-               .handle_node_announcement = handle_node_announcement_jcall,
-               .handle_channel_announcement = handle_channel_announcement_jcall,
-               .handle_channel_update = handle_channel_update_jcall,
-               .handle_htlc_fail_channel_update = handle_htlc_fail_channel_update_jcall,
-               .get_next_channel_announcements = get_next_channel_announcements_jcall,
-               .get_next_node_announcements = get_next_node_announcements_jcall,
-               .sync_routing_table = sync_routing_table_jcall,
-               .handle_reply_channel_range = handle_reply_channel_range_jcall,
-               .handle_reply_short_channel_ids_end = handle_reply_short_channel_ids_end_jcall,
-               .handle_query_channel_range = handle_query_channel_range_jcall,
-               .handle_query_short_channel_ids = handle_query_short_channel_ids_jcall,
+               .handle_node_announcement = handle_node_announcement_LDKRoutingMessageHandler_jcall,
+               .handle_channel_announcement = handle_channel_announcement_LDKRoutingMessageHandler_jcall,
+               .handle_channel_update = handle_channel_update_LDKRoutingMessageHandler_jcall,
+               .handle_htlc_fail_channel_update = handle_htlc_fail_channel_update_LDKRoutingMessageHandler_jcall,
+               .get_next_channel_announcements = get_next_channel_announcements_LDKRoutingMessageHandler_jcall,
+               .get_next_node_announcements = get_next_node_announcements_LDKRoutingMessageHandler_jcall,
+               .sync_routing_table = sync_routing_table_LDKRoutingMessageHandler_jcall,
+               .handle_reply_channel_range = handle_reply_channel_range_LDKRoutingMessageHandler_jcall,
+               .handle_reply_short_channel_ids_end = handle_reply_short_channel_ids_end_LDKRoutingMessageHandler_jcall,
+               .handle_query_channel_range = handle_query_channel_range_LDKRoutingMessageHandler_jcall,
+               .handle_query_short_channel_ids = handle_query_short_channel_ids_LDKRoutingMessageHandler_jcall,
                .free = LDKRoutingMessageHandler_JCalls_free,
                .MessageSendEventsProvider = LDKMessageSendEventsProvider_init(env, clz, MessageSendEventsProvider),
        };
@@ -6273,7 +6322,7 @@ static void LDKSocketDescriptor_JCalls_free(void* this_arg) {
                FREE(j_calls);
        }
 }
-uintptr_t send_data_jcall(void* this_arg, LDKu8slice data, bool resume_read) {
+uintptr_t send_data_LDKSocketDescriptor_jcall(void* this_arg, LDKu8slice data, bool resume_read) {
        LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -6284,7 +6333,7 @@ uintptr_t send_data_jcall(void* this_arg, LDKu8slice data, bool resume_read) {
        CHECK(obj != NULL);
        return (*env)->CallLongMethod(env, obj, j_calls->send_data_meth, data_arr, resume_read);
 }
-void disconnect_socket_jcall(void* this_arg) {
+void disconnect_socket_LDKSocketDescriptor_jcall(void* this_arg) {
        LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -6292,7 +6341,7 @@ void disconnect_socket_jcall(void* this_arg) {
        CHECK(obj != NULL);
        return (*env)->CallVoidMethod(env, obj, j_calls->disconnect_socket_meth);
 }
-bool eq_jcall(const void* this_arg, const LDKSocketDescriptor * other_arg) {
+bool eq_LDKSocketDescriptor_jcall(const void* this_arg, const LDKSocketDescriptor * other_arg) {
        LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -6302,7 +6351,7 @@ bool eq_jcall(const void* this_arg, const LDKSocketDescriptor * other_arg) {
        CHECK(obj != NULL);
        return (*env)->CallBooleanMethod(env, obj, j_calls->eq_meth, (long)other_arg_clone);
 }
-uint64_t hash_jcall(const void* this_arg) {
+uint64_t hash_LDKSocketDescriptor_jcall(const void* this_arg) {
        LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
        JNIEnv *env;
        DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
@@ -6333,10 +6382,10 @@ static inline LDKSocketDescriptor LDKSocketDescriptor_init (JNIEnv *env, jclass
 
        LDKSocketDescriptor ret = {
                .this_arg = (void*) calls,
-               .send_data = send_data_jcall,
-               .disconnect_socket = disconnect_socket_jcall,
-               .eq = eq_jcall,
-               .hash = hash_jcall,
+               .send_data = send_data_LDKSocketDescriptor_jcall,
+               .disconnect_socket = disconnect_socket_LDKSocketDescriptor_jcall,
+               .eq = eq_LDKSocketDescriptor_jcall,
+               .hash = hash_LDKSocketDescriptor_jcall,
                .clone = LDKSocketDescriptor_JCalls_clone,
                .free = LDKSocketDescriptor_JCalls_free,
        };
@@ -10189,6 +10238,21 @@ JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1set_1fee_1propo
        ChannelConfig_set_fee_proportional_millionths(&this_ptr_conv, val);
 }
 
+JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1get_1cltv_1expiry_1delta(JNIEnv *env, jclass clz, int64_t this_ptr) {
+       LDKChannelConfig this_ptr_conv;
+       this_ptr_conv.inner = (void*)(this_ptr & (~1));
+       this_ptr_conv.is_owned = false;
+       int16_t ret_val = ChannelConfig_get_cltv_expiry_delta(&this_ptr_conv);
+       return ret_val;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1set_1cltv_1expiry_1delta(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
+       LDKChannelConfig this_ptr_conv;
+       this_ptr_conv.inner = (void*)(this_ptr & (~1));
+       this_ptr_conv.is_owned = false;
+       ChannelConfig_set_cltv_expiry_delta(&this_ptr_conv, val);
+}
+
 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1get_1announced_1channel(JNIEnv *env, jclass clz, int64_t this_ptr) {
        LDKChannelConfig this_ptr_conv;
        this_ptr_conv.inner = (void*)(this_ptr & (~1));
@@ -10219,8 +10283,8 @@ JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1set_1commit_1up
        ChannelConfig_set_commit_upfront_shutdown_pubkey(&this_ptr_conv, val);
 }
 
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1new(JNIEnv *env, jclass clz, int32_t fee_proportional_millionths_arg, jboolean announced_channel_arg, jboolean commit_upfront_shutdown_pubkey_arg) {
-       LDKChannelConfig ret_var = ChannelConfig_new(fee_proportional_millionths_arg, announced_channel_arg, commit_upfront_shutdown_pubkey_arg);
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1new(JNIEnv *env, jclass clz, int32_t fee_proportional_millionths_arg, int16_t cltv_expiry_delta_arg, jboolean announced_channel_arg, jboolean commit_upfront_shutdown_pubkey_arg) {
+       LDKChannelConfig ret_var = ChannelConfig_new(fee_proportional_millionths_arg, cltv_expiry_delta_arg, announced_channel_arg, commit_upfront_shutdown_pubkey_arg);
        CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
        CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
        long ret_ref = (long)ret_var.inner;
@@ -16900,6 +16964,14 @@ JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ReplyShortChannelIdsEnd
        return ret_arr;
 }
 
+JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_QueryChannelRange_1end_1blocknum(JNIEnv *env, jclass clz, int64_t this_arg) {
+       LDKQueryChannelRange this_arg_conv;
+       this_arg_conv.inner = (void*)(this_arg & (~1));
+       this_arg_conv.is_owned = false;
+       int32_t ret_val = QueryChannelRange_end_blocknum(&this_arg_conv);
+       return ret_val;
+}
+
 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_QueryChannelRange_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
        LDKu8slice ser_ref;
        ser_ref.datalen = (*env)->GetArrayLength(env, ser);
index c102c70874f3315737172b12caf4babbaadd0fb8..cb791791be6d4b2005ab2959d690d50347bdf1d9 100644 (file)
@@ -3079,6 +3079,14 @@ JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMessageHandler_1peer_1c
 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMessageHandler_1handle_1channel_1reestablish
   (JNIEnv *, jclass, jlong, jbyteArray, jlong);
 
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    ChannelMessageHandler_handle_channel_update
+ * Signature: (J[BJ)V
+ */
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMessageHandler_1handle_1channel_1update
+  (JNIEnv *, jclass, jlong, jbyteArray, jlong);
+
 /*
  * Class:     org_ldk_impl_bindings
  * Method:    ChannelMessageHandler_handle_error
@@ -6575,6 +6583,22 @@ JNIEXPORT jint JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1get_1fee_1propo
 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1set_1fee_1proportional_1millionths
   (JNIEnv *, jclass, jlong, jint);
 
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    ChannelConfig_get_cltv_expiry_delta
+ * Signature: (J)S
+ */
+JNIEXPORT jshort JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1get_1cltv_1expiry_1delta
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    ChannelConfig_set_cltv_expiry_delta
+ * Signature: (JS)V
+ */
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1set_1cltv_1expiry_1delta
+  (JNIEnv *, jclass, jlong, jshort);
+
 /*
  * Class:     org_ldk_impl_bindings
  * Method:    ChannelConfig_get_announced_channel
@@ -6610,10 +6634,10 @@ JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1set_1commit_1up
 /*
  * Class:     org_ldk_impl_bindings
  * Method:    ChannelConfig_new
- * Signature: (IZZ)J
+ * Signature: (ISZZ)J
  */
 JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1new
-  (JNIEnv *, jclass, jint, jboolean, jboolean);
+  (JNIEnv *, jclass, jint, jshort, jboolean, jboolean);
 
 /*
  * Class:     org_ldk_impl_bindings
@@ -11583,6 +11607,14 @@ JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ReplyShortChannelIdsEnd_1read
 JNIEXPORT jbyteArray JNICALL Java_org_ldk_impl_bindings_ReplyShortChannelIdsEnd_1write
   (JNIEnv *, jclass, jlong);
 
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    QueryChannelRange_end_blocknum
+ * Signature: (J)I
+ */
+JNIEXPORT jint JNICALL Java_org_ldk_impl_bindings_QueryChannelRange_1end_1blocknum
+  (JNIEnv *, jclass, jlong);
+
 /*
  * Class:     org_ldk_impl_bindings
  * Method:    QueryChannelRange_read
index b39872cb21714a54d7a96804208e04fae0b76295..91bffd579158860bd0439dc6f40bef5193c13cad 100644 (file)
@@ -642,6 +642,15 @@ uint32_t __attribute__((visibility("default"))) TS_LDKMessageSendEvent_ref_from_
                        long msg_ref = (long)msg_var.inner & ~1;
                        return 0 /* LDKMessageSendEvent - SendShortIdsQuery */; (void) node_id_arr; (void) msg_ref;
                }
+               case LDKMessageSendEvent_SendReplyChannelRange: {
+                       int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
+                       memcpy((uint8_t*)(node_id_arr + 4), obj->send_reply_channel_range.node_id.compressed_form, 33);
+                       LDKReplyChannelRange msg_var = obj->send_reply_channel_range.msg;
+                       CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+                       CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+                       long msg_ref = (long)msg_var.inner & ~1;
+                       return 0 /* LDKMessageSendEvent - SendReplyChannelRange */; (void) node_id_arr; (void) msg_ref;
+               }
                default: abort();
        }
 }
@@ -1766,7 +1775,7 @@ static void LDKSign_JCalls_free(void* this_arg) {
                FREE(j_calls);
        }
 }
-LDKPublicKey get_per_commitment_point_jcall(const void* this_arg, uint64_t idx) {
+LDKPublicKey get_per_commitment_point_LDKSign_jcall(const void* this_arg, uint64_t idx) {
        LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
        int8_tArray ret = js_invoke_function_1(j_calls->get_per_commitment_point_meth, idx);
        LDKPublicKey ret_ref;
@@ -1774,7 +1783,7 @@ LDKPublicKey get_per_commitment_point_jcall(const void* this_arg, uint64_t idx)
        memcpy(ret_ref.compressed_form, (uint8_t*)(ret + 4), 33);
        return ret_ref;
 }
-LDKThirtyTwoBytes release_commitment_secret_jcall(const void* this_arg, uint64_t idx) {
+LDKThirtyTwoBytes release_commitment_secret_LDKSign_jcall(const void* this_arg, uint64_t idx) {
        LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
        int8_tArray ret = js_invoke_function_1(j_calls->release_commitment_secret_meth, idx);
        LDKThirtyTwoBytes ret_ref;
@@ -1782,7 +1791,7 @@ LDKThirtyTwoBytes release_commitment_secret_jcall(const void* this_arg, uint64_t
        memcpy(ret_ref.data, (uint8_t*)(ret + 4), 32);
        return ret_ref;
 }
-LDKThirtyTwoBytes channel_keys_id_jcall(const void* this_arg) {
+LDKThirtyTwoBytes channel_keys_id_LDKSign_jcall(const void* this_arg) {
        LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
        int8_tArray ret = js_invoke_function_0(j_calls->channel_keys_id_meth);
        LDKThirtyTwoBytes ret_ref;
@@ -1790,7 +1799,7 @@ LDKThirtyTwoBytes channel_keys_id_jcall(const void* this_arg) {
        memcpy(ret_ref.data, (uint8_t*)(ret + 4), 32);
        return ret_ref;
 }
-LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_counterparty_commitment_jcall(const void* this_arg, const LDKCommitmentTransaction * commitment_tx) {
+LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_counterparty_commitment_LDKSign_jcall(const void* this_arg, const LDKCommitmentTransaction * commitment_tx) {
        LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
        LDKCommitmentTransaction commitment_tx_var = *commitment_tx;
        commitment_tx_var = CommitmentTransaction_clone(commitment_tx);
@@ -1805,7 +1814,7 @@ LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_counterparty_commitment_j
        ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone((LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)ret);
        return ret_conv;
 }
-LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_holder_commitment_and_htlcs_jcall(const void* this_arg, const LDKHolderCommitmentTransaction * commitment_tx) {
+LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_holder_commitment_and_htlcs_LDKSign_jcall(const void* this_arg, const LDKHolderCommitmentTransaction * commitment_tx) {
        LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
        LDKHolderCommitmentTransaction commitment_tx_var = *commitment_tx;
        commitment_tx_var = HolderCommitmentTransaction_clone(commitment_tx);
@@ -1820,7 +1829,7 @@ LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_holder_commitment_and_htl
        ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone((LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)ret);
        return ret_conv;
 }
-LDKCResult_SignatureNoneZ sign_justice_transaction_jcall(const void* this_arg, LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (* per_commitment_key)[32], const LDKHTLCOutputInCommitment * htlc) {
+LDKCResult_SignatureNoneZ sign_justice_transaction_LDKSign_jcall(const void* this_arg, LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (* per_commitment_key)[32], const LDKHTLCOutputInCommitment * htlc) {
        LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
        LDKTransaction justice_tx_var = justice_tx;
        int8_tArray justice_tx_arr = init_arr(justice_tx_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
@@ -1841,7 +1850,7 @@ LDKCResult_SignatureNoneZ sign_justice_transaction_jcall(const void* this_arg, L
        ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)ret);
        return ret_conv;
 }
-LDKCResult_SignatureNoneZ sign_counterparty_htlc_transaction_jcall(const void* this_arg, LDKTransaction htlc_tx, uintptr_t input, uint64_t amount, LDKPublicKey per_commitment_point, const LDKHTLCOutputInCommitment * htlc) {
+LDKCResult_SignatureNoneZ sign_counterparty_htlc_transaction_LDKSign_jcall(const void* this_arg, LDKTransaction htlc_tx, uintptr_t input, uint64_t amount, LDKPublicKey per_commitment_point, const LDKHTLCOutputInCommitment * htlc) {
        LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
        LDKTransaction htlc_tx_var = htlc_tx;
        int8_tArray htlc_tx_arr = init_arr(htlc_tx_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
@@ -1862,7 +1871,7 @@ LDKCResult_SignatureNoneZ sign_counterparty_htlc_transaction_jcall(const void* t
        ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)ret);
        return ret_conv;
 }
-LDKCResult_SignatureNoneZ sign_closing_transaction_jcall(const void* this_arg, LDKTransaction closing_tx) {
+LDKCResult_SignatureNoneZ sign_closing_transaction_LDKSign_jcall(const void* this_arg, LDKTransaction closing_tx) {
        LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
        LDKTransaction closing_tx_var = closing_tx;
        int8_tArray closing_tx_arr = init_arr(closing_tx_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
@@ -1873,7 +1882,7 @@ LDKCResult_SignatureNoneZ sign_closing_transaction_jcall(const void* this_arg, L
        ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)ret);
        return ret_conv;
 }
-LDKCResult_SignatureNoneZ sign_channel_announcement_jcall(const void* this_arg, const LDKUnsignedChannelAnnouncement * msg) {
+LDKCResult_SignatureNoneZ sign_channel_announcement_LDKSign_jcall(const void* this_arg, const LDKUnsignedChannelAnnouncement * msg) {
        LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
        LDKUnsignedChannelAnnouncement msg_var = *msg;
        msg_var = UnsignedChannelAnnouncement_clone(msg);
@@ -1888,7 +1897,7 @@ LDKCResult_SignatureNoneZ sign_channel_announcement_jcall(const void* this_arg,
        ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)ret);
        return ret_conv;
 }
-void ready_channel_jcall(void* this_arg, const LDKChannelTransactionParameters * channel_parameters) {
+void ready_channel_LDKSign_jcall(void* this_arg, const LDKChannelTransactionParameters * channel_parameters) {
        LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
        LDKChannelTransactionParameters channel_parameters_var = *channel_parameters;
        channel_parameters_var = ChannelTransactionParameters_clone(channel_parameters);
@@ -1900,7 +1909,7 @@ void ready_channel_jcall(void* this_arg, const LDKChannelTransactionParameters *
        }
        js_invoke_function_1(j_calls->ready_channel_meth, channel_parameters_ref);
 }
-LDKCVec_u8Z write_jcall(const void* this_arg) {
+LDKCVec_u8Z write_LDKSign_jcall(const void* this_arg) {
        LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
        int8_tArray ret = js_invoke_function_0(j_calls->write_meth);
        LDKCVec_u8Z ret_ref;
@@ -1926,18 +1935,18 @@ static inline LDKSign LDKSign_init (/*TODO: JS Object Reference */void* o, uint3
 
        LDKSign ret = {
                .this_arg = (void*) calls,
-               .get_per_commitment_point = get_per_commitment_point_jcall,
-               .release_commitment_secret = release_commitment_secret_jcall,
-               .channel_keys_id = channel_keys_id_jcall,
-               .sign_counterparty_commitment = sign_counterparty_commitment_jcall,
-               .sign_holder_commitment_and_htlcs = sign_holder_commitment_and_htlcs_jcall,
-               .sign_justice_transaction = sign_justice_transaction_jcall,
-               .sign_counterparty_htlc_transaction = sign_counterparty_htlc_transaction_jcall,
-               .sign_closing_transaction = sign_closing_transaction_jcall,
-               .sign_channel_announcement = sign_channel_announcement_jcall,
-               .ready_channel = ready_channel_jcall,
+               .get_per_commitment_point = get_per_commitment_point_LDKSign_jcall,
+               .release_commitment_secret = release_commitment_secret_LDKSign_jcall,
+               .channel_keys_id = channel_keys_id_LDKSign_jcall,
+               .sign_counterparty_commitment = sign_counterparty_commitment_LDKSign_jcall,
+               .sign_holder_commitment_and_htlcs = sign_holder_commitment_and_htlcs_LDKSign_jcall,
+               .sign_justice_transaction = sign_justice_transaction_LDKSign_jcall,
+               .sign_counterparty_htlc_transaction = sign_counterparty_htlc_transaction_LDKSign_jcall,
+               .sign_closing_transaction = sign_closing_transaction_LDKSign_jcall,
+               .sign_channel_announcement = sign_channel_announcement_LDKSign_jcall,
+               .ready_channel = ready_channel_LDKSign_jcall,
                .clone = LDKSign_JCalls_clone,
-               .write = write_jcall,
+               .write = write_LDKSign_jcall,
                .free = LDKSign_JCalls_free,
                .pubkeys = pubkeys_conv,
                .set_pubkeys = NULL,
@@ -2336,7 +2345,7 @@ static void LDKWatch_JCalls_free(void* this_arg) {
                FREE(j_calls);
        }
 }
-LDKCResult_NoneChannelMonitorUpdateErrZ watch_channel_jcall(const void* this_arg, LDKOutPoint funding_txo, LDKChannelMonitor monitor) {
+LDKCResult_NoneChannelMonitorUpdateErrZ watch_channel_LDKWatch_jcall(const void* this_arg, LDKOutPoint funding_txo, LDKChannelMonitor monitor) {
        LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
        LDKOutPoint funding_txo_var = funding_txo;
        CHECK((((long)funding_txo_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
@@ -2357,7 +2366,7 @@ LDKCResult_NoneChannelMonitorUpdateErrZ watch_channel_jcall(const void* this_arg
        ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)ret);
        return ret_conv;
 }
-LDKCResult_NoneChannelMonitorUpdateErrZ update_channel_jcall(const void* this_arg, LDKOutPoint funding_txo, LDKChannelMonitorUpdate update) {
+LDKCResult_NoneChannelMonitorUpdateErrZ update_channel_LDKWatch_jcall(const void* this_arg, LDKOutPoint funding_txo, LDKChannelMonitorUpdate update) {
        LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
        LDKOutPoint funding_txo_var = funding_txo;
        CHECK((((long)funding_txo_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
@@ -2378,7 +2387,7 @@ LDKCResult_NoneChannelMonitorUpdateErrZ update_channel_jcall(const void* this_ar
        ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)ret);
        return ret_conv;
 }
-LDKCVec_MonitorEventZ release_pending_monitor_events_jcall(const void* this_arg) {
+LDKCVec_MonitorEventZ release_pending_monitor_events_LDKWatch_jcall(const void* this_arg) {
        LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
        uint32_tArray ret = js_invoke_function_0(j_calls->release_pending_monitor_events_meth);
        LDKCVec_MonitorEventZ ret_constr;
@@ -2408,9 +2417,9 @@ static inline LDKWatch LDKWatch_init (/*TODO: JS Object Reference */void* o) {
 
        LDKWatch ret = {
                .this_arg = (void*) calls,
-               .watch_channel = watch_channel_jcall,
-               .update_channel = update_channel_jcall,
-               .release_pending_monitor_events = release_pending_monitor_events_jcall,
+               .watch_channel = watch_channel_LDKWatch_jcall,
+               .update_channel = update_channel_LDKWatch_jcall,
+               .release_pending_monitor_events = release_pending_monitor_events_LDKWatch_jcall,
                .free = LDKWatch_JCalls_free,
        };
        return ret;
@@ -2476,7 +2485,7 @@ static void LDKBroadcasterInterface_JCalls_free(void* this_arg) {
                FREE(j_calls);
        }
 }
-void broadcast_transaction_jcall(const void* this_arg, LDKTransaction tx) {
+void broadcast_transaction_LDKBroadcasterInterface_jcall(const void* this_arg, LDKTransaction tx) {
        LDKBroadcasterInterface_JCalls *j_calls = (LDKBroadcasterInterface_JCalls*) this_arg;
        LDKTransaction tx_var = tx;
        int8_tArray tx_arr = init_arr(tx_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
@@ -2496,7 +2505,7 @@ static inline LDKBroadcasterInterface LDKBroadcasterInterface_init (/*TODO: JS O
 
        LDKBroadcasterInterface ret = {
                .this_arg = (void*) calls,
-               .broadcast_transaction = broadcast_transaction_jcall,
+               .broadcast_transaction = broadcast_transaction_LDKBroadcasterInterface_jcall,
                .free = LDKBroadcasterInterface_JCalls_free,
        };
        return ret;
@@ -2556,7 +2565,7 @@ static void LDKKeysInterface_JCalls_free(void* this_arg) {
                FREE(j_calls);
        }
 }
-LDKSecretKey get_node_secret_jcall(const void* this_arg) {
+LDKSecretKey get_node_secret_LDKKeysInterface_jcall(const void* this_arg) {
        LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
        int8_tArray ret = js_invoke_function_0(j_calls->get_node_secret_meth);
        LDKSecretKey ret_ref;
@@ -2564,7 +2573,7 @@ LDKSecretKey get_node_secret_jcall(const void* this_arg) {
        memcpy(ret_ref.bytes, (uint8_t*)(ret + 4), 32);
        return ret_ref;
 }
-LDKCVec_u8Z get_destination_script_jcall(const void* this_arg) {
+LDKCVec_u8Z get_destination_script_LDKKeysInterface_jcall(const void* this_arg) {
        LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
        int8_tArray ret = js_invoke_function_0(j_calls->get_destination_script_meth);
        LDKCVec_u8Z ret_ref;
@@ -2573,7 +2582,7 @@ LDKCVec_u8Z get_destination_script_jcall(const void* this_arg) {
        memcpy(ret_ref.data, (uint8_t*)(ret + 4), ret_ref.datalen);
        return ret_ref;
 }
-LDKPublicKey get_shutdown_pubkey_jcall(const void* this_arg) {
+LDKPublicKey get_shutdown_pubkey_LDKKeysInterface_jcall(const void* this_arg) {
        LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
        int8_tArray ret = js_invoke_function_0(j_calls->get_shutdown_pubkey_meth);
        LDKPublicKey ret_ref;
@@ -2581,14 +2590,14 @@ LDKPublicKey get_shutdown_pubkey_jcall(const void* this_arg) {
        memcpy(ret_ref.compressed_form, (uint8_t*)(ret + 4), 33);
        return ret_ref;
 }
-LDKSign get_channel_signer_jcall(const void* this_arg, bool inbound, uint64_t channel_value_satoshis) {
+LDKSign get_channel_signer_LDKKeysInterface_jcall(const void* this_arg, bool inbound, uint64_t channel_value_satoshis) {
        LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
        LDKSign* ret = (LDKSign*)js_invoke_function_2(j_calls->get_channel_signer_meth, inbound, channel_value_satoshis);
        LDKSign ret_conv = *(LDKSign*)(((uint64_t)ret) & ~1);
        ret_conv = Sign_clone(ret);
        return ret_conv;
 }
-LDKThirtyTwoBytes get_secure_random_bytes_jcall(const void* this_arg) {
+LDKThirtyTwoBytes get_secure_random_bytes_LDKKeysInterface_jcall(const void* this_arg) {
        LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
        int8_tArray ret = js_invoke_function_0(j_calls->get_secure_random_bytes_meth);
        LDKThirtyTwoBytes ret_ref;
@@ -2596,7 +2605,7 @@ LDKThirtyTwoBytes get_secure_random_bytes_jcall(const void* this_arg) {
        memcpy(ret_ref.data, (uint8_t*)(ret + 4), 32);
        return ret_ref;
 }
-LDKCResult_SignDecodeErrorZ read_chan_signer_jcall(const void* this_arg, LDKu8slice reader) {
+LDKCResult_SignDecodeErrorZ read_chan_signer_LDKKeysInterface_jcall(const void* this_arg, LDKu8slice reader) {
        LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
        LDKu8slice reader_var = reader;
        int8_tArray reader_arr = init_arr(reader_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
@@ -2618,12 +2627,12 @@ static inline LDKKeysInterface LDKKeysInterface_init (/*TODO: JS Object Referenc
 
        LDKKeysInterface ret = {
                .this_arg = (void*) calls,
-               .get_node_secret = get_node_secret_jcall,
-               .get_destination_script = get_destination_script_jcall,
-               .get_shutdown_pubkey = get_shutdown_pubkey_jcall,
-               .get_channel_signer = get_channel_signer_jcall,
-               .get_secure_random_bytes = get_secure_random_bytes_jcall,
-               .read_chan_signer = read_chan_signer_jcall,
+               .get_node_secret = get_node_secret_LDKKeysInterface_jcall,
+               .get_destination_script = get_destination_script_LDKKeysInterface_jcall,
+               .get_shutdown_pubkey = get_shutdown_pubkey_LDKKeysInterface_jcall,
+               .get_channel_signer = get_channel_signer_LDKKeysInterface_jcall,
+               .get_secure_random_bytes = get_secure_random_bytes_LDKKeysInterface_jcall,
+               .read_chan_signer = read_chan_signer_LDKKeysInterface_jcall,
                .free = LDKKeysInterface_JCalls_free,
        };
        return ret;
@@ -2691,7 +2700,7 @@ static void LDKFeeEstimator_JCalls_free(void* this_arg) {
                FREE(j_calls);
        }
 }
-uint32_t get_est_sat_per_1000_weight_jcall(const void* this_arg, LDKConfirmationTarget confirmation_target) {
+uint32_t get_est_sat_per_1000_weight_LDKFeeEstimator_jcall(const void* this_arg, LDKConfirmationTarget confirmation_target) {
        LDKFeeEstimator_JCalls *j_calls = (LDKFeeEstimator_JCalls*) this_arg;
        uint32_t confirmation_target_conv = LDKConfirmationTarget_to_js(confirmation_target);
        return js_invoke_function_1(j_calls->get_est_sat_per_1000_weight_meth, confirmation_target_conv);
@@ -2708,7 +2717,7 @@ static inline LDKFeeEstimator LDKFeeEstimator_init (/*TODO: JS Object Reference
 
        LDKFeeEstimator ret = {
                .this_arg = (void*) calls,
-               .get_est_sat_per_1000_weight = get_est_sat_per_1000_weight_jcall,
+               .get_est_sat_per_1000_weight = get_est_sat_per_1000_weight_LDKFeeEstimator_jcall,
                .free = LDKFeeEstimator_JCalls_free,
        };
        return ret;
@@ -2736,7 +2745,7 @@ static void LDKLogger_JCalls_free(void* this_arg) {
                FREE(j_calls);
        }
 }
-void log_jcall(const void* this_arg, const char* record) {
+void log_LDKLogger_jcall(const void* this_arg, const char* record) {
        LDKLogger_JCalls *j_calls = (LDKLogger_JCalls*) this_arg;
        const char* record_str = record;
        jstring record_conv = str_ref_to_ts(record_str, strlen(record_str));
@@ -2754,7 +2763,7 @@ static inline LDKLogger LDKLogger_init (/*TODO: JS Object Reference */void* o) {
 
        LDKLogger ret = {
                .this_arg = (void*) calls,
-               .log = log_jcall,
+               .log = log_LDKLogger_jcall,
                .free = LDKLogger_JCalls_free,
        };
        return ret;
@@ -3818,7 +3827,7 @@ static void LDKMessageSendEventsProvider_JCalls_free(void* this_arg) {
                FREE(j_calls);
        }
 }
-LDKCVec_MessageSendEventZ get_and_clear_pending_msg_events_jcall(const void* this_arg) {
+LDKCVec_MessageSendEventZ get_and_clear_pending_msg_events_LDKMessageSendEventsProvider_jcall(const void* this_arg) {
        LDKMessageSendEventsProvider_JCalls *j_calls = (LDKMessageSendEventsProvider_JCalls*) this_arg;
        uint32_tArray ret = js_invoke_function_0(j_calls->get_and_clear_pending_msg_events_meth);
        LDKCVec_MessageSendEventZ ret_constr;
@@ -3848,7 +3857,7 @@ static inline LDKMessageSendEventsProvider LDKMessageSendEventsProvider_init (/*
 
        LDKMessageSendEventsProvider ret = {
                .this_arg = (void*) calls,
-               .get_and_clear_pending_msg_events = get_and_clear_pending_msg_events_jcall,
+               .get_and_clear_pending_msg_events = get_and_clear_pending_msg_events_LDKMessageSendEventsProvider_jcall,
                .free = LDKMessageSendEventsProvider_JCalls_free,
        };
        return ret;
@@ -3884,7 +3893,7 @@ static void LDKEventsProvider_JCalls_free(void* this_arg) {
                FREE(j_calls);
        }
 }
-LDKCVec_EventZ get_and_clear_pending_events_jcall(const void* this_arg) {
+LDKCVec_EventZ get_and_clear_pending_events_LDKEventsProvider_jcall(const void* this_arg) {
        LDKEventsProvider_JCalls *j_calls = (LDKEventsProvider_JCalls*) this_arg;
        uint32_tArray ret = js_invoke_function_0(j_calls->get_and_clear_pending_events_meth);
        LDKCVec_EventZ ret_constr;
@@ -3914,7 +3923,7 @@ static inline LDKEventsProvider LDKEventsProvider_init (/*TODO: JS Object Refere
 
        LDKEventsProvider ret = {
                .this_arg = (void*) calls,
-               .get_and_clear_pending_events = get_and_clear_pending_events_jcall,
+               .get_and_clear_pending_events = get_and_clear_pending_events_LDKEventsProvider_jcall,
                .free = LDKEventsProvider_JCalls_free,
        };
        return ret;
@@ -3950,7 +3959,7 @@ static void LDKAccess_JCalls_free(void* this_arg) {
                FREE(j_calls);
        }
 }
-LDKCResult_TxOutAccessErrorZ get_utxo_jcall(const void* this_arg, const uint8_t (* genesis_hash)[32], uint64_t short_channel_id) {
+LDKCResult_TxOutAccessErrorZ get_utxo_LDKAccess_jcall(const void* this_arg, const uint8_t (* genesis_hash)[32], uint64_t short_channel_id) {
        LDKAccess_JCalls *j_calls = (LDKAccess_JCalls*) this_arg;
        int8_tArray genesis_hash_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
        memcpy((uint8_t*)(genesis_hash_arr + 4), *genesis_hash, 32);
@@ -3971,7 +3980,7 @@ static inline LDKAccess LDKAccess_init (/*TODO: JS Object Reference */void* o) {
 
        LDKAccess ret = {
                .this_arg = (void*) calls,
-               .get_utxo = get_utxo_jcall,
+               .get_utxo = get_utxo_LDKAccess_jcall,
                .free = LDKAccess_JCalls_free,
        };
        return ret;
@@ -4005,14 +4014,14 @@ static void LDKListen_JCalls_free(void* this_arg) {
                FREE(j_calls);
        }
 }
-void block_connected_jcall(const void* this_arg, LDKu8slice block, uint32_t height) {
+void block_connected_LDKListen_jcall(const void* this_arg, LDKu8slice block, uint32_t height) {
        LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
        LDKu8slice block_var = block;
        int8_tArray block_arr = init_arr(block_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
        memcpy((uint8_t*)(block_arr + 4), block_var.data, block_var.datalen);
        js_invoke_function_2(j_calls->block_connected_meth, block_arr, height);
 }
-void block_disconnected_jcall(const void* this_arg, const uint8_t (* header)[80], uint32_t height) {
+void block_disconnected_LDKListen_jcall(const void* this_arg, const uint8_t (* header)[80], uint32_t height) {
        LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
        int8_tArray header_arr = init_arr(80, sizeof(uint8_t), "Native int8_tArray Bytes");
        memcpy((uint8_t*)(header_arr + 4), *header, 80);
@@ -4030,8 +4039,8 @@ static inline LDKListen LDKListen_init (/*TODO: JS Object Reference */void* o) {
 
        LDKListen ret = {
                .this_arg = (void*) calls,
-               .block_connected = block_connected_jcall,
-               .block_disconnected = block_disconnected_jcall,
+               .block_connected = block_connected_LDKListen_jcall,
+               .block_disconnected = block_disconnected_LDKListen_jcall,
                .free = LDKListen_JCalls_free,
        };
        return ret;
@@ -4071,7 +4080,7 @@ static void LDKFilter_JCalls_free(void* this_arg) {
                FREE(j_calls);
        }
 }
-void register_tx_jcall(const void* this_arg, const uint8_t (* txid)[32], LDKu8slice script_pubkey) {
+void register_tx_LDKFilter_jcall(const void* this_arg, const uint8_t (* txid)[32], LDKu8slice script_pubkey) {
        LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg;
        int8_tArray txid_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
        memcpy((uint8_t*)(txid_arr + 4), *txid, 32);
@@ -4080,7 +4089,7 @@ void register_tx_jcall(const void* this_arg, const uint8_t (* txid)[32], LDKu8sl
        memcpy((uint8_t*)(script_pubkey_arr + 4), script_pubkey_var.data, script_pubkey_var.datalen);
        js_invoke_function_2(j_calls->register_tx_meth, txid_arr, script_pubkey_arr);
 }
-void register_output_jcall(const void* this_arg, const LDKOutPoint * outpoint, LDKu8slice script_pubkey) {
+void register_output_LDKFilter_jcall(const void* this_arg, const LDKOutPoint * outpoint, LDKu8slice script_pubkey) {
        LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg;
        LDKOutPoint outpoint_var = *outpoint;
        outpoint_var = OutPoint_clone(outpoint);
@@ -4107,8 +4116,8 @@ static inline LDKFilter LDKFilter_init (/*TODO: JS Object Reference */void* o) {
 
        LDKFilter ret = {
                .this_arg = (void*) calls,
-               .register_tx = register_tx_jcall,
-               .register_output = register_output_jcall,
+               .register_tx = register_tx_LDKFilter_jcall,
+               .register_output = register_output_LDKFilter_jcall,
                .free = LDKFilter_JCalls_free,
        };
        return ret;
@@ -4154,7 +4163,7 @@ static void LDKPersist_JCalls_free(void* this_arg) {
                FREE(j_calls);
        }
 }
-LDKCResult_NoneChannelMonitorUpdateErrZ persist_new_channel_jcall(const void* this_arg, LDKOutPoint id, const LDKChannelMonitor * data) {
+LDKCResult_NoneChannelMonitorUpdateErrZ persist_new_channel_LDKPersist_jcall(const void* this_arg, LDKOutPoint id, const LDKChannelMonitor * data) {
        LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) this_arg;
        LDKOutPoint id_var = id;
        CHECK((((long)id_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
@@ -4176,7 +4185,7 @@ LDKCResult_NoneChannelMonitorUpdateErrZ persist_new_channel_jcall(const void* th
        ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)ret);
        return ret_conv;
 }
-LDKCResult_NoneChannelMonitorUpdateErrZ update_persisted_channel_jcall(const void* this_arg, LDKOutPoint id, const LDKChannelMonitorUpdate * update, const LDKChannelMonitor * data) {
+LDKCResult_NoneChannelMonitorUpdateErrZ update_persisted_channel_LDKPersist_jcall(const void* this_arg, LDKOutPoint id, const LDKChannelMonitorUpdate * update, const LDKChannelMonitor * data) {
        LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) this_arg;
        LDKOutPoint id_var = id;
        CHECK((((long)id_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
@@ -4218,8 +4227,8 @@ static inline LDKPersist LDKPersist_init (/*TODO: JS Object Reference */void* o)
 
        LDKPersist ret = {
                .this_arg = (void*) calls,
-               .persist_new_channel = persist_new_channel_jcall,
-               .update_persisted_channel = update_persisted_channel_jcall,
+               .persist_new_channel = persist_new_channel_LDKPersist_jcall,
+               .update_persisted_channel = update_persisted_channel_LDKPersist_jcall,
                .free = LDKPersist_JCalls_free,
        };
        return ret;
@@ -4281,6 +4290,7 @@ typedef struct LDKChannelMessageHandler_JCalls {
        uint32_t peer_disconnected_meth;
        uint32_t peer_connected_meth;
        uint32_t handle_channel_reestablish_meth;
+       uint32_t handle_channel_update_meth;
        uint32_t handle_error_meth;
 } LDKChannelMessageHandler_JCalls;
 static void LDKChannelMessageHandler_JCalls_free(void* this_arg) {
@@ -4304,11 +4314,12 @@ static void LDKChannelMessageHandler_JCalls_free(void* this_arg) {
                js_free(j_calls->peer_disconnected_meth);
                js_free(j_calls->peer_connected_meth);
                js_free(j_calls->handle_channel_reestablish_meth);
+               js_free(j_calls->handle_channel_update_meth);
                js_free(j_calls->handle_error_meth);
                FREE(j_calls);
        }
 }
-void handle_open_channel_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKInitFeatures their_features, const LDKOpenChannel * msg) {
+void handle_open_channel_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKInitFeatures their_features, const LDKOpenChannel * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
        memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
@@ -4329,7 +4340,7 @@ void handle_open_channel_jcall(const void* this_arg, LDKPublicKey their_node_id,
        }
        js_invoke_function_3(j_calls->handle_open_channel_meth, their_node_id_arr, their_features_ref, msg_ref);
 }
-void handle_accept_channel_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKInitFeatures their_features, const LDKAcceptChannel * msg) {
+void handle_accept_channel_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKInitFeatures their_features, const LDKAcceptChannel * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
        memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
@@ -4350,7 +4361,7 @@ void handle_accept_channel_jcall(const void* this_arg, LDKPublicKey their_node_i
        }
        js_invoke_function_3(j_calls->handle_accept_channel_meth, their_node_id_arr, their_features_ref, msg_ref);
 }
-void handle_funding_created_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKFundingCreated * msg) {
+void handle_funding_created_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKFundingCreated * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
        memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
@@ -4364,7 +4375,7 @@ void handle_funding_created_jcall(const void* this_arg, LDKPublicKey their_node_
        }
        js_invoke_function_2(j_calls->handle_funding_created_meth, their_node_id_arr, msg_ref);
 }
-void handle_funding_signed_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKFundingSigned * msg) {
+void handle_funding_signed_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKFundingSigned * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
        memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
@@ -4378,7 +4389,7 @@ void handle_funding_signed_jcall(const void* this_arg, LDKPublicKey their_node_i
        }
        js_invoke_function_2(j_calls->handle_funding_signed_meth, their_node_id_arr, msg_ref);
 }
-void handle_funding_locked_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKFundingLocked * msg) {
+void handle_funding_locked_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKFundingLocked * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
        memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
@@ -4392,7 +4403,7 @@ void handle_funding_locked_jcall(const void* this_arg, LDKPublicKey their_node_i
        }
        js_invoke_function_2(j_calls->handle_funding_locked_meth, their_node_id_arr, msg_ref);
 }
-void handle_shutdown_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInitFeatures * their_features, const LDKShutdown * msg) {
+void handle_shutdown_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInitFeatures * their_features, const LDKShutdown * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
        memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
@@ -4414,7 +4425,7 @@ void handle_shutdown_jcall(const void* this_arg, LDKPublicKey their_node_id, con
        }
        js_invoke_function_3(j_calls->handle_shutdown_meth, their_node_id_arr, their_features_ref, msg_ref);
 }
-void handle_closing_signed_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKClosingSigned * msg) {
+void handle_closing_signed_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKClosingSigned * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
        memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
@@ -4428,7 +4439,7 @@ void handle_closing_signed_jcall(const void* this_arg, LDKPublicKey their_node_i
        }
        js_invoke_function_2(j_calls->handle_closing_signed_meth, their_node_id_arr, msg_ref);
 }
-void handle_update_add_htlc_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateAddHTLC * msg) {
+void handle_update_add_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateAddHTLC * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
        memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
@@ -4442,7 +4453,7 @@ void handle_update_add_htlc_jcall(const void* this_arg, LDKPublicKey their_node_
        }
        js_invoke_function_2(j_calls->handle_update_add_htlc_meth, their_node_id_arr, msg_ref);
 }
-void handle_update_fulfill_htlc_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFulfillHTLC * msg) {
+void handle_update_fulfill_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFulfillHTLC * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
        memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
@@ -4456,7 +4467,7 @@ void handle_update_fulfill_htlc_jcall(const void* this_arg, LDKPublicKey their_n
        }
        js_invoke_function_2(j_calls->handle_update_fulfill_htlc_meth, their_node_id_arr, msg_ref);
 }
-void handle_update_fail_htlc_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFailHTLC * msg) {
+void handle_update_fail_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFailHTLC * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
        memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
@@ -4470,7 +4481,7 @@ void handle_update_fail_htlc_jcall(const void* this_arg, LDKPublicKey their_node
        }
        js_invoke_function_2(j_calls->handle_update_fail_htlc_meth, their_node_id_arr, msg_ref);
 }
-void handle_update_fail_malformed_htlc_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFailMalformedHTLC * msg) {
+void handle_update_fail_malformed_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFailMalformedHTLC * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
        memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
@@ -4484,7 +4495,7 @@ void handle_update_fail_malformed_htlc_jcall(const void* this_arg, LDKPublicKey
        }
        js_invoke_function_2(j_calls->handle_update_fail_malformed_htlc_meth, their_node_id_arr, msg_ref);
 }
-void handle_commitment_signed_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKCommitmentSigned * msg) {
+void handle_commitment_signed_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKCommitmentSigned * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
        memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
@@ -4498,7 +4509,7 @@ void handle_commitment_signed_jcall(const void* this_arg, LDKPublicKey their_nod
        }
        js_invoke_function_2(j_calls->handle_commitment_signed_meth, their_node_id_arr, msg_ref);
 }
-void handle_revoke_and_ack_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKRevokeAndACK * msg) {
+void handle_revoke_and_ack_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKRevokeAndACK * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
        memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
@@ -4512,7 +4523,7 @@ void handle_revoke_and_ack_jcall(const void* this_arg, LDKPublicKey their_node_i
        }
        js_invoke_function_2(j_calls->handle_revoke_and_ack_meth, their_node_id_arr, msg_ref);
 }
-void handle_update_fee_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFee * msg) {
+void handle_update_fee_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFee * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
        memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
@@ -4526,7 +4537,7 @@ void handle_update_fee_jcall(const void* this_arg, LDKPublicKey their_node_id, c
        }
        js_invoke_function_2(j_calls->handle_update_fee_meth, their_node_id_arr, msg_ref);
 }
-void handle_announcement_signatures_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKAnnouncementSignatures * msg) {
+void handle_announcement_signatures_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKAnnouncementSignatures * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
        memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
@@ -4540,13 +4551,13 @@ void handle_announcement_signatures_jcall(const void* this_arg, LDKPublicKey the
        }
        js_invoke_function_2(j_calls->handle_announcement_signatures_meth, their_node_id_arr, msg_ref);
 }
-void peer_disconnected_jcall(const void* this_arg, LDKPublicKey their_node_id, bool no_connection_possible) {
+void peer_disconnected_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, bool no_connection_possible) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
        memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
        js_invoke_function_2(j_calls->peer_disconnected_meth, their_node_id_arr, no_connection_possible);
 }
-void peer_connected_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInit * msg) {
+void peer_connected_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInit * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
        memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
@@ -4560,7 +4571,7 @@ void peer_connected_jcall(const void* this_arg, LDKPublicKey their_node_id, cons
        }
        js_invoke_function_2(j_calls->peer_connected_meth, their_node_id_arr, msg_ref);
 }
-void handle_channel_reestablish_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKChannelReestablish * msg) {
+void handle_channel_reestablish_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKChannelReestablish * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
        memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
@@ -4574,7 +4585,21 @@ void handle_channel_reestablish_jcall(const void* this_arg, LDKPublicKey their_n
        }
        js_invoke_function_2(j_calls->handle_channel_reestablish_meth, their_node_id_arr, msg_ref);
 }
-void handle_error_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKErrorMessage * msg) {
+void handle_channel_update_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKChannelUpdate * msg) {
+       LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
+       int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
+       memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
+       LDKChannelUpdate msg_var = *msg;
+       msg_var = ChannelUpdate_clone(msg);
+       CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+       CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+       long msg_ref = (long)msg_var.inner;
+       if (msg_var.is_owned) {
+               msg_ref |= 1;
+       }
+       js_invoke_function_2(j_calls->handle_channel_update_meth, their_node_id_arr, msg_ref);
+}
+void handle_error_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKErrorMessage * msg) {
        LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
        int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
        memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
@@ -4601,25 +4626,26 @@ static inline LDKChannelMessageHandler LDKChannelMessageHandler_init (/*TODO: JS
 
        LDKChannelMessageHandler ret = {
                .this_arg = (void*) calls,
-               .handle_open_channel = handle_open_channel_jcall,
-               .handle_accept_channel = handle_accept_channel_jcall,
-               .handle_funding_created = handle_funding_created_jcall,
-               .handle_funding_signed = handle_funding_signed_jcall,
-               .handle_funding_locked = handle_funding_locked_jcall,
-               .handle_shutdown = handle_shutdown_jcall,
-               .handle_closing_signed = handle_closing_signed_jcall,
-               .handle_update_add_htlc = handle_update_add_htlc_jcall,
-               .handle_update_fulfill_htlc = handle_update_fulfill_htlc_jcall,
-               .handle_update_fail_htlc = handle_update_fail_htlc_jcall,
-               .handle_update_fail_malformed_htlc = handle_update_fail_malformed_htlc_jcall,
-               .handle_commitment_signed = handle_commitment_signed_jcall,
-               .handle_revoke_and_ack = handle_revoke_and_ack_jcall,
-               .handle_update_fee = handle_update_fee_jcall,
-               .handle_announcement_signatures = handle_announcement_signatures_jcall,
-               .peer_disconnected = peer_disconnected_jcall,
-               .peer_connected = peer_connected_jcall,
-               .handle_channel_reestablish = handle_channel_reestablish_jcall,
-               .handle_error = handle_error_jcall,
+               .handle_open_channel = handle_open_channel_LDKChannelMessageHandler_jcall,
+               .handle_accept_channel = handle_accept_channel_LDKChannelMessageHandler_jcall,
+               .handle_funding_created = handle_funding_created_LDKChannelMessageHandler_jcall,
+               .handle_funding_signed = handle_funding_signed_LDKChannelMessageHandler_jcall,
+               .handle_funding_locked = handle_funding_locked_LDKChannelMessageHandler_jcall,
+               .handle_shutdown = handle_shutdown_LDKChannelMessageHandler_jcall,
+               .handle_closing_signed = handle_closing_signed_LDKChannelMessageHandler_jcall,
+               .handle_update_add_htlc = handle_update_add_htlc_LDKChannelMessageHandler_jcall,
+               .handle_update_fulfill_htlc = handle_update_fulfill_htlc_LDKChannelMessageHandler_jcall,
+               .handle_update_fail_htlc = handle_update_fail_htlc_LDKChannelMessageHandler_jcall,
+               .handle_update_fail_malformed_htlc = handle_update_fail_malformed_htlc_LDKChannelMessageHandler_jcall,
+               .handle_commitment_signed = handle_commitment_signed_LDKChannelMessageHandler_jcall,
+               .handle_revoke_and_ack = handle_revoke_and_ack_LDKChannelMessageHandler_jcall,
+               .handle_update_fee = handle_update_fee_LDKChannelMessageHandler_jcall,
+               .handle_announcement_signatures = handle_announcement_signatures_LDKChannelMessageHandler_jcall,
+               .peer_disconnected = peer_disconnected_LDKChannelMessageHandler_jcall,
+               .peer_connected = peer_connected_LDKChannelMessageHandler_jcall,
+               .handle_channel_reestablish = handle_channel_reestablish_LDKChannelMessageHandler_jcall,
+               .handle_channel_update = handle_channel_update_LDKChannelMessageHandler_jcall,
+               .handle_error = handle_error_LDKChannelMessageHandler_jcall,
                .free = LDKChannelMessageHandler_JCalls_free,
                .MessageSendEventsProvider = LDKMessageSendEventsProvider_init(MessageSendEventsProvider),
        };
@@ -4837,6 +4863,17 @@ void  __attribute__((visibility("default"))) TS_ChannelMessageHandler_handle_cha
        (this_arg_conv->handle_channel_reestablish)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
 }
 
+void  __attribute__((visibility("default"))) TS_ChannelMessageHandler_handle_channel_update(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
+       LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
+       LDKPublicKey their_node_id_ref;
+       CHECK(*((uint32_t*)their_node_id) == 33);
+       memcpy(their_node_id_ref.compressed_form, (uint8_t*)(their_node_id + 4), 33);
+       LDKChannelUpdate msg_conv;
+       msg_conv.inner = (void*)(msg & (~1));
+       msg_conv.is_owned = false;
+       (this_arg_conv->handle_channel_update)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
+}
+
 void  __attribute__((visibility("default"))) TS_ChannelMessageHandler_handle_error(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
        LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
        LDKPublicKey their_node_id_ref;
@@ -4880,7 +4917,7 @@ static void LDKRoutingMessageHandler_JCalls_free(void* this_arg) {
                FREE(j_calls);
        }
 }
-LDKCResult_boolLightningErrorZ handle_node_announcement_jcall(const void* this_arg, const LDKNodeAnnouncement * msg) {
+LDKCResult_boolLightningErrorZ handle_node_announcement_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKNodeAnnouncement * msg) {
        LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
        LDKNodeAnnouncement msg_var = *msg;
        msg_var = NodeAnnouncement_clone(msg);
@@ -4895,7 +4932,7 @@ LDKCResult_boolLightningErrorZ handle_node_announcement_jcall(const void* this_a
        ret_conv = CResult_boolLightningErrorZ_clone((LDKCResult_boolLightningErrorZ*)ret);
        return ret_conv;
 }
-LDKCResult_boolLightningErrorZ handle_channel_announcement_jcall(const void* this_arg, const LDKChannelAnnouncement * msg) {
+LDKCResult_boolLightningErrorZ handle_channel_announcement_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKChannelAnnouncement * msg) {
        LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
        LDKChannelAnnouncement msg_var = *msg;
        msg_var = ChannelAnnouncement_clone(msg);
@@ -4910,7 +4947,7 @@ LDKCResult_boolLightningErrorZ handle_channel_announcement_jcall(const void* thi
        ret_conv = CResult_boolLightningErrorZ_clone((LDKCResult_boolLightningErrorZ*)ret);
        return ret_conv;
 }
-LDKCResult_boolLightningErrorZ handle_channel_update_jcall(const void* this_arg, const LDKChannelUpdate * msg) {
+LDKCResult_boolLightningErrorZ handle_channel_update_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKChannelUpdate * msg) {
        LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
        LDKChannelUpdate msg_var = *msg;
        msg_var = ChannelUpdate_clone(msg);
@@ -4925,12 +4962,12 @@ LDKCResult_boolLightningErrorZ handle_channel_update_jcall(const void* this_arg,
        ret_conv = CResult_boolLightningErrorZ_clone((LDKCResult_boolLightningErrorZ*)ret);
        return ret_conv;
 }
-void handle_htlc_fail_channel_update_jcall(const void* this_arg, const LDKHTLCFailChannelUpdate * update) {
+void handle_htlc_fail_channel_update_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKHTLCFailChannelUpdate * update) {
        LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
        long ret_update = (long)update;
        js_invoke_function_1(j_calls->handle_htlc_fail_channel_update_meth, ret_update);
 }
-LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ get_next_channel_announcements_jcall(const void* this_arg, uint64_t starting_point, uint8_t batch_amount) {
+LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ get_next_channel_announcements_LDKRoutingMessageHandler_jcall(const void* this_arg, uint64_t starting_point, uint8_t batch_amount) {
        LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
        uint32_tArray ret = js_invoke_function_2(j_calls->get_next_channel_announcements_meth, starting_point, batch_amount);
        LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret_constr;
@@ -4948,7 +4985,7 @@ LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ get_next_channel
        }
        return ret_constr;
 }
-LDKCVec_NodeAnnouncementZ get_next_node_announcements_jcall(const void* this_arg, LDKPublicKey starting_point, uint8_t batch_amount) {
+LDKCVec_NodeAnnouncementZ get_next_node_announcements_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey starting_point, uint8_t batch_amount) {
        LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
        int8_tArray starting_point_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
        memcpy((uint8_t*)(starting_point_arr + 4), starting_point.compressed_form, 33);
@@ -4970,7 +5007,7 @@ LDKCVec_NodeAnnouncementZ get_next_node_announcements_jcall(const void* this_arg
        }
        return ret_constr;
 }
-void sync_routing_table_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInit * init) {
+void sync_routing_table_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInit * init) {
        LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
        int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
        memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
@@ -4984,7 +5021,7 @@ void sync_routing_table_jcall(const void* this_arg, LDKPublicKey their_node_id,
        }
        js_invoke_function_2(j_calls->sync_routing_table_meth, their_node_id_arr, init_ref);
 }
-LDKCResult_NoneLightningErrorZ handle_reply_channel_range_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKReplyChannelRange msg) {
+LDKCResult_NoneLightningErrorZ handle_reply_channel_range_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKReplyChannelRange msg) {
        LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
        int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
        memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
@@ -5000,7 +5037,7 @@ LDKCResult_NoneLightningErrorZ handle_reply_channel_range_jcall(const void* this
        ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)ret);
        return ret_conv;
 }
-LDKCResult_NoneLightningErrorZ handle_reply_short_channel_ids_end_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKReplyShortChannelIdsEnd msg) {
+LDKCResult_NoneLightningErrorZ handle_reply_short_channel_ids_end_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKReplyShortChannelIdsEnd msg) {
        LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
        int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
        memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
@@ -5016,7 +5053,7 @@ LDKCResult_NoneLightningErrorZ handle_reply_short_channel_ids_end_jcall(const vo
        ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)ret);
        return ret_conv;
 }
-LDKCResult_NoneLightningErrorZ handle_query_channel_range_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKQueryChannelRange msg) {
+LDKCResult_NoneLightningErrorZ handle_query_channel_range_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKQueryChannelRange msg) {
        LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
        int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
        memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
@@ -5032,7 +5069,7 @@ LDKCResult_NoneLightningErrorZ handle_query_channel_range_jcall(const void* this
        ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)ret);
        return ret_conv;
 }
-LDKCResult_NoneLightningErrorZ handle_query_short_channel_ids_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKQueryShortChannelIds msg) {
+LDKCResult_NoneLightningErrorZ handle_query_short_channel_ids_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKQueryShortChannelIds msg) {
        LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
        int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
        memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
@@ -5061,17 +5098,17 @@ static inline LDKRoutingMessageHandler LDKRoutingMessageHandler_init (/*TODO: JS
 
        LDKRoutingMessageHandler ret = {
                .this_arg = (void*) calls,
-               .handle_node_announcement = handle_node_announcement_jcall,
-               .handle_channel_announcement = handle_channel_announcement_jcall,
-               .handle_channel_update = handle_channel_update_jcall,
-               .handle_htlc_fail_channel_update = handle_htlc_fail_channel_update_jcall,
-               .get_next_channel_announcements = get_next_channel_announcements_jcall,
-               .get_next_node_announcements = get_next_node_announcements_jcall,
-               .sync_routing_table = sync_routing_table_jcall,
-               .handle_reply_channel_range = handle_reply_channel_range_jcall,
-               .handle_reply_short_channel_ids_end = handle_reply_short_channel_ids_end_jcall,
-               .handle_query_channel_range = handle_query_channel_range_jcall,
-               .handle_query_short_channel_ids = handle_query_short_channel_ids_jcall,
+               .handle_node_announcement = handle_node_announcement_LDKRoutingMessageHandler_jcall,
+               .handle_channel_announcement = handle_channel_announcement_LDKRoutingMessageHandler_jcall,
+               .handle_channel_update = handle_channel_update_LDKRoutingMessageHandler_jcall,
+               .handle_htlc_fail_channel_update = handle_htlc_fail_channel_update_LDKRoutingMessageHandler_jcall,
+               .get_next_channel_announcements = get_next_channel_announcements_LDKRoutingMessageHandler_jcall,
+               .get_next_node_announcements = get_next_node_announcements_LDKRoutingMessageHandler_jcall,
+               .sync_routing_table = sync_routing_table_LDKRoutingMessageHandler_jcall,
+               .handle_reply_channel_range = handle_reply_channel_range_LDKRoutingMessageHandler_jcall,
+               .handle_reply_short_channel_ids_end = handle_reply_short_channel_ids_end_LDKRoutingMessageHandler_jcall,
+               .handle_query_channel_range = handle_query_channel_range_LDKRoutingMessageHandler_jcall,
+               .handle_query_short_channel_ids = handle_query_short_channel_ids_LDKRoutingMessageHandler_jcall,
                .free = LDKRoutingMessageHandler_JCalls_free,
                .MessageSendEventsProvider = LDKMessageSendEventsProvider_init(MessageSendEventsProvider),
        };
@@ -5239,24 +5276,24 @@ static void LDKSocketDescriptor_JCalls_free(void* this_arg) {
                FREE(j_calls);
        }
 }
-uintptr_t send_data_jcall(void* this_arg, LDKu8slice data, bool resume_read) {
+uintptr_t send_data_LDKSocketDescriptor_jcall(void* this_arg, LDKu8slice data, bool resume_read) {
        LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
        LDKu8slice data_var = data;
        int8_tArray data_arr = init_arr(data_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
        memcpy((uint8_t*)(data_arr + 4), data_var.data, data_var.datalen);
        return js_invoke_function_2(j_calls->send_data_meth, data_arr, resume_read);
 }
-void disconnect_socket_jcall(void* this_arg) {
+void disconnect_socket_LDKSocketDescriptor_jcall(void* this_arg) {
        LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
        js_invoke_function_0(j_calls->disconnect_socket_meth);
 }
-bool eq_jcall(const void* this_arg, const LDKSocketDescriptor * other_arg) {
+bool eq_LDKSocketDescriptor_jcall(const void* this_arg, const LDKSocketDescriptor * other_arg) {
        LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
        LDKSocketDescriptor *other_arg_clone = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
        *other_arg_clone = SocketDescriptor_clone(other_arg);
        return js_invoke_function_1(j_calls->eq_meth, (long)other_arg_clone);
 }
-uint64_t hash_jcall(const void* this_arg) {
+uint64_t hash_LDKSocketDescriptor_jcall(const void* this_arg) {
        LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
        return js_invoke_function_0(j_calls->hash_meth);
 }
@@ -5272,10 +5309,10 @@ static inline LDKSocketDescriptor LDKSocketDescriptor_init (/*TODO: JS Object Re
 
        LDKSocketDescriptor ret = {
                .this_arg = (void*) calls,
-               .send_data = send_data_jcall,
-               .disconnect_socket = disconnect_socket_jcall,
-               .eq = eq_jcall,
-               .hash = hash_jcall,
+               .send_data = send_data_LDKSocketDescriptor_jcall,
+               .disconnect_socket = disconnect_socket_LDKSocketDescriptor_jcall,
+               .eq = eq_LDKSocketDescriptor_jcall,
+               .hash = hash_LDKSocketDescriptor_jcall,
                .clone = LDKSocketDescriptor_JCalls_clone,
                .free = LDKSocketDescriptor_JCalls_free,
        };
@@ -9104,6 +9141,21 @@ void  __attribute__((visibility("default"))) TS_ChannelConfig_set_fee_proportion
        ChannelConfig_set_fee_proportional_millionths(&this_ptr_conv, val);
 }
 
+int16_t  __attribute__((visibility("default"))) TS_ChannelConfig_get_cltv_expiry_delta(uint32_t this_ptr) {
+       LDKChannelConfig this_ptr_conv;
+       this_ptr_conv.inner = (void*)(this_ptr & (~1));
+       this_ptr_conv.is_owned = false;
+       int16_t ret_val = ChannelConfig_get_cltv_expiry_delta(&this_ptr_conv);
+       return ret_val;
+}
+
+void  __attribute__((visibility("default"))) TS_ChannelConfig_set_cltv_expiry_delta(uint32_t this_ptr, int16_t val) {
+       LDKChannelConfig this_ptr_conv;
+       this_ptr_conv.inner = (void*)(this_ptr & (~1));
+       this_ptr_conv.is_owned = false;
+       ChannelConfig_set_cltv_expiry_delta(&this_ptr_conv, val);
+}
+
 jboolean  __attribute__((visibility("default"))) TS_ChannelConfig_get_announced_channel(uint32_t this_ptr) {
        LDKChannelConfig this_ptr_conv;
        this_ptr_conv.inner = (void*)(this_ptr & (~1));
@@ -9134,8 +9186,8 @@ void  __attribute__((visibility("default"))) TS_ChannelConfig_set_commit_upfront
        ChannelConfig_set_commit_upfront_shutdown_pubkey(&this_ptr_conv, val);
 }
 
-uint32_t  __attribute__((visibility("default"))) TS_ChannelConfig_new(int32_t fee_proportional_millionths_arg, jboolean announced_channel_arg, jboolean commit_upfront_shutdown_pubkey_arg) {
-       LDKChannelConfig ret_var = ChannelConfig_new(fee_proportional_millionths_arg, announced_channel_arg, commit_upfront_shutdown_pubkey_arg);
+uint32_t  __attribute__((visibility("default"))) TS_ChannelConfig_new(int32_t fee_proportional_millionths_arg, int16_t cltv_expiry_delta_arg, jboolean announced_channel_arg, jboolean commit_upfront_shutdown_pubkey_arg) {
+       LDKChannelConfig ret_var = ChannelConfig_new(fee_proportional_millionths_arg, cltv_expiry_delta_arg, announced_channel_arg, commit_upfront_shutdown_pubkey_arg);
        CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
        CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
        long ret_ref = (long)ret_var.inner;
@@ -15650,6 +15702,14 @@ int8_tArray  __attribute__((visibility("default"))) TS_ReplyShortChannelIdsEnd_w
        return ret_arr;
 }
 
+int32_t  __attribute__((visibility("default"))) TS_QueryChannelRange_end_blocknum(uint32_t this_arg) {
+       LDKQueryChannelRange this_arg_conv;
+       this_arg_conv.inner = (void*)(this_arg & (~1));
+       this_arg_conv.is_owned = false;
+       int32_t ret_val = QueryChannelRange_end_blocknum(&this_arg_conv);
+       return ret_val;
+}
+
 uint32_t  __attribute__((visibility("default"))) TS_QueryChannelRange_read(int8_tArray ser) {
        LDKu8slice ser_ref;
        ser_ref.datalen = *((uint32_t*)ser);
index efa5422f02f7fd2dfa8ea7a2dd1e6ade04f9202c..6de31bc407a786b2fae11a1f6e76d76a66b057f8 100644 (file)
@@ -317,6 +317,11 @@ public static native long new_empty_slice_vec();
                        public number msg;
                        SendShortIdsQuery(Uint8Array node_id, number msg) { this.node_id = node_id; this.msg = msg; }
                }
+               export class SendReplyChannelRange extends LDKMessageSendEvent {
+                       public Uint8Array node_id;
+                       public number msg;
+                       SendReplyChannelRange(Uint8Array node_id, number msg) { this.node_id = node_id; this.msg = msg; }
+               }
                static native void init();
        }
        static { LDKMessageSendEvent.init(); }
@@ -1214,6 +1219,7 @@ public static native long new_empty_slice_vec();
                        peer_disconnected (their_node_id: Uint8Array, no_connection_possible: boolean): void;
                        peer_connected (their_node_id: Uint8Array, msg: number): void;
                        handle_channel_reestablish (their_node_id: Uint8Array, msg: number): void;
+                       handle_channel_update (their_node_id: Uint8Array, msg: number): void;
                        handle_error (their_node_id: Uint8Array, msg: number): void;
                }
 
@@ -1368,6 +1374,14 @@ public static native long new_empty_slice_vec();
                const nativeResponseValue = wasm.ChannelMessageHandler_handle_channel_reestablish(this_arg, encodeArray(their_node_id), msg);
                // debug statements here
        }
+       // void ChannelMessageHandler_handle_channel_update LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg
+       export function ChannelMessageHandler_handle_channel_update(this_arg: number, their_node_id: Uint8Array, msg: number): void {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.ChannelMessageHandler_handle_channel_update(this_arg, encodeArray(their_node_id), msg);
+               // debug statements here
+       }
        // void ChannelMessageHandler_handle_error LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg
        export function ChannelMessageHandler_handle_error(this_arg: number, their_node_id: Uint8Array, msg: number): void {
                if(!isWasmInitialized) {
@@ -4893,6 +4907,22 @@ public static native long new_empty_slice_vec();
                const nativeResponseValue = wasm.ChannelConfig_set_fee_proportional_millionths(this_ptr, val);
                // debug statements here
        }
+       // uint16_t ChannelConfig_get_cltv_expiry_delta(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
+       export function ChannelConfig_get_cltv_expiry_delta(this_ptr: number): number {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.ChannelConfig_get_cltv_expiry_delta(this_ptr);
+               return nativeResponseValue;
+       }
+       // void ChannelConfig_set_cltv_expiry_delta(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint16_t val);
+       export function ChannelConfig_set_cltv_expiry_delta(this_ptr: number, val: number): void {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.ChannelConfig_set_cltv_expiry_delta(this_ptr, val);
+               // debug statements here
+       }
        // bool ChannelConfig_get_announced_channel(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
        export function ChannelConfig_get_announced_channel(this_ptr: number): boolean {
                if(!isWasmInitialized) {
@@ -4925,12 +4955,12 @@ public static native long new_empty_slice_vec();
                const nativeResponseValue = wasm.ChannelConfig_set_commit_upfront_shutdown_pubkey(this_ptr, val);
                // debug statements here
        }
-       // MUST_USE_RES struct LDKChannelConfig ChannelConfig_new(uint32_t fee_proportional_millionths_arg, bool announced_channel_arg, bool commit_upfront_shutdown_pubkey_arg);
-       export function ChannelConfig_new(fee_proportional_millionths_arg: number, announced_channel_arg: boolean, commit_upfront_shutdown_pubkey_arg: boolean): number {
+       // 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);
+       export function ChannelConfig_new(fee_proportional_millionths_arg: number, cltv_expiry_delta_arg: number, announced_channel_arg: boolean, commit_upfront_shutdown_pubkey_arg: boolean): number {
                if(!isWasmInitialized) {
                        throw new Error("initializeWasm() must be awaited first!");
                }
-               const nativeResponseValue = wasm.ChannelConfig_new(fee_proportional_millionths_arg, announced_channel_arg, commit_upfront_shutdown_pubkey_arg);
+               const nativeResponseValue = wasm.ChannelConfig_new(fee_proportional_millionths_arg, cltv_expiry_delta_arg, announced_channel_arg, commit_upfront_shutdown_pubkey_arg);
                return nativeResponseValue;
        }
        // struct LDKChannelConfig ChannelConfig_clone(const struct LDKChannelConfig *NONNULL_PTR orig);
@@ -9901,6 +9931,14 @@ public static native long new_empty_slice_vec();
                const nativeResponseValue = wasm.ReplyShortChannelIdsEnd_write(obj);
                return decodeArray(nativeResponseValue);
        }
+       // MUST_USE_RES uint32_t QueryChannelRange_end_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_arg);
+       export function QueryChannelRange_end_blocknum(this_arg: number): number {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.QueryChannelRange_end_blocknum(this_arg);
+               return nativeResponseValue;
+       }
        // struct LDKCResult_QueryChannelRangeDecodeErrorZ QueryChannelRange_read(struct LDKu8slice ser);
        export function QueryChannelRange_read(ser: Uint8Array): number {
                if(!isWasmInitialized) {
index 9bdf48c6b42df8cd7ea18f4d0d1532d5b6c5c6af..afb53fb01fced998b1a30a07841bce072073575e 100644 (file)
@@ -27,6 +27,15 @@ import * as bindings from '../bindings' // TODO: figure out location
                bindings.ChannelConfig_set_fee_proportional_millionths(this.ptr, val);
        }
 
+       public number get_cltv_expiry_delta() {
+               number ret = bindings.ChannelConfig_get_cltv_expiry_delta(this.ptr);
+               return ret;
+       }
+
+       public void set_cltv_expiry_delta(number val) {
+               bindings.ChannelConfig_set_cltv_expiry_delta(this.ptr, val);
+       }
+
        public boolean get_announced_channel() {
                boolean ret = bindings.ChannelConfig_get_announced_channel(this.ptr);
                return ret;
@@ -45,8 +54,8 @@ import * as bindings from '../bindings' // TODO: figure out location
                bindings.ChannelConfig_set_commit_upfront_shutdown_pubkey(this.ptr, val);
        }
 
-       public static ChannelConfig constructor_new(number fee_proportional_millionths_arg, boolean announced_channel_arg, boolean commit_upfront_shutdown_pubkey_arg) {
-               number ret = bindings.ChannelConfig_new(fee_proportional_millionths_arg, announced_channel_arg, commit_upfront_shutdown_pubkey_arg);
+       public static ChannelConfig constructor_new(number fee_proportional_millionths_arg, number cltv_expiry_delta_arg, boolean announced_channel_arg, boolean commit_upfront_shutdown_pubkey_arg) {
+               number ret = bindings.ChannelConfig_new(fee_proportional_millionths_arg, cltv_expiry_delta_arg, announced_channel_arg, commit_upfront_shutdown_pubkey_arg);
                const ret_hu_conv: ChannelConfig = new ChannelConfig(null, ret);
                ret_hu_conv.ptrs_to.add(ret_hu_conv);
                return ret_hu_conv;
index a9ffbd7cf4557a3ab16860465fe60ce8492065b2..41e892fe341fca0efb1b4a0f102ad02a509990f1 100644 (file)
@@ -127,6 +127,11 @@ import * as bindings from '../bindings' // TODO: figure out location
                                                        arg.handle_channel_reestablish(their_node_id, msg_hu_conv);
                                                },
 
+                                               handle_channel_update (their_node_id: Uint8Array, msg: number): void {
+                                                       const msg_hu_conv: ChannelUpdate = new ChannelUpdate(null, msg);
+                                                       arg.handle_channel_update(their_node_id, msg_hu_conv);
+                                               },
+
                                                handle_error (their_node_id: Uint8Array, msg: number): void {
                                                        const msg_hu_conv: ErrorMessage = new ErrorMessage(null, msg);
                                                        arg.handle_error(their_node_id, msg_hu_conv);
@@ -157,6 +162,7 @@ import * as bindings from '../bindings' // TODO: figure out location
                                peer_disconnected(their_node_id: Uint8Array, no_connection_possible: boolean): void;
                                peer_connected(their_node_id: Uint8Array, msg: Init): void;
                                handle_channel_reestablish(their_node_id: Uint8Array, msg: ChannelReestablish): void;
+                               handle_channel_update(their_node_id: Uint8Array, msg: ChannelUpdate): void;
                                handle_error(their_node_id: Uint8Array, msg: ErrorMessage): void;
                                
             }
@@ -256,6 +262,11 @@ import * as bindings from '../bindings' // TODO: figure out location
                this.ptrs_to.add(msg);
        }
 
+       public void handle_channel_update(Uint8Array 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);
+       }
+
        public void handle_error(Uint8Array their_node_id, ErrorMessage msg) {
                bindings.ChannelMessageHandler_handle_error(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
                this.ptrs_to.add(msg);
diff --git a/ts/structs/InvoiceFeatures.ts b/ts/structs/InvoiceFeatures.ts
new file mode 100644 (file)
index 0000000..ba5f0bf
--- /dev/null
@@ -0,0 +1,53 @@
+
+            
+import CommonBase from './CommonBase';
+import * as bindings from '../bindings' // TODO: figure out location
+
+
+
+            export default class InvoiceFeatures extends CommonBase {
+                constructor(_dummy: object, ptr: number) {
+                    super(ptr);
+                }
+
+                
+                protected finalize() {
+                    super.finalize();
+
+                    if (this.ptr != 0) {
+                        bindings.InvoiceFeatures_free(this.ptr);
+                    }
+                }
+       public InvoiceFeatures clone() {
+               number ret = bindings.InvoiceFeatures_clone(this.ptr);
+               const ret_hu_conv: InvoiceFeatures = new InvoiceFeatures(null, ret);
+               ret_hu_conv.ptrs_to.add(this);
+               return ret_hu_conv;
+       }
+
+       public static InvoiceFeatures constructor_empty() {
+               number ret = bindings.InvoiceFeatures_empty();
+               const ret_hu_conv: InvoiceFeatures = new InvoiceFeatures(null, ret);
+               ret_hu_conv.ptrs_to.add(ret_hu_conv);
+               return ret_hu_conv;
+       }
+
+       public static InvoiceFeatures constructor_known() {
+               number ret = bindings.InvoiceFeatures_known();
+               const ret_hu_conv: InvoiceFeatures = new InvoiceFeatures(null, ret);
+               ret_hu_conv.ptrs_to.add(ret_hu_conv);
+               return ret_hu_conv;
+       }
+
+       public Uint8Array write() {
+               Uint8Array ret = bindings.InvoiceFeatures_write(this.ptr);
+               return ret;
+       }
+
+       public static Result_InvoiceFeaturesDecodeErrorZ constructor_read(Uint8Array ser) {
+               number ret = bindings.InvoiceFeatures_read(ser);
+               Result_InvoiceFeaturesDecodeErrorZ ret_hu_conv = Result_InvoiceFeaturesDecodeErrorZ.constr_from_ptr(ret);
+               return ret_hu_conv;
+       }
+
+}
index 7c8ebdfaf782cf8f2fb0cf53156389586c35cac0..38998e2562ebfcc618d464a74efe97172b84ad0d 100644 (file)
@@ -64,6 +64,9 @@ export default class MessageSendEvent extends CommonBase {
                if (raw_val instanceof bindings.LDKMessageSendEvent.SendShortIdsQuery) {
                        return new SendShortIdsQuery(this.ptr, raw_val);
                }
+               if (raw_val instanceof bindings.LDKMessageSendEvent.SendReplyChannelRange) {
+                       return new SendReplyChannelRange(this.ptr, raw_val);
+               }
                throw new Error('oops, this should be unreachable'); // Unreachable without extending the (internal) bindings interface
        }
 
@@ -281,3 +284,15 @@ export class SendShortIdsQuery extends MessageSendEvent {
                this.msg = msg_hu_conv;
        }
 }
+export class SendReplyChannelRange extends MessageSendEvent {
+       public node_id: Uint8Array;
+       public msg: ReplyChannelRange;
+       private constructor(ptr: number, obj: bindings.LDKMessageSendEvent.SendReplyChannelRange) {
+               super(null, ptr);
+               this.node_id = obj.node_id;
+               const msg: number = obj.msg;
+               const msg_hu_conv: ReplyChannelRange = new ReplyChannelRange(null, msg);
+                       msg_hu_conv.ptrs_to.add(this);
+               this.msg = msg_hu_conv;
+       }
+}
index 4a4a6e22dd17013af439d6f5ca2d8721b4524061..1b6be47b02e9cb1b42e154b032b2b9ffae8988b5 100644 (file)
@@ -59,6 +59,11 @@ import * as bindings from '../bindings' // TODO: figure out location
                return ret_hu_conv;
        }
 
+       public number end_blocknum() {
+               number ret = bindings.QueryChannelRange_end_blocknum(this.ptr);
+               return ret;
+       }
+
        public static Result_QueryChannelRangeDecodeErrorZ constructor_read(Uint8Array ser) {
                number ret = bindings.QueryChannelRange_read(ser);
                Result_QueryChannelRangeDecodeErrorZ ret_hu_conv = Result_QueryChannelRangeDecodeErrorZ.constr_from_ptr(ret);
diff --git a/ts/structs/Result_InvoiceFeaturesDecodeErrorZ.ts b/ts/structs/Result_InvoiceFeaturesDecodeErrorZ.ts
new file mode 100644 (file)
index 0000000..ac13a5a
--- /dev/null
@@ -0,0 +1,47 @@
+
+import CommonBase from './CommonBase';
+import * as bindings from '../bindings' // TODO: figure out location
+
+public class Result_InvoiceFeaturesDecodeErrorZ extends CommonBase {
+       private Result_InvoiceFeaturesDecodeErrorZ(Object _dummy, long ptr) { super(ptr); }
+       protected void finalize() throws Throwable {
+               if (ptr != 0) { bindings.CResult_InvoiceFeaturesDecodeErrorZ_free(ptr); } super.finalize();
+       }
+
+       static Result_InvoiceFeaturesDecodeErrorZ constr_from_ptr(long ptr) {
+               if (bindings.LDKCResult_InvoiceFeaturesDecodeErrorZ_result_ok(ptr)) {
+                       return new Result_InvoiceFeaturesDecodeErrorZ_OK(null, ptr);
+               } else {
+                       return new Result_InvoiceFeaturesDecodeErrorZ_Err(null, ptr);
+               }
+       }
+       public static final class Result_InvoiceFeaturesDecodeErrorZ_OK extends Result_InvoiceFeaturesDecodeErrorZ {
+               public final InvoiceFeatures res;
+               private Result_InvoiceFeaturesDecodeErrorZ_OK(Object _dummy, long ptr) {
+                       super(_dummy, ptr);
+                       number res = bindings.LDKCResult_InvoiceFeaturesDecodeErrorZ_get_ok(ptr);
+                       const res_hu_conv: InvoiceFeatures = new InvoiceFeatures(null, res);
+                       res_hu_conv.ptrs_to.add(this);
+                       this.res = res_hu_conv;
+               }
+               public Result_InvoiceFeaturesDecodeErrorZ_OK(InvoiceFeatures res) {
+                       this(null, bindings.CResult_InvoiceFeaturesDecodeErrorZ_ok(res == null ? 0 : res.ptr & ~1));
+                       this.ptrs_to.add(res);
+               }
+       }
+
+       public static final class Result_InvoiceFeaturesDecodeErrorZ_Err extends Result_InvoiceFeaturesDecodeErrorZ {
+               public final DecodeError err;
+               private Result_InvoiceFeaturesDecodeErrorZ_Err(Object _dummy, long ptr) {
+                       super(_dummy, ptr);
+                       number err = bindings.LDKCResult_InvoiceFeaturesDecodeErrorZ_get_err(ptr);
+                       const err_hu_conv: DecodeError = new DecodeError(null, err);
+                       err_hu_conv.ptrs_to.add(this);
+                       this.err = err_hu_conv;
+               }
+               public Result_InvoiceFeaturesDecodeErrorZ_Err(DecodeError err) {
+                       this(null, bindings.CResult_InvoiceFeaturesDecodeErrorZ_err(err == null ? 0 : err.ptr & ~1));
+                       this.ptrs_to.add(err);
+               }
+       }
+}