]> git.bitcoin.ninja Git - ldk-java/commitdiff
Update auto-generated bindings for new upstream
authorMatt Corallo <git@bluematt.me>
Sat, 6 Mar 2021 00:42:32 +0000 (19:42 -0500)
committerMatt Corallo <git@bluematt.me>
Sat, 6 Mar 2021 00:45:31 +0000 (19:45 -0500)
20 files changed:
liblightningjni.so
src/main/java/org/ldk/enums/LDKNetwork.java
src/main/java/org/ldk/impl/bindings.java
src/main/java/org/ldk/structs/ChainParameters.java [new file with mode: 0644]
src/main/java/org/ldk/structs/ChannelManager.java
src/main/java/org/ldk/structs/ErroringMessageHandler.java [new file with mode: 0644]
src/main/java/org/ldk/structs/IgnoringMessageHandler.java [new file with mode: 0644]
src/main/java/org/ldk/structs/NetGraphMsgHandler.java
src/main/java/org/ldk/structs/RouteHint.java
src/main/jni/bindings.c
src/main/jni/org_ldk_impl_bindings.h
ts/bindings.c
ts/bindings.ts
ts/enums/LDKNetwork.ts
ts/structs/ChainParameters.ts [new file with mode: 0644]
ts/structs/ChannelManager.ts
ts/structs/ErroringMessageHandler.ts [new file with mode: 0644]
ts/structs/IgnoringMessageHandler.ts [new file with mode: 0644]
ts/structs/NetGraphMsgHandler.ts
ts/structs/RouteHint.ts

index 62a2a84db0e31108f42d0e0de1d8511ccacf225e..1eb4cbbf63eb5f8f44484be5945b64253bf8d66a 100755 (executable)
Binary files a/liblightningjni.so and b/liblightningjni.so differ
index 5dc35775421623716b7ae9fed06a11acd6888cec..f764ed6b42aec2d1d9102a4a16d744d919f71db8 100644 (file)
@@ -4,6 +4,7 @@ public enum LDKNetwork {
        LDKNetwork_Bitcoin,
        LDKNetwork_Testnet,
        LDKNetwork_Regtest,
+       LDKNetwork_Signet,
        ; static native void init();
        static { init(); }
 }
\ No newline at end of file
index efeb7e95636a467dc21637d4a71f93dff32beb6f..6ae3d22f0059393d1012f2c09a7590ee9a549c5b 100644 (file)
@@ -76,39 +76,6 @@ public class bindings {
        public static native boolean LDKCResult_CVec_SignatureZNoneZ_result_ok(long arg);
        public static native byte[][] LDKCResult_CVec_SignatureZNoneZ_get_ok(long arg);
        public static native void LDKCResult_CVec_SignatureZNoneZ_get_err(long arg);
-       public static native boolean LDKCResult_CVec_u8ZPeerHandleErrorZ_result_ok(long arg);
-       public static native byte[] LDKCResult_CVec_u8ZPeerHandleErrorZ_get_ok(long arg);
-       public static native long LDKCResult_CVec_u8ZPeerHandleErrorZ_get_err(long arg);
-       public static native boolean LDKCResult_NonePeerHandleErrorZ_result_ok(long arg);
-       public static native void LDKCResult_NonePeerHandleErrorZ_get_ok(long arg);
-       public static native long LDKCResult_NonePeerHandleErrorZ_get_err(long arg);
-       public static native boolean LDKCResult_boolPeerHandleErrorZ_result_ok(long arg);
-       public static native boolean LDKCResult_boolPeerHandleErrorZ_get_ok(long arg);
-       public static native long LDKCResult_boolPeerHandleErrorZ_get_err(long arg);
-       public static native boolean LDKCResult_InitFeaturesDecodeErrorZ_result_ok(long arg);
-       public static native long LDKCResult_InitFeaturesDecodeErrorZ_get_ok(long arg);
-       public static native long LDKCResult_InitFeaturesDecodeErrorZ_get_err(long arg);
-       public static native boolean LDKCResult_NodeFeaturesDecodeErrorZ_result_ok(long arg);
-       public static native long LDKCResult_NodeFeaturesDecodeErrorZ_get_ok(long arg);
-       public static native long LDKCResult_NodeFeaturesDecodeErrorZ_get_err(long arg);
-       public static native boolean LDKCResult_ChannelFeaturesDecodeErrorZ_result_ok(long arg);
-       public static native long LDKCResult_ChannelFeaturesDecodeErrorZ_get_ok(long arg);
-       public static native long LDKCResult_ChannelFeaturesDecodeErrorZ_get_err(long arg);
-       public static native boolean LDKCResult_ChannelConfigDecodeErrorZ_result_ok(long arg);
-       public static native long LDKCResult_ChannelConfigDecodeErrorZ_get_ok(long arg);
-       public static native long LDKCResult_ChannelConfigDecodeErrorZ_get_err(long arg);
-       public static native boolean LDKCResult_boolLightningErrorZ_result_ok(long arg);
-       public static native boolean LDKCResult_boolLightningErrorZ_get_ok(long arg);
-       public static native long LDKCResult_boolLightningErrorZ_get_err(long arg);
-       public static native long LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(long a, long b, long c);
-       public static native long LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(long ptr);
-       public static native long LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(long ptr);
-       public static native long LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(long ptr);
-       public static native long LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_new(long[] elems);
-       public static native long LDKCVec_NodeAnnouncementZ_new(long[] elems);
-       public static native boolean LDKCResult_NoneLightningErrorZ_result_ok(long arg);
-       public static native void LDKCResult_NoneLightningErrorZ_get_ok(long arg);
-       public static native long LDKCResult_NoneLightningErrorZ_get_err(long arg);
        public static class LDKErrorAction {
                private LDKErrorAction() {}
                public final static class DisconnectPeer extends LDKErrorAction {
@@ -240,6 +207,39 @@ public class bindings {
        static { LDKMessageSendEvent.init(); }
        public static native LDKMessageSendEvent LDKMessageSendEvent_ref_from_ptr(long ptr);
        public static native long LDKCVec_MessageSendEventZ_new(long[] elems);
+       public static native boolean LDKCResult_boolLightningErrorZ_result_ok(long arg);
+       public static native boolean LDKCResult_boolLightningErrorZ_get_ok(long arg);
+       public static native long LDKCResult_boolLightningErrorZ_get_err(long arg);
+       public static native long LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(long a, long b, long c);
+       public static native long LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(long ptr);
+       public static native long LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(long ptr);
+       public static native long LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(long ptr);
+       public static native long LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_new(long[] elems);
+       public static native long LDKCVec_NodeAnnouncementZ_new(long[] elems);
+       public static native boolean LDKCResult_NoneLightningErrorZ_result_ok(long arg);
+       public static native void LDKCResult_NoneLightningErrorZ_get_ok(long arg);
+       public static native long LDKCResult_NoneLightningErrorZ_get_err(long arg);
+       public static native boolean LDKCResult_CVec_u8ZPeerHandleErrorZ_result_ok(long arg);
+       public static native byte[] LDKCResult_CVec_u8ZPeerHandleErrorZ_get_ok(long arg);
+       public static native long LDKCResult_CVec_u8ZPeerHandleErrorZ_get_err(long arg);
+       public static native boolean LDKCResult_NonePeerHandleErrorZ_result_ok(long arg);
+       public static native void LDKCResult_NonePeerHandleErrorZ_get_ok(long arg);
+       public static native long LDKCResult_NonePeerHandleErrorZ_get_err(long arg);
+       public static native boolean LDKCResult_boolPeerHandleErrorZ_result_ok(long arg);
+       public static native boolean LDKCResult_boolPeerHandleErrorZ_get_ok(long arg);
+       public static native long LDKCResult_boolPeerHandleErrorZ_get_err(long arg);
+       public static native boolean LDKCResult_InitFeaturesDecodeErrorZ_result_ok(long arg);
+       public static native long LDKCResult_InitFeaturesDecodeErrorZ_get_ok(long arg);
+       public static native long LDKCResult_InitFeaturesDecodeErrorZ_get_err(long arg);
+       public static native boolean LDKCResult_NodeFeaturesDecodeErrorZ_result_ok(long arg);
+       public static native long LDKCResult_NodeFeaturesDecodeErrorZ_get_ok(long arg);
+       public static native long LDKCResult_NodeFeaturesDecodeErrorZ_get_err(long arg);
+       public static native boolean LDKCResult_ChannelFeaturesDecodeErrorZ_result_ok(long arg);
+       public static native long LDKCResult_ChannelFeaturesDecodeErrorZ_get_ok(long arg);
+       public static native long LDKCResult_ChannelFeaturesDecodeErrorZ_get_err(long arg);
+       public static native boolean LDKCResult_ChannelConfigDecodeErrorZ_result_ok(long arg);
+       public static native long LDKCResult_ChannelConfigDecodeErrorZ_get_ok(long arg);
+       public static native long LDKCResult_ChannelConfigDecodeErrorZ_get_err(long arg);
        public static native boolean LDKCResult_DirectionalChannelInfoDecodeErrorZ_result_ok(long arg);
        public static native long LDKCResult_DirectionalChannelInfoDecodeErrorZ_get_ok(long arg);
        public static native long LDKCResult_DirectionalChannelInfoDecodeErrorZ_get_err(long arg);
@@ -941,6 +941,34 @@ public class bindings {
        public static native void CResult_CVec_SignatureZNoneZ_free(long _res);
        // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_clone(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR orig);
        public static native long CResult_CVec_SignatureZNoneZ_clone(long orig);
+       // void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
+       public static native void CVec_MessageSendEventZ_free(long[] _res);
+       // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
+       public static native long CResult_boolLightningErrorZ_ok(boolean o);
+       // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
+       public static native long CResult_boolLightningErrorZ_err(long e);
+       // void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
+       public static native void CResult_boolLightningErrorZ_free(long _res);
+       // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
+       public static native long CResult_boolLightningErrorZ_clone(long orig);
+       // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
+       public static native long C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(long orig);
+       // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
+       public static native long C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(long a, long b, long c);
+       // void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res);
+       public static native void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(long _res);
+       // void CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(struct LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res);
+       public static native void CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(long[] _res);
+       // void CVec_NodeAnnouncementZ_free(struct LDKCVec_NodeAnnouncementZ _res);
+       public static native void CVec_NodeAnnouncementZ_free(long[] _res);
+       // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
+       public static native long CResult_NoneLightningErrorZ_ok();
+       // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
+       public static native long CResult_NoneLightningErrorZ_err(long e);
+       // void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
+       public static native void CResult_NoneLightningErrorZ_free(long _res);
+       // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
+       public static native long CResult_NoneLightningErrorZ_clone(long orig);
        // void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
        public static native void CVec_PublicKeyZ_free(byte[][] _res);
        // void CVec_u8Z_free(struct LDKCVec_u8Z _res);
@@ -995,34 +1023,6 @@ public class bindings {
        public static native void CResult_ChannelConfigDecodeErrorZ_free(long _res);
        // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_clone(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR orig);
        public static native long CResult_ChannelConfigDecodeErrorZ_clone(long orig);
-       // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
-       public static native long CResult_boolLightningErrorZ_ok(boolean o);
-       // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
-       public static native long CResult_boolLightningErrorZ_err(long e);
-       // void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
-       public static native void CResult_boolLightningErrorZ_free(long _res);
-       // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
-       public static native long CResult_boolLightningErrorZ_clone(long orig);
-       // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
-       public static native long C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(long orig);
-       // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
-       public static native long C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(long a, long b, long c);
-       // void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res);
-       public static native void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(long _res);
-       // void CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(struct LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res);
-       public static native void CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(long[] _res);
-       // void CVec_NodeAnnouncementZ_free(struct LDKCVec_NodeAnnouncementZ _res);
-       public static native void CVec_NodeAnnouncementZ_free(long[] _res);
-       // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
-       public static native long CResult_NoneLightningErrorZ_ok();
-       // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
-       public static native long CResult_NoneLightningErrorZ_err(long e);
-       // void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
-       public static native void CResult_NoneLightningErrorZ_free(long _res);
-       // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
-       public static native long CResult_NoneLightningErrorZ_clone(long orig);
-       // void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
-       public static native void CVec_MessageSendEventZ_free(long[] _res);
        // struct LDKCResult_DirectionalChannelInfoDecodeErrorZ CResult_DirectionalChannelInfoDecodeErrorZ_ok(struct LDKDirectionalChannelInfo o);
        public static native long CResult_DirectionalChannelInfoDecodeErrorZ_ok(long o);
        // struct LDKCResult_DirectionalChannelInfoDecodeErrorZ CResult_DirectionalChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
@@ -1759,21 +1759,21 @@ public class bindings {
        public static native long ChannelMonitor_clone(long orig);
        // struct LDKCVec_u8Z ChannelMonitor_write(const struct LDKChannelMonitor *NONNULL_PTR obj);
        public static native byte[] ChannelMonitor_write(long obj);
-       // MUST_USE_RES struct LDKCResult_NoneMonitorUpdateErrorZ ChannelMonitor_update_monitor(struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKChannelMonitorUpdate *NONNULL_PTR updates, const struct LDKBroadcasterInterface *NONNULL_PTR broadcaster, const struct LDKFeeEstimator *NONNULL_PTR fee_estimator, const struct LDKLogger *NONNULL_PTR logger);
+       // MUST_USE_RES struct LDKCResult_NoneMonitorUpdateErrorZ ChannelMonitor_update_monitor(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKChannelMonitorUpdate *NONNULL_PTR updates, const struct LDKBroadcasterInterface *NONNULL_PTR broadcaster, const struct LDKFeeEstimator *NONNULL_PTR fee_estimator, const struct LDKLogger *NONNULL_PTR logger);
        public static native long ChannelMonitor_update_monitor(long this_arg, long updates, long broadcaster, long fee_estimator, long logger);
        // MUST_USE_RES uint64_t ChannelMonitor_get_latest_update_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
        public static native long ChannelMonitor_get_latest_update_id(long this_arg);
        // MUST_USE_RES struct LDKC2Tuple_OutPointScriptZ ChannelMonitor_get_funding_txo(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
        public static native long ChannelMonitor_get_funding_txo(long this_arg);
-       // MUST_USE_RES struct LDKCVec_MonitorEventZ ChannelMonitor_get_and_clear_pending_monitor_events(struct LDKChannelMonitor *NONNULL_PTR this_arg);
+       // MUST_USE_RES struct LDKCVec_MonitorEventZ ChannelMonitor_get_and_clear_pending_monitor_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
        public static native long[] ChannelMonitor_get_and_clear_pending_monitor_events(long this_arg);
-       // MUST_USE_RES struct LDKCVec_EventZ ChannelMonitor_get_and_clear_pending_events(struct LDKChannelMonitor *NONNULL_PTR this_arg);
+       // MUST_USE_RES struct LDKCVec_EventZ ChannelMonitor_get_and_clear_pending_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
        public static native long[] ChannelMonitor_get_and_clear_pending_events(long this_arg);
-       // MUST_USE_RES struct LDKCVec_TransactionZ ChannelMonitor_get_latest_holder_commitment_txn(struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKLogger *NONNULL_PTR logger);
+       // MUST_USE_RES struct LDKCVec_TransactionZ ChannelMonitor_get_latest_holder_commitment_txn(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKLogger *NONNULL_PTR logger);
        public static native byte[][] ChannelMonitor_get_latest_holder_commitment_txn(long this_arg, long logger);
-       // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ChannelMonitor_block_connected(struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKLogger logger);
+       // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ChannelMonitor_block_connected(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKLogger logger);
        public static native long[] ChannelMonitor_block_connected(long this_arg, byte[] header, long[] txdata, int height, long broadcaster, long fee_estimator, long logger);
-       // void ChannelMonitor_block_disconnected(struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKLogger logger);
+       // void ChannelMonitor_block_disconnected(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKLogger logger);
        public static native void ChannelMonitor_block_disconnected(long this_arg, byte[] header, int height, long broadcaster, long fee_estimator, long logger);
        // void Persist_free(struct LDKPersist this_ptr);
        public static native void Persist_free(long this_ptr);
@@ -1929,6 +1929,22 @@ public class bindings {
        public static native long KeysManager_as_KeysInterface(long this_arg);
        // void ChannelManager_free(struct LDKChannelManager this_ptr);
        public static native void ChannelManager_free(long this_ptr);
+       // void ChainParameters_free(struct LDKChainParameters this_ptr);
+       public static native void ChainParameters_free(long this_ptr);
+       // enum LDKNetwork ChainParameters_get_network(const struct LDKChainParameters *NONNULL_PTR this_ptr);
+       public static native LDKNetwork ChainParameters_get_network(long this_ptr);
+       // void ChainParameters_set_network(struct LDKChainParameters *NONNULL_PTR this_ptr, enum LDKNetwork val);
+       public static native void ChainParameters_set_network(long this_ptr, LDKNetwork val);
+       // const uint8_t (*ChainParameters_get_latest_hash(const struct LDKChainParameters *NONNULL_PTR this_ptr))[32];
+       public static native byte[] ChainParameters_get_latest_hash(long this_ptr);
+       // void ChainParameters_set_latest_hash(struct LDKChainParameters *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
+       public static native void ChainParameters_set_latest_hash(long this_ptr, byte[] val);
+       // uintptr_t ChainParameters_get_latest_height(const struct LDKChainParameters *NONNULL_PTR this_ptr);
+       public static native long ChainParameters_get_latest_height(long this_ptr);
+       // void ChainParameters_set_latest_height(struct LDKChainParameters *NONNULL_PTR this_ptr, uintptr_t val);
+       public static native void ChainParameters_set_latest_height(long this_ptr, long val);
+       // MUST_USE_RES struct LDKChainParameters ChainParameters_new(enum LDKNetwork network_arg, struct LDKThirtyTwoBytes latest_hash_arg, uintptr_t latest_height_arg);
+       public static native long ChainParameters_new(LDKNetwork network_arg, byte[] latest_hash_arg, long latest_height_arg);
        // void ChannelDetails_free(struct LDKChannelDetails this_ptr);
        public static native void ChannelDetails_free(long this_ptr);
        // const uint8_t (*ChannelDetails_get_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr))[32];
@@ -1969,8 +1985,8 @@ public class bindings {
        public static native void PaymentSendFailure_free(long this_ptr);
        // struct LDKPaymentSendFailure PaymentSendFailure_clone(const struct LDKPaymentSendFailure *NONNULL_PTR orig);
        public static native long PaymentSendFailure_clone(long orig);
-       // MUST_USE_RES struct LDKChannelManager ChannelManager_new(enum LDKNetwork network, struct LDKFeeEstimator fee_est, struct LDKWatch chain_monitor, struct LDKBroadcasterInterface tx_broadcaster, struct LDKLogger logger, struct LDKKeysInterface keys_manager, struct LDKUserConfig config, uintptr_t current_blockchain_height);
-       public static native long ChannelManager_new(LDKNetwork network, long fee_est, long chain_monitor, long tx_broadcaster, long logger, long keys_manager, long config, long current_blockchain_height);
+       // MUST_USE_RES struct LDKChannelManager ChannelManager_new(struct LDKFeeEstimator fee_est, struct LDKWatch chain_monitor, struct LDKBroadcasterInterface tx_broadcaster, struct LDKLogger logger, struct LDKKeysInterface keys_manager, struct LDKUserConfig config, struct LDKChainParameters params);
+       public static native long ChannelManager_new(long fee_est, long chain_monitor, long tx_broadcaster, long logger, long keys_manager, long config, long params);
        // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_create_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPublicKey their_network_key, uint64_t channel_value_satoshis, uint64_t push_msat, uint64_t user_id, struct LDKUserConfig override_config);
        public static native long ChannelManager_create_channel(long this_arg, byte[] their_network_key, long channel_value_satoshis, long push_msat, long user_id, long override_config);
        // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
@@ -2901,6 +2917,22 @@ public class bindings {
        public static native long GossipTimestampFilter_read(byte[] ser);
        // struct LDKCVec_u8Z GossipTimestampFilter_write(const struct LDKGossipTimestampFilter *NONNULL_PTR obj);
        public static native byte[] GossipTimestampFilter_write(long obj);
+       // void IgnoringMessageHandler_free(struct LDKIgnoringMessageHandler this_ptr);
+       public static native void IgnoringMessageHandler_free(long this_ptr);
+       // MUST_USE_RES struct LDKIgnoringMessageHandler IgnoringMessageHandler_new(void);
+       public static native long IgnoringMessageHandler_new();
+       // struct LDKMessageSendEventsProvider IgnoringMessageHandler_as_MessageSendEventsProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
+       public static native long IgnoringMessageHandler_as_MessageSendEventsProvider(long this_arg);
+       // struct LDKRoutingMessageHandler IgnoringMessageHandler_as_RoutingMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
+       public static native long IgnoringMessageHandler_as_RoutingMessageHandler(long this_arg);
+       // void ErroringMessageHandler_free(struct LDKErroringMessageHandler this_ptr);
+       public static native void ErroringMessageHandler_free(long this_ptr);
+       // MUST_USE_RES struct LDKErroringMessageHandler ErroringMessageHandler_new(void);
+       public static native long ErroringMessageHandler_new();
+       // struct LDKMessageSendEventsProvider ErroringMessageHandler_as_MessageSendEventsProvider(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
+       public static native long ErroringMessageHandler_as_MessageSendEventsProvider(long this_arg);
+       // struct LDKChannelMessageHandler ErroringMessageHandler_as_ChannelMessageHandler(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
+       public static native long ErroringMessageHandler_as_ChannelMessageHandler(long this_arg);
        // void MessageHandler_free(struct LDKMessageHandler this_ptr);
        public static native void MessageHandler_free(long this_ptr);
        // const struct LDKChannelMessageHandler *MessageHandler_get_chan_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
@@ -3287,16 +3319,10 @@ public class bindings {
        public static native short RouteHint_get_cltv_expiry_delta(long this_ptr);
        // void RouteHint_set_cltv_expiry_delta(struct LDKRouteHint *NONNULL_PTR this_ptr, uint16_t val);
        public static native void RouteHint_set_cltv_expiry_delta(long this_ptr, short val);
-       // uint64_t RouteHint_get_htlc_minimum_msat(const struct LDKRouteHint *NONNULL_PTR this_ptr);
-       public static native long RouteHint_get_htlc_minimum_msat(long this_ptr);
-       // void RouteHint_set_htlc_minimum_msat(struct LDKRouteHint *NONNULL_PTR this_ptr, uint64_t val);
-       public static native void RouteHint_set_htlc_minimum_msat(long this_ptr, long val);
-       // MUST_USE_RES struct LDKRouteHint RouteHint_new(struct LDKPublicKey src_node_id_arg, uint64_t short_channel_id_arg, struct LDKRoutingFees fees_arg, uint16_t cltv_expiry_delta_arg, uint64_t htlc_minimum_msat_arg);
-       public static native long RouteHint_new(byte[] src_node_id_arg, long short_channel_id_arg, long fees_arg, short cltv_expiry_delta_arg, long htlc_minimum_msat_arg);
        // struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
        public static native long RouteHint_clone(long orig);
-       // struct LDKCResult_RouteLightningErrorZ get_route(struct LDKPublicKey our_node_id, const struct LDKNetworkGraph *NONNULL_PTR network, struct LDKPublicKey target, struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKCVec_RouteHintZ last_hops, uint64_t final_value_msat, uint32_t final_cltv, struct LDKLogger logger);
-       public static native long get_route(byte[] our_node_id, long network, byte[] target, long[] first_hops, long[] last_hops, long final_value_msat, int final_cltv, long logger);
+       // struct LDKCResult_RouteLightningErrorZ get_route(struct LDKPublicKey our_node_id, const struct LDKNetworkGraph *NONNULL_PTR network, struct LDKPublicKey payee, struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKCVec_RouteHintZ last_hops, uint64_t final_value_msat, uint32_t final_cltv, struct LDKLogger logger);
+       public static native long get_route(byte[] our_node_id, long network, byte[] payee, long[] first_hops, long[] last_hops, long final_value_msat, int final_cltv, long logger);
        // void NetworkGraph_free(struct LDKNetworkGraph this_ptr);
        public static native void NetworkGraph_free(long this_ptr);
        // struct LDKNetworkGraph NetworkGraph_clone(const struct LDKNetworkGraph *NONNULL_PTR orig);
@@ -3309,6 +3335,8 @@ public class bindings {
        public static native long NetGraphMsgHandler_new(byte[] genesis_hash, long chain_access, long logger);
        // MUST_USE_RES struct LDKNetGraphMsgHandler NetGraphMsgHandler_from_net_graph(struct LDKAccess *chain_access, struct LDKLogger logger, struct LDKNetworkGraph network_graph);
        public static native long NetGraphMsgHandler_from_net_graph(long chain_access, long logger, long network_graph);
+       // void NetGraphMsgHandler_add_chain_access(struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg, struct LDKAccess *chain_access);
+       public static native void NetGraphMsgHandler_add_chain_access(long this_arg, long chain_access);
        // MUST_USE_RES struct LDKLockedNetworkGraph NetGraphMsgHandler_read_locked_graph(const struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg);
        public static native long NetGraphMsgHandler_read_locked_graph(long this_arg);
        // MUST_USE_RES struct LDKNetworkGraph LockedNetworkGraph_graph(const struct LDKLockedNetworkGraph *NONNULL_PTR this_arg);
diff --git a/src/main/java/org/ldk/structs/ChainParameters.java b/src/main/java/org/ldk/structs/ChainParameters.java
new file mode 100644 (file)
index 0000000..06e5693
--- /dev/null
@@ -0,0 +1,51 @@
+package org.ldk.structs;
+
+import org.ldk.impl.bindings;
+import org.ldk.enums.*;
+import org.ldk.util.*;
+import java.util.Arrays;
+
+@SuppressWarnings("unchecked") // We correctly assign various generic arrays
+public class ChainParameters extends CommonBase {
+       ChainParameters(Object _dummy, long ptr) { super(ptr); }
+       @Override @SuppressWarnings("deprecation")
+       protected void finalize() throws Throwable {
+               super.finalize();
+               if (ptr != 0) { bindings.ChainParameters_free(ptr); }
+       }
+
+       public LDKNetwork get_network() {
+               LDKNetwork ret = bindings.ChainParameters_get_network(this.ptr);
+               return ret;
+       }
+
+       public void set_network(LDKNetwork val) {
+               bindings.ChainParameters_set_network(this.ptr, val);
+       }
+
+       public byte[] get_latest_hash() {
+               byte[] ret = bindings.ChainParameters_get_latest_hash(this.ptr);
+               return ret;
+       }
+
+       public void set_latest_hash(byte[] val) {
+               bindings.ChainParameters_set_latest_hash(this.ptr, val);
+       }
+
+       public long get_latest_height() {
+               long ret = bindings.ChainParameters_get_latest_height(this.ptr);
+               return ret;
+       }
+
+       public void set_latest_height(long val) {
+               bindings.ChainParameters_set_latest_height(this.ptr, val);
+       }
+
+       public static ChainParameters constructor_new(LDKNetwork network_arg, byte[] latest_hash_arg, long latest_height_arg) {
+               long ret = bindings.ChainParameters_new(network_arg, latest_hash_arg, latest_height_arg);
+               ChainParameters ret_hu_conv = new ChainParameters(null, ret);
+               ret_hu_conv.ptrs_to.add(ret_hu_conv);
+               return ret_hu_conv;
+       }
+
+}
index 4a141dee3defeac50ce895fb93df00ab0b565b8c..4878056820d2e08f2ad72dcd374cd2b7461e65e7 100644 (file)
@@ -14,8 +14,8 @@ public class ChannelManager extends CommonBase {
                if (ptr != 0) { bindings.ChannelManager_free(ptr); }
        }
 
-       public static ChannelManager constructor_new(LDKNetwork network, FeeEstimator fee_est, Watch chain_monitor, BroadcasterInterface tx_broadcaster, Logger logger, KeysInterface keys_manager, UserConfig config, long current_blockchain_height) {
-               long ret = bindings.ChannelManager_new(network, fee_est == null ? 0 : fee_est.ptr, chain_monitor == null ? 0 : chain_monitor.ptr, tx_broadcaster == null ? 0 : tx_broadcaster.ptr, logger == null ? 0 : logger.ptr, keys_manager == null ? 0 : keys_manager.ptr, config == null ? 0 : config.ptr & ~1, current_blockchain_height);
+       public static ChannelManager constructor_new(FeeEstimator fee_est, Watch chain_monitor, BroadcasterInterface tx_broadcaster, Logger logger, KeysInterface keys_manager, UserConfig config, LDKNetwork params_network_arg, byte[] params_latest_hash_arg, long params_latest_height_arg) {
+               long ret = bindings.ChannelManager_new(fee_est == null ? 0 : fee_est.ptr, chain_monitor == null ? 0 : chain_monitor.ptr, tx_broadcaster == null ? 0 : tx_broadcaster.ptr, logger == null ? 0 : logger.ptr, keys_manager == null ? 0 : keys_manager.ptr, config == null ? 0 : config.ptr & ~1, bindings.ChainParameters_new(params_network_arg, params_latest_hash_arg, params_latest_height_arg));
                ChannelManager ret_hu_conv = new ChannelManager(null, ret);
                ret_hu_conv.ptrs_to.add(ret_hu_conv);
                ret_hu_conv.ptrs_to.add(fee_est);
diff --git a/src/main/java/org/ldk/structs/ErroringMessageHandler.java b/src/main/java/org/ldk/structs/ErroringMessageHandler.java
new file mode 100644 (file)
index 0000000..3b8ce07
--- /dev/null
@@ -0,0 +1,38 @@
+package org.ldk.structs;
+
+import org.ldk.impl.bindings;
+import org.ldk.enums.*;
+import org.ldk.util.*;
+import java.util.Arrays;
+
+@SuppressWarnings("unchecked") // We correctly assign various generic arrays
+public class ErroringMessageHandler extends CommonBase {
+       ErroringMessageHandler(Object _dummy, long ptr) { super(ptr); }
+       @Override @SuppressWarnings("deprecation")
+       protected void finalize() throws Throwable {
+               super.finalize();
+               if (ptr != 0) { bindings.ErroringMessageHandler_free(ptr); }
+       }
+
+       public static ErroringMessageHandler constructor_new() {
+               long ret = bindings.ErroringMessageHandler_new();
+               ErroringMessageHandler ret_hu_conv = new ErroringMessageHandler(null, ret);
+               ret_hu_conv.ptrs_to.add(ret_hu_conv);
+               return ret_hu_conv;
+       }
+
+       public MessageSendEventsProvider as_MessageSendEventsProvider() {
+               long ret = bindings.ErroringMessageHandler_as_MessageSendEventsProvider(this.ptr);
+               MessageSendEventsProvider ret_hu_conv = new MessageSendEventsProvider(null, ret);
+               ret_hu_conv.ptrs_to.add(this);
+               return ret_hu_conv;
+       }
+
+       public ChannelMessageHandler as_ChannelMessageHandler() {
+               long ret = bindings.ErroringMessageHandler_as_ChannelMessageHandler(this.ptr);
+               ChannelMessageHandler ret_hu_conv = new ChannelMessageHandler(null, ret);
+               ret_hu_conv.ptrs_to.add(this);
+               return ret_hu_conv;
+       }
+
+}
diff --git a/src/main/java/org/ldk/structs/IgnoringMessageHandler.java b/src/main/java/org/ldk/structs/IgnoringMessageHandler.java
new file mode 100644 (file)
index 0000000..65ca6c6
--- /dev/null
@@ -0,0 +1,38 @@
+package org.ldk.structs;
+
+import org.ldk.impl.bindings;
+import org.ldk.enums.*;
+import org.ldk.util.*;
+import java.util.Arrays;
+
+@SuppressWarnings("unchecked") // We correctly assign various generic arrays
+public class IgnoringMessageHandler extends CommonBase {
+       IgnoringMessageHandler(Object _dummy, long ptr) { super(ptr); }
+       @Override @SuppressWarnings("deprecation")
+       protected void finalize() throws Throwable {
+               super.finalize();
+               if (ptr != 0) { bindings.IgnoringMessageHandler_free(ptr); }
+       }
+
+       public static IgnoringMessageHandler constructor_new() {
+               long ret = bindings.IgnoringMessageHandler_new();
+               IgnoringMessageHandler ret_hu_conv = new IgnoringMessageHandler(null, ret);
+               ret_hu_conv.ptrs_to.add(ret_hu_conv);
+               return ret_hu_conv;
+       }
+
+       public MessageSendEventsProvider as_MessageSendEventsProvider() {
+               long ret = bindings.IgnoringMessageHandler_as_MessageSendEventsProvider(this.ptr);
+               MessageSendEventsProvider ret_hu_conv = new MessageSendEventsProvider(null, ret);
+               ret_hu_conv.ptrs_to.add(this);
+               return ret_hu_conv;
+       }
+
+       public RoutingMessageHandler as_RoutingMessageHandler() {
+               long ret = bindings.IgnoringMessageHandler_as_RoutingMessageHandler(this.ptr);
+               RoutingMessageHandler ret_hu_conv = new RoutingMessageHandler(null, ret);
+               ret_hu_conv.ptrs_to.add(this);
+               return ret_hu_conv;
+       }
+
+}
index 898c536cfac2b10f491d07cc439eca47b08342d0..c3e2d406141d43f1e93498619d2828dbce17b1f9 100644 (file)
@@ -33,6 +33,11 @@ public class NetGraphMsgHandler extends CommonBase {
                return ret_hu_conv;
        }
 
+       public void add_chain_access(Access chain_access) {
+               bindings.NetGraphMsgHandler_add_chain_access(this.ptr, chain_access == null ? 0 : chain_access.ptr);
+               this.ptrs_to.add(chain_access);
+       }
+
        public LockedNetworkGraph read_locked_graph() {
                long ret = bindings.NetGraphMsgHandler_read_locked_graph(this.ptr);
                LockedNetworkGraph ret_hu_conv = new LockedNetworkGraph(null, ret);
index 3b15b767dcc99263f8772a551e9b744ebc8eab51..fc1e424979e5efe6f4243f5b02c985418250fd1e 100644 (file)
@@ -53,23 +53,6 @@ public class RouteHint extends CommonBase {
                bindings.RouteHint_set_cltv_expiry_delta(this.ptr, val);
        }
 
-       public long get_htlc_minimum_msat() {
-               long ret = bindings.RouteHint_get_htlc_minimum_msat(this.ptr);
-               return ret;
-       }
-
-       public void set_htlc_minimum_msat(long val) {
-               bindings.RouteHint_set_htlc_minimum_msat(this.ptr, val);
-       }
-
-       public static RouteHint constructor_new(byte[] src_node_id_arg, long short_channel_id_arg, RoutingFees fees_arg, short cltv_expiry_delta_arg, long htlc_minimum_msat_arg) {
-               long ret = bindings.RouteHint_new(src_node_id_arg, short_channel_id_arg, fees_arg == null ? 0 : fees_arg.ptr & ~1, cltv_expiry_delta_arg, htlc_minimum_msat_arg);
-               RouteHint ret_hu_conv = new RouteHint(null, ret);
-               ret_hu_conv.ptrs_to.add(ret_hu_conv);
-               ret_hu_conv.ptrs_to.add(fees_arg);
-               return ret_hu_conv;
-       }
-
        public RouteHint clone() {
                long ret = bindings.RouteHint_clone(this.ptr);
                RouteHint ret_hu_conv = new RouteHint(null, ret);
index ecf9820beb9195bc508f021ff073a1925e23df89..c00a6981a7a3a7e1a17defe586aaa48d4f74d713 100644 (file)
 #include <stdatomic.h>
 #include <stdlib.h>
 
-#include <assert.h>
-// Always run a, then assert it is true:
-#define DO_ASSERT(a) do { bool _assert_val = (a); assert(_assert_val); } while(0)
-// Assert a is true or do nothing
-#define CHECK(a) DO_ASSERT(a)
-
-// Running a leak check across all the allocations and frees of the JDK is a mess,
-// so instead we implement our own naive leak checker here, relying on the -wrap
-// linker option to wrap malloc/calloc/realloc/free, tracking everyhing allocated
-// and free'd in Rust or C across the generated bindings shared library.
-#include <threads.h>
-#include <execinfo.h>
-#include <unistd.h>
-static mtx_t allocation_mtx;
-
-void __attribute__((constructor)) init_mtx() {
-       DO_ASSERT(mtx_init(&allocation_mtx, mtx_plain) == thrd_success);
-}
-
-#define BT_MAX 128
-typedef struct allocation {
-       struct allocation* next;
-       void* ptr;
-       const char* struct_name;
-       void* bt[BT_MAX];
-       int bt_len;
-       size_t alloc_len;
-} allocation;
-static allocation* allocation_ll = NULL;
-
-void* __real_malloc(size_t len);
-void* __real_calloc(size_t nmemb, size_t len);
-static void new_allocation(void* res, const char* struct_name, size_t len) {
-       allocation* new_alloc = __real_malloc(sizeof(allocation));
-       new_alloc->ptr = res;
-       new_alloc->struct_name = struct_name;
-       new_alloc->bt_len = backtrace(new_alloc->bt, BT_MAX);
-       new_alloc->alloc_len = len;
-       DO_ASSERT(mtx_lock(&allocation_mtx) == thrd_success);
-       new_alloc->next = allocation_ll;
-       allocation_ll = new_alloc;
-       DO_ASSERT(mtx_unlock(&allocation_mtx) == thrd_success);
-}
-static void* MALLOC(size_t len, const char* struct_name) {
-       void* res = __real_malloc(len);
-       new_allocation(res, struct_name, len);
-       return res;
-}
-void __real_free(void* ptr);
-static void alloc_freed(void* ptr) {
-       allocation* p = NULL;
-       DO_ASSERT(mtx_lock(&allocation_mtx) == thrd_success);
-       allocation* it = allocation_ll;
-       while (it->ptr != ptr) {
-               p = it; it = it->next;
-               if (it == NULL) {
-                       fprintf(stderr, "Tried to free unknown pointer %p at:\n", ptr);
-                       void* bt[BT_MAX];
-                       int bt_len = backtrace(bt, BT_MAX);
-                       backtrace_symbols_fd(bt, bt_len, STDERR_FILENO);
-                       fprintf(stderr, "\n\n");
-                       DO_ASSERT(mtx_unlock(&allocation_mtx) == thrd_success);
-                       return; // addrsan should catch malloc-unknown and print more info than we have
-               }
-       }
-       if (p) { p->next = it->next; } else { allocation_ll = it->next; }
-       DO_ASSERT(mtx_unlock(&allocation_mtx) == thrd_success);
-       DO_ASSERT(it->ptr == ptr);
-       __real_free(it);
-}
-static void FREE(void* ptr) {
-       if ((long)ptr < 1024) return; // Rust loves to create pointers to the NULL page for dummys
-       alloc_freed(ptr);
-       __real_free(ptr);
-}
-
-void* __wrap_malloc(size_t len) {
-       void* res = __real_malloc(len);
-       new_allocation(res, "malloc call", len);
-       return res;
-}
-void* __wrap_calloc(size_t nmemb, size_t len) {
-       void* res = __real_calloc(nmemb, len);
-       new_allocation(res, "calloc call", len);
-       return res;
-}
-void __wrap_free(void* ptr) {
-       if (ptr == NULL) return;
-       alloc_freed(ptr);
-       __real_free(ptr);
-}
-
-void* __real_realloc(void* ptr, size_t newlen);
-void* __wrap_realloc(void* ptr, size_t len) {
-       if (ptr != NULL) alloc_freed(ptr);
-       void* res = __real_realloc(ptr, len);
-       new_allocation(res, "realloc call", len);
-       return res;
-}
-void __wrap_reallocarray(void* ptr, size_t new_sz) {
-       // Rust doesn't seem to use reallocarray currently
-       DO_ASSERT(false);
-}
-
-void __attribute__((destructor)) check_leaks() {
-       size_t alloc_count = 0;
-       size_t alloc_size = 0;
-       for (allocation* a = allocation_ll; a != NULL; a = a->next) {
-               fprintf(stderr, "%s %p (%lu bytes) remains:\n", a->struct_name, a->ptr, a->alloc_len);
-               backtrace_symbols_fd(a->bt, a->bt_len, STDERR_FILENO);
-               fprintf(stderr, "\n\n");
-               alloc_count++;
-               alloc_size += a->alloc_len;
-       }
-       fprintf(stderr, "%lu allocations remained for %lu bytes.\n", alloc_count, alloc_size);
-       DO_ASSERT(allocation_ll == NULL);
-}
+#define MALLOC(a, _) malloc(a)
+#define FREE(p) if ((long)(p) > 1024) { free(p); }
+#define DO_ASSERT(a) (void)(a)
+#define CHECK(a)
 
 static jmethodID ordinal_meth = NULL;
 static jmethodID slicedef_meth = NULL;
@@ -383,6 +270,7 @@ static inline LDKNetwork LDKNetwork_from_java(JNIEnv *env, jclass clz) {
                case 0: return LDKNetwork_Bitcoin;
                case 1: return LDKNetwork_Testnet;
                case 2: return LDKNetwork_Regtest;
+               case 3: return LDKNetwork_Signet;
        }
        abort();
 }
@@ -390,6 +278,7 @@ static jclass LDKNetwork_class = NULL;
 static jfieldID LDKNetwork_LDKNetwork_Bitcoin = NULL;
 static jfieldID LDKNetwork_LDKNetwork_Testnet = NULL;
 static jfieldID LDKNetwork_LDKNetwork_Regtest = NULL;
+static jfieldID LDKNetwork_LDKNetwork_Signet = NULL;
 JNIEXPORT void JNICALL Java_org_ldk_enums_LDKNetwork_init (JNIEnv *env, jclass clz) {
        LDKNetwork_class = (*env)->NewGlobalRef(env, clz);
        CHECK(LDKNetwork_class != NULL);
@@ -399,6 +288,8 @@ JNIEXPORT void JNICALL Java_org_ldk_enums_LDKNetwork_init (JNIEnv *env, jclass c
        CHECK(LDKNetwork_LDKNetwork_Testnet != NULL);
        LDKNetwork_LDKNetwork_Regtest = (*env)->GetStaticFieldID(env, LDKNetwork_class, "LDKNetwork_Regtest", "Lorg/ldk/enums/LDKNetwork;");
        CHECK(LDKNetwork_LDKNetwork_Regtest != NULL);
+       LDKNetwork_LDKNetwork_Signet = (*env)->GetStaticFieldID(env, LDKNetwork_class, "LDKNetwork_Signet", "Lorg/ldk/enums/LDKNetwork;");
+       CHECK(LDKNetwork_LDKNetwork_Signet != NULL);
 }
 static inline jclass LDKNetwork_to_java(JNIEnv *env, LDKNetwork val) {
        switch (val) {
@@ -408,6 +299,8 @@ static inline jclass LDKNetwork_to_java(JNIEnv *env, LDKNetwork val) {
                        return (*env)->GetStaticObjectField(env, LDKNetwork_class, LDKNetwork_LDKNetwork_Testnet);
                case LDKNetwork_Regtest:
                        return (*env)->GetStaticObjectField(env, LDKNetwork_class, LDKNetwork_LDKNetwork_Regtest);
+               case LDKNetwork_Signet:
+                       return (*env)->GetStaticObjectField(env, LDKNetwork_class, LDKNetwork_LDKNetwork_Signet);
                default: abort();
        }
 }
@@ -758,490 +651,223 @@ JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1SignatureZNo
        CHECK(!val->result_ok);
        return *val->contents.err;
 }
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1u8ZPeerHandleErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
-       return ((LDKCResult_CVec_u8ZPeerHandleErrorZ*)arg)->result_ok;
+static jclass LDKErrorAction_DisconnectPeer_class = NULL;
+static jmethodID LDKErrorAction_DisconnectPeer_meth = NULL;
+static jclass LDKErrorAction_IgnoreError_class = NULL;
+static jmethodID LDKErrorAction_IgnoreError_meth = NULL;
+static jclass LDKErrorAction_SendErrorMessage_class = NULL;
+static jmethodID LDKErrorAction_SendErrorMessage_meth = NULL;
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKErrorAction_init (JNIEnv *env, jclass clz) {
+       LDKErrorAction_DisconnectPeer_class =
+               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKErrorAction$DisconnectPeer;"));
+       CHECK(LDKErrorAction_DisconnectPeer_class != NULL);
+       LDKErrorAction_DisconnectPeer_meth = (*env)->GetMethodID(env, LDKErrorAction_DisconnectPeer_class, "<init>", "(J)V");
+       CHECK(LDKErrorAction_DisconnectPeer_meth != NULL);
+       LDKErrorAction_IgnoreError_class =
+               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKErrorAction$IgnoreError;"));
+       CHECK(LDKErrorAction_IgnoreError_class != NULL);
+       LDKErrorAction_IgnoreError_meth = (*env)->GetMethodID(env, LDKErrorAction_IgnoreError_class, "<init>", "()V");
+       CHECK(LDKErrorAction_IgnoreError_meth != NULL);
+       LDKErrorAction_SendErrorMessage_class =
+               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKErrorAction$SendErrorMessage;"));
+       CHECK(LDKErrorAction_SendErrorMessage_class != NULL);
+       LDKErrorAction_SendErrorMessage_meth = (*env)->GetMethodID(env, LDKErrorAction_SendErrorMessage_class, "<init>", "(J)V");
+       CHECK(LDKErrorAction_SendErrorMessage_meth != NULL);
 }
-JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1u8ZPeerHandleErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
-       LDKCResult_CVec_u8ZPeerHandleErrorZ *val = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(arg & ~1);
-       CHECK(val->result_ok);
-       LDKCVec_u8Z res_var = (*val->contents.result);
-       int8_tArray res_arr = (*env)->NewByteArray(env, res_var.datalen);
-       (*env)->SetByteArrayRegion(env, res_arr, 0, res_var.datalen, res_var.data);
-       return res_arr;
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKErrorAction_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
+       LDKErrorAction *obj = (LDKErrorAction*)ptr;
+       switch(obj->tag) {
+               case LDKErrorAction_DisconnectPeer: {
+                       LDKErrorMessage msg_var = obj->disconnect_peer.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, LDKErrorAction_DisconnectPeer_class, LDKErrorAction_DisconnectPeer_meth, msg_ref);
+               }
+               case LDKErrorAction_IgnoreError: {
+                       return (*env)->NewObject(env, LDKErrorAction_IgnoreError_class, LDKErrorAction_IgnoreError_meth);
+               }
+               case LDKErrorAction_SendErrorMessage: {
+                       LDKErrorMessage msg_var = obj->send_error_message.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, LDKErrorAction_SendErrorMessage_class, LDKErrorAction_SendErrorMessage_meth, msg_ref);
+               }
+               default: abort();
+       }
 }
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1u8ZPeerHandleErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
-       LDKCResult_CVec_u8ZPeerHandleErrorZ *val = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(arg & ~1);
-       CHECK(!val->result_ok);
-       LDKPeerHandleError err_var = (*val->contents.err);
-       CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
-       CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
-       long err_ref = (long)err_var.inner & ~1;
-       return err_ref;
+static jclass LDKHTLCFailChannelUpdate_ChannelUpdateMessage_class = NULL;
+static jmethodID LDKHTLCFailChannelUpdate_ChannelUpdateMessage_meth = NULL;
+static jclass LDKHTLCFailChannelUpdate_ChannelClosed_class = NULL;
+static jmethodID LDKHTLCFailChannelUpdate_ChannelClosed_meth = NULL;
+static jclass LDKHTLCFailChannelUpdate_NodeFailure_class = NULL;
+static jmethodID LDKHTLCFailChannelUpdate_NodeFailure_meth = NULL;
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKHTLCFailChannelUpdate_init (JNIEnv *env, jclass clz) {
+       LDKHTLCFailChannelUpdate_ChannelUpdateMessage_class =
+               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKHTLCFailChannelUpdate$ChannelUpdateMessage;"));
+       CHECK(LDKHTLCFailChannelUpdate_ChannelUpdateMessage_class != NULL);
+       LDKHTLCFailChannelUpdate_ChannelUpdateMessage_meth = (*env)->GetMethodID(env, LDKHTLCFailChannelUpdate_ChannelUpdateMessage_class, "<init>", "(J)V");
+       CHECK(LDKHTLCFailChannelUpdate_ChannelUpdateMessage_meth != NULL);
+       LDKHTLCFailChannelUpdate_ChannelClosed_class =
+               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKHTLCFailChannelUpdate$ChannelClosed;"));
+       CHECK(LDKHTLCFailChannelUpdate_ChannelClosed_class != NULL);
+       LDKHTLCFailChannelUpdate_ChannelClosed_meth = (*env)->GetMethodID(env, LDKHTLCFailChannelUpdate_ChannelClosed_class, "<init>", "(JZ)V");
+       CHECK(LDKHTLCFailChannelUpdate_ChannelClosed_meth != NULL);
+       LDKHTLCFailChannelUpdate_NodeFailure_class =
+               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKHTLCFailChannelUpdate$NodeFailure;"));
+       CHECK(LDKHTLCFailChannelUpdate_NodeFailure_class != NULL);
+       LDKHTLCFailChannelUpdate_NodeFailure_meth = (*env)->GetMethodID(env, LDKHTLCFailChannelUpdate_NodeFailure_class, "<init>", "([BZ)V");
+       CHECK(LDKHTLCFailChannelUpdate_NodeFailure_meth != NULL);
 }
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePeerHandleErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
-       return ((LDKCResult_NonePeerHandleErrorZ*)arg)->result_ok;
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKHTLCFailChannelUpdate_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
+       LDKHTLCFailChannelUpdate *obj = (LDKHTLCFailChannelUpdate*)ptr;
+       switch(obj->tag) {
+               case LDKHTLCFailChannelUpdate_ChannelUpdateMessage: {
+                       LDKChannelUpdate msg_var = obj->channel_update_message.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, LDKHTLCFailChannelUpdate_ChannelUpdateMessage_class, LDKHTLCFailChannelUpdate_ChannelUpdateMessage_meth, msg_ref);
+               }
+               case LDKHTLCFailChannelUpdate_ChannelClosed: {
+                       return (*env)->NewObject(env, LDKHTLCFailChannelUpdate_ChannelClosed_class, LDKHTLCFailChannelUpdate_ChannelClosed_meth, obj->channel_closed.short_channel_id, obj->channel_closed.is_permanent);
+               }
+               case LDKHTLCFailChannelUpdate_NodeFailure: {
+                       int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
+                       (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->node_failure.node_id.compressed_form);
+                       return (*env)->NewObject(env, LDKHTLCFailChannelUpdate_NodeFailure_class, LDKHTLCFailChannelUpdate_NodeFailure_meth, node_id_arr, obj->node_failure.is_permanent);
+               }
+               default: abort();
+       }
 }
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePeerHandleErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
-       LDKCResult_NonePeerHandleErrorZ *val = (LDKCResult_NonePeerHandleErrorZ*)(arg & ~1);
-       CHECK(val->result_ok);
-       return *val->contents.result;
-}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePeerHandleErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
-       LDKCResult_NonePeerHandleErrorZ *val = (LDKCResult_NonePeerHandleErrorZ*)(arg & ~1);
-       CHECK(!val->result_ok);
-       LDKPeerHandleError err_var = (*val->contents.err);
-       CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
-       CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
-       long err_ref = (long)err_var.inner & ~1;
-       return err_ref;
-}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolPeerHandleErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
-       return ((LDKCResult_boolPeerHandleErrorZ*)arg)->result_ok;
-}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolPeerHandleErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
-       LDKCResult_boolPeerHandleErrorZ *val = (LDKCResult_boolPeerHandleErrorZ*)(arg & ~1);
-       CHECK(val->result_ok);
-       return *val->contents.result;
-}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolPeerHandleErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
-       LDKCResult_boolPeerHandleErrorZ *val = (LDKCResult_boolPeerHandleErrorZ*)(arg & ~1);
-       CHECK(!val->result_ok);
-       LDKPeerHandleError err_var = (*val->contents.err);
-       CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
-       CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
-       long err_ref = (long)err_var.inner & ~1;
-       return err_ref;
-}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitFeaturesDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
-       return ((LDKCResult_InitFeaturesDecodeErrorZ*)arg)->result_ok;
-}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitFeaturesDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
-       LDKCResult_InitFeaturesDecodeErrorZ *val = (LDKCResult_InitFeaturesDecodeErrorZ*)(arg & ~1);
-       CHECK(val->result_ok);
-       LDKInitFeatures res_var = (*val->contents.result);
-       CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
-       CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
-       long res_ref = (long)res_var.inner & ~1;
-       return res_ref;
-}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitFeaturesDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
-       LDKCResult_InitFeaturesDecodeErrorZ *val = (LDKCResult_InitFeaturesDecodeErrorZ*)(arg & ~1);
-       CHECK(!val->result_ok);
-       LDKDecodeError err_var = (*val->contents.err);
-       CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
-       CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
-       long err_ref = (long)err_var.inner & ~1;
-       return err_ref;
-}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeFeaturesDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
-       return ((LDKCResult_NodeFeaturesDecodeErrorZ*)arg)->result_ok;
-}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeFeaturesDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
-       LDKCResult_NodeFeaturesDecodeErrorZ *val = (LDKCResult_NodeFeaturesDecodeErrorZ*)(arg & ~1);
-       CHECK(val->result_ok);
-       LDKNodeFeatures res_var = (*val->contents.result);
-       CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
-       CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
-       long res_ref = (long)res_var.inner & ~1;
-       return res_ref;
-}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeFeaturesDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
-       LDKCResult_NodeFeaturesDecodeErrorZ *val = (LDKCResult_NodeFeaturesDecodeErrorZ*)(arg & ~1);
-       CHECK(!val->result_ok);
-       LDKDecodeError err_var = (*val->contents.err);
-       CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
-       CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
-       long err_ref = (long)err_var.inner & ~1;
-       return err_ref;
-}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelFeaturesDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
-       return ((LDKCResult_ChannelFeaturesDecodeErrorZ*)arg)->result_ok;
-}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelFeaturesDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
-       LDKCResult_ChannelFeaturesDecodeErrorZ *val = (LDKCResult_ChannelFeaturesDecodeErrorZ*)(arg & ~1);
-       CHECK(val->result_ok);
-       LDKChannelFeatures res_var = (*val->contents.result);
-       CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
-       CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
-       long res_ref = (long)res_var.inner & ~1;
-       return res_ref;
-}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelFeaturesDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
-       LDKCResult_ChannelFeaturesDecodeErrorZ *val = (LDKCResult_ChannelFeaturesDecodeErrorZ*)(arg & ~1);
-       CHECK(!val->result_ok);
-       LDKDecodeError err_var = (*val->contents.err);
-       CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
-       CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
-       long err_ref = (long)err_var.inner & ~1;
-       return err_ref;
-}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelConfigDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
-       return ((LDKCResult_ChannelConfigDecodeErrorZ*)arg)->result_ok;
-}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelConfigDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
-       LDKCResult_ChannelConfigDecodeErrorZ *val = (LDKCResult_ChannelConfigDecodeErrorZ*)(arg & ~1);
-       CHECK(val->result_ok);
-       LDKChannelConfig res_var = (*val->contents.result);
-       CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
-       CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
-       long res_ref = (long)res_var.inner & ~1;
-       return res_ref;
-}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelConfigDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
-       LDKCResult_ChannelConfigDecodeErrorZ *val = (LDKCResult_ChannelConfigDecodeErrorZ*)(arg & ~1);
-       CHECK(!val->result_ok);
-       LDKDecodeError err_var = (*val->contents.err);
-       CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
-       CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
-       long err_ref = (long)err_var.inner & ~1;
-       return err_ref;
-}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolLightningErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
-       return ((LDKCResult_boolLightningErrorZ*)arg)->result_ok;
-}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolLightningErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
-       LDKCResult_boolLightningErrorZ *val = (LDKCResult_boolLightningErrorZ*)(arg & ~1);
-       CHECK(val->result_ok);
-       return *val->contents.result;
-}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolLightningErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
-       LDKCResult_boolLightningErrorZ *val = (LDKCResult_boolLightningErrorZ*)(arg & ~1);
-       CHECK(!val->result_ok);
-       LDKLightningError err_var = (*val->contents.err);
-       CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
-       CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
-       long err_ref = (long)err_var.inner & ~1;
-       return err_ref;
-}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1new(JNIEnv *env, jclass clz, int64_t a, int64_t b, int64_t c) {
-       LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
-       LDKChannelAnnouncement a_conv;
-       a_conv.inner = (void*)(a & (~1));
-       a_conv.is_owned = (a & 1) || (a == 0);
-       a_conv = ChannelAnnouncement_clone(&a_conv);
-       ret->a = a_conv;
-       LDKChannelUpdate b_conv;
-       b_conv.inner = (void*)(b & (~1));
-       b_conv.is_owned = (b & 1) || (b == 0);
-       b_conv = ChannelUpdate_clone(&b_conv);
-       ret->b = b_conv;
-       LDKChannelUpdate c_conv;
-       c_conv.inner = (void*)(c & (~1));
-       c_conv.is_owned = (c & 1) || (c == 0);
-       c_conv = ChannelUpdate_clone(&c_conv);
-       ret->c = c_conv;
-       return (long)ret;
-}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1get_1a(JNIEnv *env, jclass clz, int64_t ptr) {
-       LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *tuple = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(ptr & ~1);
-       LDKChannelAnnouncement a_var = tuple->a;
-       CHECK((((long)a_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
-       CHECK((((long)&a_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
-       long a_ref = (long)a_var.inner & ~1;
-       return a_ref;
-}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1get_1b(JNIEnv *env, jclass clz, int64_t ptr) {
-       LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *tuple = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(ptr & ~1);
-       LDKChannelUpdate b_var = tuple->b;
-       CHECK((((long)b_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
-       CHECK((((long)&b_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
-       long b_ref = (long)b_var.inner & ~1;
-       return b_ref;
-}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1get_1c(JNIEnv *env, jclass clz, int64_t ptr) {
-       LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *tuple = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(ptr & ~1);
-       LDKChannelUpdate c_var = tuple->c;
-       CHECK((((long)c_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
-       CHECK((((long)&c_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
-       long c_ref = (long)c_var.inner & ~1;
-       return c_ref;
-}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
-       LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret = MALLOC(sizeof(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
-       ret->datalen = (*env)->GetArrayLength(env, elems);
-       if (ret->datalen == 0) {
-               ret->data = NULL;
-       } else {
-               ret->data = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ) * ret->datalen, "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ Data");
-               int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
-               for (size_t i = 0; i < ret->datalen; i++) {
-                       int64_t arr_elem = java_elems[i];
-                       LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ arr_elem_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)arr_elem) & ~1);
-                       FREE((void*)arr_elem);
-                       ret->data[i] = arr_elem_conv;
-               }
-               (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
-       }
-       return (long)ret;
-}
-static inline LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(const LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *orig) {
-       LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret = { .data = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ) * orig->datalen, "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ clone bytes"), .datalen = orig->datalen };
-       for (size_t i = 0; i < ret.datalen; i++) {
-               ret.data[i] = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(&orig->data[i]);
-       }
-       return ret;
-}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1NodeAnnouncementZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
-       LDKCVec_NodeAnnouncementZ *ret = MALLOC(sizeof(LDKCVec_NodeAnnouncementZ), "LDKCVec_NodeAnnouncementZ");
-       ret->datalen = (*env)->GetArrayLength(env, elems);
-       if (ret->datalen == 0) {
-               ret->data = NULL;
-       } else {
-               ret->data = MALLOC(sizeof(LDKNodeAnnouncement) * ret->datalen, "LDKCVec_NodeAnnouncementZ Data");
-               int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
-               for (size_t i = 0; i < ret->datalen; i++) {
-                       int64_t arr_elem = java_elems[i];
-                       LDKNodeAnnouncement arr_elem_conv;
-                       arr_elem_conv.inner = (void*)(arr_elem & (~1));
-                       arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
-                       arr_elem_conv = NodeAnnouncement_clone(&arr_elem_conv);
-                       ret->data[i] = arr_elem_conv;
-               }
-               (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
-       }
-       return (long)ret;
-}
-static inline LDKCVec_NodeAnnouncementZ CVec_NodeAnnouncementZ_clone(const LDKCVec_NodeAnnouncementZ *orig) {
-       LDKCVec_NodeAnnouncementZ ret = { .data = MALLOC(sizeof(LDKNodeAnnouncement) * orig->datalen, "LDKCVec_NodeAnnouncementZ clone bytes"), .datalen = orig->datalen };
-       for (size_t i = 0; i < ret.datalen; i++) {
-               ret.data[i] = NodeAnnouncement_clone(&orig->data[i]);
-       }
-       return ret;
-}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneLightningErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
-       return ((LDKCResult_NoneLightningErrorZ*)arg)->result_ok;
-}
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneLightningErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
-       LDKCResult_NoneLightningErrorZ *val = (LDKCResult_NoneLightningErrorZ*)(arg & ~1);
-       CHECK(val->result_ok);
-       return *val->contents.result;
-}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneLightningErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
-       LDKCResult_NoneLightningErrorZ *val = (LDKCResult_NoneLightningErrorZ*)(arg & ~1);
-       CHECK(!val->result_ok);
-       LDKLightningError err_var = (*val->contents.err);
-       CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
-       CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
-       long err_ref = (long)err_var.inner & ~1;
-       return err_ref;
-}
-static jclass LDKErrorAction_DisconnectPeer_class = NULL;
-static jmethodID LDKErrorAction_DisconnectPeer_meth = NULL;
-static jclass LDKErrorAction_IgnoreError_class = NULL;
-static jmethodID LDKErrorAction_IgnoreError_meth = NULL;
-static jclass LDKErrorAction_SendErrorMessage_class = NULL;
-static jmethodID LDKErrorAction_SendErrorMessage_meth = NULL;
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKErrorAction_init (JNIEnv *env, jclass clz) {
-       LDKErrorAction_DisconnectPeer_class =
-               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKErrorAction$DisconnectPeer;"));
-       CHECK(LDKErrorAction_DisconnectPeer_class != NULL);
-       LDKErrorAction_DisconnectPeer_meth = (*env)->GetMethodID(env, LDKErrorAction_DisconnectPeer_class, "<init>", "(J)V");
-       CHECK(LDKErrorAction_DisconnectPeer_meth != NULL);
-       LDKErrorAction_IgnoreError_class =
-               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKErrorAction$IgnoreError;"));
-       CHECK(LDKErrorAction_IgnoreError_class != NULL);
-       LDKErrorAction_IgnoreError_meth = (*env)->GetMethodID(env, LDKErrorAction_IgnoreError_class, "<init>", "()V");
-       CHECK(LDKErrorAction_IgnoreError_meth != NULL);
-       LDKErrorAction_SendErrorMessage_class =
-               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKErrorAction$SendErrorMessage;"));
-       CHECK(LDKErrorAction_SendErrorMessage_class != NULL);
-       LDKErrorAction_SendErrorMessage_meth = (*env)->GetMethodID(env, LDKErrorAction_SendErrorMessage_class, "<init>", "(J)V");
-       CHECK(LDKErrorAction_SendErrorMessage_meth != NULL);
-}
-JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKErrorAction_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
-       LDKErrorAction *obj = (LDKErrorAction*)ptr;
-       switch(obj->tag) {
-               case LDKErrorAction_DisconnectPeer: {
-                       LDKErrorMessage msg_var = obj->disconnect_peer.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, LDKErrorAction_DisconnectPeer_class, LDKErrorAction_DisconnectPeer_meth, msg_ref);
-               }
-               case LDKErrorAction_IgnoreError: {
-                       return (*env)->NewObject(env, LDKErrorAction_IgnoreError_class, LDKErrorAction_IgnoreError_meth);
-               }
-               case LDKErrorAction_SendErrorMessage: {
-                       LDKErrorMessage msg_var = obj->send_error_message.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, LDKErrorAction_SendErrorMessage_class, LDKErrorAction_SendErrorMessage_meth, msg_ref);
-               }
-               default: abort();
-       }
-}
-static jclass LDKHTLCFailChannelUpdate_ChannelUpdateMessage_class = NULL;
-static jmethodID LDKHTLCFailChannelUpdate_ChannelUpdateMessage_meth = NULL;
-static jclass LDKHTLCFailChannelUpdate_ChannelClosed_class = NULL;
-static jmethodID LDKHTLCFailChannelUpdate_ChannelClosed_meth = NULL;
-static jclass LDKHTLCFailChannelUpdate_NodeFailure_class = NULL;
-static jmethodID LDKHTLCFailChannelUpdate_NodeFailure_meth = NULL;
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKHTLCFailChannelUpdate_init (JNIEnv *env, jclass clz) {
-       LDKHTLCFailChannelUpdate_ChannelUpdateMessage_class =
-               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKHTLCFailChannelUpdate$ChannelUpdateMessage;"));
-       CHECK(LDKHTLCFailChannelUpdate_ChannelUpdateMessage_class != NULL);
-       LDKHTLCFailChannelUpdate_ChannelUpdateMessage_meth = (*env)->GetMethodID(env, LDKHTLCFailChannelUpdate_ChannelUpdateMessage_class, "<init>", "(J)V");
-       CHECK(LDKHTLCFailChannelUpdate_ChannelUpdateMessage_meth != NULL);
-       LDKHTLCFailChannelUpdate_ChannelClosed_class =
-               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKHTLCFailChannelUpdate$ChannelClosed;"));
-       CHECK(LDKHTLCFailChannelUpdate_ChannelClosed_class != NULL);
-       LDKHTLCFailChannelUpdate_ChannelClosed_meth = (*env)->GetMethodID(env, LDKHTLCFailChannelUpdate_ChannelClosed_class, "<init>", "(JZ)V");
-       CHECK(LDKHTLCFailChannelUpdate_ChannelClosed_meth != NULL);
-       LDKHTLCFailChannelUpdate_NodeFailure_class =
-               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKHTLCFailChannelUpdate$NodeFailure;"));
-       CHECK(LDKHTLCFailChannelUpdate_NodeFailure_class != NULL);
-       LDKHTLCFailChannelUpdate_NodeFailure_meth = (*env)->GetMethodID(env, LDKHTLCFailChannelUpdate_NodeFailure_class, "<init>", "([BZ)V");
-       CHECK(LDKHTLCFailChannelUpdate_NodeFailure_meth != NULL);
-}
-JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKHTLCFailChannelUpdate_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
-       LDKHTLCFailChannelUpdate *obj = (LDKHTLCFailChannelUpdate*)ptr;
-       switch(obj->tag) {
-               case LDKHTLCFailChannelUpdate_ChannelUpdateMessage: {
-                       LDKChannelUpdate msg_var = obj->channel_update_message.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, LDKHTLCFailChannelUpdate_ChannelUpdateMessage_class, LDKHTLCFailChannelUpdate_ChannelUpdateMessage_meth, msg_ref);
-               }
-               case LDKHTLCFailChannelUpdate_ChannelClosed: {
-                       return (*env)->NewObject(env, LDKHTLCFailChannelUpdate_ChannelClosed_class, LDKHTLCFailChannelUpdate_ChannelClosed_meth, obj->channel_closed.short_channel_id, obj->channel_closed.is_permanent);
-               }
-               case LDKHTLCFailChannelUpdate_NodeFailure: {
-                       int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
-                       (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->node_failure.node_id.compressed_form);
-                       return (*env)->NewObject(env, LDKHTLCFailChannelUpdate_NodeFailure_class, LDKHTLCFailChannelUpdate_NodeFailure_meth, node_id_arr, obj->node_failure.is_permanent);
-               }
-               default: abort();
-       }
-}
-static jclass LDKMessageSendEvent_SendAcceptChannel_class = NULL;
-static jmethodID LDKMessageSendEvent_SendAcceptChannel_meth = NULL;
-static jclass LDKMessageSendEvent_SendOpenChannel_class = NULL;
-static jmethodID LDKMessageSendEvent_SendOpenChannel_meth = NULL;
-static jclass LDKMessageSendEvent_SendFundingCreated_class = NULL;
-static jmethodID LDKMessageSendEvent_SendFundingCreated_meth = NULL;
-static jclass LDKMessageSendEvent_SendFundingSigned_class = NULL;
-static jmethodID LDKMessageSendEvent_SendFundingSigned_meth = NULL;
-static jclass LDKMessageSendEvent_SendFundingLocked_class = NULL;
-static jmethodID LDKMessageSendEvent_SendFundingLocked_meth = NULL;
-static jclass LDKMessageSendEvent_SendAnnouncementSignatures_class = NULL;
-static jmethodID LDKMessageSendEvent_SendAnnouncementSignatures_meth = NULL;
-static jclass LDKMessageSendEvent_UpdateHTLCs_class = NULL;
-static jmethodID LDKMessageSendEvent_UpdateHTLCs_meth = NULL;
-static jclass LDKMessageSendEvent_SendRevokeAndACK_class = NULL;
-static jmethodID LDKMessageSendEvent_SendRevokeAndACK_meth = NULL;
-static jclass LDKMessageSendEvent_SendClosingSigned_class = NULL;
-static jmethodID LDKMessageSendEvent_SendClosingSigned_meth = NULL;
-static jclass LDKMessageSendEvent_SendShutdown_class = NULL;
-static jmethodID LDKMessageSendEvent_SendShutdown_meth = NULL;
-static jclass LDKMessageSendEvent_SendChannelReestablish_class = NULL;
-static jmethodID LDKMessageSendEvent_SendChannelReestablish_meth = NULL;
-static jclass LDKMessageSendEvent_BroadcastChannelAnnouncement_class = NULL;
-static jmethodID LDKMessageSendEvent_BroadcastChannelAnnouncement_meth = NULL;
-static jclass LDKMessageSendEvent_BroadcastNodeAnnouncement_class = NULL;
-static jmethodID LDKMessageSendEvent_BroadcastNodeAnnouncement_meth = NULL;
-static jclass LDKMessageSendEvent_BroadcastChannelUpdate_class = NULL;
-static jmethodID LDKMessageSendEvent_BroadcastChannelUpdate_meth = NULL;
-static jclass LDKMessageSendEvent_HandleError_class = NULL;
-static jmethodID LDKMessageSendEvent_HandleError_meth = NULL;
-static jclass LDKMessageSendEvent_PaymentFailureNetworkUpdate_class = NULL;
-static jmethodID LDKMessageSendEvent_PaymentFailureNetworkUpdate_meth = NULL;
-static jclass LDKMessageSendEvent_SendChannelRangeQuery_class = NULL;
-static jmethodID LDKMessageSendEvent_SendChannelRangeQuery_meth = NULL;
-static jclass LDKMessageSendEvent_SendShortIdsQuery_class = NULL;
-static jmethodID LDKMessageSendEvent_SendShortIdsQuery_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;"));
-       CHECK(LDKMessageSendEvent_SendAcceptChannel_class != NULL);
-       LDKMessageSendEvent_SendAcceptChannel_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendAcceptChannel_class, "<init>", "([BJ)V");
-       CHECK(LDKMessageSendEvent_SendAcceptChannel_meth != NULL);
-       LDKMessageSendEvent_SendOpenChannel_class =
-               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendOpenChannel;"));
-       CHECK(LDKMessageSendEvent_SendOpenChannel_class != NULL);
-       LDKMessageSendEvent_SendOpenChannel_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendOpenChannel_class, "<init>", "([BJ)V");
-       CHECK(LDKMessageSendEvent_SendOpenChannel_meth != NULL);
-       LDKMessageSendEvent_SendFundingCreated_class =
-               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendFundingCreated;"));
-       CHECK(LDKMessageSendEvent_SendFundingCreated_class != NULL);
-       LDKMessageSendEvent_SendFundingCreated_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendFundingCreated_class, "<init>", "([BJ)V");
-       CHECK(LDKMessageSendEvent_SendFundingCreated_meth != NULL);
-       LDKMessageSendEvent_SendFundingSigned_class =
-               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendFundingSigned;"));
-       CHECK(LDKMessageSendEvent_SendFundingSigned_class != NULL);
-       LDKMessageSendEvent_SendFundingSigned_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendFundingSigned_class, "<init>", "([BJ)V");
-       CHECK(LDKMessageSendEvent_SendFundingSigned_meth != NULL);
-       LDKMessageSendEvent_SendFundingLocked_class =
-               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendFundingLocked;"));
-       CHECK(LDKMessageSendEvent_SendFundingLocked_class != NULL);
-       LDKMessageSendEvent_SendFundingLocked_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendFundingLocked_class, "<init>", "([BJ)V");
-       CHECK(LDKMessageSendEvent_SendFundingLocked_meth != NULL);
-       LDKMessageSendEvent_SendAnnouncementSignatures_class =
-               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendAnnouncementSignatures;"));
-       CHECK(LDKMessageSendEvent_SendAnnouncementSignatures_class != NULL);
-       LDKMessageSendEvent_SendAnnouncementSignatures_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendAnnouncementSignatures_class, "<init>", "([BJ)V");
-       CHECK(LDKMessageSendEvent_SendAnnouncementSignatures_meth != NULL);
-       LDKMessageSendEvent_UpdateHTLCs_class =
-               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$UpdateHTLCs;"));
-       CHECK(LDKMessageSendEvent_UpdateHTLCs_class != NULL);
-       LDKMessageSendEvent_UpdateHTLCs_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_UpdateHTLCs_class, "<init>", "([BJ)V");
-       CHECK(LDKMessageSendEvent_UpdateHTLCs_meth != NULL);
-       LDKMessageSendEvent_SendRevokeAndACK_class =
-               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendRevokeAndACK;"));
-       CHECK(LDKMessageSendEvent_SendRevokeAndACK_class != NULL);
-       LDKMessageSendEvent_SendRevokeAndACK_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendRevokeAndACK_class, "<init>", "([BJ)V");
-       CHECK(LDKMessageSendEvent_SendRevokeAndACK_meth != NULL);
-       LDKMessageSendEvent_SendClosingSigned_class =
-               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendClosingSigned;"));
-       CHECK(LDKMessageSendEvent_SendClosingSigned_class != NULL);
-       LDKMessageSendEvent_SendClosingSigned_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendClosingSigned_class, "<init>", "([BJ)V");
-       CHECK(LDKMessageSendEvent_SendClosingSigned_meth != NULL);
-       LDKMessageSendEvent_SendShutdown_class =
-               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendShutdown;"));
-       CHECK(LDKMessageSendEvent_SendShutdown_class != NULL);
-       LDKMessageSendEvent_SendShutdown_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendShutdown_class, "<init>", "([BJ)V");
-       CHECK(LDKMessageSendEvent_SendShutdown_meth != NULL);
-       LDKMessageSendEvent_SendChannelReestablish_class =
-               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendChannelReestablish;"));
-       CHECK(LDKMessageSendEvent_SendChannelReestablish_class != NULL);
-       LDKMessageSendEvent_SendChannelReestablish_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendChannelReestablish_class, "<init>", "([BJ)V");
-       CHECK(LDKMessageSendEvent_SendChannelReestablish_meth != NULL);
-       LDKMessageSendEvent_BroadcastChannelAnnouncement_class =
-               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$BroadcastChannelAnnouncement;"));
-       CHECK(LDKMessageSendEvent_BroadcastChannelAnnouncement_class != NULL);
-       LDKMessageSendEvent_BroadcastChannelAnnouncement_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_BroadcastChannelAnnouncement_class, "<init>", "(JJ)V");
-       CHECK(LDKMessageSendEvent_BroadcastChannelAnnouncement_meth != NULL);
-       LDKMessageSendEvent_BroadcastNodeAnnouncement_class =
-               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$BroadcastNodeAnnouncement;"));
-       CHECK(LDKMessageSendEvent_BroadcastNodeAnnouncement_class != NULL);
-       LDKMessageSendEvent_BroadcastNodeAnnouncement_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_BroadcastNodeAnnouncement_class, "<init>", "(J)V");
-       CHECK(LDKMessageSendEvent_BroadcastNodeAnnouncement_meth != NULL);
-       LDKMessageSendEvent_BroadcastChannelUpdate_class =
-               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$BroadcastChannelUpdate;"));
-       CHECK(LDKMessageSendEvent_BroadcastChannelUpdate_class != NULL);
-       LDKMessageSendEvent_BroadcastChannelUpdate_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_BroadcastChannelUpdate_class, "<init>", "(J)V");
-       CHECK(LDKMessageSendEvent_BroadcastChannelUpdate_meth != NULL);
-       LDKMessageSendEvent_HandleError_class =
-               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$HandleError;"));
-       CHECK(LDKMessageSendEvent_HandleError_class != NULL);
-       LDKMessageSendEvent_HandleError_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_HandleError_class, "<init>", "([BJ)V");
-       CHECK(LDKMessageSendEvent_HandleError_meth != NULL);
-       LDKMessageSendEvent_PaymentFailureNetworkUpdate_class =
-               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$PaymentFailureNetworkUpdate;"));
-       CHECK(LDKMessageSendEvent_PaymentFailureNetworkUpdate_class != NULL);
-       LDKMessageSendEvent_PaymentFailureNetworkUpdate_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_PaymentFailureNetworkUpdate_class, "<init>", "(J)V");
-       CHECK(LDKMessageSendEvent_PaymentFailureNetworkUpdate_meth != NULL);
-       LDKMessageSendEvent_SendChannelRangeQuery_class =
-               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendChannelRangeQuery;"));
-       CHECK(LDKMessageSendEvent_SendChannelRangeQuery_class != NULL);
-       LDKMessageSendEvent_SendChannelRangeQuery_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendChannelRangeQuery_class, "<init>", "([BJ)V");
-       CHECK(LDKMessageSendEvent_SendChannelRangeQuery_meth != NULL);
-       LDKMessageSendEvent_SendShortIdsQuery_class =
-               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendShortIdsQuery;"));
-       CHECK(LDKMessageSendEvent_SendShortIdsQuery_class != NULL);
-       LDKMessageSendEvent_SendShortIdsQuery_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendShortIdsQuery_class, "<init>", "([BJ)V");
-       CHECK(LDKMessageSendEvent_SendShortIdsQuery_meth != NULL);
+static jclass LDKMessageSendEvent_SendAcceptChannel_class = NULL;
+static jmethodID LDKMessageSendEvent_SendAcceptChannel_meth = NULL;
+static jclass LDKMessageSendEvent_SendOpenChannel_class = NULL;
+static jmethodID LDKMessageSendEvent_SendOpenChannel_meth = NULL;
+static jclass LDKMessageSendEvent_SendFundingCreated_class = NULL;
+static jmethodID LDKMessageSendEvent_SendFundingCreated_meth = NULL;
+static jclass LDKMessageSendEvent_SendFundingSigned_class = NULL;
+static jmethodID LDKMessageSendEvent_SendFundingSigned_meth = NULL;
+static jclass LDKMessageSendEvent_SendFundingLocked_class = NULL;
+static jmethodID LDKMessageSendEvent_SendFundingLocked_meth = NULL;
+static jclass LDKMessageSendEvent_SendAnnouncementSignatures_class = NULL;
+static jmethodID LDKMessageSendEvent_SendAnnouncementSignatures_meth = NULL;
+static jclass LDKMessageSendEvent_UpdateHTLCs_class = NULL;
+static jmethodID LDKMessageSendEvent_UpdateHTLCs_meth = NULL;
+static jclass LDKMessageSendEvent_SendRevokeAndACK_class = NULL;
+static jmethodID LDKMessageSendEvent_SendRevokeAndACK_meth = NULL;
+static jclass LDKMessageSendEvent_SendClosingSigned_class = NULL;
+static jmethodID LDKMessageSendEvent_SendClosingSigned_meth = NULL;
+static jclass LDKMessageSendEvent_SendShutdown_class = NULL;
+static jmethodID LDKMessageSendEvent_SendShutdown_meth = NULL;
+static jclass LDKMessageSendEvent_SendChannelReestablish_class = NULL;
+static jmethodID LDKMessageSendEvent_SendChannelReestablish_meth = NULL;
+static jclass LDKMessageSendEvent_BroadcastChannelAnnouncement_class = NULL;
+static jmethodID LDKMessageSendEvent_BroadcastChannelAnnouncement_meth = NULL;
+static jclass LDKMessageSendEvent_BroadcastNodeAnnouncement_class = NULL;
+static jmethodID LDKMessageSendEvent_BroadcastNodeAnnouncement_meth = NULL;
+static jclass LDKMessageSendEvent_BroadcastChannelUpdate_class = NULL;
+static jmethodID LDKMessageSendEvent_BroadcastChannelUpdate_meth = NULL;
+static jclass LDKMessageSendEvent_HandleError_class = NULL;
+static jmethodID LDKMessageSendEvent_HandleError_meth = NULL;
+static jclass LDKMessageSendEvent_PaymentFailureNetworkUpdate_class = NULL;
+static jmethodID LDKMessageSendEvent_PaymentFailureNetworkUpdate_meth = NULL;
+static jclass LDKMessageSendEvent_SendChannelRangeQuery_class = NULL;
+static jmethodID LDKMessageSendEvent_SendChannelRangeQuery_meth = NULL;
+static jclass LDKMessageSendEvent_SendShortIdsQuery_class = NULL;
+static jmethodID LDKMessageSendEvent_SendShortIdsQuery_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;"));
+       CHECK(LDKMessageSendEvent_SendAcceptChannel_class != NULL);
+       LDKMessageSendEvent_SendAcceptChannel_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendAcceptChannel_class, "<init>", "([BJ)V");
+       CHECK(LDKMessageSendEvent_SendAcceptChannel_meth != NULL);
+       LDKMessageSendEvent_SendOpenChannel_class =
+               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendOpenChannel;"));
+       CHECK(LDKMessageSendEvent_SendOpenChannel_class != NULL);
+       LDKMessageSendEvent_SendOpenChannel_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendOpenChannel_class, "<init>", "([BJ)V");
+       CHECK(LDKMessageSendEvent_SendOpenChannel_meth != NULL);
+       LDKMessageSendEvent_SendFundingCreated_class =
+               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendFundingCreated;"));
+       CHECK(LDKMessageSendEvent_SendFundingCreated_class != NULL);
+       LDKMessageSendEvent_SendFundingCreated_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendFundingCreated_class, "<init>", "([BJ)V");
+       CHECK(LDKMessageSendEvent_SendFundingCreated_meth != NULL);
+       LDKMessageSendEvent_SendFundingSigned_class =
+               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendFundingSigned;"));
+       CHECK(LDKMessageSendEvent_SendFundingSigned_class != NULL);
+       LDKMessageSendEvent_SendFundingSigned_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendFundingSigned_class, "<init>", "([BJ)V");
+       CHECK(LDKMessageSendEvent_SendFundingSigned_meth != NULL);
+       LDKMessageSendEvent_SendFundingLocked_class =
+               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendFundingLocked;"));
+       CHECK(LDKMessageSendEvent_SendFundingLocked_class != NULL);
+       LDKMessageSendEvent_SendFundingLocked_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendFundingLocked_class, "<init>", "([BJ)V");
+       CHECK(LDKMessageSendEvent_SendFundingLocked_meth != NULL);
+       LDKMessageSendEvent_SendAnnouncementSignatures_class =
+               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendAnnouncementSignatures;"));
+       CHECK(LDKMessageSendEvent_SendAnnouncementSignatures_class != NULL);
+       LDKMessageSendEvent_SendAnnouncementSignatures_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendAnnouncementSignatures_class, "<init>", "([BJ)V");
+       CHECK(LDKMessageSendEvent_SendAnnouncementSignatures_meth != NULL);
+       LDKMessageSendEvent_UpdateHTLCs_class =
+               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$UpdateHTLCs;"));
+       CHECK(LDKMessageSendEvent_UpdateHTLCs_class != NULL);
+       LDKMessageSendEvent_UpdateHTLCs_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_UpdateHTLCs_class, "<init>", "([BJ)V");
+       CHECK(LDKMessageSendEvent_UpdateHTLCs_meth != NULL);
+       LDKMessageSendEvent_SendRevokeAndACK_class =
+               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendRevokeAndACK;"));
+       CHECK(LDKMessageSendEvent_SendRevokeAndACK_class != NULL);
+       LDKMessageSendEvent_SendRevokeAndACK_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendRevokeAndACK_class, "<init>", "([BJ)V");
+       CHECK(LDKMessageSendEvent_SendRevokeAndACK_meth != NULL);
+       LDKMessageSendEvent_SendClosingSigned_class =
+               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendClosingSigned;"));
+       CHECK(LDKMessageSendEvent_SendClosingSigned_class != NULL);
+       LDKMessageSendEvent_SendClosingSigned_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendClosingSigned_class, "<init>", "([BJ)V");
+       CHECK(LDKMessageSendEvent_SendClosingSigned_meth != NULL);
+       LDKMessageSendEvent_SendShutdown_class =
+               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendShutdown;"));
+       CHECK(LDKMessageSendEvent_SendShutdown_class != NULL);
+       LDKMessageSendEvent_SendShutdown_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendShutdown_class, "<init>", "([BJ)V");
+       CHECK(LDKMessageSendEvent_SendShutdown_meth != NULL);
+       LDKMessageSendEvent_SendChannelReestablish_class =
+               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendChannelReestablish;"));
+       CHECK(LDKMessageSendEvent_SendChannelReestablish_class != NULL);
+       LDKMessageSendEvent_SendChannelReestablish_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendChannelReestablish_class, "<init>", "([BJ)V");
+       CHECK(LDKMessageSendEvent_SendChannelReestablish_meth != NULL);
+       LDKMessageSendEvent_BroadcastChannelAnnouncement_class =
+               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$BroadcastChannelAnnouncement;"));
+       CHECK(LDKMessageSendEvent_BroadcastChannelAnnouncement_class != NULL);
+       LDKMessageSendEvent_BroadcastChannelAnnouncement_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_BroadcastChannelAnnouncement_class, "<init>", "(JJ)V");
+       CHECK(LDKMessageSendEvent_BroadcastChannelAnnouncement_meth != NULL);
+       LDKMessageSendEvent_BroadcastNodeAnnouncement_class =
+               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$BroadcastNodeAnnouncement;"));
+       CHECK(LDKMessageSendEvent_BroadcastNodeAnnouncement_class != NULL);
+       LDKMessageSendEvent_BroadcastNodeAnnouncement_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_BroadcastNodeAnnouncement_class, "<init>", "(J)V");
+       CHECK(LDKMessageSendEvent_BroadcastNodeAnnouncement_meth != NULL);
+       LDKMessageSendEvent_BroadcastChannelUpdate_class =
+               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$BroadcastChannelUpdate;"));
+       CHECK(LDKMessageSendEvent_BroadcastChannelUpdate_class != NULL);
+       LDKMessageSendEvent_BroadcastChannelUpdate_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_BroadcastChannelUpdate_class, "<init>", "(J)V");
+       CHECK(LDKMessageSendEvent_BroadcastChannelUpdate_meth != NULL);
+       LDKMessageSendEvent_HandleError_class =
+               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$HandleError;"));
+       CHECK(LDKMessageSendEvent_HandleError_class != NULL);
+       LDKMessageSendEvent_HandleError_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_HandleError_class, "<init>", "([BJ)V");
+       CHECK(LDKMessageSendEvent_HandleError_meth != NULL);
+       LDKMessageSendEvent_PaymentFailureNetworkUpdate_class =
+               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$PaymentFailureNetworkUpdate;"));
+       CHECK(LDKMessageSendEvent_PaymentFailureNetworkUpdate_class != NULL);
+       LDKMessageSendEvent_PaymentFailureNetworkUpdate_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_PaymentFailureNetworkUpdate_class, "<init>", "(J)V");
+       CHECK(LDKMessageSendEvent_PaymentFailureNetworkUpdate_meth != NULL);
+       LDKMessageSendEvent_SendChannelRangeQuery_class =
+               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendChannelRangeQuery;"));
+       CHECK(LDKMessageSendEvent_SendChannelRangeQuery_class != NULL);
+       LDKMessageSendEvent_SendChannelRangeQuery_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendChannelRangeQuery_class, "<init>", "([BJ)V");
+       CHECK(LDKMessageSendEvent_SendChannelRangeQuery_meth != NULL);
+       LDKMessageSendEvent_SendShortIdsQuery_class =
+               (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendShortIdsQuery;"));
+       CHECK(LDKMessageSendEvent_SendShortIdsQuery_class != NULL);
+       LDKMessageSendEvent_SendShortIdsQuery_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendShortIdsQuery_class, "<init>", "([BJ)V");
+       CHECK(LDKMessageSendEvent_SendShortIdsQuery_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;
@@ -1401,30 +1027,297 @@ JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKMessageSendEvent_1ref_1f
                default: abort();
        }
 }
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1MessageSendEventZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
-       LDKCVec_MessageSendEventZ *ret = MALLOC(sizeof(LDKCVec_MessageSendEventZ), "LDKCVec_MessageSendEventZ");
-       ret->datalen = (*env)->GetArrayLength(env, elems);
-       if (ret->datalen == 0) {
-               ret->data = NULL;
-       } else {
-               ret->data = MALLOC(sizeof(LDKMessageSendEvent) * ret->datalen, "LDKCVec_MessageSendEventZ Data");
-               int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
-               for (size_t i = 0; i < ret->datalen; i++) {
-                       int64_t arr_elem = java_elems[i];
-                       LDKMessageSendEvent arr_elem_conv = *(LDKMessageSendEvent*)(((uint64_t)arr_elem) & ~1);
-                       FREE((void*)arr_elem);
-                       ret->data[i] = arr_elem_conv;
-               }
-               (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
-       }
-       return (long)ret;
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1MessageSendEventZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
+       LDKCVec_MessageSendEventZ *ret = MALLOC(sizeof(LDKCVec_MessageSendEventZ), "LDKCVec_MessageSendEventZ");
+       ret->datalen = (*env)->GetArrayLength(env, elems);
+       if (ret->datalen == 0) {
+               ret->data = NULL;
+       } else {
+               ret->data = MALLOC(sizeof(LDKMessageSendEvent) * ret->datalen, "LDKCVec_MessageSendEventZ Data");
+               int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
+               for (size_t i = 0; i < ret->datalen; i++) {
+                       int64_t arr_elem = java_elems[i];
+                       LDKMessageSendEvent arr_elem_conv = *(LDKMessageSendEvent*)(((uint64_t)arr_elem) & ~1);
+                       FREE((void*)arr_elem);
+                       ret->data[i] = arr_elem_conv;
+               }
+               (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
+       }
+       return (long)ret;
+}
+static inline LDKCVec_MessageSendEventZ CVec_MessageSendEventZ_clone(const LDKCVec_MessageSendEventZ *orig) {
+       LDKCVec_MessageSendEventZ ret = { .data = MALLOC(sizeof(LDKMessageSendEvent) * orig->datalen, "LDKCVec_MessageSendEventZ clone bytes"), .datalen = orig->datalen };
+       for (size_t i = 0; i < ret.datalen; i++) {
+               ret.data[i] = MessageSendEvent_clone(&orig->data[i]);
+       }
+       return ret;
+}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolLightningErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
+       return ((LDKCResult_boolLightningErrorZ*)arg)->result_ok;
+}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolLightningErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
+       LDKCResult_boolLightningErrorZ *val = (LDKCResult_boolLightningErrorZ*)(arg & ~1);
+       CHECK(val->result_ok);
+       return *val->contents.result;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolLightningErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
+       LDKCResult_boolLightningErrorZ *val = (LDKCResult_boolLightningErrorZ*)(arg & ~1);
+       CHECK(!val->result_ok);
+       LDKLightningError err_var = (*val->contents.err);
+       CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+       CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+       long err_ref = (long)err_var.inner & ~1;
+       return err_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1new(JNIEnv *env, jclass clz, int64_t a, int64_t b, int64_t c) {
+       LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
+       LDKChannelAnnouncement a_conv;
+       a_conv.inner = (void*)(a & (~1));
+       a_conv.is_owned = (a & 1) || (a == 0);
+       a_conv = ChannelAnnouncement_clone(&a_conv);
+       ret->a = a_conv;
+       LDKChannelUpdate b_conv;
+       b_conv.inner = (void*)(b & (~1));
+       b_conv.is_owned = (b & 1) || (b == 0);
+       b_conv = ChannelUpdate_clone(&b_conv);
+       ret->b = b_conv;
+       LDKChannelUpdate c_conv;
+       c_conv.inner = (void*)(c & (~1));
+       c_conv.is_owned = (c & 1) || (c == 0);
+       c_conv = ChannelUpdate_clone(&c_conv);
+       ret->c = c_conv;
+       return (long)ret;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1get_1a(JNIEnv *env, jclass clz, int64_t ptr) {
+       LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *tuple = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(ptr & ~1);
+       LDKChannelAnnouncement a_var = tuple->a;
+       CHECK((((long)a_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+       CHECK((((long)&a_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+       long a_ref = (long)a_var.inner & ~1;
+       return a_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1get_1b(JNIEnv *env, jclass clz, int64_t ptr) {
+       LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *tuple = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(ptr & ~1);
+       LDKChannelUpdate b_var = tuple->b;
+       CHECK((((long)b_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+       CHECK((((long)&b_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+       long b_ref = (long)b_var.inner & ~1;
+       return b_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1get_1c(JNIEnv *env, jclass clz, int64_t ptr) {
+       LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *tuple = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(ptr & ~1);
+       LDKChannelUpdate c_var = tuple->c;
+       CHECK((((long)c_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+       CHECK((((long)&c_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+       long c_ref = (long)c_var.inner & ~1;
+       return c_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
+       LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret = MALLOC(sizeof(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
+       ret->datalen = (*env)->GetArrayLength(env, elems);
+       if (ret->datalen == 0) {
+               ret->data = NULL;
+       } else {
+               ret->data = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ) * ret->datalen, "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ Data");
+               int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
+               for (size_t i = 0; i < ret->datalen; i++) {
+                       int64_t arr_elem = java_elems[i];
+                       LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ arr_elem_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)arr_elem) & ~1);
+                       FREE((void*)arr_elem);
+                       ret->data[i] = arr_elem_conv;
+               }
+               (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
+       }
+       return (long)ret;
+}
+static inline LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(const LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *orig) {
+       LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret = { .data = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ) * orig->datalen, "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ clone bytes"), .datalen = orig->datalen };
+       for (size_t i = 0; i < ret.datalen; i++) {
+               ret.data[i] = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(&orig->data[i]);
+       }
+       return ret;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1NodeAnnouncementZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
+       LDKCVec_NodeAnnouncementZ *ret = MALLOC(sizeof(LDKCVec_NodeAnnouncementZ), "LDKCVec_NodeAnnouncementZ");
+       ret->datalen = (*env)->GetArrayLength(env, elems);
+       if (ret->datalen == 0) {
+               ret->data = NULL;
+       } else {
+               ret->data = MALLOC(sizeof(LDKNodeAnnouncement) * ret->datalen, "LDKCVec_NodeAnnouncementZ Data");
+               int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
+               for (size_t i = 0; i < ret->datalen; i++) {
+                       int64_t arr_elem = java_elems[i];
+                       LDKNodeAnnouncement arr_elem_conv;
+                       arr_elem_conv.inner = (void*)(arr_elem & (~1));
+                       arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
+                       arr_elem_conv = NodeAnnouncement_clone(&arr_elem_conv);
+                       ret->data[i] = arr_elem_conv;
+               }
+               (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
+       }
+       return (long)ret;
+}
+static inline LDKCVec_NodeAnnouncementZ CVec_NodeAnnouncementZ_clone(const LDKCVec_NodeAnnouncementZ *orig) {
+       LDKCVec_NodeAnnouncementZ ret = { .data = MALLOC(sizeof(LDKNodeAnnouncement) * orig->datalen, "LDKCVec_NodeAnnouncementZ clone bytes"), .datalen = orig->datalen };
+       for (size_t i = 0; i < ret.datalen; i++) {
+               ret.data[i] = NodeAnnouncement_clone(&orig->data[i]);
+       }
+       return ret;
+}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneLightningErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
+       return ((LDKCResult_NoneLightningErrorZ*)arg)->result_ok;
+}
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneLightningErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
+       LDKCResult_NoneLightningErrorZ *val = (LDKCResult_NoneLightningErrorZ*)(arg & ~1);
+       CHECK(val->result_ok);
+       return *val->contents.result;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneLightningErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
+       LDKCResult_NoneLightningErrorZ *val = (LDKCResult_NoneLightningErrorZ*)(arg & ~1);
+       CHECK(!val->result_ok);
+       LDKLightningError err_var = (*val->contents.err);
+       CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+       CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+       long err_ref = (long)err_var.inner & ~1;
+       return err_ref;
+}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1u8ZPeerHandleErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
+       return ((LDKCResult_CVec_u8ZPeerHandleErrorZ*)arg)->result_ok;
+}
+JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1u8ZPeerHandleErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
+       LDKCResult_CVec_u8ZPeerHandleErrorZ *val = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(arg & ~1);
+       CHECK(val->result_ok);
+       LDKCVec_u8Z res_var = (*val->contents.result);
+       int8_tArray res_arr = (*env)->NewByteArray(env, res_var.datalen);
+       (*env)->SetByteArrayRegion(env, res_arr, 0, res_var.datalen, res_var.data);
+       return res_arr;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1u8ZPeerHandleErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
+       LDKCResult_CVec_u8ZPeerHandleErrorZ *val = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(arg & ~1);
+       CHECK(!val->result_ok);
+       LDKPeerHandleError err_var = (*val->contents.err);
+       CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+       CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+       long err_ref = (long)err_var.inner & ~1;
+       return err_ref;
 }
-static inline LDKCVec_MessageSendEventZ CVec_MessageSendEventZ_clone(const LDKCVec_MessageSendEventZ *orig) {
-       LDKCVec_MessageSendEventZ ret = { .data = MALLOC(sizeof(LDKMessageSendEvent) * orig->datalen, "LDKCVec_MessageSendEventZ clone bytes"), .datalen = orig->datalen };
-       for (size_t i = 0; i < ret.datalen; i++) {
-               ret.data[i] = MessageSendEvent_clone(&orig->data[i]);
-       }
-       return ret;
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePeerHandleErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
+       return ((LDKCResult_NonePeerHandleErrorZ*)arg)->result_ok;
+}
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePeerHandleErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
+       LDKCResult_NonePeerHandleErrorZ *val = (LDKCResult_NonePeerHandleErrorZ*)(arg & ~1);
+       CHECK(val->result_ok);
+       return *val->contents.result;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePeerHandleErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
+       LDKCResult_NonePeerHandleErrorZ *val = (LDKCResult_NonePeerHandleErrorZ*)(arg & ~1);
+       CHECK(!val->result_ok);
+       LDKPeerHandleError err_var = (*val->contents.err);
+       CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+       CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+       long err_ref = (long)err_var.inner & ~1;
+       return err_ref;
+}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolPeerHandleErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
+       return ((LDKCResult_boolPeerHandleErrorZ*)arg)->result_ok;
+}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolPeerHandleErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
+       LDKCResult_boolPeerHandleErrorZ *val = (LDKCResult_boolPeerHandleErrorZ*)(arg & ~1);
+       CHECK(val->result_ok);
+       return *val->contents.result;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolPeerHandleErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
+       LDKCResult_boolPeerHandleErrorZ *val = (LDKCResult_boolPeerHandleErrorZ*)(arg & ~1);
+       CHECK(!val->result_ok);
+       LDKPeerHandleError err_var = (*val->contents.err);
+       CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+       CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+       long err_ref = (long)err_var.inner & ~1;
+       return err_ref;
+}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitFeaturesDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
+       return ((LDKCResult_InitFeaturesDecodeErrorZ*)arg)->result_ok;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitFeaturesDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
+       LDKCResult_InitFeaturesDecodeErrorZ *val = (LDKCResult_InitFeaturesDecodeErrorZ*)(arg & ~1);
+       CHECK(val->result_ok);
+       LDKInitFeatures res_var = (*val->contents.result);
+       CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+       CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+       long res_ref = (long)res_var.inner & ~1;
+       return res_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitFeaturesDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
+       LDKCResult_InitFeaturesDecodeErrorZ *val = (LDKCResult_InitFeaturesDecodeErrorZ*)(arg & ~1);
+       CHECK(!val->result_ok);
+       LDKDecodeError err_var = (*val->contents.err);
+       CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+       CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+       long err_ref = (long)err_var.inner & ~1;
+       return err_ref;
+}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeFeaturesDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
+       return ((LDKCResult_NodeFeaturesDecodeErrorZ*)arg)->result_ok;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeFeaturesDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
+       LDKCResult_NodeFeaturesDecodeErrorZ *val = (LDKCResult_NodeFeaturesDecodeErrorZ*)(arg & ~1);
+       CHECK(val->result_ok);
+       LDKNodeFeatures res_var = (*val->contents.result);
+       CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+       CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+       long res_ref = (long)res_var.inner & ~1;
+       return res_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeFeaturesDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
+       LDKCResult_NodeFeaturesDecodeErrorZ *val = (LDKCResult_NodeFeaturesDecodeErrorZ*)(arg & ~1);
+       CHECK(!val->result_ok);
+       LDKDecodeError err_var = (*val->contents.err);
+       CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+       CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+       long err_ref = (long)err_var.inner & ~1;
+       return err_ref;
+}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelFeaturesDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
+       return ((LDKCResult_ChannelFeaturesDecodeErrorZ*)arg)->result_ok;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelFeaturesDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
+       LDKCResult_ChannelFeaturesDecodeErrorZ *val = (LDKCResult_ChannelFeaturesDecodeErrorZ*)(arg & ~1);
+       CHECK(val->result_ok);
+       LDKChannelFeatures res_var = (*val->contents.result);
+       CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+       CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+       long res_ref = (long)res_var.inner & ~1;
+       return res_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelFeaturesDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
+       LDKCResult_ChannelFeaturesDecodeErrorZ *val = (LDKCResult_ChannelFeaturesDecodeErrorZ*)(arg & ~1);
+       CHECK(!val->result_ok);
+       LDKDecodeError err_var = (*val->contents.err);
+       CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+       CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+       long err_ref = (long)err_var.inner & ~1;
+       return err_ref;
+}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelConfigDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
+       return ((LDKCResult_ChannelConfigDecodeErrorZ*)arg)->result_ok;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelConfigDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
+       LDKCResult_ChannelConfigDecodeErrorZ *val = (LDKCResult_ChannelConfigDecodeErrorZ*)(arg & ~1);
+       CHECK(val->result_ok);
+       LDKChannelConfig res_var = (*val->contents.result);
+       CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+       CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+       long res_ref = (long)res_var.inner & ~1;
+       return res_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelConfigDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
+       LDKCResult_ChannelConfigDecodeErrorZ *val = (LDKCResult_ChannelConfigDecodeErrorZ*)(arg & ~1);
+       CHECK(!val->result_ok);
+       LDKDecodeError err_var = (*val->contents.err);
+       CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+       CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+       long err_ref = (long)err_var.inner & ~1;
+       return err_ref;
 }
 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1DirectionalChannelInfoDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
        return ((LDKCResult_DirectionalChannelInfoDecodeErrorZ*)arg)->result_ok;
@@ -6741,55 +6634,202 @@ JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TrustedCommitmentT
        return (long)ret_conv;
 }
 
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TrustedCommitmentTransactionNoneZ_1err(JNIEnv *env, jclass clz) {
-       LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
-       *ret_conv = CResult_TrustedCommitmentTransactionNoneZ_err();
-       return (long)ret_conv;
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TrustedCommitmentTransactionNoneZ_1err(JNIEnv *env, jclass clz) {
+       LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
+       *ret_conv = CResult_TrustedCommitmentTransactionNoneZ_err();
+       return (long)ret_conv;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1TrustedCommitmentTransactionNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
+       if ((_res & 1) != 0) return;
+       LDKCResult_TrustedCommitmentTransactionNoneZ _res_conv = *(LDKCResult_TrustedCommitmentTransactionNoneZ*)(((uint64_t)_res) & ~1);
+       FREE((void*)_res);
+       CResult_TrustedCommitmentTransactionNoneZ_free(_res_conv);
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1ok(JNIEnv *env, jclass clz, jobjectArray o) {
+       LDKCVec_SignatureZ o_constr;
+       o_constr.datalen = (*env)->GetArrayLength(env, o);
+       if (o_constr.datalen > 0)
+               o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
+       else
+               o_constr.data = NULL;
+       for (size_t i = 0; i < o_constr.datalen; i++) {
+               int8_tArray o_conv_8 = (*env)->GetObjectArrayElement(env, o, i);
+               LDKSignature o_conv_8_ref;
+               CHECK((*env)->GetArrayLength(env, o_conv_8) == 64);
+               (*env)->GetByteArrayRegion(env, o_conv_8, 0, 64, o_conv_8_ref.compact_form);
+               o_constr.data[i] = o_conv_8_ref;
+       }
+       LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
+       *ret_conv = CResult_CVec_SignatureZNoneZ_ok(o_constr);
+       return (long)ret_conv;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1err(JNIEnv *env, jclass clz) {
+       LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
+       *ret_conv = CResult_CVec_SignatureZNoneZ_err();
+       return (long)ret_conv;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
+       if ((_res & 1) != 0) return;
+       LDKCResult_CVec_SignatureZNoneZ _res_conv = *(LDKCResult_CVec_SignatureZNoneZ*)(((uint64_t)_res) & ~1);
+       FREE((void*)_res);
+       CResult_CVec_SignatureZNoneZ_free(_res_conv);
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
+       LDKCResult_CVec_SignatureZNoneZ* orig_conv = (LDKCResult_CVec_SignatureZNoneZ*)(orig & ~1);
+       LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
+       *ret_conv = CResult_CVec_SignatureZNoneZ_clone(orig_conv);
+       return (long)ret_conv;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1MessageSendEventZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
+       LDKCVec_MessageSendEventZ _res_constr;
+       _res_constr.datalen = (*env)->GetArrayLength(env, _res);
+       if (_res_constr.datalen > 0)
+               _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKMessageSendEvent), "LDKCVec_MessageSendEventZ Elements");
+       else
+               _res_constr.data = NULL;
+       int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
+       for (size_t s = 0; s < _res_constr.datalen; s++) {
+               int64_t _res_conv_18 = _res_vals[s];
+               LDKMessageSendEvent _res_conv_18_conv = *(LDKMessageSendEvent*)(((uint64_t)_res_conv_18) & ~1);
+               FREE((void*)_res_conv_18);
+               _res_constr.data[s] = _res_conv_18_conv;
+       }
+       (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
+       CVec_MessageSendEventZ_free(_res_constr);
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1ok(JNIEnv *env, jclass clz, jboolean o) {
+       LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
+       *ret_conv = CResult_boolLightningErrorZ_ok(o);
+       return (long)ret_conv;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
+       LDKLightningError e_conv;
+       e_conv.inner = (void*)(e & (~1));
+       e_conv.is_owned = (e & 1) || (e == 0);
+       e_conv = LightningError_clone(&e_conv);
+       LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
+       *ret_conv = CResult_boolLightningErrorZ_err(e_conv);
+       return (long)ret_conv;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
+       if ((_res & 1) != 0) return;
+       LDKCResult_boolLightningErrorZ _res_conv = *(LDKCResult_boolLightningErrorZ*)(((uint64_t)_res) & ~1);
+       FREE((void*)_res);
+       CResult_boolLightningErrorZ_free(_res_conv);
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
+       LDKCResult_boolLightningErrorZ* orig_conv = (LDKCResult_boolLightningErrorZ*)(orig & ~1);
+       LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
+       *ret_conv = CResult_boolLightningErrorZ_clone(orig_conv);
+       return (long)ret_conv;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
+       LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* orig_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(orig & ~1);
+       LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_ref = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
+       *ret_ref = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig_conv);
+       return (long)ret_ref;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1new(JNIEnv *env, jclass clz, int64_t a, int64_t b, int64_t c) {
+       LDKChannelAnnouncement a_conv;
+       a_conv.inner = (void*)(a & (~1));
+       a_conv.is_owned = (a & 1) || (a == 0);
+       a_conv = ChannelAnnouncement_clone(&a_conv);
+       LDKChannelUpdate b_conv;
+       b_conv.inner = (void*)(b & (~1));
+       b_conv.is_owned = (b & 1) || (b == 0);
+       b_conv = ChannelUpdate_clone(&b_conv);
+       LDKChannelUpdate c_conv;
+       c_conv.inner = (void*)(c & (~1));
+       c_conv.is_owned = (c & 1) || (c == 0);
+       c_conv = ChannelUpdate_clone(&c_conv);
+       LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_ref = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
+       *ret_ref = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a_conv, b_conv, c_conv);
+       return (long)ret_ref;
 }
 
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1TrustedCommitmentTransactionNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
        if ((_res & 1) != 0) return;
-       LDKCResult_TrustedCommitmentTransactionNoneZ _res_conv = *(LDKCResult_TrustedCommitmentTransactionNoneZ*)(((uint64_t)_res) & ~1);
+       LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)_res) & ~1);
        FREE((void*)_res);
-       CResult_TrustedCommitmentTransactionNoneZ_free(_res_conv);
+       C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res_conv);
 }
 
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1ok(JNIEnv *env, jclass clz, jobjectArray o) {
-       LDKCVec_SignatureZ o_constr;
-       o_constr.datalen = (*env)->GetArrayLength(env, o);
-       if (o_constr.datalen > 0)
-               o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
+       LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res_constr;
+       _res_constr.datalen = (*env)->GetArrayLength(env, _res);
+       if (_res_constr.datalen > 0)
+               _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ Elements");
        else
-               o_constr.data = NULL;
-       for (size_t i = 0; i < o_constr.datalen; i++) {
-               int8_tArray o_conv_8 = (*env)->GetObjectArrayElement(env, o, i);
-               LDKSignature o_conv_8_ref;
-               CHECK((*env)->GetArrayLength(env, o_conv_8) == 64);
-               (*env)->GetByteArrayRegion(env, o_conv_8, 0, 64, o_conv_8_ref.compact_form);
-               o_constr.data[i] = o_conv_8_ref;
+               _res_constr.data = NULL;
+       int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
+       for (size_t l = 0; l < _res_constr.datalen; l++) {
+               int64_t _res_conv_63 = _res_vals[l];
+               LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res_conv_63_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)_res_conv_63) & ~1);
+               FREE((void*)_res_conv_63);
+               _res_constr.data[l] = _res_conv_63_conv;
        }
-       LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
-       *ret_conv = CResult_CVec_SignatureZNoneZ_ok(o_constr);
+       (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
+       CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res_constr);
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1NodeAnnouncementZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
+       LDKCVec_NodeAnnouncementZ _res_constr;
+       _res_constr.datalen = (*env)->GetArrayLength(env, _res);
+       if (_res_constr.datalen > 0)
+               _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKNodeAnnouncement), "LDKCVec_NodeAnnouncementZ Elements");
+       else
+               _res_constr.data = NULL;
+       int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
+       for (size_t s = 0; s < _res_constr.datalen; s++) {
+               int64_t _res_conv_18 = _res_vals[s];
+               LDKNodeAnnouncement _res_conv_18_conv;
+               _res_conv_18_conv.inner = (void*)(_res_conv_18 & (~1));
+               _res_conv_18_conv.is_owned = (_res_conv_18 & 1) || (_res_conv_18 == 0);
+               _res_constr.data[s] = _res_conv_18_conv;
+       }
+       (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
+       CVec_NodeAnnouncementZ_free(_res_constr);
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1ok(JNIEnv *env, jclass clz) {
+       LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
+       *ret_conv = CResult_NoneLightningErrorZ_ok();
        return (long)ret_conv;
 }
 
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1err(JNIEnv *env, jclass clz) {
-       LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
-       *ret_conv = CResult_CVec_SignatureZNoneZ_err();
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
+       LDKLightningError e_conv;
+       e_conv.inner = (void*)(e & (~1));
+       e_conv.is_owned = (e & 1) || (e == 0);
+       e_conv = LightningError_clone(&e_conv);
+       LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
+       *ret_conv = CResult_NoneLightningErrorZ_err(e_conv);
        return (long)ret_conv;
 }
 
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
        if ((_res & 1) != 0) return;
-       LDKCResult_CVec_SignatureZNoneZ _res_conv = *(LDKCResult_CVec_SignatureZNoneZ*)(((uint64_t)_res) & ~1);
+       LDKCResult_NoneLightningErrorZ _res_conv = *(LDKCResult_NoneLightningErrorZ*)(((uint64_t)_res) & ~1);
        FREE((void*)_res);
-       CResult_CVec_SignatureZNoneZ_free(_res_conv);
+       CResult_NoneLightningErrorZ_free(_res_conv);
 }
 
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
-       LDKCResult_CVec_SignatureZNoneZ* orig_conv = (LDKCResult_CVec_SignatureZNoneZ*)(orig & ~1);
-       LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
-       *ret_conv = CResult_CVec_SignatureZNoneZ_clone(orig_conv);
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
+       LDKCResult_NoneLightningErrorZ* orig_conv = (LDKCResult_NoneLightningErrorZ*)(orig & ~1);
+       LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
+       *ret_conv = CResult_NoneLightningErrorZ_clone(orig_conv);
        return (long)ret_conv;
 }
 
@@ -6932,246 +6972,99 @@ JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InitFeaturesDecode
        return (long)ret_conv;
 }
 
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1InitFeaturesDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
-       if ((_res & 1) != 0) return;
-       LDKCResult_InitFeaturesDecodeErrorZ _res_conv = *(LDKCResult_InitFeaturesDecodeErrorZ*)(((uint64_t)_res) & ~1);
-       FREE((void*)_res);
-       CResult_InitFeaturesDecodeErrorZ_free(_res_conv);
-}
-
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeFeaturesDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
-       LDKNodeFeatures o_conv;
-       o_conv.inner = (void*)(o & (~1));
-       o_conv.is_owned = (o & 1) || (o == 0);
-       o_conv = NodeFeatures_clone(&o_conv);
-       LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
-       *ret_conv = CResult_NodeFeaturesDecodeErrorZ_ok(o_conv);
-       return (long)ret_conv;
-}
-
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeFeaturesDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
-       LDKDecodeError e_conv;
-       e_conv.inner = (void*)(e & (~1));
-       e_conv.is_owned = (e & 1) || (e == 0);
-       e_conv = DecodeError_clone(&e_conv);
-       LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
-       *ret_conv = CResult_NodeFeaturesDecodeErrorZ_err(e_conv);
-       return (long)ret_conv;
-}
-
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NodeFeaturesDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
-       if ((_res & 1) != 0) return;
-       LDKCResult_NodeFeaturesDecodeErrorZ _res_conv = *(LDKCResult_NodeFeaturesDecodeErrorZ*)(((uint64_t)_res) & ~1);
-       FREE((void*)_res);
-       CResult_NodeFeaturesDecodeErrorZ_free(_res_conv);
-}
-
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelFeaturesDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
-       LDKChannelFeatures o_conv;
-       o_conv.inner = (void*)(o & (~1));
-       o_conv.is_owned = (o & 1) || (o == 0);
-       o_conv = ChannelFeatures_clone(&o_conv);
-       LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
-       *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_ok(o_conv);
-       return (long)ret_conv;
-}
-
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelFeaturesDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
-       LDKDecodeError e_conv;
-       e_conv.inner = (void*)(e & (~1));
-       e_conv.is_owned = (e & 1) || (e == 0);
-       e_conv = DecodeError_clone(&e_conv);
-       LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
-       *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_err(e_conv);
-       return (long)ret_conv;
-}
-
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelFeaturesDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
-       if ((_res & 1) != 0) return;
-       LDKCResult_ChannelFeaturesDecodeErrorZ _res_conv = *(LDKCResult_ChannelFeaturesDecodeErrorZ*)(((uint64_t)_res) & ~1);
-       FREE((void*)_res);
-       CResult_ChannelFeaturesDecodeErrorZ_free(_res_conv);
-}
-
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelConfigDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
-       LDKChannelConfig o_conv;
-       o_conv.inner = (void*)(o & (~1));
-       o_conv.is_owned = (o & 1) || (o == 0);
-       o_conv = ChannelConfig_clone(&o_conv);
-       LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
-       *ret_conv = CResult_ChannelConfigDecodeErrorZ_ok(o_conv);
-       return (long)ret_conv;
-}
-
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelConfigDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
-       LDKDecodeError e_conv;
-       e_conv.inner = (void*)(e & (~1));
-       e_conv.is_owned = (e & 1) || (e == 0);
-       e_conv = DecodeError_clone(&e_conv);
-       LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
-       *ret_conv = CResult_ChannelConfigDecodeErrorZ_err(e_conv);
-       return (long)ret_conv;
-}
-
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelConfigDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
-       if ((_res & 1) != 0) return;
-       LDKCResult_ChannelConfigDecodeErrorZ _res_conv = *(LDKCResult_ChannelConfigDecodeErrorZ*)(((uint64_t)_res) & ~1);
-       FREE((void*)_res);
-       CResult_ChannelConfigDecodeErrorZ_free(_res_conv);
-}
-
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelConfigDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
-       LDKCResult_ChannelConfigDecodeErrorZ* orig_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)(orig & ~1);
-       LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
-       *ret_conv = CResult_ChannelConfigDecodeErrorZ_clone(orig_conv);
-       return (long)ret_conv;
-}
-
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1ok(JNIEnv *env, jclass clz, jboolean o) {
-       LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
-       *ret_conv = CResult_boolLightningErrorZ_ok(o);
-       return (long)ret_conv;
-}
-
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
-       LDKLightningError e_conv;
-       e_conv.inner = (void*)(e & (~1));
-       e_conv.is_owned = (e & 1) || (e == 0);
-       e_conv = LightningError_clone(&e_conv);
-       LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
-       *ret_conv = CResult_boolLightningErrorZ_err(e_conv);
-       return (long)ret_conv;
-}
-
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
-       if ((_res & 1) != 0) return;
-       LDKCResult_boolLightningErrorZ _res_conv = *(LDKCResult_boolLightningErrorZ*)(((uint64_t)_res) & ~1);
-       FREE((void*)_res);
-       CResult_boolLightningErrorZ_free(_res_conv);
-}
-
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
-       LDKCResult_boolLightningErrorZ* orig_conv = (LDKCResult_boolLightningErrorZ*)(orig & ~1);
-       LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
-       *ret_conv = CResult_boolLightningErrorZ_clone(orig_conv);
-       return (long)ret_conv;
-}
-
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
-       LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* orig_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(orig & ~1);
-       LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_ref = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
-       *ret_ref = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig_conv);
-       return (long)ret_ref;
-}
-
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1new(JNIEnv *env, jclass clz, int64_t a, int64_t b, int64_t c) {
-       LDKChannelAnnouncement a_conv;
-       a_conv.inner = (void*)(a & (~1));
-       a_conv.is_owned = (a & 1) || (a == 0);
-       a_conv = ChannelAnnouncement_clone(&a_conv);
-       LDKChannelUpdate b_conv;
-       b_conv.inner = (void*)(b & (~1));
-       b_conv.is_owned = (b & 1) || (b == 0);
-       b_conv = ChannelUpdate_clone(&b_conv);
-       LDKChannelUpdate c_conv;
-       c_conv.inner = (void*)(c & (~1));
-       c_conv.is_owned = (c & 1) || (c == 0);
-       c_conv = ChannelUpdate_clone(&c_conv);
-       LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_ref = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
-       *ret_ref = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a_conv, b_conv, c_conv);
-       return (long)ret_ref;
-}
-
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1InitFeaturesDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
        if ((_res & 1) != 0) return;
-       LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)_res) & ~1);
+       LDKCResult_InitFeaturesDecodeErrorZ _res_conv = *(LDKCResult_InitFeaturesDecodeErrorZ*)(((uint64_t)_res) & ~1);
        FREE((void*)_res);
-       C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res_conv);
+       CResult_InitFeaturesDecodeErrorZ_free(_res_conv);
 }
 
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
-       LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res_constr;
-       _res_constr.datalen = (*env)->GetArrayLength(env, _res);
-       if (_res_constr.datalen > 0)
-               _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ Elements");
-       else
-               _res_constr.data = NULL;
-       int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
-       for (size_t l = 0; l < _res_constr.datalen; l++) {
-               int64_t _res_conv_63 = _res_vals[l];
-               LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res_conv_63_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)_res_conv_63) & ~1);
-               FREE((void*)_res_conv_63);
-               _res_constr.data[l] = _res_conv_63_conv;
-       }
-       (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
-       CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res_constr);
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeFeaturesDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
+       LDKNodeFeatures o_conv;
+       o_conv.inner = (void*)(o & (~1));
+       o_conv.is_owned = (o & 1) || (o == 0);
+       o_conv = NodeFeatures_clone(&o_conv);
+       LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
+       *ret_conv = CResult_NodeFeaturesDecodeErrorZ_ok(o_conv);
+       return (long)ret_conv;
 }
 
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1NodeAnnouncementZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
-       LDKCVec_NodeAnnouncementZ _res_constr;
-       _res_constr.datalen = (*env)->GetArrayLength(env, _res);
-       if (_res_constr.datalen > 0)
-               _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKNodeAnnouncement), "LDKCVec_NodeAnnouncementZ Elements");
-       else
-               _res_constr.data = NULL;
-       int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
-       for (size_t s = 0; s < _res_constr.datalen; s++) {
-               int64_t _res_conv_18 = _res_vals[s];
-               LDKNodeAnnouncement _res_conv_18_conv;
-               _res_conv_18_conv.inner = (void*)(_res_conv_18 & (~1));
-               _res_conv_18_conv.is_owned = (_res_conv_18 & 1) || (_res_conv_18 == 0);
-               _res_constr.data[s] = _res_conv_18_conv;
-       }
-       (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
-       CVec_NodeAnnouncementZ_free(_res_constr);
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeFeaturesDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
+       LDKDecodeError e_conv;
+       e_conv.inner = (void*)(e & (~1));
+       e_conv.is_owned = (e & 1) || (e == 0);
+       e_conv = DecodeError_clone(&e_conv);
+       LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
+       *ret_conv = CResult_NodeFeaturesDecodeErrorZ_err(e_conv);
+       return (long)ret_conv;
 }
 
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1ok(JNIEnv *env, jclass clz) {
-       LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
-       *ret_conv = CResult_NoneLightningErrorZ_ok();
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NodeFeaturesDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
+       if ((_res & 1) != 0) return;
+       LDKCResult_NodeFeaturesDecodeErrorZ _res_conv = *(LDKCResult_NodeFeaturesDecodeErrorZ*)(((uint64_t)_res) & ~1);
+       FREE((void*)_res);
+       CResult_NodeFeaturesDecodeErrorZ_free(_res_conv);
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelFeaturesDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
+       LDKChannelFeatures o_conv;
+       o_conv.inner = (void*)(o & (~1));
+       o_conv.is_owned = (o & 1) || (o == 0);
+       o_conv = ChannelFeatures_clone(&o_conv);
+       LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
+       *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_ok(o_conv);
        return (long)ret_conv;
 }
 
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
-       LDKLightningError e_conv;
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelFeaturesDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
+       LDKDecodeError e_conv;
        e_conv.inner = (void*)(e & (~1));
        e_conv.is_owned = (e & 1) || (e == 0);
-       e_conv = LightningError_clone(&e_conv);
-       LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
-       *ret_conv = CResult_NoneLightningErrorZ_err(e_conv);
+       e_conv = DecodeError_clone(&e_conv);
+       LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
+       *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_err(e_conv);
        return (long)ret_conv;
 }
 
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelFeaturesDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
        if ((_res & 1) != 0) return;
-       LDKCResult_NoneLightningErrorZ _res_conv = *(LDKCResult_NoneLightningErrorZ*)(((uint64_t)_res) & ~1);
+       LDKCResult_ChannelFeaturesDecodeErrorZ _res_conv = *(LDKCResult_ChannelFeaturesDecodeErrorZ*)(((uint64_t)_res) & ~1);
        FREE((void*)_res);
-       CResult_NoneLightningErrorZ_free(_res_conv);
+       CResult_ChannelFeaturesDecodeErrorZ_free(_res_conv);
 }
 
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
-       LDKCResult_NoneLightningErrorZ* orig_conv = (LDKCResult_NoneLightningErrorZ*)(orig & ~1);
-       LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
-       *ret_conv = CResult_NoneLightningErrorZ_clone(orig_conv);
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelConfigDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
+       LDKChannelConfig o_conv;
+       o_conv.inner = (void*)(o & (~1));
+       o_conv.is_owned = (o & 1) || (o == 0);
+       o_conv = ChannelConfig_clone(&o_conv);
+       LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
+       *ret_conv = CResult_ChannelConfigDecodeErrorZ_ok(o_conv);
        return (long)ret_conv;
 }
 
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1MessageSendEventZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
-       LDKCVec_MessageSendEventZ _res_constr;
-       _res_constr.datalen = (*env)->GetArrayLength(env, _res);
-       if (_res_constr.datalen > 0)
-               _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKMessageSendEvent), "LDKCVec_MessageSendEventZ Elements");
-       else
-               _res_constr.data = NULL;
-       int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
-       for (size_t s = 0; s < _res_constr.datalen; s++) {
-               int64_t _res_conv_18 = _res_vals[s];
-               LDKMessageSendEvent _res_conv_18_conv = *(LDKMessageSendEvent*)(((uint64_t)_res_conv_18) & ~1);
-               FREE((void*)_res_conv_18);
-               _res_constr.data[s] = _res_conv_18_conv;
-       }
-       (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
-       CVec_MessageSendEventZ_free(_res_constr);
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelConfigDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
+       LDKDecodeError e_conv;
+       e_conv.inner = (void*)(e & (~1));
+       e_conv.is_owned = (e & 1) || (e == 0);
+       e_conv = DecodeError_clone(&e_conv);
+       LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
+       *ret_conv = CResult_ChannelConfigDecodeErrorZ_err(e_conv);
+       return (long)ret_conv;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelConfigDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
+       if ((_res & 1) != 0) return;
+       LDKCResult_ChannelConfigDecodeErrorZ _res_conv = *(LDKCResult_ChannelConfigDecodeErrorZ*)(((uint64_t)_res) & ~1);
+       FREE((void*)_res);
+       CResult_ChannelConfigDecodeErrorZ_free(_res_conv);
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelConfigDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
+       LDKCResult_ChannelConfigDecodeErrorZ* orig_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)(orig & ~1);
+       LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
+       *ret_conv = CResult_ChannelConfigDecodeErrorZ_clone(orig_conv);
+       return (long)ret_conv;
 }
 
 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1DirectionalChannelInfoDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
@@ -11596,6 +11489,78 @@ JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelManager_1free(JNIEnv *e
        ChannelManager_free(this_ptr_conv);
 }
 
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChainParameters_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
+       LDKChainParameters this_ptr_conv;
+       this_ptr_conv.inner = (void*)(this_ptr & (~1));
+       this_ptr_conv.is_owned = (this_ptr & 1) || (this_ptr == 0);
+       ChainParameters_free(this_ptr_conv);
+}
+
+JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_ChainParameters_1get_1network(JNIEnv *env, jclass clz, int64_t this_ptr) {
+       LDKChainParameters this_ptr_conv;
+       this_ptr_conv.inner = (void*)(this_ptr & (~1));
+       this_ptr_conv.is_owned = false;
+       jclass ret_conv = LDKNetwork_to_java(env, ChainParameters_get_network(&this_ptr_conv));
+       return ret_conv;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChainParameters_1set_1network(JNIEnv *env, jclass clz, int64_t this_ptr, jclass val) {
+       LDKChainParameters this_ptr_conv;
+       this_ptr_conv.inner = (void*)(this_ptr & (~1));
+       this_ptr_conv.is_owned = false;
+       LDKNetwork val_conv = LDKNetwork_from_java(env, val);
+       ChainParameters_set_network(&this_ptr_conv, val_conv);
+}
+
+JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChainParameters_1get_1latest_1hash(JNIEnv *env, jclass clz, int64_t this_ptr) {
+       LDKChainParameters this_ptr_conv;
+       this_ptr_conv.inner = (void*)(this_ptr & (~1));
+       this_ptr_conv.is_owned = false;
+       int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
+       (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *ChainParameters_get_latest_hash(&this_ptr_conv));
+       return ret_arr;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChainParameters_1set_1latest_1hash(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
+       LDKChainParameters this_ptr_conv;
+       this_ptr_conv.inner = (void*)(this_ptr & (~1));
+       this_ptr_conv.is_owned = false;
+       LDKThirtyTwoBytes val_ref;
+       CHECK((*env)->GetArrayLength(env, val) == 32);
+       (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
+       ChainParameters_set_latest_hash(&this_ptr_conv, val_ref);
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChainParameters_1get_1latest_1height(JNIEnv *env, jclass clz, int64_t this_ptr) {
+       LDKChainParameters this_ptr_conv;
+       this_ptr_conv.inner = (void*)(this_ptr & (~1));
+       this_ptr_conv.is_owned = false;
+       int64_t ret_val = ChainParameters_get_latest_height(&this_ptr_conv);
+       return ret_val;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChainParameters_1set_1latest_1height(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
+       LDKChainParameters this_ptr_conv;
+       this_ptr_conv.inner = (void*)(this_ptr & (~1));
+       this_ptr_conv.is_owned = false;
+       ChainParameters_set_latest_height(&this_ptr_conv, val);
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChainParameters_1new(JNIEnv *env, jclass clz, jclass network_arg, int8_tArray latest_hash_arg, int64_t latest_height_arg) {
+       LDKNetwork network_arg_conv = LDKNetwork_from_java(env, network_arg);
+       LDKThirtyTwoBytes latest_hash_arg_ref;
+       CHECK((*env)->GetArrayLength(env, latest_hash_arg) == 32);
+       (*env)->GetByteArrayRegion(env, latest_hash_arg, 0, 32, latest_hash_arg_ref.data);
+       LDKChainParameters ret_var = ChainParameters_new(network_arg_conv, latest_hash_arg_ref, latest_height_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;
+       if (ret_var.is_owned) {
+               ret_ref |= 1;
+       }
+       return ret_ref;
+}
+
 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
        LDKChannelDetails this_ptr_conv;
        this_ptr_conv.inner = (void*)(this_ptr & (~1));
@@ -11770,8 +11735,7 @@ JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PaymentSendFailure_1clone(J
        return ret_ref;
 }
 
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManager_1new(JNIEnv *env, jclass clz, jclass network, int64_t fee_est, int64_t chain_monitor, int64_t tx_broadcaster, int64_t logger, int64_t keys_manager, int64_t config, int64_t current_blockchain_height) {
-       LDKNetwork network_conv = LDKNetwork_from_java(env, network);
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManager_1new(JNIEnv *env, jclass clz, int64_t fee_est, int64_t chain_monitor, int64_t tx_broadcaster, int64_t logger, int64_t keys_manager, int64_t config, int64_t params) {
        LDKFeeEstimator fee_est_conv = *(LDKFeeEstimator*)(((uint64_t)fee_est) & ~1);
        if (fee_est_conv.free == LDKFeeEstimator_JCalls_free) {
                // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
@@ -11801,7 +11765,11 @@ JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManager_1new(JNIEnv
        config_conv.inner = (void*)(config & (~1));
        config_conv.is_owned = (config & 1) || (config == 0);
        config_conv = UserConfig_clone(&config_conv);
-       LDKChannelManager ret_var = ChannelManager_new(network_conv, fee_est_conv, chain_monitor_conv, tx_broadcaster_conv, logger_conv, keys_manager_conv, config_conv, current_blockchain_height);
+       LDKChainParameters params_conv;
+       params_conv.inner = (void*)(params & (~1));
+       params_conv.is_owned = (params & 1) || (params == 0);
+       // Warning: we need a move here but no clone is available for LDKChainParameters
+       LDKChannelManager ret_var = ChannelManager_new(fee_est_conv, chain_monitor_conv, tx_broadcaster_conv, logger_conv, keys_manager_conv, config_conv, params_conv);
        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;
@@ -16717,6 +16685,78 @@ JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_GossipTimestampFilter_1
        return ret_arr;
 }
 
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_IgnoringMessageHandler_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
+       LDKIgnoringMessageHandler this_ptr_conv;
+       this_ptr_conv.inner = (void*)(this_ptr & (~1));
+       this_ptr_conv.is_owned = (this_ptr & 1) || (this_ptr == 0);
+       IgnoringMessageHandler_free(this_ptr_conv);
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_IgnoringMessageHandler_1new(JNIEnv *env, jclass clz) {
+       LDKIgnoringMessageHandler ret_var = IgnoringMessageHandler_new();
+       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;
+       if (ret_var.is_owned) {
+               ret_ref |= 1;
+       }
+       return ret_ref;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_IgnoringMessageHandler_1as_1MessageSendEventsProvider(JNIEnv *env, jclass clz, int64_t this_arg) {
+       LDKIgnoringMessageHandler this_arg_conv;
+       this_arg_conv.inner = (void*)(this_arg & (~1));
+       this_arg_conv.is_owned = false;
+       LDKMessageSendEventsProvider* ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
+       *ret = IgnoringMessageHandler_as_MessageSendEventsProvider(&this_arg_conv);
+       return (long)ret;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_IgnoringMessageHandler_1as_1RoutingMessageHandler(JNIEnv *env, jclass clz, int64_t this_arg) {
+       LDKIgnoringMessageHandler this_arg_conv;
+       this_arg_conv.inner = (void*)(this_arg & (~1));
+       this_arg_conv.is_owned = false;
+       LDKRoutingMessageHandler* ret = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
+       *ret = IgnoringMessageHandler_as_RoutingMessageHandler(&this_arg_conv);
+       return (long)ret;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ErroringMessageHandler_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
+       LDKErroringMessageHandler this_ptr_conv;
+       this_ptr_conv.inner = (void*)(this_ptr & (~1));
+       this_ptr_conv.is_owned = (this_ptr & 1) || (this_ptr == 0);
+       ErroringMessageHandler_free(this_ptr_conv);
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ErroringMessageHandler_1new(JNIEnv *env, jclass clz) {
+       LDKErroringMessageHandler ret_var = ErroringMessageHandler_new();
+       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;
+       if (ret_var.is_owned) {
+               ret_ref |= 1;
+       }
+       return ret_ref;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ErroringMessageHandler_1as_1MessageSendEventsProvider(JNIEnv *env, jclass clz, int64_t this_arg) {
+       LDKErroringMessageHandler this_arg_conv;
+       this_arg_conv.inner = (void*)(this_arg & (~1));
+       this_arg_conv.is_owned = false;
+       LDKMessageSendEventsProvider* ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
+       *ret = ErroringMessageHandler_as_MessageSendEventsProvider(&this_arg_conv);
+       return (long)ret;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ErroringMessageHandler_1as_1ChannelMessageHandler(JNIEnv *env, jclass clz, int64_t this_arg) {
+       LDKErroringMessageHandler this_arg_conv;
+       this_arg_conv.inner = (void*)(this_arg & (~1));
+       this_arg_conv.is_owned = false;
+       LDKChannelMessageHandler* ret = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
+       *ret = ErroringMessageHandler_as_ChannelMessageHandler(&this_arg_conv);
+       return (long)ret;
+}
+
 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_MessageHandler_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
        LDKMessageHandler this_ptr_conv;
        this_ptr_conv.inner = (void*)(this_ptr & (~1));
@@ -18913,39 +18953,6 @@ JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RouteHint_1set_1cltv_1expiry_1
        RouteHint_set_cltv_expiry_delta(&this_ptr_conv, val);
 }
 
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHint_1get_1htlc_1minimum_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
-       LDKRouteHint this_ptr_conv;
-       this_ptr_conv.inner = (void*)(this_ptr & (~1));
-       this_ptr_conv.is_owned = false;
-       int64_t ret_val = RouteHint_get_htlc_minimum_msat(&this_ptr_conv);
-       return ret_val;
-}
-
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RouteHint_1set_1htlc_1minimum_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
-       LDKRouteHint this_ptr_conv;
-       this_ptr_conv.inner = (void*)(this_ptr & (~1));
-       this_ptr_conv.is_owned = false;
-       RouteHint_set_htlc_minimum_msat(&this_ptr_conv, val);
-}
-
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHint_1new(JNIEnv *env, jclass clz, int8_tArray src_node_id_arg, int64_t short_channel_id_arg, int64_t fees_arg, int16_t cltv_expiry_delta_arg, int64_t htlc_minimum_msat_arg) {
-       LDKPublicKey src_node_id_arg_ref;
-       CHECK((*env)->GetArrayLength(env, src_node_id_arg) == 33);
-       (*env)->GetByteArrayRegion(env, src_node_id_arg, 0, 33, src_node_id_arg_ref.compressed_form);
-       LDKRoutingFees fees_arg_conv;
-       fees_arg_conv.inner = (void*)(fees_arg & (~1));
-       fees_arg_conv.is_owned = (fees_arg & 1) || (fees_arg == 0);
-       fees_arg_conv = RoutingFees_clone(&fees_arg_conv);
-       LDKRouteHint ret_var = RouteHint_new(src_node_id_arg_ref, short_channel_id_arg, fees_arg_conv, cltv_expiry_delta_arg, htlc_minimum_msat_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;
-       if (ret_var.is_owned) {
-               ret_ref |= 1;
-       }
-       return ret_ref;
-}
-
 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHint_1clone(JNIEnv *env, jclass clz, int64_t orig) {
        LDKRouteHint orig_conv;
        orig_conv.inner = (void*)(orig & (~1));
@@ -18960,16 +18967,16 @@ JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHint_1clone(JNIEnv *en
        return ret_ref;
 }
 
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_get_1route(JNIEnv *env, jclass clz, int8_tArray our_node_id, int64_t network, int8_tArray target, int64_tArray first_hops, int64_tArray last_hops, int64_t final_value_msat, int32_t final_cltv, int64_t logger) {
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_get_1route(JNIEnv *env, jclass clz, int8_tArray our_node_id, int64_t network, int8_tArray payee, int64_tArray first_hops, int64_tArray last_hops, int64_t final_value_msat, int32_t final_cltv, int64_t logger) {
        LDKPublicKey our_node_id_ref;
        CHECK((*env)->GetArrayLength(env, our_node_id) == 33);
        (*env)->GetByteArrayRegion(env, our_node_id, 0, 33, our_node_id_ref.compressed_form);
        LDKNetworkGraph network_conv;
        network_conv.inner = (void*)(network & (~1));
        network_conv.is_owned = false;
-       LDKPublicKey target_ref;
-       CHECK((*env)->GetArrayLength(env, target) == 33);
-       (*env)->GetByteArrayRegion(env, target, 0, 33, target_ref.compressed_form);
+       LDKPublicKey payee_ref;
+       CHECK((*env)->GetArrayLength(env, payee) == 33);
+       (*env)->GetByteArrayRegion(env, payee, 0, 33, payee_ref.compressed_form);
        LDKCVec_ChannelDetailsZ first_hops_constr;
        first_hops_constr.datalen = (*env)->GetArrayLength(env, first_hops);
        if (first_hops_constr.datalen > 0)
@@ -19007,7 +19014,7 @@ JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_get_1route(JNIEnv *env, jcl
                LDKLogger_JCalls_clone(logger_conv.this_arg);
        }
        LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
-       *ret_conv = get_route(our_node_id_ref, &network_conv, target_ref, &first_hops_constr, last_hops_constr, final_value_msat, final_cltv, logger_conv);
+       *ret_conv = get_route(our_node_id_ref, &network_conv, payee_ref, &first_hops_constr, last_hops_constr, final_value_msat, final_cltv, logger_conv);
        FREE(first_hops_constr.data);
        return (long)ret_conv;
 }
@@ -19088,6 +19095,14 @@ JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetGraphMsgHandler_1from_1n
        return ret_ref;
 }
 
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NetGraphMsgHandler_1add_1chain_1access(JNIEnv *env, jclass clz, int64_t this_arg, int64_t chain_access) {
+       LDKNetGraphMsgHandler this_arg_conv;
+       this_arg_conv.inner = (void*)(this_arg & (~1));
+       this_arg_conv.is_owned = false;
+       LDKAccess* chain_access_conv = (LDKAccess*)chain_access;
+       NetGraphMsgHandler_add_chain_access(&this_arg_conv, chain_access_conv);
+}
+
 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetGraphMsgHandler_1read_1locked_1graph(JNIEnv *env, jclass clz, int64_t this_arg) {
        LDKNetGraphMsgHandler this_arg_conv;
        this_arg_conv.inner = (void*)(this_arg & (~1));
index d4b2b7525fe926a5ffb39cf1edc5818fde9aba79..623d4a4ae4f12718c2585f0791d434bd3f9d4300 100644 (file)
@@ -433,300 +433,300 @@ JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1SignatureZNo
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKCResult_CVec_u8ZPeerHandleErrorZ_result_ok
- * Signature: (J)Z
+ * Method:    LDKErrorAction_ref_from_ptr
+ * Signature: (J)Lorg/ldk/impl/bindings/LDKErrorAction;
  */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1u8ZPeerHandleErrorZ_1result_1ok
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKErrorAction_1ref_1from_1ptr
   (JNIEnv *, jclass, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKCResult_CVec_u8ZPeerHandleErrorZ_get_ok
- * Signature: (J)[B
+ * Method:    LDKHTLCFailChannelUpdate_ref_from_ptr
+ * Signature: (J)Lorg/ldk/impl/bindings/LDKHTLCFailChannelUpdate;
  */
-JNIEXPORT jbyteArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1u8ZPeerHandleErrorZ_1get_1ok
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKHTLCFailChannelUpdate_1ref_1from_1ptr
   (JNIEnv *, jclass, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKCResult_CVec_u8ZPeerHandleErrorZ_get_err
- * Signature: (J)J
+ * Method:    LDKMessageSendEvent_ref_from_ptr
+ * Signature: (J)Lorg/ldk/impl/bindings/LDKMessageSendEvent;
  */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1u8ZPeerHandleErrorZ_1get_1err
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKMessageSendEvent_1ref_1from_1ptr
   (JNIEnv *, jclass, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKCResult_NonePeerHandleErrorZ_result_ok
+ * Method:    LDKCVec_MessageSendEventZ_new
+ * Signature: ([J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1MessageSendEventZ_1new
+  (JNIEnv *, jclass, jlongArray);
+
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    LDKCResult_boolLightningErrorZ_result_ok
  * Signature: (J)Z
  */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePeerHandleErrorZ_1result_1ok
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolLightningErrorZ_1result_1ok
   (JNIEnv *, jclass, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKCResult_NonePeerHandleErrorZ_get_ok
- * Signature: (J)V
+ * Method:    LDKCResult_boolLightningErrorZ_get_ok
+ * Signature: (J)Z
  */
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePeerHandleErrorZ_1get_1ok
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolLightningErrorZ_1get_1ok
   (JNIEnv *, jclass, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKCResult_NonePeerHandleErrorZ_get_err
+ * Method:    LDKCResult_boolLightningErrorZ_get_err
  * Signature: (J)J
  */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePeerHandleErrorZ_1get_1err
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolLightningErrorZ_1get_1err
   (JNIEnv *, jclass, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKCResult_boolPeerHandleErrorZ_result_ok
- * Signature: (J)Z
+ * Method:    LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new
+ * Signature: (JJJ)J
  */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolPeerHandleErrorZ_1result_1ok
-  (JNIEnv *, jclass, jlong);
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKC3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1new
+  (JNIEnv *, jclass, jlong, jlong, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKCResult_boolPeerHandleErrorZ_get_ok
- * Signature: (J)Z
+ * Method:    LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a
+ * Signature: (J)J
  */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolPeerHandleErrorZ_1get_1ok
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKC3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1get_1a
   (JNIEnv *, jclass, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKCResult_boolPeerHandleErrorZ_get_err
+ * Method:    LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b
  * Signature: (J)J
  */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolPeerHandleErrorZ_1get_1err
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKC3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1get_1b
   (JNIEnv *, jclass, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKCResult_InitFeaturesDecodeErrorZ_result_ok
- * Signature: (J)Z
+ * Method:    LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c
+ * Signature: (J)J
  */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitFeaturesDecodeErrorZ_1result_1ok
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKC3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1get_1c
   (JNIEnv *, jclass, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKCResult_InitFeaturesDecodeErrorZ_get_ok
- * Signature: (J)J
+ * Method:    LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_new
+ * Signature: ([J)J
  */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitFeaturesDecodeErrorZ_1get_1ok
-  (JNIEnv *, jclass, jlong);
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZZ_1new
+  (JNIEnv *, jclass, jlongArray);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKCResult_InitFeaturesDecodeErrorZ_get_err
- * Signature: (J)J
+ * Method:    LDKCVec_NodeAnnouncementZ_new
+ * Signature: ([J)J
  */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitFeaturesDecodeErrorZ_1get_1err
-  (JNIEnv *, jclass, jlong);
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1NodeAnnouncementZ_1new
+  (JNIEnv *, jclass, jlongArray);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKCResult_NodeFeaturesDecodeErrorZ_result_ok
+ * Method:    LDKCResult_NoneLightningErrorZ_result_ok
  * Signature: (J)Z
  */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeFeaturesDecodeErrorZ_1result_1ok
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneLightningErrorZ_1result_1ok
   (JNIEnv *, jclass, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKCResult_NodeFeaturesDecodeErrorZ_get_ok
- * Signature: (J)J
+ * Method:    LDKCResult_NoneLightningErrorZ_get_ok
+ * Signature: (J)V
  */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeFeaturesDecodeErrorZ_1get_1ok
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneLightningErrorZ_1get_1ok
   (JNIEnv *, jclass, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKCResult_NodeFeaturesDecodeErrorZ_get_err
+ * Method:    LDKCResult_NoneLightningErrorZ_get_err
  * Signature: (J)J
  */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeFeaturesDecodeErrorZ_1get_1err
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneLightningErrorZ_1get_1err
   (JNIEnv *, jclass, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKCResult_ChannelFeaturesDecodeErrorZ_result_ok
+ * Method:    LDKCResult_CVec_u8ZPeerHandleErrorZ_result_ok
  * Signature: (J)Z
  */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelFeaturesDecodeErrorZ_1result_1ok
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1u8ZPeerHandleErrorZ_1result_1ok
   (JNIEnv *, jclass, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKCResult_ChannelFeaturesDecodeErrorZ_get_ok
- * Signature: (J)J
+ * Method:    LDKCResult_CVec_u8ZPeerHandleErrorZ_get_ok
+ * Signature: (J)[B
  */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelFeaturesDecodeErrorZ_1get_1ok
+JNIEXPORT jbyteArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1u8ZPeerHandleErrorZ_1get_1ok
   (JNIEnv *, jclass, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKCResult_ChannelFeaturesDecodeErrorZ_get_err
+ * Method:    LDKCResult_CVec_u8ZPeerHandleErrorZ_get_err
  * Signature: (J)J
  */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelFeaturesDecodeErrorZ_1get_1err
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1u8ZPeerHandleErrorZ_1get_1err
   (JNIEnv *, jclass, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKCResult_ChannelConfigDecodeErrorZ_result_ok
+ * Method:    LDKCResult_NonePeerHandleErrorZ_result_ok
  * Signature: (J)Z
  */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelConfigDecodeErrorZ_1result_1ok
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePeerHandleErrorZ_1result_1ok
   (JNIEnv *, jclass, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKCResult_ChannelConfigDecodeErrorZ_get_ok
- * Signature: (J)J
+ * Method:    LDKCResult_NonePeerHandleErrorZ_get_ok
+ * Signature: (J)V
  */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelConfigDecodeErrorZ_1get_1ok
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePeerHandleErrorZ_1get_1ok
   (JNIEnv *, jclass, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKCResult_ChannelConfigDecodeErrorZ_get_err
+ * Method:    LDKCResult_NonePeerHandleErrorZ_get_err
  * Signature: (J)J
  */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelConfigDecodeErrorZ_1get_1err
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePeerHandleErrorZ_1get_1err
   (JNIEnv *, jclass, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKCResult_boolLightningErrorZ_result_ok
+ * Method:    LDKCResult_boolPeerHandleErrorZ_result_ok
  * Signature: (J)Z
  */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolLightningErrorZ_1result_1ok
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolPeerHandleErrorZ_1result_1ok
   (JNIEnv *, jclass, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKCResult_boolLightningErrorZ_get_ok
+ * Method:    LDKCResult_boolPeerHandleErrorZ_get_ok
  * Signature: (J)Z
  */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolLightningErrorZ_1get_1ok
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolPeerHandleErrorZ_1get_1ok
   (JNIEnv *, jclass, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKCResult_boolLightningErrorZ_get_err
+ * Method:    LDKCResult_boolPeerHandleErrorZ_get_err
  * Signature: (J)J
  */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolLightningErrorZ_1get_1err
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolPeerHandleErrorZ_1get_1err
   (JNIEnv *, jclass, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new
- * Signature: (JJJ)J
+ * Method:    LDKCResult_InitFeaturesDecodeErrorZ_result_ok
+ * Signature: (J)Z
  */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKC3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1new
-  (JNIEnv *, jclass, jlong, jlong, jlong);
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitFeaturesDecodeErrorZ_1result_1ok
+  (JNIEnv *, jclass, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a
+ * Method:    LDKCResult_InitFeaturesDecodeErrorZ_get_ok
  * Signature: (J)J
  */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKC3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1get_1a
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitFeaturesDecodeErrorZ_1get_1ok
   (JNIEnv *, jclass, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b
+ * Method:    LDKCResult_InitFeaturesDecodeErrorZ_get_err
  * Signature: (J)J
  */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKC3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1get_1b
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitFeaturesDecodeErrorZ_1get_1err
   (JNIEnv *, jclass, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c
- * Signature: (J)J
+ * Method:    LDKCResult_NodeFeaturesDecodeErrorZ_result_ok
+ * Signature: (J)Z
  */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKC3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1get_1c
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeFeaturesDecodeErrorZ_1result_1ok
   (JNIEnv *, jclass, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_new
- * Signature: ([J)J
+ * Method:    LDKCResult_NodeFeaturesDecodeErrorZ_get_ok
+ * Signature: (J)J
  */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZZ_1new
-  (JNIEnv *, jclass, jlongArray);
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeFeaturesDecodeErrorZ_1get_1ok
+  (JNIEnv *, jclass, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKCVec_NodeAnnouncementZ_new
- * Signature: ([J)J
+ * Method:    LDKCResult_NodeFeaturesDecodeErrorZ_get_err
+ * Signature: (J)J
  */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1NodeAnnouncementZ_1new
-  (JNIEnv *, jclass, jlongArray);
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeFeaturesDecodeErrorZ_1get_1err
+  (JNIEnv *, jclass, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKCResult_NoneLightningErrorZ_result_ok
+ * Method:    LDKCResult_ChannelFeaturesDecodeErrorZ_result_ok
  * Signature: (J)Z
  */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneLightningErrorZ_1result_1ok
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelFeaturesDecodeErrorZ_1result_1ok
   (JNIEnv *, jclass, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKCResult_NoneLightningErrorZ_get_ok
- * Signature: (J)V
+ * Method:    LDKCResult_ChannelFeaturesDecodeErrorZ_get_ok
+ * Signature: (J)J
  */
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneLightningErrorZ_1get_1ok
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelFeaturesDecodeErrorZ_1get_1ok
   (JNIEnv *, jclass, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKCResult_NoneLightningErrorZ_get_err
+ * Method:    LDKCResult_ChannelFeaturesDecodeErrorZ_get_err
  * Signature: (J)J
  */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneLightningErrorZ_1get_1err
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelFeaturesDecodeErrorZ_1get_1err
   (JNIEnv *, jclass, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKErrorAction_ref_from_ptr
- * Signature: (J)Lorg/ldk/impl/bindings/LDKErrorAction;
+ * Method:    LDKCResult_ChannelConfigDecodeErrorZ_result_ok
+ * Signature: (J)Z
  */
-JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKErrorAction_1ref_1from_1ptr
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelConfigDecodeErrorZ_1result_1ok
   (JNIEnv *, jclass, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKHTLCFailChannelUpdate_ref_from_ptr
- * Signature: (J)Lorg/ldk/impl/bindings/LDKHTLCFailChannelUpdate;
+ * Method:    LDKCResult_ChannelConfigDecodeErrorZ_get_ok
+ * Signature: (J)J
  */
-JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKHTLCFailChannelUpdate_1ref_1from_1ptr
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelConfigDecodeErrorZ_1get_1ok
   (JNIEnv *, jclass, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    LDKMessageSendEvent_ref_from_ptr
- * Signature: (J)Lorg/ldk/impl/bindings/LDKMessageSendEvent;
+ * Method:    LDKCResult_ChannelConfigDecodeErrorZ_get_err
+ * Signature: (J)J
  */
-JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKMessageSendEvent_1ref_1from_1ptr
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelConfigDecodeErrorZ_1get_1err
   (JNIEnv *, jclass, jlong);
 
-/*
- * Class:     org_ldk_impl_bindings
- * Method:    LDKCVec_MessageSendEventZ_new
- * Signature: ([J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1MessageSendEventZ_1new
-  (JNIEnv *, jclass, jlongArray);
-
 /*
  * Class:     org_ldk_impl_bindings
  * Method:    LDKCResult_DirectionalChannelInfoDecodeErrorZ_result_ok
@@ -3513,34 +3513,146 @@ JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1TrustedCommitmentTran
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    CResult_CVec_SignatureZNoneZ_ok
- * Signature: ([[B)J
+ * Method:    CResult_CVec_SignatureZNoneZ_ok
+ * Signature: ([[B)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1ok
+  (JNIEnv *, jclass, jobjectArray);
+
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    CResult_CVec_SignatureZNoneZ_err
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1err
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    CResult_CVec_SignatureZNoneZ_free
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1free
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    CResult_CVec_SignatureZNoneZ_clone
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1clone
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    CVec_MessageSendEventZ_free
+ * Signature: ([J)V
+ */
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1MessageSendEventZ_1free
+  (JNIEnv *, jclass, jlongArray);
+
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    CResult_boolLightningErrorZ_ok
+ * Signature: (Z)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1ok
+  (JNIEnv *, jclass, jboolean);
+
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    CResult_boolLightningErrorZ_err
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1err
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    CResult_boolLightningErrorZ_free
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1free
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    CResult_boolLightningErrorZ_clone
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1clone
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1clone
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new
+ * Signature: (JJJ)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1new
+  (JNIEnv *, jclass, jlong, jlong, jlong);
+
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1free
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free
+ * Signature: ([J)V
+ */
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZZ_1free
+  (JNIEnv *, jclass, jlongArray);
+
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    CVec_NodeAnnouncementZ_free
+ * Signature: ([J)V
  */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1ok
-  (JNIEnv *, jclass, jobjectArray);
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1NodeAnnouncementZ_1free
+  (JNIEnv *, jclass, jlongArray);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    CResult_CVec_SignatureZNoneZ_err
+ * Method:    CResult_NoneLightningErrorZ_ok
  * Signature: ()J
  */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1err
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1ok
   (JNIEnv *, jclass);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    CResult_CVec_SignatureZNoneZ_free
+ * Method:    CResult_NoneLightningErrorZ_err
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1err
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    CResult_NoneLightningErrorZ_free
  * Signature: (J)V
  */
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1free
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1free
   (JNIEnv *, jclass, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
- * Method:    CResult_CVec_SignatureZNoneZ_clone
+ * Method:    CResult_NoneLightningErrorZ_clone
  * Signature: (J)J
  */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1clone
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1clone
   (JNIEnv *, jclass, jlong);
 
 /*
@@ -3759,118 +3871,6 @@ JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelConfigDecodeEr
 JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelConfigDecodeErrorZ_1clone
   (JNIEnv *, jclass, jlong);
 
-/*
- * Class:     org_ldk_impl_bindings
- * Method:    CResult_boolLightningErrorZ_ok
- * Signature: (Z)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1ok
-  (JNIEnv *, jclass, jboolean);
-
-/*
- * Class:     org_ldk_impl_bindings
- * Method:    CResult_boolLightningErrorZ_err
- * Signature: (J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1err
-  (JNIEnv *, jclass, jlong);
-
-/*
- * Class:     org_ldk_impl_bindings
- * Method:    CResult_boolLightningErrorZ_free
- * Signature: (J)V
- */
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1free
-  (JNIEnv *, jclass, jlong);
-
-/*
- * Class:     org_ldk_impl_bindings
- * Method:    CResult_boolLightningErrorZ_clone
- * Signature: (J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1clone
-  (JNIEnv *, jclass, jlong);
-
-/*
- * Class:     org_ldk_impl_bindings
- * Method:    C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone
- * Signature: (J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1clone
-  (JNIEnv *, jclass, jlong);
-
-/*
- * Class:     org_ldk_impl_bindings
- * Method:    C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new
- * Signature: (JJJ)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1new
-  (JNIEnv *, jclass, jlong, jlong, jlong);
-
-/*
- * Class:     org_ldk_impl_bindings
- * Method:    C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free
- * Signature: (J)V
- */
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1free
-  (JNIEnv *, jclass, jlong);
-
-/*
- * Class:     org_ldk_impl_bindings
- * Method:    CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free
- * Signature: ([J)V
- */
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZZ_1free
-  (JNIEnv *, jclass, jlongArray);
-
-/*
- * Class:     org_ldk_impl_bindings
- * Method:    CVec_NodeAnnouncementZ_free
- * Signature: ([J)V
- */
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1NodeAnnouncementZ_1free
-  (JNIEnv *, jclass, jlongArray);
-
-/*
- * Class:     org_ldk_impl_bindings
- * Method:    CResult_NoneLightningErrorZ_ok
- * Signature: ()J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1ok
-  (JNIEnv *, jclass);
-
-/*
- * Class:     org_ldk_impl_bindings
- * Method:    CResult_NoneLightningErrorZ_err
- * Signature: (J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1err
-  (JNIEnv *, jclass, jlong);
-
-/*
- * Class:     org_ldk_impl_bindings
- * Method:    CResult_NoneLightningErrorZ_free
- * Signature: (J)V
- */
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1free
-  (JNIEnv *, jclass, jlong);
-
-/*
- * Class:     org_ldk_impl_bindings
- * Method:    CResult_NoneLightningErrorZ_clone
- * Signature: (J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1clone
-  (JNIEnv *, jclass, jlong);
-
-/*
- * Class:     org_ldk_impl_bindings
- * Method:    CVec_MessageSendEventZ_free
- * Signature: ([J)V
- */
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1MessageSendEventZ_1free
-  (JNIEnv *, jclass, jlongArray);
-
 /*
  * Class:     org_ldk_impl_bindings
  * Method:    CResult_DirectionalChannelInfoDecodeErrorZ_ok
@@ -7495,6 +7495,70 @@ JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_KeysManager_1as_1KeysInterfac
 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelManager_1free
   (JNIEnv *, jclass, jlong);
 
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    ChainParameters_free
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChainParameters_1free
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    ChainParameters_get_network
+ * Signature: (J)Lorg/ldk/enums/LDKNetwork;
+ */
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_ChainParameters_1get_1network
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    ChainParameters_set_network
+ * Signature: (JLorg/ldk/enums/LDKNetwork;)V
+ */
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChainParameters_1set_1network
+  (JNIEnv *, jclass, jlong, jobject);
+
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    ChainParameters_get_latest_hash
+ * Signature: (J)[B
+ */
+JNIEXPORT jbyteArray JNICALL Java_org_ldk_impl_bindings_ChainParameters_1get_1latest_1hash
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    ChainParameters_set_latest_hash
+ * Signature: (J[B)V
+ */
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChainParameters_1set_1latest_1hash
+  (JNIEnv *, jclass, jlong, jbyteArray);
+
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    ChainParameters_get_latest_height
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ChainParameters_1get_1latest_1height
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    ChainParameters_set_latest_height
+ * Signature: (JJ)V
+ */
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChainParameters_1set_1latest_1height
+  (JNIEnv *, jclass, jlong, jlong);
+
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    ChainParameters_new
+ * Signature: (Lorg/ldk/enums/LDKNetwork;[BJ)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ChainParameters_1new
+  (JNIEnv *, jclass, jobject, jbyteArray, jlong);
+
 /*
  * Class:     org_ldk_impl_bindings
  * Method:    ChannelDetails_free
@@ -7658,10 +7722,10 @@ JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_PaymentSendFailure_1clone
 /*
  * Class:     org_ldk_impl_bindings
  * Method:    ChannelManager_new
- * Signature: (Lorg/ldk/enums/LDKNetwork;JJJJJJJ)J
+ * Signature: (JJJJJJJ)J
  */
 JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ChannelManager_1new
-  (JNIEnv *, jclass, jobject, jlong, jlong, jlong, jlong, jlong, jlong, jlong);
+  (JNIEnv *, jclass, jlong, jlong, jlong, jlong, jlong, jlong, jlong);
 
 /*
  * Class:     org_ldk_impl_bindings
@@ -11383,6 +11447,70 @@ JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_GossipTimestampFilter_1read
 JNIEXPORT jbyteArray JNICALL Java_org_ldk_impl_bindings_GossipTimestampFilter_1write
   (JNIEnv *, jclass, jlong);
 
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    IgnoringMessageHandler_free
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_IgnoringMessageHandler_1free
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    IgnoringMessageHandler_new
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_IgnoringMessageHandler_1new
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    IgnoringMessageHandler_as_MessageSendEventsProvider
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_IgnoringMessageHandler_1as_1MessageSendEventsProvider
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    IgnoringMessageHandler_as_RoutingMessageHandler
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_IgnoringMessageHandler_1as_1RoutingMessageHandler
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    ErroringMessageHandler_free
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ErroringMessageHandler_1free
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    ErroringMessageHandler_new
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ErroringMessageHandler_1new
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    ErroringMessageHandler_as_MessageSendEventsProvider
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ErroringMessageHandler_1as_1MessageSendEventsProvider
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    ErroringMessageHandler_as_ChannelMessageHandler
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ErroringMessageHandler_1as_1ChannelMessageHandler
+  (JNIEnv *, jclass, jlong);
+
 /*
  * Class:     org_ldk_impl_bindings
  * Method:    MessageHandler_free
@@ -12927,30 +13055,6 @@ JNIEXPORT jshort JNICALL Java_org_ldk_impl_bindings_RouteHint_1get_1cltv_1expiry
 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RouteHint_1set_1cltv_1expiry_1delta
   (JNIEnv *, jclass, jlong, jshort);
 
-/*
- * Class:     org_ldk_impl_bindings
- * Method:    RouteHint_get_htlc_minimum_msat
- * Signature: (J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_RouteHint_1get_1htlc_1minimum_1msat
-  (JNIEnv *, jclass, jlong);
-
-/*
- * Class:     org_ldk_impl_bindings
- * Method:    RouteHint_set_htlc_minimum_msat
- * Signature: (JJ)V
- */
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RouteHint_1set_1htlc_1minimum_1msat
-  (JNIEnv *, jclass, jlong, jlong);
-
-/*
- * Class:     org_ldk_impl_bindings
- * Method:    RouteHint_new
- * Signature: ([BJJSJ)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_RouteHint_1new
-  (JNIEnv *, jclass, jbyteArray, jlong, jlong, jshort, jlong);
-
 /*
  * Class:     org_ldk_impl_bindings
  * Method:    RouteHint_clone
@@ -13015,6 +13119,14 @@ JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_NetGraphMsgHandler_1new
 JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_NetGraphMsgHandler_1from_1net_1graph
   (JNIEnv *, jclass, jlong, jlong, jlong);
 
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    NetGraphMsgHandler_add_chain_access
+ * Signature: (JJ)V
+ */
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NetGraphMsgHandler_1add_1chain_1access
+  (JNIEnv *, jclass, jlong, jlong);
+
 /*
  * Class:     org_ldk_impl_bindings
  * Method:    NetGraphMsgHandler_read_locked_graph
index fc4a25bb73c9c271886618cbdab0560ec8eca87e..6a6178c5589805e0271bc9b38354f173ef2f3693 100644 (file)
@@ -13,93 +13,13 @@ static inline void assert(bool expression) {
        if (!expression) { abort(); }
 }
 
-// Always run a, then assert it is true:
-#define DO_ASSERT(a) do { bool _assert_val = (a); assert(_assert_val); } while(0)
-// Assert a is true or do nothing
-#define CHECK(a) DO_ASSERT(a)
-
-// Running a leak check across all the allocations and frees of the JDK is a mess,
-// so instead we implement our own naive leak checker here, relying on the -wrap
-// linker option to wrap malloc/calloc/realloc/free, tracking everyhing allocated
-// and free'd in Rust or C across the generated bindings shared library.
-
-#define BT_MAX 128
-typedef struct allocation {
-       struct allocation* next;
-       void* ptr;
-       const char* struct_name;
-} allocation;
-static allocation* allocation_ll = NULL;
-
-void* __real_malloc(size_t len);
-void* __real_calloc(size_t nmemb, size_t len);
-static void new_allocation(void* res, const char* struct_name) {
-       allocation* new_alloc = __real_malloc(sizeof(allocation));
-       new_alloc->ptr = res;
-       new_alloc->struct_name = struct_name;
-       new_alloc->next = allocation_ll;
-       allocation_ll = new_alloc;
-}
-static void* MALLOC(size_t len, const char* struct_name) {
-       void* res = __real_malloc(len);
-       new_allocation(res, struct_name);
-       return res;
-}
-void __real_free(void* ptr);
-static void alloc_freed(void* ptr) {
-       allocation* p = NULL;
-       allocation* it = allocation_ll;
-       while (it->ptr != ptr) {
-               p = it; it = it->next;
-               if (it == NULL) {
-                       //XXX: fprintf(stderr, "Tried to free unknown pointer %p\n", ptr);
-                       return; // addrsan should catch malloc-unknown and print more info than we have
-               }
-       }
-       if (p) { p->next = it->next; } else { allocation_ll = it->next; }
-       DO_ASSERT(it->ptr == ptr);
-       __real_free(it);
-}
-static void FREE(void* ptr) {
-       if ((long)ptr < 1024) return; // Rust loves to create pointers to the NULL page for dummys
-       alloc_freed(ptr);
-       __real_free(ptr);
-}
-
-void* __wrap_malloc(size_t len) {
-       void* res = __real_malloc(len);
-       new_allocation(res, "malloc call");
-       return res;
-}
-void* __wrap_calloc(size_t nmemb, size_t len) {
-       void* res = __real_calloc(nmemb, len);
-       new_allocation(res, "calloc call");
-       return res;
-}
-void __wrap_free(void* ptr) {
-       if (ptr == NULL) return;
-       alloc_freed(ptr);
-       __real_free(ptr);
-}
+void *malloc(size_t size);
+void free(void *ptr);
 
-void* __real_realloc(void* ptr, size_t newlen);
-void* __wrap_realloc(void* ptr, size_t len) {
-       if (ptr != NULL) alloc_freed(ptr);
-       void* res = __real_realloc(ptr, len);
-       new_allocation(res, "realloc call");
-       return res;
-}
-void __wrap_reallocarray(void* ptr, size_t new_sz) {
-       // Rust doesn't seem to use reallocarray currently
-       DO_ASSERT(false);
-}
-
-void __attribute__((destructor)) check_leaks() {
-       for (allocation* a = allocation_ll; a != NULL; a = a->next) {
-               //XXX: fprintf(stderr, "%s %p remains\n", a->struct_name, a->ptr);
-       }
-       DO_ASSERT(allocation_ll == NULL);
-}
+#define MALLOC(a, _) malloc(a)
+#define FREE(p) if ((long)(p) > 1024) { free(p); }
+#define DO_ASSERT(a) (void)(a)
+#define CHECK(a)
 
 // We assume that CVec_u8Z and u8slice are the same size and layout (and thus pointers to the two can be mixed)
 _Static_assert(sizeof(LDKCVec_u8Z) == sizeof(LDKu8slice), "Vec<u8> and [u8] need to have been mapped identically");
@@ -207,6 +127,7 @@ static inline LDKNetwork LDKNetwork_from_js(int32_t ord) {
                case 0: return LDKNetwork_Bitcoin;
                case 1: return LDKNetwork_Testnet;
                case 2: return LDKNetwork_Regtest;
+               case 3: return LDKNetwork_Signet;
        }
        abort();
 }
@@ -215,6 +136,7 @@ static inline int32_t LDKNetwork_to_js(LDKNetwork val) {
                case LDKNetwork_Bitcoin: return 0;
                case LDKNetwork_Testnet: return 1;
                case LDKNetwork_Regtest: return 2;
+               case LDKNetwork_Signet: return 3;
                default: abort();
        }
 }
@@ -521,143 +443,231 @@ void  __attribute__((visibility("default"))) TS_LDKCResult_CVec_SignatureZNoneZ_
        CHECK(!val->result_ok);
        return *val->contents.err;
 }
-jboolean  __attribute__((visibility("default"))) TS_LDKCResult_CVec_u8ZPeerHandleErrorZ_result_ok(uint32_t arg) {
-       return ((LDKCResult_CVec_u8ZPeerHandleErrorZ*)arg)->result_ok;
-}
-int8_tArray  __attribute__((visibility("default"))) TS_LDKCResult_CVec_u8ZPeerHandleErrorZ_get_ok(uint32_t arg) {
-       LDKCResult_CVec_u8ZPeerHandleErrorZ *val = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(arg & ~1);
-       CHECK(val->result_ok);
-       LDKCVec_u8Z res_var = (*val->contents.result);
-       int8_tArray res_arr = init_arr(res_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
-       memcpy((uint8_t*)(res_arr + 4), res_var.data, res_var.datalen);
-       return res_arr;
+uint32_t __attribute__((visibility("default"))) TS_LDKErrorAction_ref_from_ptr(uint32_t ptr) {
+       LDKErrorAction *obj = (LDKErrorAction*)ptr;
+       switch(obj->tag) {
+               case LDKErrorAction_DisconnectPeer: {
+                       LDKErrorMessage msg_var = obj->disconnect_peer.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 /* LDKErrorAction - DisconnectPeer */; (void) msg_ref;
+               }
+               case LDKErrorAction_IgnoreError: {
+                       return 0 /* LDKErrorAction - IgnoreError */;
+               }
+               case LDKErrorAction_SendErrorMessage: {
+                       LDKErrorMessage msg_var = obj->send_error_message.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 /* LDKErrorAction - SendErrorMessage */; (void) msg_ref;
+               }
+               default: abort();
+       }
 }
-uint32_t  __attribute__((visibility("default"))) TS_LDKCResult_CVec_u8ZPeerHandleErrorZ_get_err(uint32_t arg) {
-       LDKCResult_CVec_u8ZPeerHandleErrorZ *val = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(arg & ~1);
-       CHECK(!val->result_ok);
-       LDKPeerHandleError err_var = (*val->contents.err);
-       CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
-       CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
-       long err_ref = (long)err_var.inner & ~1;
-       return err_ref;
+uint32_t __attribute__((visibility("default"))) TS_LDKHTLCFailChannelUpdate_ref_from_ptr(uint32_t ptr) {
+       LDKHTLCFailChannelUpdate *obj = (LDKHTLCFailChannelUpdate*)ptr;
+       switch(obj->tag) {
+               case LDKHTLCFailChannelUpdate_ChannelUpdateMessage: {
+                       LDKChannelUpdate msg_var = obj->channel_update_message.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 /* LDKHTLCFailChannelUpdate - ChannelUpdateMessage */; (void) msg_ref;
+               }
+               case LDKHTLCFailChannelUpdate_ChannelClosed: {
+                       return 0 /* LDKHTLCFailChannelUpdate - ChannelClosed */; (void) obj->channel_closed.short_channel_id; (void) obj->channel_closed.is_permanent;
+               }
+               case LDKHTLCFailChannelUpdate_NodeFailure: {
+                       int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
+                       memcpy((uint8_t*)(node_id_arr + 4), obj->node_failure.node_id.compressed_form, 33);
+                       return 0 /* LDKHTLCFailChannelUpdate - NodeFailure */; (void) node_id_arr; (void) obj->node_failure.is_permanent;
+               }
+               default: abort();
+       }
 }
-jboolean  __attribute__((visibility("default"))) TS_LDKCResult_NonePeerHandleErrorZ_result_ok(uint32_t arg) {
-       return ((LDKCResult_NonePeerHandleErrorZ*)arg)->result_ok;
+uint32_t __attribute__((visibility("default"))) TS_LDKMessageSendEvent_ref_from_ptr(uint32_t ptr) {
+       LDKMessageSendEvent *obj = (LDKMessageSendEvent*)ptr;
+       switch(obj->tag) {
+               case LDKMessageSendEvent_SendAcceptChannel: {
+                       int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
+                       memcpy((uint8_t*)(node_id_arr + 4), obj->send_accept_channel.node_id.compressed_form, 33);
+                       LDKAcceptChannel msg_var = obj->send_accept_channel.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 - SendAcceptChannel */; (void) node_id_arr; (void) msg_ref;
+               }
+               case LDKMessageSendEvent_SendOpenChannel: {
+                       int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
+                       memcpy((uint8_t*)(node_id_arr + 4), obj->send_open_channel.node_id.compressed_form, 33);
+                       LDKOpenChannel msg_var = obj->send_open_channel.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 - SendOpenChannel */; (void) node_id_arr; (void) msg_ref;
+               }
+               case LDKMessageSendEvent_SendFundingCreated: {
+                       int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
+                       memcpy((uint8_t*)(node_id_arr + 4), obj->send_funding_created.node_id.compressed_form, 33);
+                       LDKFundingCreated msg_var = obj->send_funding_created.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 - SendFundingCreated */; (void) node_id_arr; (void) msg_ref;
+               }
+               case LDKMessageSendEvent_SendFundingSigned: {
+                       int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
+                       memcpy((uint8_t*)(node_id_arr + 4), obj->send_funding_signed.node_id.compressed_form, 33);
+                       LDKFundingSigned msg_var = obj->send_funding_signed.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 - SendFundingSigned */; (void) node_id_arr; (void) msg_ref;
+               }
+               case LDKMessageSendEvent_SendFundingLocked: {
+                       int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
+                       memcpy((uint8_t*)(node_id_arr + 4), obj->send_funding_locked.node_id.compressed_form, 33);
+                       LDKFundingLocked msg_var = obj->send_funding_locked.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 - SendFundingLocked */; (void) node_id_arr; (void) msg_ref;
+               }
+               case LDKMessageSendEvent_SendAnnouncementSignatures: {
+                       int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
+                       memcpy((uint8_t*)(node_id_arr + 4), obj->send_announcement_signatures.node_id.compressed_form, 33);
+                       LDKAnnouncementSignatures msg_var = obj->send_announcement_signatures.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 - SendAnnouncementSignatures */; (void) node_id_arr; (void) msg_ref;
+               }
+               case LDKMessageSendEvent_UpdateHTLCs: {
+                       int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
+                       memcpy((uint8_t*)(node_id_arr + 4), obj->update_htl_cs.node_id.compressed_form, 33);
+                       LDKCommitmentUpdate updates_var = obj->update_htl_cs.updates;
+                       CHECK((((long)updates_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+                       CHECK((((long)&updates_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+                       long updates_ref = (long)updates_var.inner & ~1;
+                       return 0 /* LDKMessageSendEvent - UpdateHTLCs */; (void) node_id_arr; (void) updates_ref;
+               }
+               case LDKMessageSendEvent_SendRevokeAndACK: {
+                       int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
+                       memcpy((uint8_t*)(node_id_arr + 4), obj->send_revoke_and_ack.node_id.compressed_form, 33);
+                       LDKRevokeAndACK msg_var = obj->send_revoke_and_ack.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 - SendRevokeAndACK */; (void) node_id_arr; (void) msg_ref;
+               }
+               case LDKMessageSendEvent_SendClosingSigned: {
+                       int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
+                       memcpy((uint8_t*)(node_id_arr + 4), obj->send_closing_signed.node_id.compressed_form, 33);
+                       LDKClosingSigned msg_var = obj->send_closing_signed.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 - SendClosingSigned */; (void) node_id_arr; (void) msg_ref;
+               }
+               case LDKMessageSendEvent_SendShutdown: {
+                       int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
+                       memcpy((uint8_t*)(node_id_arr + 4), obj->send_shutdown.node_id.compressed_form, 33);
+                       LDKShutdown msg_var = obj->send_shutdown.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 - SendShutdown */; (void) node_id_arr; (void) msg_ref;
+               }
+               case LDKMessageSendEvent_SendChannelReestablish: {
+                       int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
+                       memcpy((uint8_t*)(node_id_arr + 4), obj->send_channel_reestablish.node_id.compressed_form, 33);
+                       LDKChannelReestablish msg_var = obj->send_channel_reestablish.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 - SendChannelReestablish */; (void) node_id_arr; (void) msg_ref;
+               }
+               case LDKMessageSendEvent_BroadcastChannelAnnouncement: {
+                       LDKChannelAnnouncement msg_var = obj->broadcast_channel_announcement.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;
+                       LDKChannelUpdate update_msg_var = obj->broadcast_channel_announcement.update_msg;
+                       CHECK((((long)update_msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+                       CHECK((((long)&update_msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+                       long update_msg_ref = (long)update_msg_var.inner & ~1;
+                       return 0 /* LDKMessageSendEvent - BroadcastChannelAnnouncement */; (void) msg_ref; (void) update_msg_ref;
+               }
+               case LDKMessageSendEvent_BroadcastNodeAnnouncement: {
+                       LDKNodeAnnouncement msg_var = obj->broadcast_node_announcement.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 - BroadcastNodeAnnouncement */; (void) msg_ref;
+               }
+               case LDKMessageSendEvent_BroadcastChannelUpdate: {
+                       LDKChannelUpdate msg_var = obj->broadcast_channel_update.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 - BroadcastChannelUpdate */; (void) msg_ref;
+               }
+               case LDKMessageSendEvent_HandleError: {
+                       int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
+                       memcpy((uint8_t*)(node_id_arr + 4), obj->handle_error.node_id.compressed_form, 33);
+                       long action_ref = ((long)&obj->handle_error.action) | 1;
+                       return 0 /* LDKMessageSendEvent - HandleError */; (void) node_id_arr; (void) action_ref;
+               }
+               case LDKMessageSendEvent_PaymentFailureNetworkUpdate: {
+                       long update_ref = ((long)&obj->payment_failure_network_update.update) | 1;
+                       return 0 /* LDKMessageSendEvent - PaymentFailureNetworkUpdate */; (void) update_ref;
+               }
+               case LDKMessageSendEvent_SendChannelRangeQuery: {
+                       int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
+                       memcpy((uint8_t*)(node_id_arr + 4), obj->send_channel_range_query.node_id.compressed_form, 33);
+                       LDKQueryChannelRange msg_var = obj->send_channel_range_query.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 - SendChannelRangeQuery */; (void) node_id_arr; (void) msg_ref;
+               }
+               case LDKMessageSendEvent_SendShortIdsQuery: {
+                       int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
+                       memcpy((uint8_t*)(node_id_arr + 4), obj->send_short_ids_query.node_id.compressed_form, 33);
+                       LDKQueryShortChannelIds msg_var = obj->send_short_ids_query.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 - SendShortIdsQuery */; (void) node_id_arr; (void) msg_ref;
+               }
+               default: abort();
+       }
 }
-void  __attribute__((visibility("default"))) TS_LDKCResult_NonePeerHandleErrorZ_get_ok(uint32_t arg) {
-       LDKCResult_NonePeerHandleErrorZ *val = (LDKCResult_NonePeerHandleErrorZ*)(arg & ~1);
-       CHECK(val->result_ok);
-       return *val->contents.result;
+uint32_t  __attribute__((visibility("default"))) TS_LDKCVec_MessageSendEventZ_new(uint32_tArray elems) {
+       LDKCVec_MessageSendEventZ *ret = MALLOC(sizeof(LDKCVec_MessageSendEventZ), "LDKCVec_MessageSendEventZ");
+       ret->datalen = *((uint32_t*)elems);
+       if (ret->datalen == 0) {
+               ret->data = NULL;
+       } else {
+               ret->data = MALLOC(sizeof(LDKMessageSendEvent) * ret->datalen, "LDKCVec_MessageSendEventZ Data");
+               uint32_t *java_elems = (uint32_t*)(elems + 4);
+               for (size_t i = 0; i < ret->datalen; i++) {
+                       uint32_t arr_elem = java_elems[i];
+                       LDKMessageSendEvent arr_elem_conv = *(LDKMessageSendEvent*)(((uint64_t)arr_elem) & ~1);
+                       FREE((void*)arr_elem);
+                       ret->data[i] = arr_elem_conv;
+               }
+       }
+       return (long)ret;
 }
-uint32_t  __attribute__((visibility("default"))) TS_LDKCResult_NonePeerHandleErrorZ_get_err(uint32_t arg) {
-       LDKCResult_NonePeerHandleErrorZ *val = (LDKCResult_NonePeerHandleErrorZ*)(arg & ~1);
-       CHECK(!val->result_ok);
-       LDKPeerHandleError err_var = (*val->contents.err);
-       CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
-       CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
-       long err_ref = (long)err_var.inner & ~1;
-       return err_ref;
-}
-jboolean  __attribute__((visibility("default"))) TS_LDKCResult_boolPeerHandleErrorZ_result_ok(uint32_t arg) {
-       return ((LDKCResult_boolPeerHandleErrorZ*)arg)->result_ok;
-}
-jboolean  __attribute__((visibility("default"))) TS_LDKCResult_boolPeerHandleErrorZ_get_ok(uint32_t arg) {
-       LDKCResult_boolPeerHandleErrorZ *val = (LDKCResult_boolPeerHandleErrorZ*)(arg & ~1);
-       CHECK(val->result_ok);
-       return *val->contents.result;
-}
-uint32_t  __attribute__((visibility("default"))) TS_LDKCResult_boolPeerHandleErrorZ_get_err(uint32_t arg) {
-       LDKCResult_boolPeerHandleErrorZ *val = (LDKCResult_boolPeerHandleErrorZ*)(arg & ~1);
-       CHECK(!val->result_ok);
-       LDKPeerHandleError err_var = (*val->contents.err);
-       CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
-       CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
-       long err_ref = (long)err_var.inner & ~1;
-       return err_ref;
-}
-jboolean  __attribute__((visibility("default"))) TS_LDKCResult_InitFeaturesDecodeErrorZ_result_ok(uint32_t arg) {
-       return ((LDKCResult_InitFeaturesDecodeErrorZ*)arg)->result_ok;
-}
-uint32_t  __attribute__((visibility("default"))) TS_LDKCResult_InitFeaturesDecodeErrorZ_get_ok(uint32_t arg) {
-       LDKCResult_InitFeaturesDecodeErrorZ *val = (LDKCResult_InitFeaturesDecodeErrorZ*)(arg & ~1);
-       CHECK(val->result_ok);
-       LDKInitFeatures res_var = (*val->contents.result);
-       CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
-       CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
-       long res_ref = (long)res_var.inner & ~1;
-       return res_ref;
-}
-uint32_t  __attribute__((visibility("default"))) TS_LDKCResult_InitFeaturesDecodeErrorZ_get_err(uint32_t arg) {
-       LDKCResult_InitFeaturesDecodeErrorZ *val = (LDKCResult_InitFeaturesDecodeErrorZ*)(arg & ~1);
-       CHECK(!val->result_ok);
-       LDKDecodeError err_var = (*val->contents.err);
-       CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
-       CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
-       long err_ref = (long)err_var.inner & ~1;
-       return err_ref;
-}
-jboolean  __attribute__((visibility("default"))) TS_LDKCResult_NodeFeaturesDecodeErrorZ_result_ok(uint32_t arg) {
-       return ((LDKCResult_NodeFeaturesDecodeErrorZ*)arg)->result_ok;
-}
-uint32_t  __attribute__((visibility("default"))) TS_LDKCResult_NodeFeaturesDecodeErrorZ_get_ok(uint32_t arg) {
-       LDKCResult_NodeFeaturesDecodeErrorZ *val = (LDKCResult_NodeFeaturesDecodeErrorZ*)(arg & ~1);
-       CHECK(val->result_ok);
-       LDKNodeFeatures res_var = (*val->contents.result);
-       CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
-       CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
-       long res_ref = (long)res_var.inner & ~1;
-       return res_ref;
-}
-uint32_t  __attribute__((visibility("default"))) TS_LDKCResult_NodeFeaturesDecodeErrorZ_get_err(uint32_t arg) {
-       LDKCResult_NodeFeaturesDecodeErrorZ *val = (LDKCResult_NodeFeaturesDecodeErrorZ*)(arg & ~1);
-       CHECK(!val->result_ok);
-       LDKDecodeError err_var = (*val->contents.err);
-       CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
-       CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
-       long err_ref = (long)err_var.inner & ~1;
-       return err_ref;
-}
-jboolean  __attribute__((visibility("default"))) TS_LDKCResult_ChannelFeaturesDecodeErrorZ_result_ok(uint32_t arg) {
-       return ((LDKCResult_ChannelFeaturesDecodeErrorZ*)arg)->result_ok;
-}
-uint32_t  __attribute__((visibility("default"))) TS_LDKCResult_ChannelFeaturesDecodeErrorZ_get_ok(uint32_t arg) {
-       LDKCResult_ChannelFeaturesDecodeErrorZ *val = (LDKCResult_ChannelFeaturesDecodeErrorZ*)(arg & ~1);
-       CHECK(val->result_ok);
-       LDKChannelFeatures res_var = (*val->contents.result);
-       CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
-       CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
-       long res_ref = (long)res_var.inner & ~1;
-       return res_ref;
-}
-uint32_t  __attribute__((visibility("default"))) TS_LDKCResult_ChannelFeaturesDecodeErrorZ_get_err(uint32_t arg) {
-       LDKCResult_ChannelFeaturesDecodeErrorZ *val = (LDKCResult_ChannelFeaturesDecodeErrorZ*)(arg & ~1);
-       CHECK(!val->result_ok);
-       LDKDecodeError err_var = (*val->contents.err);
-       CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
-       CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
-       long err_ref = (long)err_var.inner & ~1;
-       return err_ref;
-}
-jboolean  __attribute__((visibility("default"))) TS_LDKCResult_ChannelConfigDecodeErrorZ_result_ok(uint32_t arg) {
-       return ((LDKCResult_ChannelConfigDecodeErrorZ*)arg)->result_ok;
-}
-uint32_t  __attribute__((visibility("default"))) TS_LDKCResult_ChannelConfigDecodeErrorZ_get_ok(uint32_t arg) {
-       LDKCResult_ChannelConfigDecodeErrorZ *val = (LDKCResult_ChannelConfigDecodeErrorZ*)(arg & ~1);
-       CHECK(val->result_ok);
-       LDKChannelConfig res_var = (*val->contents.result);
-       CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
-       CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
-       long res_ref = (long)res_var.inner & ~1;
-       return res_ref;
-}
-uint32_t  __attribute__((visibility("default"))) TS_LDKCResult_ChannelConfigDecodeErrorZ_get_err(uint32_t arg) {
-       LDKCResult_ChannelConfigDecodeErrorZ *val = (LDKCResult_ChannelConfigDecodeErrorZ*)(arg & ~1);
-       CHECK(!val->result_ok);
-       LDKDecodeError err_var = (*val->contents.err);
-       CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
-       CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
-       long err_ref = (long)err_var.inner & ~1;
-       return err_ref;
+static inline LDKCVec_MessageSendEventZ CVec_MessageSendEventZ_clone(const LDKCVec_MessageSendEventZ *orig) {
+       LDKCVec_MessageSendEventZ ret = { .data = MALLOC(sizeof(LDKMessageSendEvent) * orig->datalen, "LDKCVec_MessageSendEventZ clone bytes"), .datalen = orig->datalen };
+       for (size_t i = 0; i < ret.datalen; i++) {
+               ret.data[i] = MessageSendEvent_clone(&orig->data[i]);
+       }
+       return ret;
 }
 jboolean  __attribute__((visibility("default"))) TS_LDKCResult_boolLightningErrorZ_result_ok(uint32_t arg) {
        return ((LDKCResult_boolLightningErrorZ*)arg)->result_ok;
@@ -786,231 +796,143 @@ uint32_t  __attribute__((visibility("default"))) TS_LDKCResult_NoneLightningErro
        long err_ref = (long)err_var.inner & ~1;
        return err_ref;
 }
-uint32_t __attribute__((visibility("default"))) TS_LDKErrorAction_ref_from_ptr(uint32_t ptr) {
-       LDKErrorAction *obj = (LDKErrorAction*)ptr;
-       switch(obj->tag) {
-               case LDKErrorAction_DisconnectPeer: {
-                       LDKErrorMessage msg_var = obj->disconnect_peer.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 /* LDKErrorAction - DisconnectPeer */; (void) msg_ref;
-               }
-               case LDKErrorAction_IgnoreError: {
-                       return 0 /* LDKErrorAction - IgnoreError */;
-               }
-               case LDKErrorAction_SendErrorMessage: {
-                       LDKErrorMessage msg_var = obj->send_error_message.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 /* LDKErrorAction - SendErrorMessage */; (void) msg_ref;
-               }
-               default: abort();
-       }
-}
-uint32_t __attribute__((visibility("default"))) TS_LDKHTLCFailChannelUpdate_ref_from_ptr(uint32_t ptr) {
-       LDKHTLCFailChannelUpdate *obj = (LDKHTLCFailChannelUpdate*)ptr;
-       switch(obj->tag) {
-               case LDKHTLCFailChannelUpdate_ChannelUpdateMessage: {
-                       LDKChannelUpdate msg_var = obj->channel_update_message.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 /* LDKHTLCFailChannelUpdate - ChannelUpdateMessage */; (void) msg_ref;
-               }
-               case LDKHTLCFailChannelUpdate_ChannelClosed: {
-                       return 0 /* LDKHTLCFailChannelUpdate - ChannelClosed */; (void) obj->channel_closed.short_channel_id; (void) obj->channel_closed.is_permanent;
-               }
-               case LDKHTLCFailChannelUpdate_NodeFailure: {
-                       int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
-                       memcpy((uint8_t*)(node_id_arr + 4), obj->node_failure.node_id.compressed_form, 33);
-                       return 0 /* LDKHTLCFailChannelUpdate - NodeFailure */; (void) node_id_arr; (void) obj->node_failure.is_permanent;
-               }
-               default: abort();
-       }
+jboolean  __attribute__((visibility("default"))) TS_LDKCResult_CVec_u8ZPeerHandleErrorZ_result_ok(uint32_t arg) {
+       return ((LDKCResult_CVec_u8ZPeerHandleErrorZ*)arg)->result_ok;
 }
-uint32_t __attribute__((visibility("default"))) TS_LDKMessageSendEvent_ref_from_ptr(uint32_t ptr) {
-       LDKMessageSendEvent *obj = (LDKMessageSendEvent*)ptr;
-       switch(obj->tag) {
-               case LDKMessageSendEvent_SendAcceptChannel: {
-                       int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
-                       memcpy((uint8_t*)(node_id_arr + 4), obj->send_accept_channel.node_id.compressed_form, 33);
-                       LDKAcceptChannel msg_var = obj->send_accept_channel.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 - SendAcceptChannel */; (void) node_id_arr; (void) msg_ref;
-               }
-               case LDKMessageSendEvent_SendOpenChannel: {
-                       int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
-                       memcpy((uint8_t*)(node_id_arr + 4), obj->send_open_channel.node_id.compressed_form, 33);
-                       LDKOpenChannel msg_var = obj->send_open_channel.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 - SendOpenChannel */; (void) node_id_arr; (void) msg_ref;
-               }
-               case LDKMessageSendEvent_SendFundingCreated: {
-                       int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
-                       memcpy((uint8_t*)(node_id_arr + 4), obj->send_funding_created.node_id.compressed_form, 33);
-                       LDKFundingCreated msg_var = obj->send_funding_created.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 - SendFundingCreated */; (void) node_id_arr; (void) msg_ref;
-               }
-               case LDKMessageSendEvent_SendFundingSigned: {
-                       int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
-                       memcpy((uint8_t*)(node_id_arr + 4), obj->send_funding_signed.node_id.compressed_form, 33);
-                       LDKFundingSigned msg_var = obj->send_funding_signed.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 - SendFundingSigned */; (void) node_id_arr; (void) msg_ref;
-               }
-               case LDKMessageSendEvent_SendFundingLocked: {
-                       int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
-                       memcpy((uint8_t*)(node_id_arr + 4), obj->send_funding_locked.node_id.compressed_form, 33);
-                       LDKFundingLocked msg_var = obj->send_funding_locked.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 - SendFundingLocked */; (void) node_id_arr; (void) msg_ref;
-               }
-               case LDKMessageSendEvent_SendAnnouncementSignatures: {
-                       int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
-                       memcpy((uint8_t*)(node_id_arr + 4), obj->send_announcement_signatures.node_id.compressed_form, 33);
-                       LDKAnnouncementSignatures msg_var = obj->send_announcement_signatures.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 - SendAnnouncementSignatures */; (void) node_id_arr; (void) msg_ref;
-               }
-               case LDKMessageSendEvent_UpdateHTLCs: {
-                       int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
-                       memcpy((uint8_t*)(node_id_arr + 4), obj->update_htl_cs.node_id.compressed_form, 33);
-                       LDKCommitmentUpdate updates_var = obj->update_htl_cs.updates;
-                       CHECK((((long)updates_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
-                       CHECK((((long)&updates_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
-                       long updates_ref = (long)updates_var.inner & ~1;
-                       return 0 /* LDKMessageSendEvent - UpdateHTLCs */; (void) node_id_arr; (void) updates_ref;
-               }
-               case LDKMessageSendEvent_SendRevokeAndACK: {
-                       int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
-                       memcpy((uint8_t*)(node_id_arr + 4), obj->send_revoke_and_ack.node_id.compressed_form, 33);
-                       LDKRevokeAndACK msg_var = obj->send_revoke_and_ack.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 - SendRevokeAndACK */; (void) node_id_arr; (void) msg_ref;
-               }
-               case LDKMessageSendEvent_SendClosingSigned: {
-                       int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
-                       memcpy((uint8_t*)(node_id_arr + 4), obj->send_closing_signed.node_id.compressed_form, 33);
-                       LDKClosingSigned msg_var = obj->send_closing_signed.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 - SendClosingSigned */; (void) node_id_arr; (void) msg_ref;
-               }
-               case LDKMessageSendEvent_SendShutdown: {
-                       int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
-                       memcpy((uint8_t*)(node_id_arr + 4), obj->send_shutdown.node_id.compressed_form, 33);
-                       LDKShutdown msg_var = obj->send_shutdown.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 - SendShutdown */; (void) node_id_arr; (void) msg_ref;
-               }
-               case LDKMessageSendEvent_SendChannelReestablish: {
-                       int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
-                       memcpy((uint8_t*)(node_id_arr + 4), obj->send_channel_reestablish.node_id.compressed_form, 33);
-                       LDKChannelReestablish msg_var = obj->send_channel_reestablish.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 - SendChannelReestablish */; (void) node_id_arr; (void) msg_ref;
-               }
-               case LDKMessageSendEvent_BroadcastChannelAnnouncement: {
-                       LDKChannelAnnouncement msg_var = obj->broadcast_channel_announcement.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;
-                       LDKChannelUpdate update_msg_var = obj->broadcast_channel_announcement.update_msg;
-                       CHECK((((long)update_msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
-                       CHECK((((long)&update_msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
-                       long update_msg_ref = (long)update_msg_var.inner & ~1;
-                       return 0 /* LDKMessageSendEvent - BroadcastChannelAnnouncement */; (void) msg_ref; (void) update_msg_ref;
-               }
-               case LDKMessageSendEvent_BroadcastNodeAnnouncement: {
-                       LDKNodeAnnouncement msg_var = obj->broadcast_node_announcement.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 - BroadcastNodeAnnouncement */; (void) msg_ref;
-               }
-               case LDKMessageSendEvent_BroadcastChannelUpdate: {
-                       LDKChannelUpdate msg_var = obj->broadcast_channel_update.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 - BroadcastChannelUpdate */; (void) msg_ref;
-               }
-               case LDKMessageSendEvent_HandleError: {
-                       int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
-                       memcpy((uint8_t*)(node_id_arr + 4), obj->handle_error.node_id.compressed_form, 33);
-                       long action_ref = ((long)&obj->handle_error.action) | 1;
-                       return 0 /* LDKMessageSendEvent - HandleError */; (void) node_id_arr; (void) action_ref;
-               }
-               case LDKMessageSendEvent_PaymentFailureNetworkUpdate: {
-                       long update_ref = ((long)&obj->payment_failure_network_update.update) | 1;
-                       return 0 /* LDKMessageSendEvent - PaymentFailureNetworkUpdate */; (void) update_ref;
-               }
-               case LDKMessageSendEvent_SendChannelRangeQuery: {
-                       int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
-                       memcpy((uint8_t*)(node_id_arr + 4), obj->send_channel_range_query.node_id.compressed_form, 33);
-                       LDKQueryChannelRange msg_var = obj->send_channel_range_query.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 - SendChannelRangeQuery */; (void) node_id_arr; (void) msg_ref;
-               }
-               case LDKMessageSendEvent_SendShortIdsQuery: {
-                       int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
-                       memcpy((uint8_t*)(node_id_arr + 4), obj->send_short_ids_query.node_id.compressed_form, 33);
-                       LDKQueryShortChannelIds msg_var = obj->send_short_ids_query.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 - SendShortIdsQuery */; (void) node_id_arr; (void) msg_ref;
-               }
-               default: abort();
-       }
+int8_tArray  __attribute__((visibility("default"))) TS_LDKCResult_CVec_u8ZPeerHandleErrorZ_get_ok(uint32_t arg) {
+       LDKCResult_CVec_u8ZPeerHandleErrorZ *val = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(arg & ~1);
+       CHECK(val->result_ok);
+       LDKCVec_u8Z res_var = (*val->contents.result);
+       int8_tArray res_arr = init_arr(res_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
+       memcpy((uint8_t*)(res_arr + 4), res_var.data, res_var.datalen);
+       return res_arr;
 }
-uint32_t  __attribute__((visibility("default"))) TS_LDKCVec_MessageSendEventZ_new(uint32_tArray elems) {
-       LDKCVec_MessageSendEventZ *ret = MALLOC(sizeof(LDKCVec_MessageSendEventZ), "LDKCVec_MessageSendEventZ");
-       ret->datalen = *((uint32_t*)elems);
-       if (ret->datalen == 0) {
-               ret->data = NULL;
-       } else {
-               ret->data = MALLOC(sizeof(LDKMessageSendEvent) * ret->datalen, "LDKCVec_MessageSendEventZ Data");
-               uint32_t *java_elems = (uint32_t*)(elems + 4);
-               for (size_t i = 0; i < ret->datalen; i++) {
-                       uint32_t arr_elem = java_elems[i];
-                       LDKMessageSendEvent arr_elem_conv = *(LDKMessageSendEvent*)(((uint64_t)arr_elem) & ~1);
-                       FREE((void*)arr_elem);
-                       ret->data[i] = arr_elem_conv;
-               }
-       }
-       return (long)ret;
+uint32_t  __attribute__((visibility("default"))) TS_LDKCResult_CVec_u8ZPeerHandleErrorZ_get_err(uint32_t arg) {
+       LDKCResult_CVec_u8ZPeerHandleErrorZ *val = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(arg & ~1);
+       CHECK(!val->result_ok);
+       LDKPeerHandleError err_var = (*val->contents.err);
+       CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+       CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+       long err_ref = (long)err_var.inner & ~1;
+       return err_ref;
 }
-static inline LDKCVec_MessageSendEventZ CVec_MessageSendEventZ_clone(const LDKCVec_MessageSendEventZ *orig) {
-       LDKCVec_MessageSendEventZ ret = { .data = MALLOC(sizeof(LDKMessageSendEvent) * orig->datalen, "LDKCVec_MessageSendEventZ clone bytes"), .datalen = orig->datalen };
-       for (size_t i = 0; i < ret.datalen; i++) {
-               ret.data[i] = MessageSendEvent_clone(&orig->data[i]);
-       }
-       return ret;
+jboolean  __attribute__((visibility("default"))) TS_LDKCResult_NonePeerHandleErrorZ_result_ok(uint32_t arg) {
+       return ((LDKCResult_NonePeerHandleErrorZ*)arg)->result_ok;
+}
+void  __attribute__((visibility("default"))) TS_LDKCResult_NonePeerHandleErrorZ_get_ok(uint32_t arg) {
+       LDKCResult_NonePeerHandleErrorZ *val = (LDKCResult_NonePeerHandleErrorZ*)(arg & ~1);
+       CHECK(val->result_ok);
+       return *val->contents.result;
+}
+uint32_t  __attribute__((visibility("default"))) TS_LDKCResult_NonePeerHandleErrorZ_get_err(uint32_t arg) {
+       LDKCResult_NonePeerHandleErrorZ *val = (LDKCResult_NonePeerHandleErrorZ*)(arg & ~1);
+       CHECK(!val->result_ok);
+       LDKPeerHandleError err_var = (*val->contents.err);
+       CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+       CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+       long err_ref = (long)err_var.inner & ~1;
+       return err_ref;
+}
+jboolean  __attribute__((visibility("default"))) TS_LDKCResult_boolPeerHandleErrorZ_result_ok(uint32_t arg) {
+       return ((LDKCResult_boolPeerHandleErrorZ*)arg)->result_ok;
+}
+jboolean  __attribute__((visibility("default"))) TS_LDKCResult_boolPeerHandleErrorZ_get_ok(uint32_t arg) {
+       LDKCResult_boolPeerHandleErrorZ *val = (LDKCResult_boolPeerHandleErrorZ*)(arg & ~1);
+       CHECK(val->result_ok);
+       return *val->contents.result;
+}
+uint32_t  __attribute__((visibility("default"))) TS_LDKCResult_boolPeerHandleErrorZ_get_err(uint32_t arg) {
+       LDKCResult_boolPeerHandleErrorZ *val = (LDKCResult_boolPeerHandleErrorZ*)(arg & ~1);
+       CHECK(!val->result_ok);
+       LDKPeerHandleError err_var = (*val->contents.err);
+       CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+       CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+       long err_ref = (long)err_var.inner & ~1;
+       return err_ref;
+}
+jboolean  __attribute__((visibility("default"))) TS_LDKCResult_InitFeaturesDecodeErrorZ_result_ok(uint32_t arg) {
+       return ((LDKCResult_InitFeaturesDecodeErrorZ*)arg)->result_ok;
+}
+uint32_t  __attribute__((visibility("default"))) TS_LDKCResult_InitFeaturesDecodeErrorZ_get_ok(uint32_t arg) {
+       LDKCResult_InitFeaturesDecodeErrorZ *val = (LDKCResult_InitFeaturesDecodeErrorZ*)(arg & ~1);
+       CHECK(val->result_ok);
+       LDKInitFeatures res_var = (*val->contents.result);
+       CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+       CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+       long res_ref = (long)res_var.inner & ~1;
+       return res_ref;
+}
+uint32_t  __attribute__((visibility("default"))) TS_LDKCResult_InitFeaturesDecodeErrorZ_get_err(uint32_t arg) {
+       LDKCResult_InitFeaturesDecodeErrorZ *val = (LDKCResult_InitFeaturesDecodeErrorZ*)(arg & ~1);
+       CHECK(!val->result_ok);
+       LDKDecodeError err_var = (*val->contents.err);
+       CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+       CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+       long err_ref = (long)err_var.inner & ~1;
+       return err_ref;
+}
+jboolean  __attribute__((visibility("default"))) TS_LDKCResult_NodeFeaturesDecodeErrorZ_result_ok(uint32_t arg) {
+       return ((LDKCResult_NodeFeaturesDecodeErrorZ*)arg)->result_ok;
+}
+uint32_t  __attribute__((visibility("default"))) TS_LDKCResult_NodeFeaturesDecodeErrorZ_get_ok(uint32_t arg) {
+       LDKCResult_NodeFeaturesDecodeErrorZ *val = (LDKCResult_NodeFeaturesDecodeErrorZ*)(arg & ~1);
+       CHECK(val->result_ok);
+       LDKNodeFeatures res_var = (*val->contents.result);
+       CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+       CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+       long res_ref = (long)res_var.inner & ~1;
+       return res_ref;
+}
+uint32_t  __attribute__((visibility("default"))) TS_LDKCResult_NodeFeaturesDecodeErrorZ_get_err(uint32_t arg) {
+       LDKCResult_NodeFeaturesDecodeErrorZ *val = (LDKCResult_NodeFeaturesDecodeErrorZ*)(arg & ~1);
+       CHECK(!val->result_ok);
+       LDKDecodeError err_var = (*val->contents.err);
+       CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+       CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+       long err_ref = (long)err_var.inner & ~1;
+       return err_ref;
+}
+jboolean  __attribute__((visibility("default"))) TS_LDKCResult_ChannelFeaturesDecodeErrorZ_result_ok(uint32_t arg) {
+       return ((LDKCResult_ChannelFeaturesDecodeErrorZ*)arg)->result_ok;
+}
+uint32_t  __attribute__((visibility("default"))) TS_LDKCResult_ChannelFeaturesDecodeErrorZ_get_ok(uint32_t arg) {
+       LDKCResult_ChannelFeaturesDecodeErrorZ *val = (LDKCResult_ChannelFeaturesDecodeErrorZ*)(arg & ~1);
+       CHECK(val->result_ok);
+       LDKChannelFeatures res_var = (*val->contents.result);
+       CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+       CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+       long res_ref = (long)res_var.inner & ~1;
+       return res_ref;
+}
+uint32_t  __attribute__((visibility("default"))) TS_LDKCResult_ChannelFeaturesDecodeErrorZ_get_err(uint32_t arg) {
+       LDKCResult_ChannelFeaturesDecodeErrorZ *val = (LDKCResult_ChannelFeaturesDecodeErrorZ*)(arg & ~1);
+       CHECK(!val->result_ok);
+       LDKDecodeError err_var = (*val->contents.err);
+       CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+       CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+       long err_ref = (long)err_var.inner & ~1;
+       return err_ref;
+}
+jboolean  __attribute__((visibility("default"))) TS_LDKCResult_ChannelConfigDecodeErrorZ_result_ok(uint32_t arg) {
+       return ((LDKCResult_ChannelConfigDecodeErrorZ*)arg)->result_ok;
+}
+uint32_t  __attribute__((visibility("default"))) TS_LDKCResult_ChannelConfigDecodeErrorZ_get_ok(uint32_t arg) {
+       LDKCResult_ChannelConfigDecodeErrorZ *val = (LDKCResult_ChannelConfigDecodeErrorZ*)(arg & ~1);
+       CHECK(val->result_ok);
+       LDKChannelConfig res_var = (*val->contents.result);
+       CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+       CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+       long res_ref = (long)res_var.inner & ~1;
+       return res_ref;
+}
+uint32_t  __attribute__((visibility("default"))) TS_LDKCResult_ChannelConfigDecodeErrorZ_get_err(uint32_t arg) {
+       LDKCResult_ChannelConfigDecodeErrorZ *val = (LDKCResult_ChannelConfigDecodeErrorZ*)(arg & ~1);
+       CHECK(!val->result_ok);
+       LDKDecodeError err_var = (*val->contents.err);
+       CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+       CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+       long err_ref = (long)err_var.inner & ~1;
+       return err_ref;
 }
 jboolean  __attribute__((visibility("default"))) TS_LDKCResult_DirectionalChannelInfoDecodeErrorZ_result_ok(uint32_t arg) {
        return ((LDKCResult_DirectionalChannelInfoDecodeErrorZ*)arg)->result_ok;
@@ -5655,56 +5577,200 @@ uint32_t  __attribute__((visibility("default"))) TS_CResult_TrustedCommitmentTra
        return (long)ret_conv;
 }
 
-uint32_t  __attribute__((visibility("default"))) TS_CResult_TrustedCommitmentTransactionNoneZ_err() {
-       LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
-       *ret_conv = CResult_TrustedCommitmentTransactionNoneZ_err();
-       return (long)ret_conv;
+uint32_t  __attribute__((visibility("default"))) TS_CResult_TrustedCommitmentTransactionNoneZ_err() {
+       LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
+       *ret_conv = CResult_TrustedCommitmentTransactionNoneZ_err();
+       return (long)ret_conv;
+}
+
+void  __attribute__((visibility("default"))) TS_CResult_TrustedCommitmentTransactionNoneZ_free(uint32_t _res) {
+       if ((_res & 1) != 0) return;
+       LDKCResult_TrustedCommitmentTransactionNoneZ _res_conv = *(LDKCResult_TrustedCommitmentTransactionNoneZ*)(((uint64_t)_res) & ~1);
+       FREE((void*)_res);
+       CResult_TrustedCommitmentTransactionNoneZ_free(_res_conv);
+}
+
+uint32_t  __attribute__((visibility("default"))) TS_CResult_CVec_SignatureZNoneZ_ok(ptrArray o) {
+       LDKCVec_SignatureZ o_constr;
+       o_constr.datalen = *((uint32_t*)o);
+       if (o_constr.datalen > 0)
+               o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
+       else
+               o_constr.data = NULL;
+       int8_tArray* o_vals = (int8_tArray*)(o + 4);
+       for (size_t m = 0; m < o_constr.datalen; m++) {
+               int8_tArray o_conv_12 = o_vals[m];
+               LDKSignature o_conv_12_ref;
+               CHECK(*((uint32_t*)o_conv_12) == 64);
+               memcpy(o_conv_12_ref.compact_form, (uint8_t*)(o_conv_12 + 4), 64);
+               o_constr.data[m] = o_conv_12_ref;
+       }
+       LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
+       *ret_conv = CResult_CVec_SignatureZNoneZ_ok(o_constr);
+       return (long)ret_conv;
+}
+
+uint32_t  __attribute__((visibility("default"))) TS_CResult_CVec_SignatureZNoneZ_err() {
+       LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
+       *ret_conv = CResult_CVec_SignatureZNoneZ_err();
+       return (long)ret_conv;
+}
+
+void  __attribute__((visibility("default"))) TS_CResult_CVec_SignatureZNoneZ_free(uint32_t _res) {
+       if ((_res & 1) != 0) return;
+       LDKCResult_CVec_SignatureZNoneZ _res_conv = *(LDKCResult_CVec_SignatureZNoneZ*)(((uint64_t)_res) & ~1);
+       FREE((void*)_res);
+       CResult_CVec_SignatureZNoneZ_free(_res_conv);
+}
+
+uint32_t  __attribute__((visibility("default"))) TS_CResult_CVec_SignatureZNoneZ_clone(uint32_t orig) {
+       LDKCResult_CVec_SignatureZNoneZ* orig_conv = (LDKCResult_CVec_SignatureZNoneZ*)(orig & ~1);
+       LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
+       *ret_conv = CResult_CVec_SignatureZNoneZ_clone(orig_conv);
+       return (long)ret_conv;
+}
+
+void  __attribute__((visibility("default"))) TS_CVec_MessageSendEventZ_free(uint32_tArray _res) {
+       LDKCVec_MessageSendEventZ _res_constr;
+       _res_constr.datalen = *((uint32_t*)_res);
+       if (_res_constr.datalen > 0)
+               _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKMessageSendEvent), "LDKCVec_MessageSendEventZ Elements");
+       else
+               _res_constr.data = NULL;
+       uint32_t* _res_vals = (uint32_t*)(_res + 4);
+       for (size_t s = 0; s < _res_constr.datalen; s++) {
+               uint32_t _res_conv_18 = _res_vals[s];
+               LDKMessageSendEvent _res_conv_18_conv = *(LDKMessageSendEvent*)(((uint64_t)_res_conv_18) & ~1);
+               FREE((void*)_res_conv_18);
+               _res_constr.data[s] = _res_conv_18_conv;
+       }
+       CVec_MessageSendEventZ_free(_res_constr);
+}
+
+uint32_t  __attribute__((visibility("default"))) TS_CResult_boolLightningErrorZ_ok(jboolean o) {
+       LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
+       *ret_conv = CResult_boolLightningErrorZ_ok(o);
+       return (long)ret_conv;
+}
+
+uint32_t  __attribute__((visibility("default"))) TS_CResult_boolLightningErrorZ_err(uint32_t e) {
+       LDKLightningError e_conv;
+       e_conv.inner = (void*)(e & (~1));
+       e_conv.is_owned = (e & 1) || (e == 0);
+       e_conv = LightningError_clone(&e_conv);
+       LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
+       *ret_conv = CResult_boolLightningErrorZ_err(e_conv);
+       return (long)ret_conv;
+}
+
+void  __attribute__((visibility("default"))) TS_CResult_boolLightningErrorZ_free(uint32_t _res) {
+       if ((_res & 1) != 0) return;
+       LDKCResult_boolLightningErrorZ _res_conv = *(LDKCResult_boolLightningErrorZ*)(((uint64_t)_res) & ~1);
+       FREE((void*)_res);
+       CResult_boolLightningErrorZ_free(_res_conv);
+}
+
+uint32_t  __attribute__((visibility("default"))) TS_CResult_boolLightningErrorZ_clone(uint32_t orig) {
+       LDKCResult_boolLightningErrorZ* orig_conv = (LDKCResult_boolLightningErrorZ*)(orig & ~1);
+       LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
+       *ret_conv = CResult_boolLightningErrorZ_clone(orig_conv);
+       return (long)ret_conv;
+}
+
+uint32_t  __attribute__((visibility("default"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(uint32_t orig) {
+       LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* orig_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(orig & ~1);
+       LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_ref = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
+       *ret_ref = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig_conv);
+       return (long)ret_ref;
+}
+
+uint32_t  __attribute__((visibility("default"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(uint32_t a, uint32_t b, uint32_t c) {
+       LDKChannelAnnouncement a_conv;
+       a_conv.inner = (void*)(a & (~1));
+       a_conv.is_owned = (a & 1) || (a == 0);
+       a_conv = ChannelAnnouncement_clone(&a_conv);
+       LDKChannelUpdate b_conv;
+       b_conv.inner = (void*)(b & (~1));
+       b_conv.is_owned = (b & 1) || (b == 0);
+       b_conv = ChannelUpdate_clone(&b_conv);
+       LDKChannelUpdate c_conv;
+       c_conv.inner = (void*)(c & (~1));
+       c_conv.is_owned = (c & 1) || (c == 0);
+       c_conv = ChannelUpdate_clone(&c_conv);
+       LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_ref = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
+       *ret_ref = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a_conv, b_conv, c_conv);
+       return (long)ret_ref;
 }
 
-void  __attribute__((visibility("default"))) TS_CResult_TrustedCommitmentTransactionNoneZ_free(uint32_t _res) {
+void  __attribute__((visibility("default"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(uint32_t _res) {
        if ((_res & 1) != 0) return;
-       LDKCResult_TrustedCommitmentTransactionNoneZ _res_conv = *(LDKCResult_TrustedCommitmentTransactionNoneZ*)(((uint64_t)_res) & ~1);
+       LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)_res) & ~1);
        FREE((void*)_res);
-       CResult_TrustedCommitmentTransactionNoneZ_free(_res_conv);
+       C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res_conv);
 }
 
-uint32_t  __attribute__((visibility("default"))) TS_CResult_CVec_SignatureZNoneZ_ok(ptrArray o) {
-       LDKCVec_SignatureZ o_constr;
-       o_constr.datalen = *((uint32_t*)o);
-       if (o_constr.datalen > 0)
-               o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
+void  __attribute__((visibility("default"))) TS_CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(uint32_tArray _res) {
+       LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res_constr;
+       _res_constr.datalen = *((uint32_t*)_res);
+       if (_res_constr.datalen > 0)
+               _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ Elements");
        else
-               o_constr.data = NULL;
-       int8_tArray* o_vals = (int8_tArray*)(o + 4);
-       for (size_t m = 0; m < o_constr.datalen; m++) {
-               int8_tArray o_conv_12 = o_vals[m];
-               LDKSignature o_conv_12_ref;
-               CHECK(*((uint32_t*)o_conv_12) == 64);
-               memcpy(o_conv_12_ref.compact_form, (uint8_t*)(o_conv_12 + 4), 64);
-               o_constr.data[m] = o_conv_12_ref;
+               _res_constr.data = NULL;
+       uint32_t* _res_vals = (uint32_t*)(_res + 4);
+       for (size_t l = 0; l < _res_constr.datalen; l++) {
+               uint32_t _res_conv_63 = _res_vals[l];
+               LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res_conv_63_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)_res_conv_63) & ~1);
+               FREE((void*)_res_conv_63);
+               _res_constr.data[l] = _res_conv_63_conv;
        }
-       LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
-       *ret_conv = CResult_CVec_SignatureZNoneZ_ok(o_constr);
+       CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res_constr);
+}
+
+void  __attribute__((visibility("default"))) TS_CVec_NodeAnnouncementZ_free(uint32_tArray _res) {
+       LDKCVec_NodeAnnouncementZ _res_constr;
+       _res_constr.datalen = *((uint32_t*)_res);
+       if (_res_constr.datalen > 0)
+               _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKNodeAnnouncement), "LDKCVec_NodeAnnouncementZ Elements");
+       else
+               _res_constr.data = NULL;
+       uint32_t* _res_vals = (uint32_t*)(_res + 4);
+       for (size_t s = 0; s < _res_constr.datalen; s++) {
+               uint32_t _res_conv_18 = _res_vals[s];
+               LDKNodeAnnouncement _res_conv_18_conv;
+               _res_conv_18_conv.inner = (void*)(_res_conv_18 & (~1));
+               _res_conv_18_conv.is_owned = (_res_conv_18 & 1) || (_res_conv_18 == 0);
+               _res_constr.data[s] = _res_conv_18_conv;
+       }
+       CVec_NodeAnnouncementZ_free(_res_constr);
+}
+
+uint32_t  __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_ok() {
+       LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
+       *ret_conv = CResult_NoneLightningErrorZ_ok();
        return (long)ret_conv;
 }
 
-uint32_t  __attribute__((visibility("default"))) TS_CResult_CVec_SignatureZNoneZ_err() {
-       LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
-       *ret_conv = CResult_CVec_SignatureZNoneZ_err();
+uint32_t  __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_err(uint32_t e) {
+       LDKLightningError e_conv;
+       e_conv.inner = (void*)(e & (~1));
+       e_conv.is_owned = (e & 1) || (e == 0);
+       e_conv = LightningError_clone(&e_conv);
+       LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
+       *ret_conv = CResult_NoneLightningErrorZ_err(e_conv);
        return (long)ret_conv;
 }
 
-void  __attribute__((visibility("default"))) TS_CResult_CVec_SignatureZNoneZ_free(uint32_t _res) {
+void  __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_free(uint32_t _res) {
        if ((_res & 1) != 0) return;
-       LDKCResult_CVec_SignatureZNoneZ _res_conv = *(LDKCResult_CVec_SignatureZNoneZ*)(((uint64_t)_res) & ~1);
+       LDKCResult_NoneLightningErrorZ _res_conv = *(LDKCResult_NoneLightningErrorZ*)(((uint64_t)_res) & ~1);
        FREE((void*)_res);
-       CResult_CVec_SignatureZNoneZ_free(_res_conv);
+       CResult_NoneLightningErrorZ_free(_res_conv);
 }
 
-uint32_t  __attribute__((visibility("default"))) TS_CResult_CVec_SignatureZNoneZ_clone(uint32_t orig) {
-       LDKCResult_CVec_SignatureZNoneZ* orig_conv = (LDKCResult_CVec_SignatureZNoneZ*)(orig & ~1);
-       LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
-       *ret_conv = CResult_CVec_SignatureZNoneZ_clone(orig_conv);
+uint32_t  __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_clone(uint32_t orig) {
+       LDKCResult_NoneLightningErrorZ* orig_conv = (LDKCResult_NoneLightningErrorZ*)(orig & ~1);
+       LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
+       *ret_conv = CResult_NoneLightningErrorZ_clone(orig_conv);
        return (long)ret_conv;
 }
 
@@ -5844,247 +5910,103 @@ uint32_t  __attribute__((visibility("default"))) TS_CResult_InitFeaturesDecodeEr
        e_conv.is_owned = (e & 1) || (e == 0);
        e_conv = DecodeError_clone(&e_conv);
        LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
-       *ret_conv = CResult_InitFeaturesDecodeErrorZ_err(e_conv);
-       return (long)ret_conv;
-}
-
-void  __attribute__((visibility("default"))) TS_CResult_InitFeaturesDecodeErrorZ_free(uint32_t _res) {
-       if ((_res & 1) != 0) return;
-       LDKCResult_InitFeaturesDecodeErrorZ _res_conv = *(LDKCResult_InitFeaturesDecodeErrorZ*)(((uint64_t)_res) & ~1);
-       FREE((void*)_res);
-       CResult_InitFeaturesDecodeErrorZ_free(_res_conv);
-}
-
-uint32_t  __attribute__((visibility("default"))) TS_CResult_NodeFeaturesDecodeErrorZ_ok(uint32_t o) {
-       LDKNodeFeatures o_conv;
-       o_conv.inner = (void*)(o & (~1));
-       o_conv.is_owned = (o & 1) || (o == 0);
-       o_conv = NodeFeatures_clone(&o_conv);
-       LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
-       *ret_conv = CResult_NodeFeaturesDecodeErrorZ_ok(o_conv);
-       return (long)ret_conv;
-}
-
-uint32_t  __attribute__((visibility("default"))) TS_CResult_NodeFeaturesDecodeErrorZ_err(uint32_t e) {
-       LDKDecodeError e_conv;
-       e_conv.inner = (void*)(e & (~1));
-       e_conv.is_owned = (e & 1) || (e == 0);
-       e_conv = DecodeError_clone(&e_conv);
-       LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
-       *ret_conv = CResult_NodeFeaturesDecodeErrorZ_err(e_conv);
-       return (long)ret_conv;
-}
-
-void  __attribute__((visibility("default"))) TS_CResult_NodeFeaturesDecodeErrorZ_free(uint32_t _res) {
-       if ((_res & 1) != 0) return;
-       LDKCResult_NodeFeaturesDecodeErrorZ _res_conv = *(LDKCResult_NodeFeaturesDecodeErrorZ*)(((uint64_t)_res) & ~1);
-       FREE((void*)_res);
-       CResult_NodeFeaturesDecodeErrorZ_free(_res_conv);
-}
-
-uint32_t  __attribute__((visibility("default"))) TS_CResult_ChannelFeaturesDecodeErrorZ_ok(uint32_t o) {
-       LDKChannelFeatures o_conv;
-       o_conv.inner = (void*)(o & (~1));
-       o_conv.is_owned = (o & 1) || (o == 0);
-       o_conv = ChannelFeatures_clone(&o_conv);
-       LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
-       *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_ok(o_conv);
-       return (long)ret_conv;
-}
-
-uint32_t  __attribute__((visibility("default"))) TS_CResult_ChannelFeaturesDecodeErrorZ_err(uint32_t e) {
-       LDKDecodeError e_conv;
-       e_conv.inner = (void*)(e & (~1));
-       e_conv.is_owned = (e & 1) || (e == 0);
-       e_conv = DecodeError_clone(&e_conv);
-       LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
-       *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_err(e_conv);
-       return (long)ret_conv;
-}
-
-void  __attribute__((visibility("default"))) TS_CResult_ChannelFeaturesDecodeErrorZ_free(uint32_t _res) {
-       if ((_res & 1) != 0) return;
-       LDKCResult_ChannelFeaturesDecodeErrorZ _res_conv = *(LDKCResult_ChannelFeaturesDecodeErrorZ*)(((uint64_t)_res) & ~1);
-       FREE((void*)_res);
-       CResult_ChannelFeaturesDecodeErrorZ_free(_res_conv);
-}
-
-uint32_t  __attribute__((visibility("default"))) TS_CResult_ChannelConfigDecodeErrorZ_ok(uint32_t o) {
-       LDKChannelConfig o_conv;
-       o_conv.inner = (void*)(o & (~1));
-       o_conv.is_owned = (o & 1) || (o == 0);
-       o_conv = ChannelConfig_clone(&o_conv);
-       LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
-       *ret_conv = CResult_ChannelConfigDecodeErrorZ_ok(o_conv);
-       return (long)ret_conv;
-}
-
-uint32_t  __attribute__((visibility("default"))) TS_CResult_ChannelConfigDecodeErrorZ_err(uint32_t e) {
-       LDKDecodeError e_conv;
-       e_conv.inner = (void*)(e & (~1));
-       e_conv.is_owned = (e & 1) || (e == 0);
-       e_conv = DecodeError_clone(&e_conv);
-       LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
-       *ret_conv = CResult_ChannelConfigDecodeErrorZ_err(e_conv);
-       return (long)ret_conv;
-}
-
-void  __attribute__((visibility("default"))) TS_CResult_ChannelConfigDecodeErrorZ_free(uint32_t _res) {
-       if ((_res & 1) != 0) return;
-       LDKCResult_ChannelConfigDecodeErrorZ _res_conv = *(LDKCResult_ChannelConfigDecodeErrorZ*)(((uint64_t)_res) & ~1);
-       FREE((void*)_res);
-       CResult_ChannelConfigDecodeErrorZ_free(_res_conv);
-}
-
-uint32_t  __attribute__((visibility("default"))) TS_CResult_ChannelConfigDecodeErrorZ_clone(uint32_t orig) {
-       LDKCResult_ChannelConfigDecodeErrorZ* orig_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)(orig & ~1);
-       LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
-       *ret_conv = CResult_ChannelConfigDecodeErrorZ_clone(orig_conv);
-       return (long)ret_conv;
-}
-
-uint32_t  __attribute__((visibility("default"))) TS_CResult_boolLightningErrorZ_ok(jboolean o) {
-       LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
-       *ret_conv = CResult_boolLightningErrorZ_ok(o);
-       return (long)ret_conv;
-}
-
-uint32_t  __attribute__((visibility("default"))) TS_CResult_boolLightningErrorZ_err(uint32_t e) {
-       LDKLightningError e_conv;
-       e_conv.inner = (void*)(e & (~1));
-       e_conv.is_owned = (e & 1) || (e == 0);
-       e_conv = LightningError_clone(&e_conv);
-       LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
-       *ret_conv = CResult_boolLightningErrorZ_err(e_conv);
-       return (long)ret_conv;
-}
-
-void  __attribute__((visibility("default"))) TS_CResult_boolLightningErrorZ_free(uint32_t _res) {
-       if ((_res & 1) != 0) return;
-       LDKCResult_boolLightningErrorZ _res_conv = *(LDKCResult_boolLightningErrorZ*)(((uint64_t)_res) & ~1);
-       FREE((void*)_res);
-       CResult_boolLightningErrorZ_free(_res_conv);
-}
-
-uint32_t  __attribute__((visibility("default"))) TS_CResult_boolLightningErrorZ_clone(uint32_t orig) {
-       LDKCResult_boolLightningErrorZ* orig_conv = (LDKCResult_boolLightningErrorZ*)(orig & ~1);
-       LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
-       *ret_conv = CResult_boolLightningErrorZ_clone(orig_conv);
-       return (long)ret_conv;
-}
-
-uint32_t  __attribute__((visibility("default"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(uint32_t orig) {
-       LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* orig_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(orig & ~1);
-       LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_ref = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
-       *ret_ref = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig_conv);
-       return (long)ret_ref;
-}
-
-uint32_t  __attribute__((visibility("default"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(uint32_t a, uint32_t b, uint32_t c) {
-       LDKChannelAnnouncement a_conv;
-       a_conv.inner = (void*)(a & (~1));
-       a_conv.is_owned = (a & 1) || (a == 0);
-       a_conv = ChannelAnnouncement_clone(&a_conv);
-       LDKChannelUpdate b_conv;
-       b_conv.inner = (void*)(b & (~1));
-       b_conv.is_owned = (b & 1) || (b == 0);
-       b_conv = ChannelUpdate_clone(&b_conv);
-       LDKChannelUpdate c_conv;
-       c_conv.inner = (void*)(c & (~1));
-       c_conv.is_owned = (c & 1) || (c == 0);
-       c_conv = ChannelUpdate_clone(&c_conv);
-       LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_ref = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
-       *ret_ref = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a_conv, b_conv, c_conv);
-       return (long)ret_ref;
+       *ret_conv = CResult_InitFeaturesDecodeErrorZ_err(e_conv);
+       return (long)ret_conv;
 }
 
-void  __attribute__((visibility("default"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(uint32_t _res) {
+void  __attribute__((visibility("default"))) TS_CResult_InitFeaturesDecodeErrorZ_free(uint32_t _res) {
        if ((_res & 1) != 0) return;
-       LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)_res) & ~1);
+       LDKCResult_InitFeaturesDecodeErrorZ _res_conv = *(LDKCResult_InitFeaturesDecodeErrorZ*)(((uint64_t)_res) & ~1);
        FREE((void*)_res);
-       C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res_conv);
+       CResult_InitFeaturesDecodeErrorZ_free(_res_conv);
 }
 
-void  __attribute__((visibility("default"))) TS_CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(uint32_tArray _res) {
-       LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res_constr;
-       _res_constr.datalen = *((uint32_t*)_res);
-       if (_res_constr.datalen > 0)
-               _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ Elements");
-       else
-               _res_constr.data = NULL;
-       uint32_t* _res_vals = (uint32_t*)(_res + 4);
-       for (size_t l = 0; l < _res_constr.datalen; l++) {
-               uint32_t _res_conv_63 = _res_vals[l];
-               LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res_conv_63_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)_res_conv_63) & ~1);
-               FREE((void*)_res_conv_63);
-               _res_constr.data[l] = _res_conv_63_conv;
-       }
-       CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res_constr);
+uint32_t  __attribute__((visibility("default"))) TS_CResult_NodeFeaturesDecodeErrorZ_ok(uint32_t o) {
+       LDKNodeFeatures o_conv;
+       o_conv.inner = (void*)(o & (~1));
+       o_conv.is_owned = (o & 1) || (o == 0);
+       o_conv = NodeFeatures_clone(&o_conv);
+       LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
+       *ret_conv = CResult_NodeFeaturesDecodeErrorZ_ok(o_conv);
+       return (long)ret_conv;
 }
 
-void  __attribute__((visibility("default"))) TS_CVec_NodeAnnouncementZ_free(uint32_tArray _res) {
-       LDKCVec_NodeAnnouncementZ _res_constr;
-       _res_constr.datalen = *((uint32_t*)_res);
-       if (_res_constr.datalen > 0)
-               _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKNodeAnnouncement), "LDKCVec_NodeAnnouncementZ Elements");
-       else
-               _res_constr.data = NULL;
-       uint32_t* _res_vals = (uint32_t*)(_res + 4);
-       for (size_t s = 0; s < _res_constr.datalen; s++) {
-               uint32_t _res_conv_18 = _res_vals[s];
-               LDKNodeAnnouncement _res_conv_18_conv;
-               _res_conv_18_conv.inner = (void*)(_res_conv_18 & (~1));
-               _res_conv_18_conv.is_owned = (_res_conv_18 & 1) || (_res_conv_18 == 0);
-               _res_constr.data[s] = _res_conv_18_conv;
-       }
-       CVec_NodeAnnouncementZ_free(_res_constr);
+uint32_t  __attribute__((visibility("default"))) TS_CResult_NodeFeaturesDecodeErrorZ_err(uint32_t e) {
+       LDKDecodeError e_conv;
+       e_conv.inner = (void*)(e & (~1));
+       e_conv.is_owned = (e & 1) || (e == 0);
+       e_conv = DecodeError_clone(&e_conv);
+       LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
+       *ret_conv = CResult_NodeFeaturesDecodeErrorZ_err(e_conv);
+       return (long)ret_conv;
 }
 
-uint32_t  __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_ok() {
-       LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
-       *ret_conv = CResult_NoneLightningErrorZ_ok();
+void  __attribute__((visibility("default"))) TS_CResult_NodeFeaturesDecodeErrorZ_free(uint32_t _res) {
+       if ((_res & 1) != 0) return;
+       LDKCResult_NodeFeaturesDecodeErrorZ _res_conv = *(LDKCResult_NodeFeaturesDecodeErrorZ*)(((uint64_t)_res) & ~1);
+       FREE((void*)_res);
+       CResult_NodeFeaturesDecodeErrorZ_free(_res_conv);
+}
+
+uint32_t  __attribute__((visibility("default"))) TS_CResult_ChannelFeaturesDecodeErrorZ_ok(uint32_t o) {
+       LDKChannelFeatures o_conv;
+       o_conv.inner = (void*)(o & (~1));
+       o_conv.is_owned = (o & 1) || (o == 0);
+       o_conv = ChannelFeatures_clone(&o_conv);
+       LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
+       *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_ok(o_conv);
        return (long)ret_conv;
 }
 
-uint32_t  __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_err(uint32_t e) {
-       LDKLightningError e_conv;
+uint32_t  __attribute__((visibility("default"))) TS_CResult_ChannelFeaturesDecodeErrorZ_err(uint32_t e) {
+       LDKDecodeError e_conv;
        e_conv.inner = (void*)(e & (~1));
        e_conv.is_owned = (e & 1) || (e == 0);
-       e_conv = LightningError_clone(&e_conv);
-       LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
-       *ret_conv = CResult_NoneLightningErrorZ_err(e_conv);
+       e_conv = DecodeError_clone(&e_conv);
+       LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
+       *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_err(e_conv);
        return (long)ret_conv;
 }
 
-void  __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_free(uint32_t _res) {
+void  __attribute__((visibility("default"))) TS_CResult_ChannelFeaturesDecodeErrorZ_free(uint32_t _res) {
        if ((_res & 1) != 0) return;
-       LDKCResult_NoneLightningErrorZ _res_conv = *(LDKCResult_NoneLightningErrorZ*)(((uint64_t)_res) & ~1);
+       LDKCResult_ChannelFeaturesDecodeErrorZ _res_conv = *(LDKCResult_ChannelFeaturesDecodeErrorZ*)(((uint64_t)_res) & ~1);
        FREE((void*)_res);
-       CResult_NoneLightningErrorZ_free(_res_conv);
+       CResult_ChannelFeaturesDecodeErrorZ_free(_res_conv);
 }
 
-uint32_t  __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_clone(uint32_t orig) {
-       LDKCResult_NoneLightningErrorZ* orig_conv = (LDKCResult_NoneLightningErrorZ*)(orig & ~1);
-       LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
-       *ret_conv = CResult_NoneLightningErrorZ_clone(orig_conv);
+uint32_t  __attribute__((visibility("default"))) TS_CResult_ChannelConfigDecodeErrorZ_ok(uint32_t o) {
+       LDKChannelConfig o_conv;
+       o_conv.inner = (void*)(o & (~1));
+       o_conv.is_owned = (o & 1) || (o == 0);
+       o_conv = ChannelConfig_clone(&o_conv);
+       LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
+       *ret_conv = CResult_ChannelConfigDecodeErrorZ_ok(o_conv);
        return (long)ret_conv;
 }
 
-void  __attribute__((visibility("default"))) TS_CVec_MessageSendEventZ_free(uint32_tArray _res) {
-       LDKCVec_MessageSendEventZ _res_constr;
-       _res_constr.datalen = *((uint32_t*)_res);
-       if (_res_constr.datalen > 0)
-               _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKMessageSendEvent), "LDKCVec_MessageSendEventZ Elements");
-       else
-               _res_constr.data = NULL;
-       uint32_t* _res_vals = (uint32_t*)(_res + 4);
-       for (size_t s = 0; s < _res_constr.datalen; s++) {
-               uint32_t _res_conv_18 = _res_vals[s];
-               LDKMessageSendEvent _res_conv_18_conv = *(LDKMessageSendEvent*)(((uint64_t)_res_conv_18) & ~1);
-               FREE((void*)_res_conv_18);
-               _res_constr.data[s] = _res_conv_18_conv;
-       }
-       CVec_MessageSendEventZ_free(_res_constr);
+uint32_t  __attribute__((visibility("default"))) TS_CResult_ChannelConfigDecodeErrorZ_err(uint32_t e) {
+       LDKDecodeError e_conv;
+       e_conv.inner = (void*)(e & (~1));
+       e_conv.is_owned = (e & 1) || (e == 0);
+       e_conv = DecodeError_clone(&e_conv);
+       LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
+       *ret_conv = CResult_ChannelConfigDecodeErrorZ_err(e_conv);
+       return (long)ret_conv;
+}
+
+void  __attribute__((visibility("default"))) TS_CResult_ChannelConfigDecodeErrorZ_free(uint32_t _res) {
+       if ((_res & 1) != 0) return;
+       LDKCResult_ChannelConfigDecodeErrorZ _res_conv = *(LDKCResult_ChannelConfigDecodeErrorZ*)(((uint64_t)_res) & ~1);
+       FREE((void*)_res);
+       CResult_ChannelConfigDecodeErrorZ_free(_res_conv);
+}
+
+uint32_t  __attribute__((visibility("default"))) TS_CResult_ChannelConfigDecodeErrorZ_clone(uint32_t orig) {
+       LDKCResult_ChannelConfigDecodeErrorZ* orig_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)(orig & ~1);
+       LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
+       *ret_conv = CResult_ChannelConfigDecodeErrorZ_clone(orig_conv);
+       return (long)ret_conv;
 }
 
 uint32_t  __attribute__((visibility("default"))) TS_CResult_DirectionalChannelInfoDecodeErrorZ_ok(uint32_t o) {
@@ -10435,6 +10357,78 @@ void  __attribute__((visibility("default"))) TS_ChannelManager_free(uint32_t thi
        ChannelManager_free(this_ptr_conv);
 }
 
+void  __attribute__((visibility("default"))) TS_ChainParameters_free(uint32_t this_ptr) {
+       LDKChainParameters this_ptr_conv;
+       this_ptr_conv.inner = (void*)(this_ptr & (~1));
+       this_ptr_conv.is_owned = (this_ptr & 1) || (this_ptr == 0);
+       ChainParameters_free(this_ptr_conv);
+}
+
+uint32_t  __attribute__((visibility("default"))) TS_ChainParameters_get_network(uint32_t this_ptr) {
+       LDKChainParameters this_ptr_conv;
+       this_ptr_conv.inner = (void*)(this_ptr & (~1));
+       this_ptr_conv.is_owned = false;
+       uint32_t ret_conv = LDKNetwork_to_js(ChainParameters_get_network(&this_ptr_conv));
+       return ret_conv;
+}
+
+void  __attribute__((visibility("default"))) TS_ChainParameters_set_network(uint32_t this_ptr, uint32_t val) {
+       LDKChainParameters this_ptr_conv;
+       this_ptr_conv.inner = (void*)(this_ptr & (~1));
+       this_ptr_conv.is_owned = false;
+       LDKNetwork val_conv = LDKNetwork_from_js(val);
+       ChainParameters_set_network(&this_ptr_conv, val_conv);
+}
+
+int8_tArray  __attribute__((visibility("default"))) TS_ChainParameters_get_latest_hash(uint32_t this_ptr) {
+       LDKChainParameters this_ptr_conv;
+       this_ptr_conv.inner = (void*)(this_ptr & (~1));
+       this_ptr_conv.is_owned = false;
+       int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
+       memcpy((uint8_t*)(ret_arr + 4), *ChainParameters_get_latest_hash(&this_ptr_conv), 32);
+       return ret_arr;
+}
+
+void  __attribute__((visibility("default"))) TS_ChainParameters_set_latest_hash(uint32_t this_ptr, int8_tArray val) {
+       LDKChainParameters this_ptr_conv;
+       this_ptr_conv.inner = (void*)(this_ptr & (~1));
+       this_ptr_conv.is_owned = false;
+       LDKThirtyTwoBytes val_ref;
+       CHECK(*((uint32_t*)val) == 32);
+       memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
+       ChainParameters_set_latest_hash(&this_ptr_conv, val_ref);
+}
+
+int64_t  __attribute__((visibility("default"))) TS_ChainParameters_get_latest_height(uint32_t this_ptr) {
+       LDKChainParameters this_ptr_conv;
+       this_ptr_conv.inner = (void*)(this_ptr & (~1));
+       this_ptr_conv.is_owned = false;
+       int64_t ret_val = ChainParameters_get_latest_height(&this_ptr_conv);
+       return ret_val;
+}
+
+void  __attribute__((visibility("default"))) TS_ChainParameters_set_latest_height(uint32_t this_ptr, int64_t val) {
+       LDKChainParameters this_ptr_conv;
+       this_ptr_conv.inner = (void*)(this_ptr & (~1));
+       this_ptr_conv.is_owned = false;
+       ChainParameters_set_latest_height(&this_ptr_conv, val);
+}
+
+uint32_t  __attribute__((visibility("default"))) TS_ChainParameters_new(uint32_t network_arg, int8_tArray latest_hash_arg, int64_t latest_height_arg) {
+       LDKNetwork network_arg_conv = LDKNetwork_from_js(network_arg);
+       LDKThirtyTwoBytes latest_hash_arg_ref;
+       CHECK(*((uint32_t*)latest_hash_arg) == 32);
+       memcpy(latest_hash_arg_ref.data, (uint8_t*)(latest_hash_arg + 4), 32);
+       LDKChainParameters ret_var = ChainParameters_new(network_arg_conv, latest_hash_arg_ref, latest_height_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;
+       if (ret_var.is_owned) {
+               ret_ref |= 1;
+       }
+       return ret_ref;
+}
+
 void  __attribute__((visibility("default"))) TS_ChannelDetails_free(uint32_t this_ptr) {
        LDKChannelDetails this_ptr_conv;
        this_ptr_conv.inner = (void*)(this_ptr & (~1));
@@ -10609,8 +10603,7 @@ uint32_t  __attribute__((visibility("default"))) TS_PaymentSendFailure_clone(uin
        return ret_ref;
 }
 
-uint32_t  __attribute__((visibility("default"))) TS_ChannelManager_new(uint32_t network, uint32_t fee_est, uint32_t chain_monitor, uint32_t tx_broadcaster, uint32_t logger, uint32_t keys_manager, uint32_t config, int64_t current_blockchain_height) {
-       LDKNetwork network_conv = LDKNetwork_from_js(network);
+uint32_t  __attribute__((visibility("default"))) TS_ChannelManager_new(uint32_t fee_est, uint32_t chain_monitor, uint32_t tx_broadcaster, uint32_t logger, uint32_t keys_manager, uint32_t config, uint32_t params) {
        LDKFeeEstimator fee_est_conv = *(LDKFeeEstimator*)(((uint64_t)fee_est) & ~1);
        LDKWatch chain_monitor_conv = *(LDKWatch*)(((uint64_t)chain_monitor) & ~1);
        LDKBroadcasterInterface tx_broadcaster_conv = *(LDKBroadcasterInterface*)(((uint64_t)tx_broadcaster) & ~1);
@@ -10620,7 +10613,11 @@ uint32_t  __attribute__((visibility("default"))) TS_ChannelManager_new(uint32_t
        config_conv.inner = (void*)(config & (~1));
        config_conv.is_owned = (config & 1) || (config == 0);
        config_conv = UserConfig_clone(&config_conv);
-       LDKChannelManager ret_var = ChannelManager_new(network_conv, fee_est_conv, chain_monitor_conv, tx_broadcaster_conv, logger_conv, keys_manager_conv, config_conv, current_blockchain_height);
+       LDKChainParameters params_conv;
+       params_conv.inner = (void*)(params & (~1));
+       params_conv.is_owned = (params & 1) || (params == 0);
+       // Warning: we need a move here but no clone is available for LDKChainParameters
+       LDKChannelManager ret_var = ChannelManager_new(fee_est_conv, chain_monitor_conv, tx_broadcaster_conv, logger_conv, keys_manager_conv, config_conv, params_conv);
        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;
@@ -15447,6 +15444,78 @@ int8_tArray  __attribute__((visibility("default"))) TS_GossipTimestampFilter_wri
        return ret_arr;
 }
 
+void  __attribute__((visibility("default"))) TS_IgnoringMessageHandler_free(uint32_t this_ptr) {
+       LDKIgnoringMessageHandler this_ptr_conv;
+       this_ptr_conv.inner = (void*)(this_ptr & (~1));
+       this_ptr_conv.is_owned = (this_ptr & 1) || (this_ptr == 0);
+       IgnoringMessageHandler_free(this_ptr_conv);
+}
+
+uint32_t  __attribute__((visibility("default"))) TS_IgnoringMessageHandler_new() {
+       LDKIgnoringMessageHandler ret_var = IgnoringMessageHandler_new();
+       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;
+       if (ret_var.is_owned) {
+               ret_ref |= 1;
+       }
+       return ret_ref;
+}
+
+uint32_t  __attribute__((visibility("default"))) TS_IgnoringMessageHandler_as_MessageSendEventsProvider(uint32_t this_arg) {
+       LDKIgnoringMessageHandler this_arg_conv;
+       this_arg_conv.inner = (void*)(this_arg & (~1));
+       this_arg_conv.is_owned = false;
+       LDKMessageSendEventsProvider* ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
+       *ret = IgnoringMessageHandler_as_MessageSendEventsProvider(&this_arg_conv);
+       return (long)ret;
+}
+
+uint32_t  __attribute__((visibility("default"))) TS_IgnoringMessageHandler_as_RoutingMessageHandler(uint32_t this_arg) {
+       LDKIgnoringMessageHandler this_arg_conv;
+       this_arg_conv.inner = (void*)(this_arg & (~1));
+       this_arg_conv.is_owned = false;
+       LDKRoutingMessageHandler* ret = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
+       *ret = IgnoringMessageHandler_as_RoutingMessageHandler(&this_arg_conv);
+       return (long)ret;
+}
+
+void  __attribute__((visibility("default"))) TS_ErroringMessageHandler_free(uint32_t this_ptr) {
+       LDKErroringMessageHandler this_ptr_conv;
+       this_ptr_conv.inner = (void*)(this_ptr & (~1));
+       this_ptr_conv.is_owned = (this_ptr & 1) || (this_ptr == 0);
+       ErroringMessageHandler_free(this_ptr_conv);
+}
+
+uint32_t  __attribute__((visibility("default"))) TS_ErroringMessageHandler_new() {
+       LDKErroringMessageHandler ret_var = ErroringMessageHandler_new();
+       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;
+       if (ret_var.is_owned) {
+               ret_ref |= 1;
+       }
+       return ret_ref;
+}
+
+uint32_t  __attribute__((visibility("default"))) TS_ErroringMessageHandler_as_MessageSendEventsProvider(uint32_t this_arg) {
+       LDKErroringMessageHandler this_arg_conv;
+       this_arg_conv.inner = (void*)(this_arg & (~1));
+       this_arg_conv.is_owned = false;
+       LDKMessageSendEventsProvider* ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
+       *ret = ErroringMessageHandler_as_MessageSendEventsProvider(&this_arg_conv);
+       return (long)ret;
+}
+
+uint32_t  __attribute__((visibility("default"))) TS_ErroringMessageHandler_as_ChannelMessageHandler(uint32_t this_arg) {
+       LDKErroringMessageHandler this_arg_conv;
+       this_arg_conv.inner = (void*)(this_arg & (~1));
+       this_arg_conv.is_owned = false;
+       LDKChannelMessageHandler* ret = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
+       *ret = ErroringMessageHandler_as_ChannelMessageHandler(&this_arg_conv);
+       return (long)ret;
+}
+
 void  __attribute__((visibility("default"))) TS_MessageHandler_free(uint32_t this_ptr) {
        LDKMessageHandler this_ptr_conv;
        this_ptr_conv.inner = (void*)(this_ptr & (~1));
@@ -17602,39 +17671,6 @@ void  __attribute__((visibility("default"))) TS_RouteHint_set_cltv_expiry_delta(
        RouteHint_set_cltv_expiry_delta(&this_ptr_conv, val);
 }
 
-int64_t  __attribute__((visibility("default"))) TS_RouteHint_get_htlc_minimum_msat(uint32_t this_ptr) {
-       LDKRouteHint this_ptr_conv;
-       this_ptr_conv.inner = (void*)(this_ptr & (~1));
-       this_ptr_conv.is_owned = false;
-       int64_t ret_val = RouteHint_get_htlc_minimum_msat(&this_ptr_conv);
-       return ret_val;
-}
-
-void  __attribute__((visibility("default"))) TS_RouteHint_set_htlc_minimum_msat(uint32_t this_ptr, int64_t val) {
-       LDKRouteHint this_ptr_conv;
-       this_ptr_conv.inner = (void*)(this_ptr & (~1));
-       this_ptr_conv.is_owned = false;
-       RouteHint_set_htlc_minimum_msat(&this_ptr_conv, val);
-}
-
-uint32_t  __attribute__((visibility("default"))) TS_RouteHint_new(int8_tArray src_node_id_arg, int64_t short_channel_id_arg, uint32_t fees_arg, int16_t cltv_expiry_delta_arg, int64_t htlc_minimum_msat_arg) {
-       LDKPublicKey src_node_id_arg_ref;
-       CHECK(*((uint32_t*)src_node_id_arg) == 33);
-       memcpy(src_node_id_arg_ref.compressed_form, (uint8_t*)(src_node_id_arg + 4), 33);
-       LDKRoutingFees fees_arg_conv;
-       fees_arg_conv.inner = (void*)(fees_arg & (~1));
-       fees_arg_conv.is_owned = (fees_arg & 1) || (fees_arg == 0);
-       fees_arg_conv = RoutingFees_clone(&fees_arg_conv);
-       LDKRouteHint ret_var = RouteHint_new(src_node_id_arg_ref, short_channel_id_arg, fees_arg_conv, cltv_expiry_delta_arg, htlc_minimum_msat_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;
-       if (ret_var.is_owned) {
-               ret_ref |= 1;
-       }
-       return ret_ref;
-}
-
 uint32_t  __attribute__((visibility("default"))) TS_RouteHint_clone(uint32_t orig) {
        LDKRouteHint orig_conv;
        orig_conv.inner = (void*)(orig & (~1));
@@ -17649,16 +17685,16 @@ uint32_t  __attribute__((visibility("default"))) TS_RouteHint_clone(uint32_t ori
        return ret_ref;
 }
 
-uint32_t  __attribute__((visibility("default"))) TS_get_route(int8_tArray our_node_id, uint32_t network, int8_tArray target, uint32_tArray first_hops, uint32_tArray last_hops, int64_t final_value_msat, int32_t final_cltv, uint32_t logger) {
+uint32_t  __attribute__((visibility("default"))) TS_get_route(int8_tArray our_node_id, uint32_t network, int8_tArray payee, uint32_tArray first_hops, uint32_tArray last_hops, int64_t final_value_msat, int32_t final_cltv, uint32_t logger) {
        LDKPublicKey our_node_id_ref;
        CHECK(*((uint32_t*)our_node_id) == 33);
        memcpy(our_node_id_ref.compressed_form, (uint8_t*)(our_node_id + 4), 33);
        LDKNetworkGraph network_conv;
        network_conv.inner = (void*)(network & (~1));
        network_conv.is_owned = false;
-       LDKPublicKey target_ref;
-       CHECK(*((uint32_t*)target) == 33);
-       memcpy(target_ref.compressed_form, (uint8_t*)(target + 4), 33);
+       LDKPublicKey payee_ref;
+       CHECK(*((uint32_t*)payee) == 33);
+       memcpy(payee_ref.compressed_form, (uint8_t*)(payee + 4), 33);
        LDKCVec_ChannelDetailsZ first_hops_constr;
        first_hops_constr.datalen = *((uint32_t*)first_hops);
        if (first_hops_constr.datalen > 0)
@@ -17690,7 +17726,7 @@ uint32_t  __attribute__((visibility("default"))) TS_get_route(int8_tArray our_no
        }
        LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
        LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
-       *ret_conv = get_route(our_node_id_ref, &network_conv, target_ref, &first_hops_constr, last_hops_constr, final_value_msat, final_cltv, logger_conv);
+       *ret_conv = get_route(our_node_id_ref, &network_conv, payee_ref, &first_hops_constr, last_hops_constr, final_value_msat, final_cltv, logger_conv);
        FREE(first_hops_constr.data);
        return (long)ret_conv;
 }
@@ -17763,6 +17799,14 @@ uint32_t  __attribute__((visibility("default"))) TS_NetGraphMsgHandler_from_net_
        return ret_ref;
 }
 
+void  __attribute__((visibility("default"))) TS_NetGraphMsgHandler_add_chain_access(uint32_t this_arg, uint32_t chain_access) {
+       LDKNetGraphMsgHandler this_arg_conv;
+       this_arg_conv.inner = (void*)(this_arg & (~1));
+       this_arg_conv.is_owned = false;
+       LDKAccess* chain_access_conv = (LDKAccess*)chain_access;
+       NetGraphMsgHandler_add_chain_access(&this_arg_conv, chain_access_conv);
+}
+
 uint32_t  __attribute__((visibility("default"))) TS_NetGraphMsgHandler_read_locked_graph(uint32_t this_arg) {
        LDKNetGraphMsgHandler this_arg_conv;
        this_arg_conv.inner = (void*)(this_arg & (~1));
index 712fef7d3e1d5e9b64c2832f8f92a26c7f29ac3b..ed4a3fdfb1a1101a1d944099fc66d433b55460f8 100644 (file)
@@ -191,39 +191,6 @@ public static native long new_empty_slice_vec();
        public static native boolean LDKCResult_CVec_SignatureZNoneZ_result_ok(long arg);
        public static native Uint8Array[] LDKCResult_CVec_SignatureZNoneZ_get_ok(long arg);
        public static native void LDKCResult_CVec_SignatureZNoneZ_get_err(long arg);
-       public static native boolean LDKCResult_CVec_u8ZPeerHandleErrorZ_result_ok(long arg);
-       public static native Uint8Array LDKCResult_CVec_u8ZPeerHandleErrorZ_get_ok(long arg);
-       public static native number LDKCResult_CVec_u8ZPeerHandleErrorZ_get_err(long arg);
-       public static native boolean LDKCResult_NonePeerHandleErrorZ_result_ok(long arg);
-       public static native void LDKCResult_NonePeerHandleErrorZ_get_ok(long arg);
-       public static native number LDKCResult_NonePeerHandleErrorZ_get_err(long arg);
-       public static native boolean LDKCResult_boolPeerHandleErrorZ_result_ok(long arg);
-       public static native boolean LDKCResult_boolPeerHandleErrorZ_get_ok(long arg);
-       public static native number LDKCResult_boolPeerHandleErrorZ_get_err(long arg);
-       public static native boolean LDKCResult_InitFeaturesDecodeErrorZ_result_ok(long arg);
-       public static native number LDKCResult_InitFeaturesDecodeErrorZ_get_ok(long arg);
-       public static native number LDKCResult_InitFeaturesDecodeErrorZ_get_err(long arg);
-       public static native boolean LDKCResult_NodeFeaturesDecodeErrorZ_result_ok(long arg);
-       public static native number LDKCResult_NodeFeaturesDecodeErrorZ_get_ok(long arg);
-       public static native number LDKCResult_NodeFeaturesDecodeErrorZ_get_err(long arg);
-       public static native boolean LDKCResult_ChannelFeaturesDecodeErrorZ_result_ok(long arg);
-       public static native number LDKCResult_ChannelFeaturesDecodeErrorZ_get_ok(long arg);
-       public static native number LDKCResult_ChannelFeaturesDecodeErrorZ_get_err(long arg);
-       public static native boolean LDKCResult_ChannelConfigDecodeErrorZ_result_ok(long arg);
-       public static native number LDKCResult_ChannelConfigDecodeErrorZ_get_ok(long arg);
-       public static native number LDKCResult_ChannelConfigDecodeErrorZ_get_err(long arg);
-       public static native boolean LDKCResult_boolLightningErrorZ_result_ok(long arg);
-       public static native boolean LDKCResult_boolLightningErrorZ_get_ok(long arg);
-       public static native number LDKCResult_boolLightningErrorZ_get_err(long arg);
-       public static native long LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(number a, number b, number c);
-       public static native number LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(long ptr);
-       public static native number LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(long ptr);
-       public static native number LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(long ptr);
-       public static native long LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_new(number[] elems);
-       public static native long LDKCVec_NodeAnnouncementZ_new(number[] elems);
-       public static native boolean LDKCResult_NoneLightningErrorZ_result_ok(long arg);
-       public static native void LDKCResult_NoneLightningErrorZ_get_ok(long arg);
-       public static native number LDKCResult_NoneLightningErrorZ_get_err(long arg);
        public static class LDKErrorAction {
                private LDKErrorAction() {}
                export class DisconnectPeer extends LDKErrorAction {
@@ -355,6 +322,39 @@ public static native long new_empty_slice_vec();
        static { LDKMessageSendEvent.init(); }
        public static native LDKMessageSendEvent LDKMessageSendEvent_ref_from_ptr(long ptr);
        public static native long LDKCVec_MessageSendEventZ_new(number[] elems);
+       public static native boolean LDKCResult_boolLightningErrorZ_result_ok(long arg);
+       public static native boolean LDKCResult_boolLightningErrorZ_get_ok(long arg);
+       public static native number LDKCResult_boolLightningErrorZ_get_err(long arg);
+       public static native long LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(number a, number b, number c);
+       public static native number LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(long ptr);
+       public static native number LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(long ptr);
+       public static native number LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(long ptr);
+       public static native long LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_new(number[] elems);
+       public static native long LDKCVec_NodeAnnouncementZ_new(number[] elems);
+       public static native boolean LDKCResult_NoneLightningErrorZ_result_ok(long arg);
+       public static native void LDKCResult_NoneLightningErrorZ_get_ok(long arg);
+       public static native number LDKCResult_NoneLightningErrorZ_get_err(long arg);
+       public static native boolean LDKCResult_CVec_u8ZPeerHandleErrorZ_result_ok(long arg);
+       public static native Uint8Array LDKCResult_CVec_u8ZPeerHandleErrorZ_get_ok(long arg);
+       public static native number LDKCResult_CVec_u8ZPeerHandleErrorZ_get_err(long arg);
+       public static native boolean LDKCResult_NonePeerHandleErrorZ_result_ok(long arg);
+       public static native void LDKCResult_NonePeerHandleErrorZ_get_ok(long arg);
+       public static native number LDKCResult_NonePeerHandleErrorZ_get_err(long arg);
+       public static native boolean LDKCResult_boolPeerHandleErrorZ_result_ok(long arg);
+       public static native boolean LDKCResult_boolPeerHandleErrorZ_get_ok(long arg);
+       public static native number LDKCResult_boolPeerHandleErrorZ_get_err(long arg);
+       public static native boolean LDKCResult_InitFeaturesDecodeErrorZ_result_ok(long arg);
+       public static native number LDKCResult_InitFeaturesDecodeErrorZ_get_ok(long arg);
+       public static native number LDKCResult_InitFeaturesDecodeErrorZ_get_err(long arg);
+       public static native boolean LDKCResult_NodeFeaturesDecodeErrorZ_result_ok(long arg);
+       public static native number LDKCResult_NodeFeaturesDecodeErrorZ_get_ok(long arg);
+       public static native number LDKCResult_NodeFeaturesDecodeErrorZ_get_err(long arg);
+       public static native boolean LDKCResult_ChannelFeaturesDecodeErrorZ_result_ok(long arg);
+       public static native number LDKCResult_ChannelFeaturesDecodeErrorZ_get_ok(long arg);
+       public static native number LDKCResult_ChannelFeaturesDecodeErrorZ_get_err(long arg);
+       public static native boolean LDKCResult_ChannelConfigDecodeErrorZ_result_ok(long arg);
+       public static native number LDKCResult_ChannelConfigDecodeErrorZ_get_ok(long arg);
+       public static native number LDKCResult_ChannelConfigDecodeErrorZ_get_err(long arg);
        public static native boolean LDKCResult_DirectionalChannelInfoDecodeErrorZ_result_ok(long arg);
        public static native number LDKCResult_DirectionalChannelInfoDecodeErrorZ_get_ok(long arg);
        public static native number LDKCResult_DirectionalChannelInfoDecodeErrorZ_get_err(long arg);
@@ -1938,6 +1938,118 @@ public static native long new_empty_slice_vec();
                const nativeResponseValue = wasm.CResult_CVec_SignatureZNoneZ_clone(orig);
                return nativeResponseValue;
        }
+       // void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
+       export function CVec_MessageSendEventZ_free(_res: number[]): void {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.CVec_MessageSendEventZ_free(_res);
+               // debug statements here
+       }
+       // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
+       export function CResult_boolLightningErrorZ_ok(o: boolean): number {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.CResult_boolLightningErrorZ_ok(o);
+               return nativeResponseValue;
+       }
+       // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
+       export function CResult_boolLightningErrorZ_err(e: number): number {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.CResult_boolLightningErrorZ_err(e);
+               return nativeResponseValue;
+       }
+       // void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
+       export function CResult_boolLightningErrorZ_free(_res: number): void {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.CResult_boolLightningErrorZ_free(_res);
+               // debug statements here
+       }
+       // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
+       export function CResult_boolLightningErrorZ_clone(orig: number): number {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.CResult_boolLightningErrorZ_clone(orig);
+               return nativeResponseValue;
+       }
+       // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
+       export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig: number): number {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig);
+               return nativeResponseValue;
+       }
+       // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
+       export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a: number, b: number, c: number): number {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a, b, c);
+               return nativeResponseValue;
+       }
+       // void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res);
+       export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res: number): void {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res);
+               // debug statements here
+       }
+       // void CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(struct LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res);
+       export function CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res: number[]): void {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res);
+               // debug statements here
+       }
+       // void CVec_NodeAnnouncementZ_free(struct LDKCVec_NodeAnnouncementZ _res);
+       export function CVec_NodeAnnouncementZ_free(_res: number[]): void {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.CVec_NodeAnnouncementZ_free(_res);
+               // debug statements here
+       }
+       // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
+       export function CResult_NoneLightningErrorZ_ok(): number {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.CResult_NoneLightningErrorZ_ok();
+               return nativeResponseValue;
+       }
+       // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
+       export function CResult_NoneLightningErrorZ_err(e: number): number {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.CResult_NoneLightningErrorZ_err(e);
+               return nativeResponseValue;
+       }
+       // void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
+       export function CResult_NoneLightningErrorZ_free(_res: number): void {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.CResult_NoneLightningErrorZ_free(_res);
+               // debug statements here
+       }
+       // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
+       export function CResult_NoneLightningErrorZ_clone(orig: number): number {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.CResult_NoneLightningErrorZ_clone(orig);
+               return nativeResponseValue;
+       }
        // void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
        export function CVec_PublicKeyZ_free(_res: Uint8Array[]): void {
                if(!isWasmInitialized) {
@@ -2154,118 +2266,6 @@ public static native long new_empty_slice_vec();
                const nativeResponseValue = wasm.CResult_ChannelConfigDecodeErrorZ_clone(orig);
                return nativeResponseValue;
        }
-       // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
-       export function CResult_boolLightningErrorZ_ok(o: boolean): number {
-               if(!isWasmInitialized) {
-                       throw new Error("initializeWasm() must be awaited first!");
-               }
-               const nativeResponseValue = wasm.CResult_boolLightningErrorZ_ok(o);
-               return nativeResponseValue;
-       }
-       // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
-       export function CResult_boolLightningErrorZ_err(e: number): number {
-               if(!isWasmInitialized) {
-                       throw new Error("initializeWasm() must be awaited first!");
-               }
-               const nativeResponseValue = wasm.CResult_boolLightningErrorZ_err(e);
-               return nativeResponseValue;
-       }
-       // void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
-       export function CResult_boolLightningErrorZ_free(_res: number): void {
-               if(!isWasmInitialized) {
-                       throw new Error("initializeWasm() must be awaited first!");
-               }
-               const nativeResponseValue = wasm.CResult_boolLightningErrorZ_free(_res);
-               // debug statements here
-       }
-       // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
-       export function CResult_boolLightningErrorZ_clone(orig: number): number {
-               if(!isWasmInitialized) {
-                       throw new Error("initializeWasm() must be awaited first!");
-               }
-               const nativeResponseValue = wasm.CResult_boolLightningErrorZ_clone(orig);
-               return nativeResponseValue;
-       }
-       // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
-       export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig: number): number {
-               if(!isWasmInitialized) {
-                       throw new Error("initializeWasm() must be awaited first!");
-               }
-               const nativeResponseValue = wasm.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig);
-               return nativeResponseValue;
-       }
-       // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
-       export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a: number, b: number, c: number): number {
-               if(!isWasmInitialized) {
-                       throw new Error("initializeWasm() must be awaited first!");
-               }
-               const nativeResponseValue = wasm.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a, b, c);
-               return nativeResponseValue;
-       }
-       // void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res);
-       export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res: number): void {
-               if(!isWasmInitialized) {
-                       throw new Error("initializeWasm() must be awaited first!");
-               }
-               const nativeResponseValue = wasm.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res);
-               // debug statements here
-       }
-       // void CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(struct LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res);
-       export function CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res: number[]): void {
-               if(!isWasmInitialized) {
-                       throw new Error("initializeWasm() must be awaited first!");
-               }
-               const nativeResponseValue = wasm.CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res);
-               // debug statements here
-       }
-       // void CVec_NodeAnnouncementZ_free(struct LDKCVec_NodeAnnouncementZ _res);
-       export function CVec_NodeAnnouncementZ_free(_res: number[]): void {
-               if(!isWasmInitialized) {
-                       throw new Error("initializeWasm() must be awaited first!");
-               }
-               const nativeResponseValue = wasm.CVec_NodeAnnouncementZ_free(_res);
-               // debug statements here
-       }
-       // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
-       export function CResult_NoneLightningErrorZ_ok(): number {
-               if(!isWasmInitialized) {
-                       throw new Error("initializeWasm() must be awaited first!");
-               }
-               const nativeResponseValue = wasm.CResult_NoneLightningErrorZ_ok();
-               return nativeResponseValue;
-       }
-       // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
-       export function CResult_NoneLightningErrorZ_err(e: number): number {
-               if(!isWasmInitialized) {
-                       throw new Error("initializeWasm() must be awaited first!");
-               }
-               const nativeResponseValue = wasm.CResult_NoneLightningErrorZ_err(e);
-               return nativeResponseValue;
-       }
-       // void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
-       export function CResult_NoneLightningErrorZ_free(_res: number): void {
-               if(!isWasmInitialized) {
-                       throw new Error("initializeWasm() must be awaited first!");
-               }
-               const nativeResponseValue = wasm.CResult_NoneLightningErrorZ_free(_res);
-               // debug statements here
-       }
-       // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
-       export function CResult_NoneLightningErrorZ_clone(orig: number): number {
-               if(!isWasmInitialized) {
-                       throw new Error("initializeWasm() must be awaited first!");
-               }
-               const nativeResponseValue = wasm.CResult_NoneLightningErrorZ_clone(orig);
-               return nativeResponseValue;
-       }
-       // void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
-       export function CVec_MessageSendEventZ_free(_res: number[]): void {
-               if(!isWasmInitialized) {
-                       throw new Error("initializeWasm() must be awaited first!");
-               }
-               const nativeResponseValue = wasm.CVec_MessageSendEventZ_free(_res);
-               // debug statements here
-       }
        // struct LDKCResult_DirectionalChannelInfoDecodeErrorZ CResult_DirectionalChannelInfoDecodeErrorZ_ok(struct LDKDirectionalChannelInfo o);
        export function CResult_DirectionalChannelInfoDecodeErrorZ_ok(o: number): number {
                if(!isWasmInitialized) {
@@ -5210,7 +5210,7 @@ public static native long new_empty_slice_vec();
                const nativeResponseValue = wasm.ChannelMonitor_write(obj);
                return decodeArray(nativeResponseValue);
        }
-       // MUST_USE_RES struct LDKCResult_NoneMonitorUpdateErrorZ ChannelMonitor_update_monitor(struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKChannelMonitorUpdate *NONNULL_PTR updates, const struct LDKBroadcasterInterface *NONNULL_PTR broadcaster, const struct LDKFeeEstimator *NONNULL_PTR fee_estimator, const struct LDKLogger *NONNULL_PTR logger);
+       // MUST_USE_RES struct LDKCResult_NoneMonitorUpdateErrorZ ChannelMonitor_update_monitor(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKChannelMonitorUpdate *NONNULL_PTR updates, const struct LDKBroadcasterInterface *NONNULL_PTR broadcaster, const struct LDKFeeEstimator *NONNULL_PTR fee_estimator, const struct LDKLogger *NONNULL_PTR logger);
        export function ChannelMonitor_update_monitor(this_arg: number, updates: number, broadcaster: number, fee_estimator: number, logger: number): number {
                if(!isWasmInitialized) {
                        throw new Error("initializeWasm() must be awaited first!");
@@ -5234,7 +5234,7 @@ public static native long new_empty_slice_vec();
                const nativeResponseValue = wasm.ChannelMonitor_get_funding_txo(this_arg);
                return nativeResponseValue;
        }
-       // MUST_USE_RES struct LDKCVec_MonitorEventZ ChannelMonitor_get_and_clear_pending_monitor_events(struct LDKChannelMonitor *NONNULL_PTR this_arg);
+       // MUST_USE_RES struct LDKCVec_MonitorEventZ ChannelMonitor_get_and_clear_pending_monitor_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
        export function ChannelMonitor_get_and_clear_pending_monitor_events(this_arg: number): number[] {
                if(!isWasmInitialized) {
                        throw new Error("initializeWasm() must be awaited first!");
@@ -5242,7 +5242,7 @@ public static native long new_empty_slice_vec();
                const nativeResponseValue = wasm.ChannelMonitor_get_and_clear_pending_monitor_events(this_arg);
                return nativeResponseValue;
        }
-       // MUST_USE_RES struct LDKCVec_EventZ ChannelMonitor_get_and_clear_pending_events(struct LDKChannelMonitor *NONNULL_PTR this_arg);
+       // MUST_USE_RES struct LDKCVec_EventZ ChannelMonitor_get_and_clear_pending_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
        export function ChannelMonitor_get_and_clear_pending_events(this_arg: number): number[] {
                if(!isWasmInitialized) {
                        throw new Error("initializeWasm() must be awaited first!");
@@ -5250,7 +5250,7 @@ public static native long new_empty_slice_vec();
                const nativeResponseValue = wasm.ChannelMonitor_get_and_clear_pending_events(this_arg);
                return nativeResponseValue;
        }
-       // MUST_USE_RES struct LDKCVec_TransactionZ ChannelMonitor_get_latest_holder_commitment_txn(struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKLogger *NONNULL_PTR logger);
+       // MUST_USE_RES struct LDKCVec_TransactionZ ChannelMonitor_get_latest_holder_commitment_txn(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKLogger *NONNULL_PTR logger);
        export function ChannelMonitor_get_latest_holder_commitment_txn(this_arg: number, logger: number): Uint8Array[] {
                if(!isWasmInitialized) {
                        throw new Error("initializeWasm() must be awaited first!");
@@ -5258,7 +5258,7 @@ public static native long new_empty_slice_vec();
                const nativeResponseValue = wasm.ChannelMonitor_get_latest_holder_commitment_txn(this_arg, logger);
                return nativeResponseValue;
        }
-       // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ChannelMonitor_block_connected(struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKLogger logger);
+       // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ChannelMonitor_block_connected(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKLogger logger);
        export function ChannelMonitor_block_connected(this_arg: number, header: Uint8Array, txdata: number[], height: number, broadcaster: number, fee_estimator: number, logger: number): number[] {
                if(!isWasmInitialized) {
                        throw new Error("initializeWasm() must be awaited first!");
@@ -5266,7 +5266,7 @@ public static native long new_empty_slice_vec();
                const nativeResponseValue = wasm.ChannelMonitor_block_connected(this_arg, encodeArray(header), txdata, height, broadcaster, fee_estimator, logger);
                return nativeResponseValue;
        }
-       // void ChannelMonitor_block_disconnected(struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKLogger logger);
+       // void ChannelMonitor_block_disconnected(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKLogger logger);
        export function ChannelMonitor_block_disconnected(this_arg: number, header: Uint8Array, height: number, broadcaster: number, fee_estimator: number, logger: number): void {
                if(!isWasmInitialized) {
                        throw new Error("initializeWasm() must be awaited first!");
@@ -5890,6 +5890,70 @@ public static native long new_empty_slice_vec();
                const nativeResponseValue = wasm.ChannelManager_free(this_ptr);
                // debug statements here
        }
+       // void ChainParameters_free(struct LDKChainParameters this_ptr);
+       export function ChainParameters_free(this_ptr: number): void {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.ChainParameters_free(this_ptr);
+               // debug statements here
+       }
+       // enum LDKNetwork ChainParameters_get_network(const struct LDKChainParameters *NONNULL_PTR this_ptr);
+       export function ChainParameters_get_network(this_ptr: number): LDKNetwork {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.ChainParameters_get_network(this_ptr);
+               return nativeResponseValue;
+       }
+       // void ChainParameters_set_network(struct LDKChainParameters *NONNULL_PTR this_ptr, enum LDKNetwork val);
+       export function ChainParameters_set_network(this_ptr: number, val: LDKNetwork): void {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.ChainParameters_set_network(this_ptr, val);
+               // debug statements here
+       }
+       // const uint8_t (*ChainParameters_get_latest_hash(const struct LDKChainParameters *NONNULL_PTR this_ptr))[32];
+       export function ChainParameters_get_latest_hash(this_ptr: number): Uint8Array {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.ChainParameters_get_latest_hash(this_ptr);
+               return decodeArray(nativeResponseValue);
+       }
+       // void ChainParameters_set_latest_hash(struct LDKChainParameters *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
+       export function ChainParameters_set_latest_hash(this_ptr: number, val: Uint8Array): void {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.ChainParameters_set_latest_hash(this_ptr, encodeArray(val));
+               // debug statements here
+       }
+       // uintptr_t ChainParameters_get_latest_height(const struct LDKChainParameters *NONNULL_PTR this_ptr);
+       export function ChainParameters_get_latest_height(this_ptr: number): number {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.ChainParameters_get_latest_height(this_ptr);
+               return nativeResponseValue;
+       }
+       // void ChainParameters_set_latest_height(struct LDKChainParameters *NONNULL_PTR this_ptr, uintptr_t val);
+       export function ChainParameters_set_latest_height(this_ptr: number, val: number): void {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.ChainParameters_set_latest_height(this_ptr, val);
+               // debug statements here
+       }
+       // MUST_USE_RES struct LDKChainParameters ChainParameters_new(enum LDKNetwork network_arg, struct LDKThirtyTwoBytes latest_hash_arg, uintptr_t latest_height_arg);
+       export function ChainParameters_new(network_arg: LDKNetwork, latest_hash_arg: Uint8Array, latest_height_arg: number): number {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.ChainParameters_new(network_arg, encodeArray(latest_hash_arg), latest_height_arg);
+               return nativeResponseValue;
+       }
        // void ChannelDetails_free(struct LDKChannelDetails this_ptr);
        export function ChannelDetails_free(this_ptr: number): void {
                if(!isWasmInitialized) {
@@ -6050,12 +6114,12 @@ public static native long new_empty_slice_vec();
                const nativeResponseValue = wasm.PaymentSendFailure_clone(orig);
                return nativeResponseValue;
        }
-       // MUST_USE_RES struct LDKChannelManager ChannelManager_new(enum LDKNetwork network, struct LDKFeeEstimator fee_est, struct LDKWatch chain_monitor, struct LDKBroadcasterInterface tx_broadcaster, struct LDKLogger logger, struct LDKKeysInterface keys_manager, struct LDKUserConfig config, uintptr_t current_blockchain_height);
-       export function ChannelManager_new(network: LDKNetwork, fee_est: number, chain_monitor: number, tx_broadcaster: number, logger: number, keys_manager: number, config: number, current_blockchain_height: number): number {
+       // MUST_USE_RES struct LDKChannelManager ChannelManager_new(struct LDKFeeEstimator fee_est, struct LDKWatch chain_monitor, struct LDKBroadcasterInterface tx_broadcaster, struct LDKLogger logger, struct LDKKeysInterface keys_manager, struct LDKUserConfig config, struct LDKChainParameters params);
+       export function ChannelManager_new(fee_est: number, chain_monitor: number, tx_broadcaster: number, logger: number, keys_manager: number, config: number, params: number): number {
                if(!isWasmInitialized) {
                        throw new Error("initializeWasm() must be awaited first!");
                }
-               const nativeResponseValue = wasm.ChannelManager_new(network, fee_est, chain_monitor, tx_broadcaster, logger, keys_manager, config, current_blockchain_height);
+               const nativeResponseValue = wasm.ChannelManager_new(fee_est, chain_monitor, tx_broadcaster, logger, keys_manager, config, params);
                return nativeResponseValue;
        }
        // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_create_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPublicKey their_network_key, uint64_t channel_value_satoshis, uint64_t push_msat, uint64_t user_id, struct LDKUserConfig override_config);
@@ -9778,6 +9842,70 @@ public static native long new_empty_slice_vec();
                const nativeResponseValue = wasm.GossipTimestampFilter_write(obj);
                return decodeArray(nativeResponseValue);
        }
+       // void IgnoringMessageHandler_free(struct LDKIgnoringMessageHandler this_ptr);
+       export function IgnoringMessageHandler_free(this_ptr: number): void {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.IgnoringMessageHandler_free(this_ptr);
+               // debug statements here
+       }
+       // MUST_USE_RES struct LDKIgnoringMessageHandler IgnoringMessageHandler_new(void);
+       export function IgnoringMessageHandler_new(): number {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.IgnoringMessageHandler_new();
+               return nativeResponseValue;
+       }
+       // struct LDKMessageSendEventsProvider IgnoringMessageHandler_as_MessageSendEventsProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
+       export function IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg: number): number {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg);
+               return nativeResponseValue;
+       }
+       // struct LDKRoutingMessageHandler IgnoringMessageHandler_as_RoutingMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
+       export function IgnoringMessageHandler_as_RoutingMessageHandler(this_arg: number): number {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.IgnoringMessageHandler_as_RoutingMessageHandler(this_arg);
+               return nativeResponseValue;
+       }
+       // void ErroringMessageHandler_free(struct LDKErroringMessageHandler this_ptr);
+       export function ErroringMessageHandler_free(this_ptr: number): void {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.ErroringMessageHandler_free(this_ptr);
+               // debug statements here
+       }
+       // MUST_USE_RES struct LDKErroringMessageHandler ErroringMessageHandler_new(void);
+       export function ErroringMessageHandler_new(): number {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.ErroringMessageHandler_new();
+               return nativeResponseValue;
+       }
+       // struct LDKMessageSendEventsProvider ErroringMessageHandler_as_MessageSendEventsProvider(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
+       export function ErroringMessageHandler_as_MessageSendEventsProvider(this_arg: number): number {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.ErroringMessageHandler_as_MessageSendEventsProvider(this_arg);
+               return nativeResponseValue;
+       }
+       // struct LDKChannelMessageHandler ErroringMessageHandler_as_ChannelMessageHandler(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
+       export function ErroringMessageHandler_as_ChannelMessageHandler(this_arg: number): number {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.ErroringMessageHandler_as_ChannelMessageHandler(this_arg);
+               return nativeResponseValue;
+       }
        // void MessageHandler_free(struct LDKMessageHandler this_ptr);
        export function MessageHandler_free(this_ptr: number): void {
                if(!isWasmInitialized) {
@@ -11322,30 +11450,6 @@ public static native long new_empty_slice_vec();
                const nativeResponseValue = wasm.RouteHint_set_cltv_expiry_delta(this_ptr, val);
                // debug statements here
        }
-       // uint64_t RouteHint_get_htlc_minimum_msat(const struct LDKRouteHint *NONNULL_PTR this_ptr);
-       export function RouteHint_get_htlc_minimum_msat(this_ptr: number): number {
-               if(!isWasmInitialized) {
-                       throw new Error("initializeWasm() must be awaited first!");
-               }
-               const nativeResponseValue = wasm.RouteHint_get_htlc_minimum_msat(this_ptr);
-               return nativeResponseValue;
-       }
-       // void RouteHint_set_htlc_minimum_msat(struct LDKRouteHint *NONNULL_PTR this_ptr, uint64_t val);
-       export function RouteHint_set_htlc_minimum_msat(this_ptr: number, val: number): void {
-               if(!isWasmInitialized) {
-                       throw new Error("initializeWasm() must be awaited first!");
-               }
-               const nativeResponseValue = wasm.RouteHint_set_htlc_minimum_msat(this_ptr, val);
-               // debug statements here
-       }
-       // MUST_USE_RES struct LDKRouteHint RouteHint_new(struct LDKPublicKey src_node_id_arg, uint64_t short_channel_id_arg, struct LDKRoutingFees fees_arg, uint16_t cltv_expiry_delta_arg, uint64_t htlc_minimum_msat_arg);
-       export function RouteHint_new(src_node_id_arg: Uint8Array, short_channel_id_arg: number, fees_arg: number, cltv_expiry_delta_arg: number, htlc_minimum_msat_arg: number): number {
-               if(!isWasmInitialized) {
-                       throw new Error("initializeWasm() must be awaited first!");
-               }
-               const nativeResponseValue = wasm.RouteHint_new(encodeArray(src_node_id_arg), short_channel_id_arg, fees_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg);
-               return nativeResponseValue;
-       }
        // struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
        export function RouteHint_clone(orig: number): number {
                if(!isWasmInitialized) {
@@ -11354,12 +11458,12 @@ public static native long new_empty_slice_vec();
                const nativeResponseValue = wasm.RouteHint_clone(orig);
                return nativeResponseValue;
        }
-       // struct LDKCResult_RouteLightningErrorZ get_route(struct LDKPublicKey our_node_id, const struct LDKNetworkGraph *NONNULL_PTR network, struct LDKPublicKey target, struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKCVec_RouteHintZ last_hops, uint64_t final_value_msat, uint32_t final_cltv, struct LDKLogger logger);
-       export function get_route(our_node_id: Uint8Array, network: number, target: Uint8Array, first_hops: number[], last_hops: number[], final_value_msat: number, final_cltv: number, logger: number): number {
+       // struct LDKCResult_RouteLightningErrorZ get_route(struct LDKPublicKey our_node_id, const struct LDKNetworkGraph *NONNULL_PTR network, struct LDKPublicKey payee, struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKCVec_RouteHintZ last_hops, uint64_t final_value_msat, uint32_t final_cltv, struct LDKLogger logger);
+       export function get_route(our_node_id: Uint8Array, network: number, payee: Uint8Array, first_hops: number[], last_hops: number[], final_value_msat: number, final_cltv: number, logger: number): number {
                if(!isWasmInitialized) {
                        throw new Error("initializeWasm() must be awaited first!");
                }
-               const nativeResponseValue = wasm.get_route(encodeArray(our_node_id), network, encodeArray(target), first_hops, last_hops, final_value_msat, final_cltv, logger);
+               const nativeResponseValue = wasm.get_route(encodeArray(our_node_id), network, encodeArray(payee), first_hops, last_hops, final_value_msat, final_cltv, logger);
                return nativeResponseValue;
        }
        // void NetworkGraph_free(struct LDKNetworkGraph this_ptr);
@@ -11410,6 +11514,14 @@ public static native long new_empty_slice_vec();
                const nativeResponseValue = wasm.NetGraphMsgHandler_from_net_graph(chain_access, logger, network_graph);
                return nativeResponseValue;
        }
+       // void NetGraphMsgHandler_add_chain_access(struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg, struct LDKAccess *chain_access);
+       export function NetGraphMsgHandler_add_chain_access(this_arg: number, chain_access: number): void {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.NetGraphMsgHandler_add_chain_access(this_arg, chain_access);
+               // debug statements here
+       }
        // MUST_USE_RES struct LDKLockedNetworkGraph NetGraphMsgHandler_read_locked_graph(const struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg);
        export function NetGraphMsgHandler_read_locked_graph(this_arg: number): number {
                if(!isWasmInitialized) {
index fed72559cdb2713139fc5d6970df3fa565a3e5b3..057b6a7693eb9d9fe56b8af07b03fe2f759dd57a 100644 (file)
@@ -3,5 +3,6 @@
                 LDKNetwork_Bitcoin,
                                LDKNetwork_Testnet,
                                LDKNetwork_Regtest,
+                               LDKNetwork_Signet,
                                
             }
diff --git a/ts/structs/ChainParameters.ts b/ts/structs/ChainParameters.ts
new file mode 100644 (file)
index 0000000..24a2b5f
--- /dev/null
@@ -0,0 +1,55 @@
+
+            
+import CommonBase from './CommonBase';
+import * as bindings from '../bindings' // TODO: figure out location
+
+
+
+            export default class ChainParameters extends CommonBase {
+                constructor(_dummy: object, ptr: number) {
+                    super(ptr);
+                }
+
+                
+                protected finalize() {
+                    super.finalize();
+
+                    if (this.ptr != 0) {
+                        bindings.ChainParameters_free(this.ptr);
+                    }
+                }
+       public LDKNetwork get_network() {
+               LDKNetwork ret = bindings.ChainParameters_get_network(this.ptr);
+               return ret;
+       }
+
+       public void set_network(LDKNetwork val) {
+               bindings.ChainParameters_set_network(this.ptr, val);
+       }
+
+       public Uint8Array get_latest_hash() {
+               Uint8Array ret = bindings.ChainParameters_get_latest_hash(this.ptr);
+               return ret;
+       }
+
+       public void set_latest_hash(Uint8Array val) {
+               bindings.ChainParameters_set_latest_hash(this.ptr, val);
+       }
+
+       public number get_latest_height() {
+               number ret = bindings.ChainParameters_get_latest_height(this.ptr);
+               return ret;
+       }
+
+       public void set_latest_height(number val) {
+               bindings.ChainParameters_set_latest_height(this.ptr, val);
+       }
+
+       public static ChainParameters constructor_new(LDKNetwork network_arg, Uint8Array latest_hash_arg, number latest_height_arg) {
+               number ret = bindings.ChainParameters_new(network_arg, latest_hash_arg, latest_height_arg);
+               const ret_hu_conv: ChainParameters = new ChainParameters(null, ret);
+               ret_hu_conv.ptrs_to.add(ret_hu_conv);
+               return ret_hu_conv;
+       }
+
+}
index 10525ab8833b925e8daaddb01bfdaae74c06584b..72337ed604cdd530e377c95eee8f5d3b675b19ff 100644 (file)
@@ -18,8 +18,8 @@ import * as bindings from '../bindings' // TODO: figure out location
                         bindings.ChannelManager_free(this.ptr);
                     }
                 }
-       public static ChannelManager constructor_new(LDKNetwork network, FeeEstimator fee_est, Watch chain_monitor, BroadcasterInterface tx_broadcaster, Logger logger, KeysInterface keys_manager, UserConfig config, number current_blockchain_height) {
-               number ret = bindings.ChannelManager_new(network, fee_est == null ? 0 : fee_est.ptr, chain_monitor == null ? 0 : chain_monitor.ptr, tx_broadcaster == null ? 0 : tx_broadcaster.ptr, logger == null ? 0 : logger.ptr, keys_manager == null ? 0 : keys_manager.ptr, config == null ? 0 : config.ptr & ~1, current_blockchain_height);
+       public static ChannelManager constructor_new(FeeEstimator fee_est, Watch chain_monitor, BroadcasterInterface tx_broadcaster, Logger logger, KeysInterface keys_manager, UserConfig config, LDKNetwork params_network_arg, Uint8Array params_latest_hash_arg, number params_latest_height_arg) {
+               number ret = bindings.ChannelManager_new(fee_est == null ? 0 : fee_est.ptr, chain_monitor == null ? 0 : chain_monitor.ptr, tx_broadcaster == null ? 0 : tx_broadcaster.ptr, logger == null ? 0 : logger.ptr, keys_manager == null ? 0 : keys_manager.ptr, config == null ? 0 : config.ptr & ~1, bindings.ChainParameters_new(params_network_arg, params_latest_hash_arg, params_latest_height_arg));
                const ret_hu_conv: ChannelManager = new ChannelManager(null, ret);
                ret_hu_conv.ptrs_to.add(ret_hu_conv);
                ret_hu_conv.ptrs_to.add(fee_est);
diff --git a/ts/structs/ErroringMessageHandler.ts b/ts/structs/ErroringMessageHandler.ts
new file mode 100644 (file)
index 0000000..b5c2f8b
--- /dev/null
@@ -0,0 +1,42 @@
+
+            
+import CommonBase from './CommonBase';
+import * as bindings from '../bindings' // TODO: figure out location
+
+
+
+            export default class ErroringMessageHandler extends CommonBase {
+                constructor(_dummy: object, ptr: number) {
+                    super(ptr);
+                }
+
+                
+                protected finalize() {
+                    super.finalize();
+
+                    if (this.ptr != 0) {
+                        bindings.ErroringMessageHandler_free(this.ptr);
+                    }
+                }
+       public static ErroringMessageHandler constructor_new() {
+               number ret = bindings.ErroringMessageHandler_new();
+               const ret_hu_conv: ErroringMessageHandler = new ErroringMessageHandler(null, ret);
+               ret_hu_conv.ptrs_to.add(ret_hu_conv);
+               return ret_hu_conv;
+       }
+
+       public MessageSendEventsProvider as_MessageSendEventsProvider() {
+               number ret = bindings.ErroringMessageHandler_as_MessageSendEventsProvider(this.ptr);
+               MessageSendEventsProvider ret_hu_conv = new MessageSendEventsProvider(null, ret);
+               ret_hu_conv.ptrs_to.add(this);
+               return ret_hu_conv;
+       }
+
+       public ChannelMessageHandler as_ChannelMessageHandler() {
+               number ret = bindings.ErroringMessageHandler_as_ChannelMessageHandler(this.ptr);
+               ChannelMessageHandler ret_hu_conv = new ChannelMessageHandler(null, ret);
+               ret_hu_conv.ptrs_to.add(this);
+               return ret_hu_conv;
+       }
+
+}
diff --git a/ts/structs/IgnoringMessageHandler.ts b/ts/structs/IgnoringMessageHandler.ts
new file mode 100644 (file)
index 0000000..934a356
--- /dev/null
@@ -0,0 +1,42 @@
+
+            
+import CommonBase from './CommonBase';
+import * as bindings from '../bindings' // TODO: figure out location
+
+
+
+            export default class IgnoringMessageHandler extends CommonBase {
+                constructor(_dummy: object, ptr: number) {
+                    super(ptr);
+                }
+
+                
+                protected finalize() {
+                    super.finalize();
+
+                    if (this.ptr != 0) {
+                        bindings.IgnoringMessageHandler_free(this.ptr);
+                    }
+                }
+       public static IgnoringMessageHandler constructor_new() {
+               number ret = bindings.IgnoringMessageHandler_new();
+               const ret_hu_conv: IgnoringMessageHandler = new IgnoringMessageHandler(null, ret);
+               ret_hu_conv.ptrs_to.add(ret_hu_conv);
+               return ret_hu_conv;
+       }
+
+       public MessageSendEventsProvider as_MessageSendEventsProvider() {
+               number ret = bindings.IgnoringMessageHandler_as_MessageSendEventsProvider(this.ptr);
+               MessageSendEventsProvider ret_hu_conv = new MessageSendEventsProvider(null, ret);
+               ret_hu_conv.ptrs_to.add(this);
+               return ret_hu_conv;
+       }
+
+       public RoutingMessageHandler as_RoutingMessageHandler() {
+               number ret = bindings.IgnoringMessageHandler_as_RoutingMessageHandler(this.ptr);
+               RoutingMessageHandler ret_hu_conv = new RoutingMessageHandler(null, ret);
+               ret_hu_conv.ptrs_to.add(this);
+               return ret_hu_conv;
+       }
+
+}
index 841ae35388890134bf1c4e6457b7188872fcf4ae..cfcb2d6174c386ba3f7af0573bfc629179072eb0 100644 (file)
@@ -37,6 +37,11 @@ import * as bindings from '../bindings' // TODO: figure out location
                return ret_hu_conv;
        }
 
+       public void add_chain_access(Access chain_access) {
+               bindings.NetGraphMsgHandler_add_chain_access(this.ptr, chain_access == null ? 0 : chain_access.ptr);
+               this.ptrs_to.add(chain_access);
+       }
+
        public LockedNetworkGraph read_locked_graph() {
                number ret = bindings.NetGraphMsgHandler_read_locked_graph(this.ptr);
                const ret_hu_conv: LockedNetworkGraph = new LockedNetworkGraph(null, ret);
index 4f338da840fae6f5c04c19f91b97c85d800d34fd..9e0474f570694d33499e9c6882b70c13383f0354 100644 (file)
@@ -57,23 +57,6 @@ import * as bindings from '../bindings' // TODO: figure out location
                bindings.RouteHint_set_cltv_expiry_delta(this.ptr, val);
        }
 
-       public number get_htlc_minimum_msat() {
-               number ret = bindings.RouteHint_get_htlc_minimum_msat(this.ptr);
-               return ret;
-       }
-
-       public void set_htlc_minimum_msat(number val) {
-               bindings.RouteHint_set_htlc_minimum_msat(this.ptr, val);
-       }
-
-       public static RouteHint constructor_new(Uint8Array src_node_id_arg, number short_channel_id_arg, RoutingFees fees_arg, number cltv_expiry_delta_arg, number htlc_minimum_msat_arg) {
-               number ret = bindings.RouteHint_new(src_node_id_arg, short_channel_id_arg, fees_arg == null ? 0 : fees_arg.ptr & ~1, cltv_expiry_delta_arg, htlc_minimum_msat_arg);
-               const ret_hu_conv: RouteHint = new RouteHint(null, ret);
-               ret_hu_conv.ptrs_to.add(ret_hu_conv);
-               ret_hu_conv.ptrs_to.add(fees_arg);
-               return ret_hu_conv;
-       }
-
        public RouteHint clone() {
                number ret = bindings.RouteHint_clone(this.ptr);
                const ret_hu_conv: RouteHint = new RouteHint(null, ret);