From: Matt Corallo Date: Tue, 28 Jul 2020 17:14:25 +0000 (-0400) Subject: Initial bindings header generation demo X-Git-Tag: v0.0.1~169 X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=commitdiff_plain;h=71687f75fe56a9e3fee27742ad4d000876fcdbb3;p=ldk-java Initial bindings header generation demo --- diff --git a/genbindings.py b/genbindings.py new file mode 100755 index 00000000..9f7e1369 --- /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 ac88ed96..e0fb8cbd 100644 --- 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 index 00000000..70c9d853 --- /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); + } + + +}