Initial bindings header generation demo

diff --git a/genbindings.py b/genbindings.py
new file mode 100755 (executable)
index 0000000..9f7e136
--- /dev/null
+++ b/genbindings.py
@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+import sys, re
+
+if len(sys.argv) != 3:
+    print("USAGE: /path/to/lightning.h /path/to/bindings.java")
+    sys.exit(1)
+
+with open(sys.argv[1]) as f, open(sys.argv[2], "w") as out_f:
+    var_is_arr_regex = re.compile("\(\*([A-za-z_]*)\)\[[0-9]*\]");
+    def map_type(fn_arg, print_void):
+        fn_arg = fn_arg.strip()
+        if fn_arg.startswith("MUST_USE_RES "):
+            fn_arg = fn_arg[13:]
+        if fn_arg.startswith("const "):
+            fn_arg = fn_arg[6:]
+        if fn_arg.startswith("void"):
+            if print_void:
+                out_f.write("void")
+            else:
+                return
+            fn_arg = fn_arg.strip("void ")
+        elif fn_arg.startswith("bool"):
+            out_f.write("boolean")
+            fn_arg = fn_arg.strip("bool ")
+        elif fn_arg.startswith("uint8_t"):
+            out_f.write("byte")
+            fn_arg = fn_arg.strip("uint8_t ")
+        elif fn_arg.startswith("uint32_t"):
+            out_f.write("int")
+            fn_arg = fn_arg.strip("uint32_t ")
+        elif fn_arg.startswith("uint64_t"):
+            out_f.write("long")
+            fn_arg = fn_arg.strip("uint64_t ")
+        else:
+            out_f.write("long")
+            fn_arg = "".join([e + " " for e in fn_arg.split(" ")[1:]]).strip()
+        var_is_arr = var_is_arr_regex.match(fn_arg)
+        if var_is_arr is not None:
+            out_f.write("[] " + var_is_arr.group(1))
+        elif fn_arg.strip() != "":
+            out_f.write(" " + fn_arg.replace('*', '').strip())
+        elif not print_void:
+            out_f.write(" arg");
+
+    def map_fn_args(fn_args):
+        for idx, arg in enumerate(fn_args.split(',')):
+            if idx != 0:
+                out_f.write(", ")
+            map_type(arg, False)
+
+    def map_fn(re_match, ret_ty_suffix):
+        out_f.write("\t/// " + line)
+        out_f.write("\tpublic static native ")
+        map_type(re_match.group(1), True)
+        out_f.write(ret_ty_suffix + " " + re_match.group(2).replace('_', '') + "(")
+        map_fn_args(re_match.group(3))
+        out_f.write(");\n")
+
+    out_f.write("""package org.ldk;
+
+public class bindings {
+       static {
+               System.loadLibrary(\"lightning\");
+       }
+
+""")
+
+    in_block_comment = False
+    in_block_enum = False
+    in_block_struct = False
+    in_block_union = False
+
+    fn_ptr_regex = re.compile("^extern const ([A-Za-z_0-9\* ]*) \(\*(.*)\)\((.*)\);$")
+    fn_ret_arr_regex = re.compile("(.*) \(\*(.*)\((.*)\)\)\[.*\];$")
+    reg_fn_regex = re.compile("([A-Za-z_0-9\* ]*) \*?([a-zA-Z_0-9]*)\((.*)\);$")
+
+    for line in f:
+        if in_block_comment:
+            #out_f.write("\t" + line)
+            if line.endswith("*/\n"):
+                in_block_comment = False
+        elif in_block_struct:
+            if line.startswith("} "):
+                in_block_struct = False
+        elif in_block_union:
+            if line.startswith("} "):
+                in_block_union = False
+        elif in_block_enum:
+            if line.startswith("} "):
+                in_block_enum = False
+        else:
+            fn_ptr = fn_ptr_regex.match(line)
+            fn_ret_arr = fn_ret_arr_regex.match(line)
+            reg_fn = reg_fn_regex.match(line)
+
+            if line.startswith("#include <"):
+                pass
+            elif line.startswith("/*"):
+                #out_f.write("\t" + line)
+                if not line.endswith("*/\n"):
+                    in_block_comment = True
+            elif line.startswith("typedef enum "):
+                in_block_enum = True
+            elif line.startswith("typedef struct "):
+                in_block_struct = True
+            elif line.startswith("typedef union "):
+                in_block_union = True
+            elif line.startswith("typedef "):
+                pass
+            elif fn_ptr is not None:
+                map_fn(fn_ptr, "")
+            elif fn_ret_arr is not None:
+                map_fn(fn_ret_arr, "[]")
+            elif reg_fn is not None:
+                map_fn(reg_fn, "")
+            else:
+                assert(line == "\n")
+
+    out_f.write("}\n");

diff --git a/src/main/java/org/ldk/bindings.java b/src/main/java/org/ldk/bindings.java
index ac88ed96c096df5fb74d2da3b82f7fd08f6dab6e..e0fb8cbdf2a08ef01a0ff679d96c0495723ae436 100644 (file)
--- a/src/main/java/org/ldk/bindings.java
+++ b/src/main/java/org/ldk/bindings.java
@@ -1,8 +1,1024 @@
 package org.ldk;
 
-class bindings {
-    static {
-        System.loadLibrary("lightning");
-    }
+public class bindings {
+       static {
+               System.loadLibrary("lightning");
+       }
 
+       /// extern const void (*C2Tuple_OutPointScriptZ_free)(LDKC2Tuple_OutPointScriptZ);
+       public static native void C2TupleOutPointScriptZfree(long arg);
+       /// extern const void (*C2Tuple_Scriptu64Z_free)(LDKC2Tuple_Scriptu64Z);
+       public static native void C2TupleScriptu64Zfree(long arg);
+       /// extern const void (*C2Tuple_SecretKey_u832Z_free)(LDKC2Tuple_SecretKey_u832Z);
+       public static native void C2TupleSecretKeyu832Zfree(long arg);
+       /// extern const void (*C2Tuple_SignatureCVec_SignatureZZ_free)(LDKC2Tuple_SignatureCVec_SignatureZZ);
+       public static native void C2TupleSignatureCVecSignatureZZfree(long arg);
+       /// extern const void (*C2Tuple_Txidu32Z_free)(LDKC2Tuple_Txidu32Z);
+       public static native void C2TupleTxidu32Zfree(long arg);
+       /// extern const void (*C2Tuple_u64u64Z_free)(LDKC2Tuple_u64u64Z);
+       public static native void C2Tupleu64u64Zfree(long arg);
+       /// extern const void (*C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free)(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ);
+       public static native void C3TupleChannelAnnouncementChannelUpdateChannelUpdateZfree(long arg);
+       /// extern const LDKCResult_C2Tuple_Scriptu64ZChainErrorZ (*CResult_C2Tuple_Scriptu64ZChainErrorZ_err)(LDKChainError);
+       public static native long CResultC2TupleScriptu64ZChainErrorZerr(long arg);
+       /// extern const void (*CResult_C2Tuple_Scriptu64ZChainErrorZ_free)(LDKCResult_C2Tuple_Scriptu64ZChainErrorZ);
+       public static native void CResultC2TupleScriptu64ZChainErrorZfree(long arg);
+       /// extern const LDKCResult_C2Tuple_Scriptu64ZChainErrorZ (*CResult_C2Tuple_Scriptu64ZChainErrorZ_good)(LDKC2Tuple_Scriptu64Z);
+       public static native long CResultC2TupleScriptu64ZChainErrorZgood(long arg);
+       /// extern const void (*CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free)(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ);
+       public static native void CResultC2TupleSignatureCVecSignatureZZNoneZfree(long arg);
+       /// extern const LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ (*CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_good)(LDKC2Tuple_SignatureCVec_SignatureZZ);
+       public static native long CResultC2TupleSignatureCVecSignatureZZNoneZgood(long arg);
+       /// extern const void (*CResult_CVec_SignatureZNoneZ_free)(LDKCResult_CVec_SignatureZNoneZ);
+       public static native void CResultCVecSignatureZNoneZfree(long arg);
+       /// extern const LDKCResult_CVec_SignatureZNoneZ (*CResult_CVec_SignatureZNoneZ_good)(LDKCVec_SignatureZ);
+       public static native long CResultCVecSignatureZNoneZgood(long arg);
+       /// extern const LDKCResult_CVec_u8ZPeerHandleErrorZ (*CResult_CVec_u8ZPeerHandleErrorZ_err)(LDKPeerHandleError);
+       public static native long CResultCVecu8ZPeerHandleErrorZerr(long arg);
+       /// extern const void (*CResult_CVec_u8ZPeerHandleErrorZ_free)(LDKCResult_CVec_u8ZPeerHandleErrorZ);
+       public static native void CResultCVecu8ZPeerHandleErrorZfree(long arg);
+       /// extern const LDKCResult_CVec_u8ZPeerHandleErrorZ (*CResult_CVec_u8ZPeerHandleErrorZ_good)(LDKCVec_u8Z);
+       public static native long CResultCVecu8ZPeerHandleErrorZgood(long arg);
+       /// extern const LDKCResult_NoneAPIErrorZ (*CResult_NoneAPIErrorZ_err)(LDKAPIError);
+       public static native long CResultNoneAPIErrorZerr(long arg);
+       /// extern const void (*CResult_NoneAPIErrorZ_free)(LDKCResult_NoneAPIErrorZ);
+       public static native void CResultNoneAPIErrorZfree(long arg);
+       /// extern const LDKCResult_NoneChannelMonitorUpdateErrZ (*CResult_NoneChannelMonitorUpdateErrZ_err)(LDKChannelMonitorUpdateErr);
+       public static native long CResultNoneChannelMonitorUpdateErrZerr(long arg);
+       /// extern const void (*CResult_NoneChannelMonitorUpdateErrZ_free)(LDKCResult_NoneChannelMonitorUpdateErrZ);
+       public static native void CResultNoneChannelMonitorUpdateErrZfree(long arg);
+       /// extern const LDKCResult_NoneMonitorUpdateErrorZ (*CResult_NoneMonitorUpdateErrorZ_err)(LDKMonitorUpdateError);
+       public static native long CResultNoneMonitorUpdateErrorZerr(long arg);
+       /// extern const void (*CResult_NoneMonitorUpdateErrorZ_free)(LDKCResult_NoneMonitorUpdateErrorZ);
+       public static native void CResultNoneMonitorUpdateErrorZfree(long arg);
+       /// extern const LDKCResult_NonePaymentSendFailureZ (*CResult_NonePaymentSendFailureZ_err)(LDKPaymentSendFailure);
+       public static native long CResultNonePaymentSendFailureZerr(long arg);
+       /// extern const void (*CResult_NonePaymentSendFailureZ_free)(LDKCResult_NonePaymentSendFailureZ);
+       public static native void CResultNonePaymentSendFailureZfree(long arg);
+       /// extern const LDKCResult_NonePeerHandleErrorZ (*CResult_NonePeerHandleErrorZ_err)(LDKPeerHandleError);
+       public static native long CResultNonePeerHandleErrorZerr(long arg);
+       /// extern const void (*CResult_NonePeerHandleErrorZ_free)(LDKCResult_NonePeerHandleErrorZ);
+       public static native void CResultNonePeerHandleErrorZfree(long arg);
+       /// extern const LDKCResult_RouteLightningErrorZ (*CResult_RouteLightningErrorZ_err)(LDKLightningError);
+       public static native long CResultRouteLightningErrorZerr(long arg);
+       /// extern const void (*CResult_RouteLightningErrorZ_free)(LDKCResult_RouteLightningErrorZ);
+       public static native void CResultRouteLightningErrorZfree(long arg);
+       /// extern const LDKCResult_RouteLightningErrorZ (*CResult_RouteLightningErrorZ_good)(LDKRoute);
+       public static native long CResultRouteLightningErrorZgood(long arg);
+       /// extern const void (*CResult_SignatureNoneZ_free)(LDKCResult_SignatureNoneZ);
+       public static native void CResultSignatureNoneZfree(long arg);
+       /// extern const LDKCResult_SignatureNoneZ (*CResult_SignatureNoneZ_good)(LDKSignature);
+       public static native long CResultSignatureNoneZgood(long arg);
+       /// extern const LDKCResult_boolLightningErrorZ (*CResult_boolLightningErrorZ_err)(LDKLightningError);
+       public static native long CResultboolLightningErrorZerr(long arg);
+       /// extern const void (*CResult_boolLightningErrorZ_free)(LDKCResult_boolLightningErrorZ);
+       public static native void CResultboolLightningErrorZfree(long arg);
+       /// extern const LDKCResult_boolLightningErrorZ (*CResult_boolLightningErrorZ_good)(bool);
+       public static native long CResultboolLightningErrorZgood(boolean arg);
+       /// extern const LDKCResult_boolPeerHandleErrorZ (*CResult_boolPeerHandleErrorZ_err)(LDKPeerHandleError);
+       public static native long CResultboolPeerHandleErrorZerr(long arg);
+       /// extern const void (*CResult_boolPeerHandleErrorZ_free)(LDKCResult_boolPeerHandleErrorZ);
+       public static native void CResultboolPeerHandleErrorZfree(long arg);
+       /// extern const LDKCResult_boolPeerHandleErrorZ (*CResult_boolPeerHandleErrorZ_good)(bool);
+       public static native long CResultboolPeerHandleErrorZgood(boolean arg);
+       /// extern const void (*CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free)(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ);
+       public static native void CVecC3TupleChannelAnnouncementChannelUpdateChannelUpdateZZfree(long arg);
+       /// extern const void (*CVec_CVec_RouteHopZZ_free)(LDKCVec_CVec_RouteHopZZ);
+       public static native void CVecCVecRouteHopZZfree(long arg);
+       /// extern const void (*CVec_ChannelDetailsZ_free)(LDKCVec_ChannelDetailsZ);
+       public static native void CVecChannelDetailsZfree(long arg);
+       /// extern const void (*CVec_EventZ_free)(LDKCVec_EventZ);
+       public static native void CVecEventZfree(long arg);
+       /// extern const void (*CVec_HTLCUpdateZ_free)(LDKCVec_HTLCUpdateZ);
+       public static native void CVecHTLCUpdateZfree(long arg);
+       /// extern const void (*CVec_MessageSendEventZ_free)(LDKCVec_MessageSendEventZ);
+       public static native void CVecMessageSendEventZfree(long arg);
+       /// extern const void (*CVec_NetAddressZ_free)(LDKCVec_NetAddressZ);
+       public static native void CVecNetAddressZfree(long arg);
+       /// extern const void (*CVec_NodeAnnouncementZ_free)(LDKCVec_NodeAnnouncementZ);
+       public static native void CVecNodeAnnouncementZfree(long arg);
+       /// extern const void (*CVec_PublicKeyZ_free)(LDKCVec_PublicKeyZ);
+       public static native void CVecPublicKeyZfree(long arg);
+       /// extern const void (*CVec_RouteHopZ_free)(LDKCVec_RouteHopZ);
+       public static native void CVecRouteHopZfree(long arg);
+       /// extern const void (*CVec_SignatureZ_free)(LDKCVec_SignatureZ);
+       public static native void CVecSignatureZfree(long arg);
+       /// extern const void (*CVec_SpendableOutputDescriptorZ_free)(LDKCVec_SpendableOutputDescriptorZ);
+       public static native void CVecSpendableOutputDescriptorZfree(long arg);
+       /// extern const void (*CVec_TransactionZ_free)(LDKCVec_TransactionZ);
+       public static native void CVecTransactionZfree(long arg);
+       /// extern const void (*CVec_UpdateAddHTLCZ_free)(LDKCVec_UpdateAddHTLCZ);
+       public static native void CVecUpdateAddHTLCZfree(long arg);
+       /// extern const void (*CVec_UpdateFailHTLCZ_free)(LDKCVec_UpdateFailHTLCZ);
+       public static native void CVecUpdateFailHTLCZfree(long arg);
+       /// extern const void (*CVec_UpdateFailMalformedHTLCZ_free)(LDKCVec_UpdateFailMalformedHTLCZ);
+       public static native void CVecUpdateFailMalformedHTLCZfree(long arg);
+       /// extern const void (*CVec_UpdateFulfillHTLCZ_free)(LDKCVec_UpdateFulfillHTLCZ);
+       public static native void CVecUpdateFulfillHTLCZfree(long arg);
+       /// extern const void (*CVec_u64Z_free)(LDKCVec_u64Z);
+       public static native void CVecu64Zfree(long arg);
+       /// extern const void (*CVec_u8Z_free)(LDKCVec_u8Z);
+       public static native void CVecu8Zfree(long arg);
+       /// extern const void (*CVec_usizeZ_free)(LDKCVec_usizeZ);
+       public static native void CVecusizeZfree(long arg);
+       /// LDKC2Tuple_Txidu32Z C2Tuple_Txidu32Z_new(LDKThirtyTwoBytes a, uint32_t b);
+       public static native long C2TupleTxidu32Znew(long a, int b);
+       /// LDKC2Tuple_Scriptu64Z C2Tuple_Scriptu64Z_new(LDKCVec_u8Z a, uint64_t b);
+       public static native long C2TupleScriptu64Znew(long a, long b);
+       /// LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_new(uint64_t a, uint64_t b);
+       public static native long C2Tupleu64u64Znew(long a, long b);
+       /// LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_new(LDKSignature a, LDKCVec_SignatureZ b);
+       public static native long C2TupleSignatureCVecSignatureZZnew(long a, long b);
+       /// LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(void);
+       public static native long CResultC2TupleSignatureCVecSignatureZZNoneZerr();
+       /// LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_err(void);
+       public static native long CResultSignatureNoneZerr();
+       /// LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_err(void);
+       public static native long CResultCVecSignatureZNoneZerr();
+       /// LDKC2Tuple_SecretKey_u832Z C2Tuple_SecretKey_u832Z_new(LDKSecretKey a, LDKThirtyTwoBytes b);
+       public static native long C2TupleSecretKeyu832Znew(long a, long b);
+       /// LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_good(void);
+       public static native long CResultNoneAPIErrorZgood();
+       /// LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_good(void);
+       public static native long CResultNonePaymentSendFailureZgood();
+       /// LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_good(void);
+       public static native long CResultNoneChannelMonitorUpdateErrZgood();
+       /// LDKCResult_NoneMonitorUpdateErrorZ CResult_NoneMonitorUpdateErrorZ_good(void);
+       public static native long CResultNoneMonitorUpdateErrorZgood();
+       /// LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_new(LDKOutPoint a, LDKCVec_u8Z b);
+       public static native long C2TupleOutPointScriptZnew(long a, long b);
+       /// LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(LDKChannelAnnouncement a, LDKChannelUpdate b, LDKChannelUpdate c);
+       public static native long C3TupleChannelAnnouncementChannelUpdateChannelUpdateZnew(long a, long b, long c);
+       /// LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_good(void);
+       public static native long CResultNonePeerHandleErrorZgood();
+       /// void Event_free(LDKEvent this_ptr);
+       public static native void Eventfree(long this_ptr);
+       /// void MessageSendEvent_free(LDKMessageSendEvent this_ptr);
+       public static native void MessageSendEventfree(long this_ptr);
+       /// void MessageSendEventsProvider_free(LDKMessageSendEventsProvider this_ptr);
+       public static native void MessageSendEventsProviderfree(long this_ptr);
+       /// void EventsProvider_free(LDKEventsProvider this_ptr);
+       public static native void EventsProviderfree(long this_ptr);
+       /// void APIError_free(LDKAPIError this_ptr);
+       public static native void APIErrorfree(long this_ptr);
+       /// MUST_USE_RES LDKLevel Level_max(void);
+       public static native long Levelmax();
+       /// void Logger_free(LDKLogger this_ptr);
+       public static native void Loggerfree(long this_ptr);
+       /// void ChannelHandshakeConfig_free(LDKChannelHandshakeConfig this_ptr);
+       public static native void ChannelHandshakeConfigfree(long this_ptr);
+       /// uint32_t ChannelHandshakeConfig_get_minimum_depth(const LDKChannelHandshakeConfig *this_ptr);
+       public static native int ChannelHandshakeConfiggetminimumdepth(long this_ptr);
+       /// void ChannelHandshakeConfig_set_minimum_depth(LDKChannelHandshakeConfig *this_ptr, uint32_t val);
+       public static native void ChannelHandshakeConfigsetminimumdepth(long this_ptr, int val);
+       /// uint16_t ChannelHandshakeConfig_get_our_to_self_delay(const LDKChannelHandshakeConfig *this_ptr);
+       public static native long ChannelHandshakeConfiggetourtoselfdelay(long this_ptr);
+       /// void ChannelHandshakeConfig_set_our_to_self_delay(LDKChannelHandshakeConfig *this_ptr, uint16_t val);
+       public static native void ChannelHandshakeConfigsetourtoselfdelay(long this_ptr, long val);
+       /// uint64_t ChannelHandshakeConfig_get_our_htlc_minimum_msat(const LDKChannelHandshakeConfig *this_ptr);
+       public static native long ChannelHandshakeConfiggetourhtlcminimummsat(long this_ptr);
+       /// void ChannelHandshakeConfig_set_our_htlc_minimum_msat(LDKChannelHandshakeConfig *this_ptr, uint64_t val);
+       public static native void ChannelHandshakeConfigsetourhtlcminimummsat(long this_ptr, long val);
+       /// MUST_USE_RES LDKChannelHandshakeConfig ChannelHandshakeConfig_new(uint32_t minimum_depth_arg, uint16_t our_to_self_delay_arg, uint64_t our_htlc_minimum_msat_arg);
+       public static native long ChannelHandshakeConfignew(int minimum_depth_arg, long our_to_self_delay_arg, long our_htlc_minimum_msat_arg);
+       /// MUST_USE_RES LDKChannelHandshakeConfig ChannelHandshakeConfig_default(void);
+       public static native long ChannelHandshakeConfigdefault();
+       /// void ChannelHandshakeLimits_free(LDKChannelHandshakeLimits this_ptr);
+       public static native void ChannelHandshakeLimitsfree(long this_ptr);
+       /// uint64_t ChannelHandshakeLimits_get_min_funding_satoshis(const LDKChannelHandshakeLimits *this_ptr);
+       public static native long ChannelHandshakeLimitsgetminfundingsatoshis(long this_ptr);
+       /// void ChannelHandshakeLimits_set_min_funding_satoshis(LDKChannelHandshakeLimits *this_ptr, uint64_t val);
+       public static native void ChannelHandshakeLimitssetminfundingsatoshis(long this_ptr, long val);
+       /// uint64_t ChannelHandshakeLimits_get_max_htlc_minimum_msat(const LDKChannelHandshakeLimits *this_ptr);
+       public static native long ChannelHandshakeLimitsgetmaxhtlcminimummsat(long this_ptr);
+       /// void ChannelHandshakeLimits_set_max_htlc_minimum_msat(LDKChannelHandshakeLimits *this_ptr, uint64_t val);
+       public static native void ChannelHandshakeLimitssetmaxhtlcminimummsat(long this_ptr, long val);
+       /// uint64_t ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(const LDKChannelHandshakeLimits *this_ptr);
+       public static native long ChannelHandshakeLimitsgetminmaxhtlcvalueinflightmsat(long this_ptr);
+       /// void ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(LDKChannelHandshakeLimits *this_ptr, uint64_t val);
+       public static native void ChannelHandshakeLimitssetminmaxhtlcvalueinflightmsat(long this_ptr, long val);
+       /// uint64_t ChannelHandshakeLimits_get_max_channel_reserve_satoshis(const LDKChannelHandshakeLimits *this_ptr);
+       public static native long ChannelHandshakeLimitsgetmaxchannelreservesatoshis(long this_ptr);
+       /// void ChannelHandshakeLimits_set_max_channel_reserve_satoshis(LDKChannelHandshakeLimits *this_ptr, uint64_t val);
+       public static native void ChannelHandshakeLimitssetmaxchannelreservesatoshis(long this_ptr, long val);
+       /// uint16_t ChannelHandshakeLimits_get_min_max_accepted_htlcs(const LDKChannelHandshakeLimits *this_ptr);
+       public static native long ChannelHandshakeLimitsgetminmaxacceptedhtlcs(long this_ptr);
+       /// void ChannelHandshakeLimits_set_min_max_accepted_htlcs(LDKChannelHandshakeLimits *this_ptr, uint16_t val);
+       public static native void ChannelHandshakeLimitssetminmaxacceptedhtlcs(long this_ptr, long val);
+       /// uint64_t ChannelHandshakeLimits_get_min_dust_limit_satoshis(const LDKChannelHandshakeLimits *this_ptr);
+       public static native long ChannelHandshakeLimitsgetmindustlimitsatoshis(long this_ptr);
+       /// void ChannelHandshakeLimits_set_min_dust_limit_satoshis(LDKChannelHandshakeLimits *this_ptr, uint64_t val);
+       public static native void ChannelHandshakeLimitssetmindustlimitsatoshis(long this_ptr, long val);
+       /// uint64_t ChannelHandshakeLimits_get_max_dust_limit_satoshis(const LDKChannelHandshakeLimits *this_ptr);
+       public static native long ChannelHandshakeLimitsgetmaxdustlimitsatoshis(long this_ptr);
+       /// void ChannelHandshakeLimits_set_max_dust_limit_satoshis(LDKChannelHandshakeLimits *this_ptr, uint64_t val);
+       public static native void ChannelHandshakeLimitssetmaxdustlimitsatoshis(long this_ptr, long val);
+       /// uint32_t ChannelHandshakeLimits_get_max_minimum_depth(const LDKChannelHandshakeLimits *this_ptr);
+       public static native int ChannelHandshakeLimitsgetmaxminimumdepth(long this_ptr);
+       /// void ChannelHandshakeLimits_set_max_minimum_depth(LDKChannelHandshakeLimits *this_ptr, uint32_t val);
+       public static native void ChannelHandshakeLimitssetmaxminimumdepth(long this_ptr, int val);
+       /// bool ChannelHandshakeLimits_get_force_announced_channel_preference(const LDKChannelHandshakeLimits *this_ptr);
+       public static native boolean ChannelHandshakeLimitsgetforceannouncedchannelpreference(long this_ptr);
+       /// void ChannelHandshakeLimits_set_force_announced_channel_preference(LDKChannelHandshakeLimits *this_ptr, bool val);
+       public static native void ChannelHandshakeLimitssetforceannouncedchannelpreference(long this_ptr, boolean va);
+       /// uint16_t ChannelHandshakeLimits_get_their_to_self_delay(const LDKChannelHandshakeLimits *this_ptr);
+       public static native long ChannelHandshakeLimitsgettheirtoselfdelay(long this_ptr);
+       /// void ChannelHandshakeLimits_set_their_to_self_delay(LDKChannelHandshakeLimits *this_ptr, uint16_t val);
+       public static native void ChannelHandshakeLimitssettheirtoselfdelay(long this_ptr, long val);
+       /// MUST_USE_RES LDKChannelHandshakeLimits ChannelHandshakeLimits_new(uint64_t min_funding_satoshis_arg, uint64_t max_htlc_minimum_msat_arg, uint64_t min_max_htlc_value_in_flight_msat_arg, uint64_t max_channel_reserve_satoshis_arg, uint16_t min_max_accepted_htlcs_arg, uint64_t min_dust_limit_satoshis_arg, uint64_t max_dust_limit_satoshis_arg, uint32_t max_minimum_depth_arg, bool force_announced_channel_preference_arg, uint16_t their_to_self_delay_arg);
+       public static native long ChannelHandshakeLimitsnew(long min_funding_satoshis_arg, long max_htlc_minimum_msat_arg, long min_max_htlc_value_in_flight_msat_arg, long max_channel_reserve_satoshis_arg, long min_max_accepted_htlcs_arg, long min_dust_limit_satoshis_arg, long max_dust_limit_satoshis_arg, int max_minimum_depth_arg, boolean force_announced_channel_preference_arg, long their_to_self_delay_arg);
+       /// MUST_USE_RES LDKChannelHandshakeLimits ChannelHandshakeLimits_default(void);
+       public static native long ChannelHandshakeLimitsdefault();
+       /// void ChannelConfig_free(LDKChannelConfig this_ptr);
+       public static native void ChannelConfigfree(long this_ptr);
+       /// uint32_t ChannelConfig_get_fee_proportional_millionths(const LDKChannelConfig *this_ptr);
+       public static native int ChannelConfiggetfeeproportionalmillionths(long this_ptr);
+       /// void ChannelConfig_set_fee_proportional_millionths(LDKChannelConfig *this_ptr, uint32_t val);
+       public static native void ChannelConfigsetfeeproportionalmillionths(long this_ptr, int val);
+       /// bool ChannelConfig_get_announced_channel(const LDKChannelConfig *this_ptr);
+       public static native boolean ChannelConfiggetannouncedchannel(long this_ptr);
+       /// void ChannelConfig_set_announced_channel(LDKChannelConfig *this_ptr, bool val);
+       public static native void ChannelConfigsetannouncedchannel(long this_ptr, boolean va);
+       /// bool ChannelConfig_get_commit_upfront_shutdown_pubkey(const LDKChannelConfig *this_ptr);
+       public static native boolean ChannelConfiggetcommitupfrontshutdownpubkey(long this_ptr);
+       /// void ChannelConfig_set_commit_upfront_shutdown_pubkey(LDKChannelConfig *this_ptr, bool val);
+       public static native void ChannelConfigsetcommitupfrontshutdownpubkey(long this_ptr, boolean va);
+       /// MUST_USE_RES LDKChannelConfig ChannelConfig_new(uint32_t fee_proportional_millionths_arg, bool announced_channel_arg, bool commit_upfront_shutdown_pubkey_arg);
+       public static native long ChannelConfignew(int fee_proportional_millionths_arg, boolean announced_channel_arg, boolean commit_upfront_shutdown_pubkey_arg);
+       /// MUST_USE_RES LDKChannelConfig ChannelConfig_default(void);
+       public static native long ChannelConfigdefault();
+       /// LDKCVec_u8Z ChannelConfig_write(const LDKChannelConfig *obj);
+       public static native long ChannelConfigwrite(long obj);
+       /// LDKChannelConfig ChannelConfig_read(LDKu8slice ser);
+       public static native long ChannelConfigread(long ser);
+       /// void UserConfig_free(LDKUserConfig this_ptr);
+       public static native void UserConfigfree(long this_ptr);
+       /// LDKChannelHandshakeConfig UserConfig_get_own_channel_config(const LDKUserConfig *this_ptr);
+       public static native long UserConfiggetownchannelconfig(long this_ptr);
+       /// void UserConfig_set_own_channel_config(LDKUserConfig *this_ptr, LDKChannelHandshakeConfig val);
+       public static native void UserConfigsetownchannelconfig(long this_ptr, long val);
+       /// LDKChannelHandshakeLimits UserConfig_get_peer_channel_config_limits(const LDKUserConfig *this_ptr);
+       public static native long UserConfiggetpeerchannelconfiglimits(long this_ptr);
+       /// void UserConfig_set_peer_channel_config_limits(LDKUserConfig *this_ptr, LDKChannelHandshakeLimits val);
+       public static native void UserConfigsetpeerchannelconfiglimits(long this_ptr, long val);
+       /// LDKChannelConfig UserConfig_get_channel_options(const LDKUserConfig *this_ptr);
+       public static native long UserConfiggetchanneloptions(long this_ptr);
+       /// void UserConfig_set_channel_options(LDKUserConfig *this_ptr, LDKChannelConfig val);
+       public static native void UserConfigsetchanneloptions(long this_ptr, long val);
+       /// MUST_USE_RES LDKUserConfig UserConfig_new(LDKChannelHandshakeConfig own_channel_config_arg, LDKChannelHandshakeLimits peer_channel_config_limits_arg, LDKChannelConfig channel_options_arg);
+       public static native long UserConfignew(long own_channel_config_arg, long peer_channel_config_limits_arg, long channel_options_arg);
+       /// MUST_USE_RES LDKUserConfig UserConfig_default(void);
+       public static native long UserConfigdefault();
+       /// void ChainWatchInterface_free(LDKChainWatchInterface this_ptr);
+       public static native void ChainWatchInterfacefree(long this_ptr);
+       /// void BroadcasterInterface_free(LDKBroadcasterInterface this_ptr);
+       public static native void BroadcasterInterfacefree(long this_ptr);
+       /// void ChainListener_free(LDKChainListener this_ptr);
+       public static native void ChainListenerfree(long this_ptr);
+       /// void FeeEstimator_free(LDKFeeEstimator this_ptr);
+       public static native void FeeEstimatorfree(long this_ptr);
+       /// void ChainWatchedUtil_free(LDKChainWatchedUtil this_ptr);
+       public static native void ChainWatchedUtilfree(long this_ptr);
+       /// MUST_USE_RES LDKChainWatchedUtil ChainWatchedUtil_new(void);
+       public static native long ChainWatchedUtilnew();
+       /// MUST_USE_RES bool ChainWatchedUtil_register_tx(LDKChainWatchedUtil *this_arg, const uint8_t (*txid)[32], LDKu8slice script_pub_key);
+       public static native boolean ChainWatchedUtilregistertx(long this_arg, byte[] txid, long script_pub_key);
+       /// MUST_USE_RES bool ChainWatchedUtil_register_outpoint(LDKChainWatchedUtil *this_arg, LDKC2Tuple_Txidu32Z outpoint, LDKu8slice _script_pub_key);
+       public static native boolean ChainWatchedUtilregisteroutpoint(long this_arg, long outpoint, long _script_pub_key);
+       /// MUST_USE_RES bool ChainWatchedUtil_watch_all(LDKChainWatchedUtil *this_arg);
+       public static native boolean ChainWatchedUtilwatchall(long this_arg);
+       /// MUST_USE_RES bool ChainWatchedUtil_does_match_tx(const LDKChainWatchedUtil *this_arg, LDKTransaction tx);
+       public static native boolean ChainWatchedUtildoesmatchtx(long this_arg, long tx);
+       /// void BlockNotifier_free(LDKBlockNotifier this_ptr);
+       public static native void BlockNotifierfree(long this_ptr);
+       /// MUST_USE_RES LDKBlockNotifier BlockNotifier_new(LDKChainWatchInterface chain_monitor);
+       public static native long BlockNotifiernew(long chain_monitor);
+       /// void BlockNotifier_register_listener(const LDKBlockNotifier *this_arg, LDKChainListener listener);
+       public static native void BlockNotifierregisterlistener(long this_arg, long listener);
+       /// void BlockNotifier_block_connected(const LDKBlockNotifier *this_arg, LDKu8slice block, uint32_t height);
+       public static native void BlockNotifierblockconnected(long this_arg, long block, int heigh);
+       /// MUST_USE_RES bool BlockNotifier_block_connected_checked(const LDKBlockNotifier *this_arg, const uint8_t (*header)[80], uint32_t height, LDKCTransactionSlice txn_matched, LDKusizeslice indexes_of_txn_matched);
+       public static native boolean BlockNotifierblockconnectedchecked(long this_arg, byte[] header, int heigh, long txn_matched, long indexes_of_txn_matched);
+       /// void BlockNotifier_block_disconnected(const LDKBlockNotifier *this_arg, const uint8_t (*header)[80], uint32_t disconnected_height);
+       public static native void BlockNotifierblockdisconnected(long this_arg, byte[] header, int disconnected_heigh);
+       /// void ChainWatchInterfaceUtil_free(LDKChainWatchInterfaceUtil this_ptr);
+       public static native void ChainWatchInterfaceUtilfree(long this_ptr);
+       /// LDKChainWatchInterface ChainWatchInterfaceUtil_as_ChainWatchInterface(const LDKChainWatchInterfaceUtil *this_arg);
+       public static native long ChainWatchInterfaceUtilasChainWatchInterface(long this_arg);
+       /// MUST_USE_RES LDKChainWatchInterfaceUtil ChainWatchInterfaceUtil_new(LDKNetwork network);
+       public static native long ChainWatchInterfaceUtilnew(long network);
+       /// MUST_USE_RES bool ChainWatchInterfaceUtil_does_match_tx(const LDKChainWatchInterfaceUtil *this_arg, LDKTransaction tx);
+       public static native boolean ChainWatchInterfaceUtildoesmatchtx(long this_arg, long tx);
+       /// void OutPoint_free(LDKOutPoint this_ptr);
+       public static native void OutPointfree(long this_ptr);
+       /// const uint8_t (*OutPoint_get_txid(const LDKOutPoint *this_ptr))[32];
+       public static native byte[] OutPointgettxid(long this_ptr);
+       /// void OutPoint_set_txid(LDKOutPoint *this_ptr, LDKThirtyTwoBytes val);
+       public static native void OutPointsettxid(long this_ptr, long val);
+       /// uint16_t OutPoint_get_index(const LDKOutPoint *this_ptr);
+       public static native long OutPointgetindex(long this_ptr);
+       /// void OutPoint_set_index(LDKOutPoint *this_ptr, uint16_t val);
+       public static native void OutPointsetindex(long this_ptr, long val);
+       /// MUST_USE_RES LDKOutPoint OutPoint_new(LDKThirtyTwoBytes txid_arg, uint16_t index_arg);
+       public static native long OutPointnew(long txid_arg, long index_arg);
+       /// MUST_USE_RES LDKThirtyTwoBytes OutPoint_to_channel_id(const LDKOutPoint *this_arg);
+       public static native long OutPointtochannelid(long this_arg);
+       /// LDKCVec_u8Z OutPoint_write(const LDKOutPoint *obj);
+       public static native long OutPointwrite(long obj);
+       /// LDKOutPoint OutPoint_read(LDKu8slice ser);
+       public static native long OutPointread(long ser);
+       /// void SpendableOutputDescriptor_free(LDKSpendableOutputDescriptor this_ptr);
+       public static native void SpendableOutputDescriptorfree(long this_ptr);
+       /// LDKCVec_u8Z SpendableOutputDescriptor_write(const LDKSpendableOutputDescriptor *obj);
+       public static native long SpendableOutputDescriptorwrite(long obj);
+       /// LDKSpendableOutputDescriptor SpendableOutputDescriptor_read(LDKu8slice ser);
+       public static native long SpendableOutputDescriptorread(long ser);
+       /// void ChannelKeys_free(LDKChannelKeys this_ptr);
+       public static native void ChannelKeysfree(long this_ptr);
+       /// void KeysInterface_free(LDKKeysInterface this_ptr);
+       public static native void KeysInterfacefree(long this_ptr);
+       /// void InMemoryChannelKeys_free(LDKInMemoryChannelKeys this_ptr);
+       public static native void InMemoryChannelKeysfree(long this_ptr);
+       /// const uint8_t (*InMemoryChannelKeys_get_funding_key(const LDKInMemoryChannelKeys *this_ptr))[32];
+       public static native byte[] InMemoryChannelKeysgetfundingkey(long this_ptr);
+       /// void InMemoryChannelKeys_set_funding_key(LDKInMemoryChannelKeys *this_ptr, LDKSecretKey val);
+       public static native void InMemoryChannelKeyssetfundingkey(long this_ptr, long val);
+       /// const uint8_t (*InMemoryChannelKeys_get_revocation_base_key(const LDKInMemoryChannelKeys *this_ptr))[32];
+       public static native byte[] InMemoryChannelKeysgetrevocationbasekey(long this_ptr);
+       /// void InMemoryChannelKeys_set_revocation_base_key(LDKInMemoryChannelKeys *this_ptr, LDKSecretKey val);
+       public static native void InMemoryChannelKeyssetrevocationbasekey(long this_ptr, long val);
+       /// const uint8_t (*InMemoryChannelKeys_get_payment_key(const LDKInMemoryChannelKeys *this_ptr))[32];
+       public static native byte[] InMemoryChannelKeysgetpaymentkey(long this_ptr);
+       /// void InMemoryChannelKeys_set_payment_key(LDKInMemoryChannelKeys *this_ptr, LDKSecretKey val);
+       public static native void InMemoryChannelKeyssetpaymentkey(long this_ptr, long val);
+       /// const uint8_t (*InMemoryChannelKeys_get_delayed_payment_base_key(const LDKInMemoryChannelKeys *this_ptr))[32];
+       public static native byte[] InMemoryChannelKeysgetdelayedpaymentbasekey(long this_ptr);
+       /// void InMemoryChannelKeys_set_delayed_payment_base_key(LDKInMemoryChannelKeys *this_ptr, LDKSecretKey val);
+       public static native void InMemoryChannelKeyssetdelayedpaymentbasekey(long this_ptr, long val);
+       /// const uint8_t (*InMemoryChannelKeys_get_htlc_base_key(const LDKInMemoryChannelKeys *this_ptr))[32];
+       public static native byte[] InMemoryChannelKeysgethtlcbasekey(long this_ptr);
+       /// void InMemoryChannelKeys_set_htlc_base_key(LDKInMemoryChannelKeys *this_ptr, LDKSecretKey val);
+       public static native void InMemoryChannelKeyssethtlcbasekey(long this_ptr, long val);
+       /// const uint8_t (*InMemoryChannelKeys_get_commitment_seed(const LDKInMemoryChannelKeys *this_ptr))[32];
+       public static native byte[] InMemoryChannelKeysgetcommitmentseed(long this_ptr);
+       /// void InMemoryChannelKeys_set_commitment_seed(LDKInMemoryChannelKeys *this_ptr, LDKThirtyTwoBytes val);
+       public static native void InMemoryChannelKeyssetcommitmentseed(long this_ptr, long val);
+       /// MUST_USE_RES LDKInMemoryChannelKeys InMemoryChannelKeys_new(LDKSecretKey funding_key, LDKSecretKey revocation_base_key, LDKSecretKey payment_key, LDKSecretKey delayed_payment_base_key, LDKSecretKey htlc_base_key, LDKThirtyTwoBytes commitment_seed, uint64_t channel_value_satoshis, LDKC2Tuple_u64u64Z key_derivation_params);
+       public static native long InMemoryChannelKeysnew(long funding_key, long revocation_base_key, long payment_key, long delayed_payment_base_key, long htlc_base_key, long commitment_seed, long channel_value_satoshis, long key_derivation_params);
+       /// LDKChannelKeys InMemoryChannelKeys_as_ChannelKeys(const LDKInMemoryChannelKeys *this_arg);
+       public static native long InMemoryChannelKeysasChannelKeys(long this_arg);
+       /// LDKCVec_u8Z InMemoryChannelKeys_write(const LDKInMemoryChannelKeys *obj);
+       public static native long InMemoryChannelKeyswrite(long obj);
+       /// LDKInMemoryChannelKeys InMemoryChannelKeys_read(LDKu8slice ser);
+       public static native long InMemoryChannelKeysread(long ser);
+       /// void KeysManager_free(LDKKeysManager this_ptr);
+       public static native void KeysManagerfree(long this_ptr);
+       /// MUST_USE_RES LDKKeysManager KeysManager_new(const uint8_t (*seed)[32], LDKNetwork network, uint64_t starting_time_secs, uint32_t starting_time_nanos);
+       public static native long KeysManagernew(byte[] seed, long network, long starting_time_secs, int starting_time_nanos);
+       /// MUST_USE_RES LDKInMemoryChannelKeys KeysManager_derive_channel_keys(const LDKKeysManager *this_arg, uint64_t channel_value_satoshis, uint64_t params_1, uint64_t params_2);
+       public static native long KeysManagerderivechannelkeys(long this_arg, long channel_value_satoshis, long params_1, long params_2);
+       /// LDKKeysInterface KeysManager_as_KeysInterface(const LDKKeysManager *this_arg);
+       public static native long KeysManagerasKeysInterface(long this_arg);
+       /// void ChannelManager_free(LDKChannelManager this_ptr);
+       public static native void ChannelManagerfree(long this_ptr);
+       /// void ChannelDetails_free(LDKChannelDetails this_ptr);
+       public static native void ChannelDetailsfree(long this_ptr);
+       /// const uint8_t (*ChannelDetails_get_channel_id(const LDKChannelDetails *this_ptr))[32];
+       public static native byte[] ChannelDetailsgetchannelid(long this_ptr);
+       /// void ChannelDetails_set_channel_id(LDKChannelDetails *this_ptr, LDKThirtyTwoBytes val);
+       public static native void ChannelDetailssetchannelid(long this_ptr, long val);
+       /// LDKPublicKey ChannelDetails_get_remote_network_id(const LDKChannelDetails *this_ptr);
+       public static native long ChannelDetailsgetremotenetworkid(long this_ptr);
+       /// void ChannelDetails_set_remote_network_id(LDKChannelDetails *this_ptr, LDKPublicKey val);
+       public static native void ChannelDetailssetremotenetworkid(long this_ptr, long val);
+       /// LDKInitFeatures ChannelDetails_get_counterparty_features(const LDKChannelDetails *this_ptr);
+       public static native long ChannelDetailsgetcounterpartyfeatures(long this_ptr);
+       /// void ChannelDetails_set_counterparty_features(LDKChannelDetails *this_ptr, LDKInitFeatures val);
+       public static native void ChannelDetailssetcounterpartyfeatures(long this_ptr, long val);
+       /// uint64_t ChannelDetails_get_channel_value_satoshis(const LDKChannelDetails *this_ptr);
+       public static native long ChannelDetailsgetchannelvaluesatoshis(long this_ptr);
+       /// void ChannelDetails_set_channel_value_satoshis(LDKChannelDetails *this_ptr, uint64_t val);
+       public static native void ChannelDetailssetchannelvaluesatoshis(long this_ptr, long val);
+       /// uint64_t ChannelDetails_get_user_id(const LDKChannelDetails *this_ptr);
+       public static native long ChannelDetailsgetuserid(long this_ptr);
+       /// void ChannelDetails_set_user_id(LDKChannelDetails *this_ptr, uint64_t val);
+       public static native void ChannelDetailssetuserid(long this_ptr, long val);
+       /// uint64_t ChannelDetails_get_outbound_capacity_msat(const LDKChannelDetails *this_ptr);
+       public static native long ChannelDetailsgetoutboundcapacitymsat(long this_ptr);
+       /// void ChannelDetails_set_outbound_capacity_msat(LDKChannelDetails *this_ptr, uint64_t val);
+       public static native void ChannelDetailssetoutboundcapacitymsat(long this_ptr, long val);
+       /// uint64_t ChannelDetails_get_inbound_capacity_msat(const LDKChannelDetails *this_ptr);
+       public static native long ChannelDetailsgetinboundcapacitymsat(long this_ptr);
+       /// void ChannelDetails_set_inbound_capacity_msat(LDKChannelDetails *this_ptr, uint64_t val);
+       public static native void ChannelDetailssetinboundcapacitymsat(long this_ptr, long val);
+       /// bool ChannelDetails_get_is_live(const LDKChannelDetails *this_ptr);
+       public static native boolean ChannelDetailsgetislive(long this_ptr);
+       /// void ChannelDetails_set_is_live(LDKChannelDetails *this_ptr, bool val);
+       public static native void ChannelDetailssetislive(long this_ptr, boolean va);
+       /// void PaymentSendFailure_free(LDKPaymentSendFailure this_ptr);
+       public static native void PaymentSendFailurefree(long this_ptr);
+       /// MUST_USE_RES LDKChannelManager ChannelManager_new(LDKNetwork network, LDKFeeEstimator fee_est, LDKManyChannelMonitor monitor, LDKBroadcasterInterface tx_broadcaster, LDKLogger logger, LDKKeysInterface keys_manager, LDKUserConfig config, uintptr_t current_blockchain_height);
+       public static native long ChannelManagernew(long network, long fee_est, long monitor, long tx_broadcaster, long logger, long keys_manager, long config, long current_blockchain_height);
+       /// MUST_USE_RES LDKCResult_NoneAPIErrorZ ChannelManager_create_channel(const LDKChannelManager *this_arg, LDKPublicKey their_network_key, uint64_t channel_value_satoshis, uint64_t push_msat, uint64_t user_id, LDKUserConfig override_config);
+       public static native long ChannelManagercreatechannel(long this_arg, long their_network_key, long channel_value_satoshis, long push_msa, long ser_id, long override_config);
+       /// MUST_USE_RES LDKCVec_ChannelDetailsZ ChannelManager_list_channels(const LDKChannelManager *this_arg);
+       public static native long ChannelManagerlistchannels(long this_arg);
+       /// MUST_USE_RES LDKCVec_ChannelDetailsZ ChannelManager_list_usable_channels(const LDKChannelManager *this_arg);
+       public static native long ChannelManagerlistusablechannels(long this_arg);
+       /// MUST_USE_RES LDKCResult_NoneAPIErrorZ ChannelManager_close_channel(const LDKChannelManager *this_arg, const uint8_t (*channel_id)[32]);
+       public static native long ChannelManagerclosechannel(long this_arg, byte[] channel_id);
+       /// void ChannelManager_force_close_channel(const LDKChannelManager *this_arg, const uint8_t (*channel_id)[32]);
+       public static native void ChannelManagerforceclosechannel(long this_arg, byte[] channel_id);
+       /// void ChannelManager_force_close_all_channels(const LDKChannelManager *this_arg);
+       public static native void ChannelManagerforcecloseallchannels(long this_arg);
+       /// MUST_USE_RES LDKCResult_NonePaymentSendFailureZ ChannelManager_send_payment(const LDKChannelManager *this_arg, const LDKRoute *route, LDKThirtyTwoBytes payment_hash, LDKThirtyTwoBytes payment_secret);
+       public static native long ChannelManagersendpayment(long this_arg, long route, long payment_hash, long payment_secret);
+       /// void ChannelManager_funding_transaction_generated(const LDKChannelManager *this_arg, const uint8_t (*temporary_channel_id)[32], LDKOutPoint funding_txo);
+       public static native void ChannelManagerfundingtransactiongenerated(long this_arg, byte[] temporary_channel_id, long funding_txo);
+       /// void ChannelManager_broadcast_node_announcement(const LDKChannelManager *this_arg, LDKThreeBytes rgb, LDKThirtyTwoBytes alias, LDKCVec_NetAddressZ addresses);
+       public static native void ChannelManagerbroadcastnodeannouncement(long this_arg, long rgb, long alias, long addresses);
+       /// void ChannelManager_process_pending_htlc_forwards(const LDKChannelManager *this_arg);
+       public static native void ChannelManagerprocesspendinghtlcforwards(long this_arg);
+       /// void ChannelManager_timer_chan_freshness_every_min(const LDKChannelManager *this_arg);
+       public static native void ChannelManagertimerchanfreshnesseverymin(long this_arg);
+       /// MUST_USE_RES bool ChannelManager_fail_htlc_backwards(const LDKChannelManager *this_arg, const uint8_t (*payment_hash)[32], LDKThirtyTwoBytes payment_secret);
+       public static native boolean ChannelManagerfailhtlcbackwards(long this_arg, byte[] payment_hash, long payment_secret);
+       /// MUST_USE_RES bool ChannelManager_claim_funds(const LDKChannelManager *this_arg, LDKThirtyTwoBytes payment_preimage, LDKThirtyTwoBytes payment_secret, uint64_t expected_amount);
+       public static native boolean ChannelManagerclaimfunds(long this_arg, long payment_preimage, long payment_secret, long expected_amo);
+       /// MUST_USE_RES LDKPublicKey ChannelManager_get_our_node_id(const LDKChannelManager *this_arg);
+       public static native long ChannelManagergetournodeid(long this_arg);
+       /// void ChannelManager_channel_monitor_updated(const LDKChannelManager *this_arg, const LDKOutPoint *funding_txo, uint64_t highest_applied_update_id);
+       public static native void ChannelManagerchannelmonitorupdated(long this_arg, long funding_txo, long highest_applied_update_id);
+       /// LDKMessageSendEventsProvider ChannelManager_as_MessageSendEventsProvider(const LDKChannelManager *this_arg);
+       public static native long ChannelManagerasMessageSendEventsProvider(long this_arg);
+       /// LDKEventsProvider ChannelManager_as_EventsProvider(const LDKChannelManager *this_arg);
+       public static native long ChannelManagerasEventsProvider(long this_arg);
+       /// LDKChainListener ChannelManager_as_ChainListener(const LDKChannelManager *this_arg);
+       public static native long ChannelManagerasChainListener(long this_arg);
+       /// LDKChannelMessageHandler ChannelManager_as_ChannelMessageHandler(const LDKChannelManager *this_arg);
+       public static native long ChannelManagerasChannelMessageHandler(long this_arg);
+       /// void ChannelMonitorUpdate_free(LDKChannelMonitorUpdate this_ptr);
+       public static native void ChannelMonitorUpdatefree(long this_ptr);
+       /// uint64_t ChannelMonitorUpdate_get_update_id(const LDKChannelMonitorUpdate *this_ptr);
+       public static native long ChannelMonitorUpdategetupdateid(long this_ptr);
+       /// void ChannelMonitorUpdate_set_update_id(LDKChannelMonitorUpdate *this_ptr, uint64_t val);
+       public static native void ChannelMonitorUpdatesetupdateid(long this_ptr, long val);
+       /// LDKCVec_u8Z ChannelMonitorUpdate_write(const LDKChannelMonitorUpdate *obj);
+       public static native long ChannelMonitorUpdatewrite(long obj);
+       /// LDKChannelMonitorUpdate ChannelMonitorUpdate_read(LDKu8slice ser);
+       public static native long ChannelMonitorUpdateread(long ser);
+       /// void MonitorUpdateError_free(LDKMonitorUpdateError this_ptr);
+       public static native void MonitorUpdateErrorfree(long this_ptr);
+       /// void HTLCUpdate_free(LDKHTLCUpdate this_ptr);
+       public static native void HTLCUpdatefree(long this_ptr);
+       /// LDKCVec_u8Z HTLCUpdate_write(const LDKHTLCUpdate *obj);
+       public static native long HTLCUpdatewrite(long obj);
+       /// LDKHTLCUpdate HTLCUpdate_read(LDKu8slice ser);
+       public static native long HTLCUpdateread(long ser);
+       /// void ChannelMonitor_free(LDKChannelMonitor this_ptr);
+       public static native void ChannelMonitorfree(long this_ptr);
+       /// void ManyChannelMonitor_free(LDKManyChannelMonitor this_ptr);
+       public static native void ManyChannelMonitorfree(long this_ptr);
+       /// MUST_USE_RES LDKCResult_NoneMonitorUpdateErrorZ ChannelMonitor_update_monitor(LDKChannelMonitor *this_arg, LDKChannelMonitorUpdate updates, const LDKBroadcasterInterface *broadcaster, const LDKLogger *logger);
+       public static native long ChannelMonitorupdatemonitor(long this_arg, long updates, long broadcaster, long logger);
+       /// MUST_USE_RES uint64_t ChannelMonitor_get_latest_update_id(const LDKChannelMonitor *this_arg);
+       public static native long ChannelMonitorgetlatestupdateid(long this_arg);
+       /// MUST_USE_RES LDKC2Tuple_OutPointScriptZ ChannelMonitor_get_funding_txo(const LDKChannelMonitor *this_arg);
+       public static native long ChannelMonitorgetfundingtxo(long this_arg);
+       /// MUST_USE_RES LDKCVec_HTLCUpdateZ ChannelMonitor_get_and_clear_pending_htlcs_updated(LDKChannelMonitor *this_arg);
+       public static native long ChannelMonitorgetandclearpendinghtlcsupdated(long this_arg);
+       /// MUST_USE_RES LDKCVec_EventZ ChannelMonitor_get_and_clear_pending_events(LDKChannelMonitor *this_arg);
+       public static native long ChannelMonitorgetandclearpendingevents(long this_arg);
+       /// MUST_USE_RES LDKCVec_TransactionZ ChannelMonitor_get_latest_local_commitment_txn(LDKChannelMonitor *this_arg, const LDKLogger *logger);
+       public static native long ChannelMonitorgetlatestlocalcommitmenttxn(long this_arg, long logger);
+       /// void DecodeError_free(LDKDecodeError this_ptr);
+       public static native void DecodeErrorfree(long this_ptr);
+       /// void Init_free(LDKInit this_ptr);
+       public static native void Initfree(long this_ptr);
+       /// void ErrorMessage_free(LDKErrorMessage this_ptr);
+       public static native void ErrorMessagefree(long this_ptr);
+       /// void Ping_free(LDKPing this_ptr);
+       public static native void Pingfree(long this_ptr);
+       /// void Pong_free(LDKPong this_ptr);
+       public static native void Pongfree(long this_ptr);
+       /// void OpenChannel_free(LDKOpenChannel this_ptr);
+       public static native void OpenChannelfree(long this_ptr);
+       /// void AcceptChannel_free(LDKAcceptChannel this_ptr);
+       public static native void AcceptChannelfree(long this_ptr);
+       /// void FundingCreated_free(LDKFundingCreated this_ptr);
+       public static native void FundingCreatedfree(long this_ptr);
+       /// void FundingSigned_free(LDKFundingSigned this_ptr);
+       public static native void FundingSignedfree(long this_ptr);
+       /// void FundingLocked_free(LDKFundingLocked this_ptr);
+       public static native void FundingLockedfree(long this_ptr);
+       /// const uint8_t (*FundingLocked_get_channel_id(const LDKFundingLocked *this_ptr))[32];
+       public static native byte[] FundingLockedgetchannelid(long this_ptr);
+       /// void FundingLocked_set_channel_id(LDKFundingLocked *this_ptr, LDKThirtyTwoBytes val);
+       public static native void FundingLockedsetchannelid(long this_ptr, long val);
+       /// LDKPublicKey FundingLocked_get_next_per_commitment_point(const LDKFundingLocked *this_ptr);
+       public static native long FundingLockedgetnextpercommitmentpoint(long this_ptr);
+       /// void FundingLocked_set_next_per_commitment_point(LDKFundingLocked *this_ptr, LDKPublicKey val);
+       public static native void FundingLockedsetnextpercommitmentpoint(long this_ptr, long val);
+       /// MUST_USE_RES LDKFundingLocked FundingLocked_new(LDKThirtyTwoBytes channel_id_arg, LDKPublicKey next_per_commitment_point_arg);
+       public static native long FundingLockednew(long channel_id_arg, long next_per_commitment_point_arg);
+       /// void Shutdown_free(LDKShutdown this_ptr);
+       public static native void Shutdownfree(long this_ptr);
+       /// void ClosingSigned_free(LDKClosingSigned this_ptr);
+       public static native void ClosingSignedfree(long this_ptr);
+       /// void UpdateAddHTLC_free(LDKUpdateAddHTLC this_ptr);
+       public static native void UpdateAddHTLCfree(long this_ptr);
+       /// void UpdateFulfillHTLC_free(LDKUpdateFulfillHTLC this_ptr);
+       public static native void UpdateFulfillHTLCfree(long this_ptr);
+       /// void UpdateFailHTLC_free(LDKUpdateFailHTLC this_ptr);
+       public static native void UpdateFailHTLCfree(long this_ptr);
+       /// void UpdateFailMalformedHTLC_free(LDKUpdateFailMalformedHTLC this_ptr);
+       public static native void UpdateFailMalformedHTLCfree(long this_ptr);
+       /// void CommitmentSigned_free(LDKCommitmentSigned this_ptr);
+       public static native void CommitmentSignedfree(long this_ptr);
+       /// void RevokeAndACK_free(LDKRevokeAndACK this_ptr);
+       public static native void RevokeAndACKfree(long this_ptr);
+       /// void UpdateFee_free(LDKUpdateFee this_ptr);
+       public static native void UpdateFeefree(long this_ptr);
+       /// void ChannelReestablish_free(LDKChannelReestablish this_ptr);
+       public static native void ChannelReestablishfree(long this_ptr);
+       /// void AnnouncementSignatures_free(LDKAnnouncementSignatures this_ptr);
+       public static native void AnnouncementSignaturesfree(long this_ptr);
+       /// void NetAddress_free(LDKNetAddress this_ptr);
+       public static native void NetAddressfree(long this_ptr);
+       /// void UnsignedNodeAnnouncement_free(LDKUnsignedNodeAnnouncement this_ptr);
+       public static native void UnsignedNodeAnnouncementfree(long this_ptr);
+       /// LDKPublicKey UnsignedNodeAnnouncement_get_node_id(const LDKUnsignedNodeAnnouncement *this_ptr);
+       public static native long UnsignedNodeAnnouncementgetnodeid(long this_ptr);
+       /// void UnsignedNodeAnnouncement_set_node_id(LDKUnsignedNodeAnnouncement *this_ptr, LDKPublicKey val);
+       public static native void UnsignedNodeAnnouncementsetnodeid(long this_ptr, long val);
+       /// void NodeAnnouncement_free(LDKNodeAnnouncement this_ptr);
+       public static native void NodeAnnouncementfree(long this_ptr);
+       /// void UnsignedChannelAnnouncement_free(LDKUnsignedChannelAnnouncement this_ptr);
+       public static native void UnsignedChannelAnnouncementfree(long this_ptr);
+       /// LDKPublicKey UnsignedChannelAnnouncement_get_node_id_1(const LDKUnsignedChannelAnnouncement *this_ptr);
+       public static native long UnsignedChannelAnnouncementgetnodeid1(long this_ptr);
+       /// void UnsignedChannelAnnouncement_set_node_id_1(LDKUnsignedChannelAnnouncement *this_ptr, LDKPublicKey val);
+       public static native void UnsignedChannelAnnouncementsetnodeid1(long this_ptr, long val);
+       /// LDKPublicKey UnsignedChannelAnnouncement_get_node_id_2(const LDKUnsignedChannelAnnouncement *this_ptr);
+       public static native long UnsignedChannelAnnouncementgetnodeid2(long this_ptr);
+       /// void UnsignedChannelAnnouncement_set_node_id_2(LDKUnsignedChannelAnnouncement *this_ptr, LDKPublicKey val);
+       public static native void UnsignedChannelAnnouncementsetnodeid2(long this_ptr, long val);
+       /// void ChannelAnnouncement_free(LDKChannelAnnouncement this_ptr);
+       public static native void ChannelAnnouncementfree(long this_ptr);
+       /// void ChannelUpdate_free(LDKChannelUpdate this_ptr);
+       public static native void ChannelUpdatefree(long this_ptr);
+       /// void ErrorAction_free(LDKErrorAction this_ptr);
+       public static native void ErrorActionfree(long this_ptr);
+       /// void LightningError_free(LDKLightningError this_ptr);
+       public static native void LightningErrorfree(long this_ptr);
+       /// LDKStr LightningError_get_err(const LDKLightningError *this_ptr);
+       public static native long LightningErrorgeterr(long this_ptr);
+       /// void LightningError_set_err(LDKLightningError *this_ptr, LDKCVec_u8Z val);
+       public static native void LightningErrorseterr(long this_ptr, long val);
+       /// LDKErrorAction LightningError_get_action(const LDKLightningError *this_ptr);
+       public static native long LightningErrorgetaction(long this_ptr);
+       /// void LightningError_set_action(LDKLightningError *this_ptr, LDKErrorAction val);
+       public static native void LightningErrorsetaction(long this_ptr, long val);
+       /// MUST_USE_RES LDKLightningError LightningError_new(LDKCVec_u8Z err_arg, LDKErrorAction action_arg);
+       public static native long LightningErrornew(long err_arg, long action_arg);
+       /// void CommitmentUpdate_free(LDKCommitmentUpdate this_ptr);
+       public static native void CommitmentUpdatefree(long this_ptr);
+       /// void CommitmentUpdate_set_update_add_htlcs(LDKCommitmentUpdate *this_ptr, LDKCVec_UpdateAddHTLCZ val);
+       public static native void CommitmentUpdatesetupdateaddhtlcs(long this_ptr, long val);
+       /// void CommitmentUpdate_set_update_fulfill_htlcs(LDKCommitmentUpdate *this_ptr, LDKCVec_UpdateFulfillHTLCZ val);
+       public static native void CommitmentUpdatesetupdatefulfillhtlcs(long this_ptr, long val);
+       /// void CommitmentUpdate_set_update_fail_htlcs(LDKCommitmentUpdate *this_ptr, LDKCVec_UpdateFailHTLCZ val);
+       public static native void CommitmentUpdatesetupdatefailhtlcs(long this_ptr, long val);
+       /// void CommitmentUpdate_set_update_fail_malformed_htlcs(LDKCommitmentUpdate *this_ptr, LDKCVec_UpdateFailMalformedHTLCZ val);
+       public static native void CommitmentUpdatesetupdatefailmalformedhtlcs(long this_ptr, long val);
+       /// LDKUpdateFee CommitmentUpdate_get_update_fee(const LDKCommitmentUpdate *this_ptr);
+       public static native long CommitmentUpdategetupdatefee(long this_ptr);
+       /// void CommitmentUpdate_set_update_fee(LDKCommitmentUpdate *this_ptr, LDKUpdateFee val);
+       public static native void CommitmentUpdatesetupdatefee(long this_ptr, long val);
+       /// LDKCommitmentSigned CommitmentUpdate_get_commitment_signed(const LDKCommitmentUpdate *this_ptr);
+       public static native long CommitmentUpdategetcommitmentsigned(long this_ptr);
+       /// void CommitmentUpdate_set_commitment_signed(LDKCommitmentUpdate *this_ptr, LDKCommitmentSigned val);
+       public static native void CommitmentUpdatesetcommitmentsigned(long this_ptr, long val);
+       /// MUST_USE_RES LDKCommitmentUpdate CommitmentUpdate_new(LDKCVec_UpdateAddHTLCZ update_add_htlcs_arg, LDKCVec_UpdateFulfillHTLCZ update_fulfill_htlcs_arg, LDKCVec_UpdateFailHTLCZ update_fail_htlcs_arg, LDKCVec_UpdateFailMalformedHTLCZ update_fail_malformed_htlcs_arg, LDKUpdateFee update_fee_arg, LDKCommitmentSigned commitment_signed_arg);
+       public static native long CommitmentUpdatenew(long update_add_htlcs_arg, long update_fulfill_htlcs_arg, long update_fail_htlcs_arg, long update_fail_malformed_htlcs_arg, long update_fee_arg, long commitment_signed_arg);
+       /// void HTLCFailChannelUpdate_free(LDKHTLCFailChannelUpdate this_ptr);
+       public static native void HTLCFailChannelUpdatefree(long this_ptr);
+       /// void ChannelMessageHandler_free(LDKChannelMessageHandler this_ptr);
+       public static native void ChannelMessageHandlerfree(long this_ptr);
+       /// void RoutingMessageHandler_free(LDKRoutingMessageHandler this_ptr);
+       public static native void RoutingMessageHandlerfree(long this_ptr);
+       /// LDKCVec_u8Z AcceptChannel_write(const LDKAcceptChannel *obj);
+       public static native long AcceptChannelwrite(long obj);
+       /// LDKAcceptChannel AcceptChannel_read(LDKu8slice ser);
+       public static native long AcceptChannelread(long ser);
+       /// LDKCVec_u8Z AnnouncementSignatures_write(const LDKAnnouncementSignatures *obj);
+       public static native long AnnouncementSignatureswrite(long obj);
+       /// LDKAnnouncementSignatures AnnouncementSignatures_read(LDKu8slice ser);
+       public static native long AnnouncementSignaturesread(long ser);
+       /// LDKCVec_u8Z ChannelReestablish_write(const LDKChannelReestablish *obj);
+       public static native long ChannelReestablishwrite(long obj);
+       /// LDKChannelReestablish ChannelReestablish_read(LDKu8slice ser);
+       public static native long ChannelReestablishread(long ser);
+       /// LDKCVec_u8Z ClosingSigned_write(const LDKClosingSigned *obj);
+       public static native long ClosingSignedwrite(long obj);
+       /// LDKClosingSigned ClosingSigned_read(LDKu8slice ser);
+       public static native long ClosingSignedread(long ser);
+       /// LDKCVec_u8Z CommitmentSigned_write(const LDKCommitmentSigned *obj);
+       public static native long CommitmentSignedwrite(long obj);
+       /// LDKCommitmentSigned CommitmentSigned_read(LDKu8slice ser);
+       public static native long CommitmentSignedread(long ser);
+       /// LDKCVec_u8Z FundingCreated_write(const LDKFundingCreated *obj);
+       public static native long FundingCreatedwrite(long obj);
+       /// LDKFundingCreated FundingCreated_read(LDKu8slice ser);
+       public static native long FundingCreatedread(long ser);
+       /// LDKCVec_u8Z FundingSigned_write(const LDKFundingSigned *obj);
+       public static native long FundingSignedwrite(long obj);
+       /// LDKFundingSigned FundingSigned_read(LDKu8slice ser);
+       public static native long FundingSignedread(long ser);
+       /// LDKCVec_u8Z FundingLocked_write(const LDKFundingLocked *obj);
+       public static native long FundingLockedwrite(long obj);
+       /// LDKFundingLocked FundingLocked_read(LDKu8slice ser);
+       public static native long FundingLockedread(long ser);
+       /// LDKCVec_u8Z Init_write(const LDKInit *obj);
+       public static native long Initwrite(long obj);
+       /// LDKInit Init_read(LDKu8slice ser);
+       public static native long Initread(long ser);
+       /// LDKCVec_u8Z OpenChannel_write(const LDKOpenChannel *obj);
+       public static native long OpenChannelwrite(long obj);
+       /// LDKOpenChannel OpenChannel_read(LDKu8slice ser);
+       public static native long OpenChannelread(long ser);
+       /// LDKCVec_u8Z RevokeAndACK_write(const LDKRevokeAndACK *obj);
+       public static native long RevokeAndACKwrite(long obj);
+       /// LDKRevokeAndACK RevokeAndACK_read(LDKu8slice ser);
+       public static native long RevokeAndACKread(long ser);
+       /// LDKCVec_u8Z Shutdown_write(const LDKShutdown *obj);
+       public static native long Shutdownwrite(long obj);
+       /// LDKShutdown Shutdown_read(LDKu8slice ser);
+       public static native long Shutdownread(long ser);
+       /// LDKCVec_u8Z UpdateFailHTLC_write(const LDKUpdateFailHTLC *obj);
+       public static native long UpdateFailHTLCwrite(long obj);
+       /// LDKUpdateFailHTLC UpdateFailHTLC_read(LDKu8slice ser);
+       public static native long UpdateFailHTLCread(long ser);
+       /// LDKCVec_u8Z UpdateFailMalformedHTLC_write(const LDKUpdateFailMalformedHTLC *obj);
+       public static native long UpdateFailMalformedHTLCwrite(long obj);
+       /// LDKUpdateFailMalformedHTLC UpdateFailMalformedHTLC_read(LDKu8slice ser);
+       public static native long UpdateFailMalformedHTLCread(long ser);
+       /// LDKCVec_u8Z UpdateFee_write(const LDKUpdateFee *obj);
+       public static native long UpdateFeewrite(long obj);
+       /// LDKUpdateFee UpdateFee_read(LDKu8slice ser);
+       public static native long UpdateFeeread(long ser);
+       /// LDKCVec_u8Z UpdateFulfillHTLC_write(const LDKUpdateFulfillHTLC *obj);
+       public static native long UpdateFulfillHTLCwrite(long obj);
+       /// LDKUpdateFulfillHTLC UpdateFulfillHTLC_read(LDKu8slice ser);
+       public static native long UpdateFulfillHTLCread(long ser);
+       /// LDKCVec_u8Z UpdateAddHTLC_write(const LDKUpdateAddHTLC *obj);
+       public static native long UpdateAddHTLCwrite(long obj);
+       /// LDKUpdateAddHTLC UpdateAddHTLC_read(LDKu8slice ser);
+       public static native long UpdateAddHTLCread(long ser);
+       /// LDKCVec_u8Z Ping_write(const LDKPing *obj);
+       public static native long Pingwrite(long obj);
+       /// LDKPing Ping_read(LDKu8slice ser);
+       public static native long Pingread(long ser);
+       /// LDKCVec_u8Z Pong_write(const LDKPong *obj);
+       public static native long Pongwrite(long obj);
+       /// LDKPong Pong_read(LDKu8slice ser);
+       public static native long Pongread(long ser);
+       /// LDKCVec_u8Z UnsignedChannelAnnouncement_write(const LDKUnsignedChannelAnnouncement *obj);
+       public static native long UnsignedChannelAnnouncementwrite(long obj);
+       /// LDKUnsignedChannelAnnouncement UnsignedChannelAnnouncement_read(LDKu8slice ser);
+       public static native long UnsignedChannelAnnouncementread(long ser);
+       /// LDKCVec_u8Z ChannelAnnouncement_write(const LDKChannelAnnouncement *obj);
+       public static native long ChannelAnnouncementwrite(long obj);
+       /// LDKChannelAnnouncement ChannelAnnouncement_read(LDKu8slice ser);
+       public static native long ChannelAnnouncementread(long ser);
+       /// LDKCVec_u8Z ChannelUpdate_write(const LDKChannelUpdate *obj);
+       public static native long ChannelUpdatewrite(long obj);
+       /// LDKChannelUpdate ChannelUpdate_read(LDKu8slice ser);
+       public static native long ChannelUpdateread(long ser);
+       /// LDKCVec_u8Z ErrorMessage_write(const LDKErrorMessage *obj);
+       public static native long ErrorMessagewrite(long obj);
+       /// LDKErrorMessage ErrorMessage_read(LDKu8slice ser);
+       public static native long ErrorMessageread(long ser);
+       /// LDKCVec_u8Z UnsignedNodeAnnouncement_write(const LDKUnsignedNodeAnnouncement *obj);
+       public static native long UnsignedNodeAnnouncementwrite(long obj);
+       /// LDKUnsignedNodeAnnouncement UnsignedNodeAnnouncement_read(LDKu8slice ser);
+       public static native long UnsignedNodeAnnouncementread(long ser);
+       /// LDKCVec_u8Z NodeAnnouncement_write(const LDKNodeAnnouncement *obj);
+       public static native long NodeAnnouncementwrite(long obj);
+       /// LDKNodeAnnouncement NodeAnnouncement_read(LDKu8slice ser);
+       public static native long NodeAnnouncementread(long ser);
+       /// void MessageHandler_free(LDKMessageHandler this_ptr);
+       public static native void MessageHandlerfree(long this_ptr);
+       /// const LDKChannelMessageHandler *MessageHandler_get_chan_handler(const LDKMessageHandler *this_ptr);
+       public static native long MessageHandlergetchanhandler(long this_ptr);
+       /// void MessageHandler_set_chan_handler(LDKMessageHandler *this_ptr, LDKChannelMessageHandler val);
+       public static native void MessageHandlersetchanhandler(long this_ptr, long val);
+       /// const LDKRoutingMessageHandler *MessageHandler_get_route_handler(const LDKMessageHandler *this_ptr);
+       public static native long MessageHandlergetroutehandler(long this_ptr);
+       /// void MessageHandler_set_route_handler(LDKMessageHandler *this_ptr, LDKRoutingMessageHandler val);
+       public static native void MessageHandlersetroutehandler(long this_ptr, long val);
+       /// MUST_USE_RES LDKMessageHandler MessageHandler_new(LDKChannelMessageHandler chan_handler_arg, LDKRoutingMessageHandler route_handler_arg);
+       public static native long MessageHandlernew(long chan_handler_arg, long route_handler_arg);
+       /// void SocketDescriptor_free(LDKSocketDescriptor this_ptr);
+       public static native void SocketDescriptorfree(long this_ptr);
+       /// void PeerHandleError_free(LDKPeerHandleError this_ptr);
+       public static native void PeerHandleErrorfree(long this_ptr);
+       /// bool PeerHandleError_get_no_connection_possible(const LDKPeerHandleError *this_ptr);
+       public static native boolean PeerHandleErrorgetnoconnectionpossible(long this_ptr);
+       /// void PeerHandleError_set_no_connection_possible(LDKPeerHandleError *this_ptr, bool val);
+       public static native void PeerHandleErrorsetnoconnectionpossible(long this_ptr, boolean va);
+       /// MUST_USE_RES LDKPeerHandleError PeerHandleError_new(bool no_connection_possible_arg);
+       public static native long PeerHandleErrornew(boolean no_connection_possible_arg);
+       /// void PeerManager_free(LDKPeerManager this_ptr);
+       public static native void PeerManagerfree(long this_ptr);
+       /// MUST_USE_RES LDKPeerManager PeerManager_new(LDKMessageHandler message_handler, LDKSecretKey our_node_secret, const uint8_t (*ephemeral_random_data)[32], LDKLogger logger);
+       public static native long PeerManagernew(long message_handler, long our_node_secret, byte[] ephemeral_random_data, long logger);
+       /// MUST_USE_RES LDKCVec_PublicKeyZ PeerManager_get_peer_node_ids(const LDKPeerManager *this_arg);
+       public static native long PeerManagergetpeernodeids(long this_arg);
+       /// MUST_USE_RES LDKCResult_CVec_u8ZPeerHandleErrorZ PeerManager_new_outbound_connection(const LDKPeerManager *this_arg, LDKPublicKey their_node_id, LDKSocketDescriptor descriptor);
+       public static native long PeerManagernewoutboundconnection(long this_arg, long their_node_id, long descriptor);
+       /// MUST_USE_RES LDKCResult_NonePeerHandleErrorZ PeerManager_new_inbound_connection(const LDKPeerManager *this_arg, LDKSocketDescriptor descriptor);
+       public static native long PeerManagernewinboundconnection(long this_arg, long descriptor);
+       /// MUST_USE_RES LDKCResult_NonePeerHandleErrorZ PeerManager_write_buffer_space_avail(const LDKPeerManager *this_arg, LDKSocketDescriptor *descriptor);
+       public static native long PeerManagerwritebufferspaceavail(long this_arg, long descriptor);
+       /// MUST_USE_RES LDKCResult_boolPeerHandleErrorZ PeerManager_read_event(const LDKPeerManager *this_arg, LDKSocketDescriptor *peer_descriptor, LDKu8slice data);
+       public static native long PeerManagerreadevent(long this_arg, long peer_descriptor, long data);
+       /// void PeerManager_process_events(const LDKPeerManager *this_arg);
+       public static native void PeerManagerprocessevents(long this_arg);
+       /// void PeerManager_socket_disconnected(const LDKPeerManager *this_arg, const LDKSocketDescriptor *descriptor);
+       public static native void PeerManagersocketdisconnected(long this_arg, long descriptor);
+       /// void PeerManager_timer_tick_occured(const LDKPeerManager *this_arg);
+       public static native void PeerManagertimertickoccured(long this_arg);
+       /// LDKThirtyTwoBytes build_commitment_secret(const uint8_t (*commitment_seed)[32], uint64_t idx);
+       public static native long buildcommitmentsecret(byte[] commitment_seed, long dx);
+       /// void TxCreationKeys_free(LDKTxCreationKeys this_ptr);
+       public static native void TxCreationKeysfree(long this_ptr);
+       /// LDKPublicKey TxCreationKeys_get_per_commitment_point(const LDKTxCreationKeys *this_ptr);
+       public static native long TxCreationKeysgetpercommitmentpoint(long this_ptr);
+       /// void TxCreationKeys_set_per_commitment_point(LDKTxCreationKeys *this_ptr, LDKPublicKey val);
+       public static native void TxCreationKeyssetpercommitmentpoint(long this_ptr, long val);
+       /// LDKCVec_u8Z TxCreationKeys_write(const LDKTxCreationKeys *obj);
+       public static native long TxCreationKeyswrite(long obj);
+       /// LDKTxCreationKeys TxCreationKeys_read(LDKu8slice ser);
+       public static native long TxCreationKeysread(long ser);
+       /// void ChannelPublicKeys_free(LDKChannelPublicKeys this_ptr);
+       public static native void ChannelPublicKeysfree(long this_ptr);
+       /// LDKPublicKey ChannelPublicKeys_get_funding_pubkey(const LDKChannelPublicKeys *this_ptr);
+       public static native long ChannelPublicKeysgetfundingpubkey(long this_ptr);
+       /// void ChannelPublicKeys_set_funding_pubkey(LDKChannelPublicKeys *this_ptr, LDKPublicKey val);
+       public static native void ChannelPublicKeyssetfundingpubkey(long this_ptr, long val);
+       /// LDKPublicKey ChannelPublicKeys_get_revocation_basepoint(const LDKChannelPublicKeys *this_ptr);
+       public static native long ChannelPublicKeysgetrevocationbasepoint(long this_ptr);
+       /// void ChannelPublicKeys_set_revocation_basepoint(LDKChannelPublicKeys *this_ptr, LDKPublicKey val);
+       public static native void ChannelPublicKeyssetrevocationbasepoint(long this_ptr, long val);
+       /// LDKPublicKey ChannelPublicKeys_get_payment_point(const LDKChannelPublicKeys *this_ptr);
+       public static native long ChannelPublicKeysgetpaymentpoint(long this_ptr);
+       /// void ChannelPublicKeys_set_payment_point(LDKChannelPublicKeys *this_ptr, LDKPublicKey val);
+       public static native void ChannelPublicKeyssetpaymentpoint(long this_ptr, long val);
+       /// LDKPublicKey ChannelPublicKeys_get_delayed_payment_basepoint(const LDKChannelPublicKeys *this_ptr);
+       public static native long ChannelPublicKeysgetdelayedpaymentbasepoint(long this_ptr);
+       /// void ChannelPublicKeys_set_delayed_payment_basepoint(LDKChannelPublicKeys *this_ptr, LDKPublicKey val);
+       public static native void ChannelPublicKeyssetdelayedpaymentbasepoint(long this_ptr, long val);
+       /// LDKPublicKey ChannelPublicKeys_get_htlc_basepoint(const LDKChannelPublicKeys *this_ptr);
+       public static native long ChannelPublicKeysgethtlcbasepoint(long this_ptr);
+       /// void ChannelPublicKeys_set_htlc_basepoint(LDKChannelPublicKeys *this_ptr, LDKPublicKey val);
+       public static native void ChannelPublicKeyssethtlcbasepoint(long this_ptr, long val);
+       /// MUST_USE_RES LDKChannelPublicKeys ChannelPublicKeys_new(LDKPublicKey funding_pubkey_arg, LDKPublicKey revocation_basepoint_arg, LDKPublicKey payment_point_arg, LDKPublicKey delayed_payment_basepoint_arg, LDKPublicKey htlc_basepoint_arg);
+       public static native long ChannelPublicKeysnew(long funding_pubkey_arg, long revocation_basepoint_arg, long payment_point_arg, long delayed_payment_basepoint_arg, long htlc_basepoint_arg);
+       /// LDKCVec_u8Z ChannelPublicKeys_write(const LDKChannelPublicKeys *obj);
+       public static native long ChannelPublicKeyswrite(long obj);
+       /// LDKChannelPublicKeys ChannelPublicKeys_read(LDKu8slice ser);
+       public static native long ChannelPublicKeysread(long ser);
+       /// LDKCVec_u8Z get_revokeable_redeemscript(LDKPublicKey revocation_key, uint16_t to_self_delay, LDKPublicKey delayed_payment_key);
+       public static native long getrevokeableredeemscript(long revocation_key, long to_self_delay, long delayed_payment_key);
+       /// void HTLCOutputInCommitment_free(LDKHTLCOutputInCommitment this_ptr);
+       public static native void HTLCOutputInCommitmentfree(long this_ptr);
+       /// bool HTLCOutputInCommitment_get_offered(const LDKHTLCOutputInCommitment *this_ptr);
+       public static native boolean HTLCOutputInCommitmentgetoffered(long this_ptr);
+       /// void HTLCOutputInCommitment_set_offered(LDKHTLCOutputInCommitment *this_ptr, bool val);
+       public static native void HTLCOutputInCommitmentsetoffered(long this_ptr, boolean va);
+       /// uint64_t HTLCOutputInCommitment_get_amount_msat(const LDKHTLCOutputInCommitment *this_ptr);
+       public static native long HTLCOutputInCommitmentgetamountmsat(long this_ptr);
+       /// void HTLCOutputInCommitment_set_amount_msat(LDKHTLCOutputInCommitment *this_ptr, uint64_t val);
+       public static native void HTLCOutputInCommitmentsetamountmsat(long this_ptr, long val);
+       /// uint32_t HTLCOutputInCommitment_get_cltv_expiry(const LDKHTLCOutputInCommitment *this_ptr);
+       public static native int HTLCOutputInCommitmentgetcltvexpiry(long this_ptr);
+       /// void HTLCOutputInCommitment_set_cltv_expiry(LDKHTLCOutputInCommitment *this_ptr, uint32_t val);
+       public static native void HTLCOutputInCommitmentsetcltvexpiry(long this_ptr, int val);
+       /// const uint8_t (*HTLCOutputInCommitment_get_payment_hash(const LDKHTLCOutputInCommitment *this_ptr))[32];
+       public static native byte[] HTLCOutputInCommitmentgetpaymenthash(long this_ptr);
+       /// void HTLCOutputInCommitment_set_payment_hash(LDKHTLCOutputInCommitment *this_ptr, LDKThirtyTwoBytes val);
+       public static native void HTLCOutputInCommitmentsetpaymenthash(long this_ptr, long val);
+       /// LDKCVec_u8Z HTLCOutputInCommitment_write(const LDKHTLCOutputInCommitment *obj);
+       public static native long HTLCOutputInCommitmentwrite(long obj);
+       /// LDKHTLCOutputInCommitment HTLCOutputInCommitment_read(LDKu8slice ser);
+       public static native long HTLCOutputInCommitmentread(long ser);
+       /// LDKCVec_u8Z get_htlc_redeemscript(const LDKHTLCOutputInCommitment *htlc, const LDKTxCreationKeys *keys);
+       public static native long gethtlcredeemscript(long htlc, long keys);
+       /// LDKCVec_u8Z make_funding_redeemscript(LDKPublicKey a, LDKPublicKey b);
+       public static native long makefundingredeemscript(long a, long b);
+       /// LDKCVec_u8Z build_htlc_transaction(const uint8_t (*prev_hash)[32], uint32_t feerate_per_kw, uint16_t to_self_delay, const LDKHTLCOutputInCommitment *htlc, LDKPublicKey a_delayed_payment_key, LDKPublicKey revocation_key);
+       public static native long buildhtlctransaction(byte[] prev_hash, int feerate_per_kw, long to_self_delay, long htlc, long a_delayed_payment_key, long revocation_key);
+       /// void LocalCommitmentTransaction_free(LDKLocalCommitmentTransaction this_ptr);
+       public static native void LocalCommitmentTransactionfree(long this_ptr);
+       /// LDKCVec_u8Z LocalCommitmentTransaction_get_unsigned_tx(const LDKLocalCommitmentTransaction *this_ptr);
+       public static native long LocalCommitmentTransactiongetunsignedtx(long this_ptr);
+       /// void LocalCommitmentTransaction_set_unsigned_tx(LDKLocalCommitmentTransaction *this_ptr, LDKCVec_u8Z val);
+       public static native void LocalCommitmentTransactionsetunsignedtx(long this_ptr, long val);
+       /// LDKSignature LocalCommitmentTransaction_get_their_sig(const LDKLocalCommitmentTransaction *this_ptr);
+       public static native long LocalCommitmentTransactiongettheirsig(long this_ptr);
+       /// void LocalCommitmentTransaction_set_their_sig(LDKLocalCommitmentTransaction *this_ptr, LDKSignature val);
+       public static native void LocalCommitmentTransactionsettheirsig(long this_ptr, long val);
+       /// LDKTxCreationKeys LocalCommitmentTransaction_get_local_keys(const LDKLocalCommitmentTransaction *this_ptr);
+       public static native long LocalCommitmentTransactiongetlocalkeys(long this_ptr);
+       /// void LocalCommitmentTransaction_set_local_keys(LDKLocalCommitmentTransaction *this_ptr, LDKTxCreationKeys val);
+       public static native void LocalCommitmentTransactionsetlocalkeys(long this_ptr, long val);
+       /// uint32_t LocalCommitmentTransaction_get_feerate_per_kw(const LDKLocalCommitmentTransaction *this_ptr);
+       public static native int LocalCommitmentTransactiongetfeerateperkw(long this_ptr);
+       /// void LocalCommitmentTransaction_set_feerate_per_kw(LDKLocalCommitmentTransaction *this_ptr, uint32_t val);
+       public static native void LocalCommitmentTransactionsetfeerateperkw(long this_ptr, int val);
+       /// MUST_USE_RES LDKThirtyTwoBytes LocalCommitmentTransaction_txid(const LDKLocalCommitmentTransaction *this_arg);
+       public static native long LocalCommitmentTransactiontxid(long this_arg);
+       /// MUST_USE_RES LDKSignature LocalCommitmentTransaction_get_local_sig(const LDKLocalCommitmentTransaction *this_arg, const uint8_t (*funding_key)[32], LDKu8slice funding_redeemscript, uint64_t channel_value_satoshis);
+       public static native long LocalCommitmentTransactiongetlocalsig(long this_arg, byte[] funding_key, long funding_redeemscript, long channel_value_satoshis);
+       /// LDKCVec_u8Z LocalCommitmentTransaction_write(const LDKLocalCommitmentTransaction *obj);
+       public static native long LocalCommitmentTransactionwrite(long obj);
+       /// LDKLocalCommitmentTransaction LocalCommitmentTransaction_read(LDKu8slice ser);
+       public static native long LocalCommitmentTransactionread(long ser);
+       /// void InitFeatures_free(LDKInitFeatures this_ptr);
+       public static native void InitFeaturesfree(long this_ptr);
+       /// void NodeFeatures_free(LDKNodeFeatures this_ptr);
+       public static native void NodeFeaturesfree(long this_ptr);
+       /// void ChannelFeatures_free(LDKChannelFeatures this_ptr);
+       public static native void ChannelFeaturesfree(long this_ptr);
+       /// void RouteHop_free(LDKRouteHop this_ptr);
+       public static native void RouteHopfree(long this_ptr);
+       /// LDKPublicKey RouteHop_get_pubkey(const LDKRouteHop *this_ptr);
+       public static native long RouteHopgetpubkey(long this_ptr);
+       /// void RouteHop_set_pubkey(LDKRouteHop *this_ptr, LDKPublicKey val);
+       public static native void RouteHopsetpubkey(long this_ptr, long val);
+       /// uint64_t RouteHop_get_short_channel_id(const LDKRouteHop *this_ptr);
+       public static native long RouteHopgetshortchannelid(long this_ptr);
+       /// void RouteHop_set_short_channel_id(LDKRouteHop *this_ptr, uint64_t val);
+       public static native void RouteHopsetshortchannelid(long this_ptr, long val);
+       /// uint64_t RouteHop_get_fee_msat(const LDKRouteHop *this_ptr);
+       public static native long RouteHopgetfeemsat(long this_ptr);
+       /// void RouteHop_set_fee_msat(LDKRouteHop *this_ptr, uint64_t val);
+       public static native void RouteHopsetfeemsat(long this_ptr, long val);
+       /// uint32_t RouteHop_get_cltv_expiry_delta(const LDKRouteHop *this_ptr);
+       public static native int RouteHopgetcltvexpirydelta(long this_ptr);
+       /// void RouteHop_set_cltv_expiry_delta(LDKRouteHop *this_ptr, uint32_t val);
+       public static native void RouteHopsetcltvexpirydelta(long this_ptr, int val);
+       /// void Route_free(LDKRoute this_ptr);
+       public static native void Routefree(long this_ptr);
+       /// void Route_set_paths(LDKRoute *this_ptr, LDKCVec_CVec_RouteHopZZ val);
+       public static native void Routesetpaths(long this_ptr, long val);
+       /// MUST_USE_RES LDKRoute Route_new(LDKCVec_CVec_RouteHopZZ paths_arg);
+       public static native long Routenew(long paths_arg);
+       /// LDKCVec_u8Z Route_write(const LDKRoute *obj);
+       public static native long Routewrite(long obj);
+       /// LDKRoute Route_read(LDKu8slice ser);
+       public static native long Routeread(long ser);
+       /// void RouteHint_free(LDKRouteHint this_ptr);
+       public static native void RouteHintfree(long this_ptr);
+       /// LDKPublicKey RouteHint_get_src_node_id(const LDKRouteHint *this_ptr);
+       public static native long RouteHintgetsrcnodeid(long this_ptr);
+       /// void RouteHint_set_src_node_id(LDKRouteHint *this_ptr, LDKPublicKey val);
+       public static native void RouteHintsetsrcnodeid(long this_ptr, long val);
+       /// uint64_t RouteHint_get_short_channel_id(const LDKRouteHint *this_ptr);
+       public static native long RouteHintgetshortchannelid(long this_ptr);
+       /// void RouteHint_set_short_channel_id(LDKRouteHint *this_ptr, uint64_t val);
+       public static native void RouteHintsetshortchannelid(long this_ptr, long val);
+       /// LDKRoutingFees RouteHint_get_fees(const LDKRouteHint *this_ptr);
+       public static native long RouteHintgetfees(long this_ptr);
+       /// void RouteHint_set_fees(LDKRouteHint *this_ptr, LDKRoutingFees val);
+       public static native void RouteHintsetfees(long this_ptr, long val);
+       /// uint16_t RouteHint_get_cltv_expiry_delta(const LDKRouteHint *this_ptr);
+       public static native long RouteHintgetcltvexpirydelta(long this_ptr);
+       /// void RouteHint_set_cltv_expiry_delta(LDKRouteHint *this_ptr, uint16_t val);
+       public static native void RouteHintsetcltvexpirydelta(long this_ptr, long val);
+       /// uint64_t RouteHint_get_htlc_minimum_msat(const LDKRouteHint *this_ptr);
+       public static native long RouteHintgethtlcminimummsat(long this_ptr);
+       /// void RouteHint_set_htlc_minimum_msat(LDKRouteHint *this_ptr, uint64_t val);
+       public static native void RouteHintsethtlcminimummsat(long this_ptr, long val);
+       /// MUST_USE_RES LDKRouteHint RouteHint_new(LDKPublicKey src_node_id_arg, uint64_t short_channel_id_arg, LDKRoutingFees fees_arg, uint16_t cltv_expiry_delta_arg, uint64_t htlc_minimum_msat_arg);
+       public static native long RouteHintnew(long src_node_id_arg, long short_channel_id_arg, long fees_arg, long cltv_expiry_delta_arg, long htlc_minimum_msat_arg);
+       /// LDKCResult_RouteLightningErrorZ get_route(LDKPublicKey our_node_id, const LDKNetworkGraph *network, LDKPublicKey target, const LDKCChannelDetailsSlice *first_hops, LDKCRouteHintSlice last_hops, uint64_t final_value_msat, uint32_t final_cltv, LDKLogger logger);
+       public static native long getroute(long our_node_id, long network, long target, long first_hops, long last_hops, long final_value_msa, int final_cltv, long logger);
+       /// void NetworkGraph_free(LDKNetworkGraph this_ptr);
+       public static native void NetworkGraphfree(long this_ptr);
+       /// void NetGraphMsgHandler_free(LDKNetGraphMsgHandler this_ptr);
+       public static native void NetGraphMsgHandlerfree(long this_ptr);
+       /// MUST_USE_RES LDKNetGraphMsgHandler NetGraphMsgHandler_new(LDKChainWatchInterface chain_monitor, LDKLogger logger);
+       public static native long NetGraphMsgHandlernew(long chain_monitor, long logger);
+       /// MUST_USE_RES LDKNetGraphMsgHandler NetGraphMsgHandler_from_net_graph(LDKChainWatchInterface chain_monitor, LDKLogger logger, LDKNetworkGraph network_graph);
+       public static native long NetGraphMsgHandlerfromnetgraph(long chain_monitor, long logger, long network_graph);
+       /// LDKRoutingMessageHandler NetGraphMsgHandler_as_RoutingMessageHandler(const LDKNetGraphMsgHandler *this_arg);
+       public static native long NetGraphMsgHandlerasRoutingMessageHandler(long this_arg);
+       /// void DirectionalChannelInfo_free(LDKDirectionalChannelInfo this_ptr);
+       public static native void DirectionalChannelInfofree(long this_ptr);
+       /// uint32_t DirectionalChannelInfo_get_last_update(const LDKDirectionalChannelInfo *this_ptr);
+       public static native int DirectionalChannelInfogetlastupdate(long this_ptr);
+       /// void DirectionalChannelInfo_set_last_update(LDKDirectionalChannelInfo *this_ptr, uint32_t val);
+       public static native void DirectionalChannelInfosetlastupdate(long this_ptr, int val);
+       /// bool DirectionalChannelInfo_get_enabled(const LDKDirectionalChannelInfo *this_ptr);
+       public static native boolean DirectionalChannelInfogetenabled(long this_ptr);
+       /// void DirectionalChannelInfo_set_enabled(LDKDirectionalChannelInfo *this_ptr, bool val);
+       public static native void DirectionalChannelInfosetenabled(long this_ptr, boolean va);
+       /// uint16_t DirectionalChannelInfo_get_cltv_expiry_delta(const LDKDirectionalChannelInfo *this_ptr);
+       public static native long DirectionalChannelInfogetcltvexpirydelta(long this_ptr);
+       /// void DirectionalChannelInfo_set_cltv_expiry_delta(LDKDirectionalChannelInfo *this_ptr, uint16_t val);
+       public static native void DirectionalChannelInfosetcltvexpirydelta(long this_ptr, long val);
+       /// uint64_t DirectionalChannelInfo_get_htlc_minimum_msat(const LDKDirectionalChannelInfo *this_ptr);
+       public static native long DirectionalChannelInfogethtlcminimummsat(long this_ptr);
+       /// void DirectionalChannelInfo_set_htlc_minimum_msat(LDKDirectionalChannelInfo *this_ptr, uint64_t val);
+       public static native void DirectionalChannelInfosethtlcminimummsat(long this_ptr, long val);
+       /// LDKCVec_u8Z DirectionalChannelInfo_write(const LDKDirectionalChannelInfo *obj);
+       public static native long DirectionalChannelInfowrite(long obj);
+       /// LDKDirectionalChannelInfo DirectionalChannelInfo_read(LDKu8slice ser);
+       public static native long DirectionalChannelInforead(long ser);
+       /// void ChannelInfo_free(LDKChannelInfo this_ptr);
+       public static native void ChannelInfofree(long this_ptr);
+       /// LDKPublicKey ChannelInfo_get_node_one(const LDKChannelInfo *this_ptr);
+       public static native long ChannelInfogetnodeone(long this_ptr);
+       /// void ChannelInfo_set_node_one(LDKChannelInfo *this_ptr, LDKPublicKey val);
+       public static native void ChannelInfosetnodeone(long this_ptr, long val);
+       /// LDKDirectionalChannelInfo ChannelInfo_get_one_to_two(const LDKChannelInfo *this_ptr);
+       public static native long ChannelInfogetonetotwo(long this_ptr);
+       /// void ChannelInfo_set_one_to_two(LDKChannelInfo *this_ptr, LDKDirectionalChannelInfo val);
+       public static native void ChannelInfosetonetotwo(long this_ptr, long val);
+       /// LDKPublicKey ChannelInfo_get_node_two(const LDKChannelInfo *this_ptr);
+       public static native long ChannelInfogetnodetwo(long this_ptr);
+       /// void ChannelInfo_set_node_two(LDKChannelInfo *this_ptr, LDKPublicKey val);
+       public static native void ChannelInfosetnodetwo(long this_ptr, long val);
+       /// LDKDirectionalChannelInfo ChannelInfo_get_two_to_one(const LDKChannelInfo *this_ptr);
+       public static native long ChannelInfogettwotoone(long this_ptr);
+       /// void ChannelInfo_set_two_to_one(LDKChannelInfo *this_ptr, LDKDirectionalChannelInfo val);
+       public static native void ChannelInfosettwotoone(long this_ptr, long val);
+       /// LDKCVec_u8Z ChannelInfo_write(const LDKChannelInfo *obj);
+       public static native long ChannelInfowrite(long obj);
+       /// LDKChannelInfo ChannelInfo_read(LDKu8slice ser);
+       public static native long ChannelInforead(long ser);
+       /// void RoutingFees_free(LDKRoutingFees this_ptr);
+       public static native void RoutingFeesfree(long this_ptr);
+       /// uint32_t RoutingFees_get_base_msat(const LDKRoutingFees *this_ptr);
+       public static native int RoutingFeesgetbasemsat(long this_ptr);
+       /// void RoutingFees_set_base_msat(LDKRoutingFees *this_ptr, uint32_t val);
+       public static native void RoutingFeessetbasemsat(long this_ptr, int val);
+       /// uint32_t RoutingFees_get_proportional_millionths(const LDKRoutingFees *this_ptr);
+       public static native int RoutingFeesgetproportionalmillionths(long this_ptr);
+       /// void RoutingFees_set_proportional_millionths(LDKRoutingFees *this_ptr, uint32_t val);
+       public static native void RoutingFeessetproportionalmillionths(long this_ptr, int val);
+       /// MUST_USE_RES LDKRoutingFees RoutingFees_new(uint32_t base_msat_arg, uint32_t proportional_millionths_arg);
+       public static native long RoutingFeesnew(int base_msat_arg, int proportional_millionths_arg);
+       /// LDKRoutingFees RoutingFees_read(LDKu8slice ser);
+       public static native long RoutingFeesread(long ser);
+       /// LDKCVec_u8Z RoutingFees_write(const LDKRoutingFees *obj);
+       public static native long RoutingFeeswrite(long obj);
+       /// void NodeAnnouncementInfo_free(LDKNodeAnnouncementInfo this_ptr);
+       public static native void NodeAnnouncementInfofree(long this_ptr);
+       /// uint32_t NodeAnnouncementInfo_get_last_update(const LDKNodeAnnouncementInfo *this_ptr);
+       public static native int NodeAnnouncementInfogetlastupdate(long this_ptr);
+       /// void NodeAnnouncementInfo_set_last_update(LDKNodeAnnouncementInfo *this_ptr, uint32_t val);
+       public static native void NodeAnnouncementInfosetlastupdate(long this_ptr, int val);
+       /// const uint8_t (*NodeAnnouncementInfo_get_rgb(const LDKNodeAnnouncementInfo *this_ptr))[3];
+       public static native byte[] NodeAnnouncementInfogetrgb(long this_ptr);
+       /// void NodeAnnouncementInfo_set_rgb(LDKNodeAnnouncementInfo *this_ptr, LDKThreeBytes val);
+       public static native void NodeAnnouncementInfosetrgb(long this_ptr, long val);
+       /// const uint8_t (*NodeAnnouncementInfo_get_alias(const LDKNodeAnnouncementInfo *this_ptr))[32];
+       public static native byte[] NodeAnnouncementInfogetalias(long this_ptr);
+       /// void NodeAnnouncementInfo_set_alias(LDKNodeAnnouncementInfo *this_ptr, LDKThirtyTwoBytes val);
+       public static native void NodeAnnouncementInfosetalias(long this_ptr, long val);
+       /// void NodeAnnouncementInfo_set_addresses(LDKNodeAnnouncementInfo *this_ptr, LDKCVec_NetAddressZ val);
+       public static native void NodeAnnouncementInfosetaddresses(long this_ptr, long val);
+       /// LDKCVec_u8Z NodeAnnouncementInfo_write(const LDKNodeAnnouncementInfo *obj);
+       public static native long NodeAnnouncementInfowrite(long obj);
+       /// LDKNodeAnnouncementInfo NodeAnnouncementInfo_read(LDKu8slice ser);
+       public static native long NodeAnnouncementInforead(long ser);
+       /// void NodeInfo_free(LDKNodeInfo this_ptr);
+       public static native void NodeInfofree(long this_ptr);
+       /// void NodeInfo_set_channels(LDKNodeInfo *this_ptr, LDKCVec_u64Z val);
+       public static native void NodeInfosetchannels(long this_ptr, long val);
+       /// LDKRoutingFees NodeInfo_get_lowest_inbound_channel_fees(const LDKNodeInfo *this_ptr);
+       public static native long NodeInfogetlowestinboundchannelfees(long this_ptr);
+       /// void NodeInfo_set_lowest_inbound_channel_fees(LDKNodeInfo *this_ptr, LDKRoutingFees val);
+       public static native void NodeInfosetlowestinboundchannelfees(long this_ptr, long val);
+       /// LDKNodeAnnouncementInfo NodeInfo_get_announcement_info(const LDKNodeInfo *this_ptr);
+       public static native long NodeInfogetannouncementinfo(long this_ptr);
+       /// void NodeInfo_set_announcement_info(LDKNodeInfo *this_ptr, LDKNodeAnnouncementInfo val);
+       public static native void NodeInfosetannouncementinfo(long this_ptr, long val);
+       /// MUST_USE_RES LDKNodeInfo NodeInfo_new(LDKCVec_u64Z channels_arg, LDKRoutingFees lowest_inbound_channel_fees_arg, LDKNodeAnnouncementInfo announcement_info_arg);
+       public static native long NodeInfonew(long channels_arg, long lowest_inbound_channel_fees_arg, long announcement_info_arg);
+       /// LDKCVec_u8Z NodeInfo_write(const LDKNodeInfo *obj);
+       public static native long NodeInfowrite(long obj);
+       /// LDKNodeInfo NodeInfo_read(LDKu8slice ser);
+       public static native long NodeInforead(long ser);
+       /// LDKCVec_u8Z NetworkGraph_write(const LDKNetworkGraph *obj);
+       public static native long NetworkGraphwrite(long obj);
+       /// LDKNetworkGraph NetworkGraph_read(LDKu8slice ser);
+       public static native long NetworkGraphread(long ser);
+       /// MUST_USE_RES LDKNetworkGraph NetworkGraph_new(void);
+       public static native long NetworkGraphnew();
+       /// void NetworkGraph_close_channel_from_update(LDKNetworkGraph *this_arg, uint64_t short_channel_id, bool is_permanent);
+       public static native void NetworkGraphclosechannelfromupdate(long this_arg, long short_channel_id, boolean is_permanent);
 }

diff --git a/src/main/java/org/ldk/ln/channelmanager/ChannelManager.java b/src/main/java/org/ldk/ln/channelmanager/ChannelManager.java
new file mode 100644 (file)
index 0000000..70c9d85
--- /dev/null
+++ b/src/main/java/org/ldk/ln/channelmanager/ChannelManager.java
@@ -0,0 +1,11 @@
+package org.ldk.ln.channelmanager;
+
+import org.ldk.bindings;
+
+public class ChannelManager {
+    void asdf() {
+        bindings.CResult_NonePaymentSendFailureZ_err(0);
+    }
+
+
+}