From: Matt Corallo Date: Wed, 29 Jul 2020 04:41:30 +0000 (-0400) Subject: Also output a C wrapper that correctly wraps all the JNI functions X-Git-Tag: v0.0.1~168 X-Git-Url: http://git.bitcoin.ninja/index.cgi?p=ldk-java;a=commitdiff_plain;h=51e2bf67d61c39f6f5b048e1ad6db82dbe80af9c Also output a C wrapper that correctly wraps all the JNI functions --- diff --git a/genbindings.py b/genbindings.py index 9f7e1369..851bbdb6 100755 --- a/genbindings.py +++ b/genbindings.py @@ -1,62 +1,162 @@ #!/usr/bin/env python3 import sys, re -if len(sys.argv) != 3: - print("USAGE: /path/to/lightning.h /path/to/bindings.java") +if len(sys.argv) != 4: + print("USAGE: /path/to/lightning.h /path/to/bindings/output.java /path/to/bindings/output.c") 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): +with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java, open(sys.argv[3], "w") as out_c: + var_is_arr_regex = re.compile("\(\*([A-za-z_]*)\)\[([0-9]*)\]") + var_ty_regex = re.compile("([A-za-z_0-9]*)(.*)") + def map_type(fn_arg, print_void, ret_arr_len): 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:] + + c_ty = None + is_ptr_to_obj = None if fn_arg.startswith("void"): if print_void: - out_f.write("void") + out_java.write("void") + c_ty = "void" else: - return + return (None, None, None) fn_arg = fn_arg.strip("void ") elif fn_arg.startswith("bool"): - out_f.write("boolean") + out_java.write("boolean") + c_ty = "jboolean" fn_arg = fn_arg.strip("bool ") elif fn_arg.startswith("uint8_t"): - out_f.write("byte") + out_java.write("byte") + c_ty = "jbyte" fn_arg = fn_arg.strip("uint8_t ") elif fn_arg.startswith("uint32_t"): - out_f.write("int") + out_java.write("int") + c_ty = "jint" fn_arg = fn_arg.strip("uint32_t ") elif fn_arg.startswith("uint64_t"): - out_f.write("long") + out_java.write("long") + c_ty = "jlong" fn_arg = fn_arg.strip("uint64_t ") else: - out_f.write("long") - fn_arg = "".join([e + " " for e in fn_arg.split(" ")[1:]]).strip() + ma = var_ty_regex.match(fn_arg) + out_java.write("long") + out_c.write("jlong") + is_ptr_to_obj = ma.group(1) + fn_arg = ma.group(2) + if c_ty is not None: + out_c.write(c_ty) + 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()) + no_ptr = fn_arg.replace('*', '') + if var_is_arr is not None or ret_arr_len is not None: + out_java.write("[] ") + out_c.write("Array ") + if var_is_arr is not None: + arr_name = var_is_arr.group(1) + arr_len = var_is_arr.group(2) + out_java.write(arr_name) + out_c.write(arr_name) + else: + arr_name = "ret" + arr_len = ret_arr_len + assert(c_ty == "jbyte") + return ("unsigned char " + arr_name + "_arr[" + arr_len + "];\n" + + "(*_env)->GetByteArrayRegion (_env, """ + arr_name + ", 0, " + arr_len + ", " + arr_name + "_arr);\n" + + "unsigned char (*""" + arr_name + "_ref)[" + arr_len + "] = &" + arr_name + "_arr;", + (c_ty + "Array " + arr_name + "_arr = (*_env)->NewByteArray(_env, 0); // XXX: len 0\n" + + "(*_env)->SetByteArrayRegion(_env, " + arr_name + "_arr, 0, " + arr_len + ", *", + ");\nreturn ret_arr;"), + arr_name + "_ref") + elif no_ptr.strip() != "": + # If we have a parameter name, print it (noting that it may indicate its a pointer) + out_java.write(" " + no_ptr.strip()) + out_c.write(" " + no_ptr.strip()) + if is_ptr_to_obj is not None: + if no_ptr == fn_arg: + return (is_ptr_to_obj + " " + no_ptr.strip() + "_conv = *(" + is_ptr_to_obj + "*)" + no_ptr.strip() + ";", + "XXX2", no_ptr.strip() + "_conv") + else: + return (is_ptr_to_obj + "* " + no_ptr.strip() + "_conv = (" + is_ptr_to_obj + "*)" + no_ptr.strip() + ";", + "XXX2", no_ptr.strip() + "_conv") + elif no_ptr != fn_arg: + return ("YYY1", "XXX3", no_ptr.strip()) + else: + return (None, "XXX4", no_ptr.strip()) elif not print_void: - out_f.write(" arg"); + # We don't have a parameter name, and want one, just call it arg + out_java.write(" arg") + out_c.write(" arg") + if is_ptr_to_obj is not None: + return (is_ptr_to_obj + " arg_conv = *(" + is_ptr_to_obj + "*)arg;", "XXX2", "arg_conv") + else: + return (None, "XXX6", "arg") + else: + # We don't have a parameter name, and don't want one (cause we're returning) + if is_ptr_to_obj is not None: + if no_ptr == fn_arg: + return (None, (is_ptr_to_obj + "* ret = malloc(sizeof(" + is_ptr_to_obj + "));\n*ret = ", ";\nreturn (long)ret;"), None) + else: + return (None, ("return (long) ", ";"), None) + else: + return (None, None, None) - def map_fn_args(fn_args): + def map_fn_args(fn_args, f): for idx, arg in enumerate(fn_args.split(',')): if idx != 0: - out_f.write(", ") + out_java.write(", ") + if arg != "void": + out_c.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") + def map_fn(re_match, ret_arr_len): + out_java.write("\t/// " + line) + out_java.write("\tpublic static native ") + out_c.write("JNIEXPORT ") + + _, ret_conv, _ = map_type(re_match.group(1), True, ret_arr_len) + if ret_conv is not None: + ret_conv_pfx, ret_conv_sfx = ret_conv + + out_java.write(" " + re_match.group(2).replace('_', '') + "(") + out_c.write(" JNICALL " + re_match.group(2).replace('_', '') + "(JNIEnv * _env, jclass _b") + + arg_names = [] + for idx, arg in enumerate(re_match.group(3).split(',')): + if idx != 0: + out_java.write(", ") + if arg != "void": + out_c.write(", ") + arg_names.append(map_type(arg, False, None)) + + out_java.write(");\n") + out_c.write(") {\n") + + for arg_conv, _, _ in arg_names: + if arg_conv is not None: + out_c.write("\t" + arg_conv.replace('\n', "\n\t") + "\n"); + + if ret_conv is not None: + out_c.write("\t" + ret_conv_pfx.replace('\n', '\n\t')); + else: + out_c.write("\treturn "); + + out_c.write(re_match.group(2) + "(") + for idx, (_, _, arg) in enumerate(arg_names): + if arg is not None: + if idx != 0: + out_c.write(", ") + out_c.write(arg) + out_c.write(")") + if ret_conv is not None: + out_c.write(ret_conv_sfx.replace('\n', '\n\t')) + else: + out_c.write(";") + out_c.write("\n}\n\n") - out_f.write("""package org.ldk; + out_java.write("""package org.ldk; public class bindings { static { @@ -64,6 +164,9 @@ public class bindings { } """) + out_c.write("#include \"org_ldk_bindings.h\"\n") + out_c.write("#include \n\n") + out_c.write("#include \n\n") in_block_comment = False in_block_enum = False @@ -71,12 +174,12 @@ public class bindings { 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]*)\((.*)\);$") + fn_ret_arr_regex = re.compile("(.*) \(\*(.*)\((.*)\)\)\[([0-9]*)\];$") + reg_fn_regex = re.compile("([A-Za-z_0-9\* ]* \*?)([a-zA-Z_0-9]*)\((.*)\);$") - for line in f: + for line in in_h: if in_block_comment: - #out_f.write("\t" + line) + #out_java.write("\t" + line) if line.endswith("*/\n"): in_block_comment = False elif in_block_struct: @@ -96,7 +199,7 @@ public class bindings { if line.startswith("#include <"): pass elif line.startswith("/*"): - #out_f.write("\t" + line) + #out_java.write("\t" + line) if not line.endswith("*/\n"): in_block_comment = True elif line.startswith("typedef enum "): @@ -108,12 +211,12 @@ public class bindings { elif line.startswith("typedef "): pass elif fn_ptr is not None: - map_fn(fn_ptr, "") + map_fn(fn_ptr, None) elif fn_ret_arr is not None: - map_fn(fn_ret_arr, "[]") + map_fn(fn_ret_arr, fn_ret_arr.group(4)) elif reg_fn is not None: - map_fn(reg_fn, "") + map_fn(reg_fn, None) else: assert(line == "\n") - out_f.write("}\n"); + out_java.write("}\n") diff --git a/genbindings.sh b/genbindings.sh new file mode 100755 index 00000000..9ddaa5b0 --- /dev/null +++ b/genbindings.sh @@ -0,0 +1,10 @@ +#!/bin/sh +if [ "$1" = "" -o "$2" = "" ]; then + echo "USAGE: path/to/rust-lightning \"JNI_CFLAGS\"" + echo "For JNI_CFLAGS you probably want -I/usr/lib/jvm/java-11-openjdk-amd64/include/ -I/usr/lib/jvm/java-11-openjdk-amd64/include/linux/" + exit 1 +fi +set -e +./genbindings.py "$1/lightning-c-bindings/include/lightning.h" src/main/java/org/ldk/bindings.java src/main/jni/bindings.c +javac -h src/main/jni src/main/java/org/ldk/bindings.java +gcc -shared -fPIC -Wno-pointer-sign -Wall -Isrc/main/jni -I"$1/lightning-c-bindings/include/" $2 src/main/jni/bindings.c "$1"/target/debug/liblightning.a diff --git a/src/main/java/org/ldk/bindings.java b/src/main/java/org/ldk/bindings.java index e0fb8cbd..60e13c1a 100644 --- a/src/main/java/org/ldk/bindings.java +++ b/src/main/java/org/ldk/bindings.java @@ -312,7 +312,7 @@ public class bindings { /// 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); + 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); @@ -340,27 +340,27 @@ public class bindings { /// 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); + 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); + 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); + 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); + 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); + 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); + 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); @@ -384,7 +384,7 @@ public class bindings { /// 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); + 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); @@ -512,7 +512,7 @@ public class bindings { /// 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); + 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); @@ -806,7 +806,7 @@ public class bindings { /// 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); + 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); @@ -982,11 +982,11 @@ public class bindings { /// 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); + 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); + 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); diff --git a/src/main/jni/bindings.c b/src/main/jni/bindings.c new file mode 100644 index 00000000..60c1fe1d --- /dev/null +++ b/src/main/jni/bindings.c @@ -0,0 +1,3166 @@ +#include "org_ldk_bindings.h" +#include + +#include + +JNIEXPORT void JNICALL C2TupleOutPointScriptZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKC2Tuple_OutPointScriptZ arg_conv = *(LDKC2Tuple_OutPointScriptZ*)arg; + return C2Tuple_OutPointScriptZ_free(arg_conv); +} + +JNIEXPORT void JNICALL C2TupleScriptu64Zfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKC2Tuple_Scriptu64Z arg_conv = *(LDKC2Tuple_Scriptu64Z*)arg; + return C2Tuple_Scriptu64Z_free(arg_conv); +} + +JNIEXPORT void JNICALL C2TupleSecretKeyu832Zfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKC2Tuple_SecretKey_u832Z arg_conv = *(LDKC2Tuple_SecretKey_u832Z*)arg; + return C2Tuple_SecretKey_u832Z_free(arg_conv); +} + +JNIEXPORT void JNICALL C2TupleSignatureCVecSignatureZZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKC2Tuple_SignatureCVec_SignatureZZ arg_conv = *(LDKC2Tuple_SignatureCVec_SignatureZZ*)arg; + return C2Tuple_SignatureCVec_SignatureZZ_free(arg_conv); +} + +JNIEXPORT void JNICALL C2TupleTxidu32Zfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKC2Tuple_Txidu32Z arg_conv = *(LDKC2Tuple_Txidu32Z*)arg; + return C2Tuple_Txidu32Z_free(arg_conv); +} + +JNIEXPORT void JNICALL C2Tupleu64u64Zfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKC2Tuple_u64u64Z arg_conv = *(LDKC2Tuple_u64u64Z*)arg; + return C2Tuple_u64u64Z_free(arg_conv); +} + +JNIEXPORT void JNICALL C3TupleChannelAnnouncementChannelUpdateChannelUpdateZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ arg_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)arg; + return C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(arg_conv); +} + +JNIEXPORT jlong JNICALL CResultC2TupleScriptu64ZChainErrorZerr(JNIEnv * _env, jclass _b, jlong arg) { + LDKChainError arg_conv = *(LDKChainError*)arg; + LDKCResult_C2Tuple_Scriptu64ZChainErrorZ* ret = malloc(sizeof(LDKCResult_C2Tuple_Scriptu64ZChainErrorZ)); + *ret = CResult_C2Tuple_Scriptu64ZChainErrorZ_err(arg_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL CResultC2TupleScriptu64ZChainErrorZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKCResult_C2Tuple_Scriptu64ZChainErrorZ arg_conv = *(LDKCResult_C2Tuple_Scriptu64ZChainErrorZ*)arg; + return CResult_C2Tuple_Scriptu64ZChainErrorZ_free(arg_conv); +} + +JNIEXPORT jlong JNICALL CResultC2TupleScriptu64ZChainErrorZgood(JNIEnv * _env, jclass _b, jlong arg) { + LDKC2Tuple_Scriptu64Z arg_conv = *(LDKC2Tuple_Scriptu64Z*)arg; + LDKCResult_C2Tuple_Scriptu64ZChainErrorZ* ret = malloc(sizeof(LDKCResult_C2Tuple_Scriptu64ZChainErrorZ)); + *ret = CResult_C2Tuple_Scriptu64ZChainErrorZ_good(arg_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL CResultC2TupleSignatureCVecSignatureZZNoneZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ arg_conv = *(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)arg; + return CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(arg_conv); +} + +JNIEXPORT jlong JNICALL CResultC2TupleSignatureCVecSignatureZZNoneZgood(JNIEnv * _env, jclass _b, jlong arg) { + LDKC2Tuple_SignatureCVec_SignatureZZ arg_conv = *(LDKC2Tuple_SignatureCVec_SignatureZZ*)arg; + LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret = malloc(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ)); + *ret = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_good(arg_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL CResultCVecSignatureZNoneZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKCResult_CVec_SignatureZNoneZ arg_conv = *(LDKCResult_CVec_SignatureZNoneZ*)arg; + return CResult_CVec_SignatureZNoneZ_free(arg_conv); +} + +JNIEXPORT jlong JNICALL CResultCVecSignatureZNoneZgood(JNIEnv * _env, jclass _b, jlong arg) { + LDKCVec_SignatureZ arg_conv = *(LDKCVec_SignatureZ*)arg; + LDKCResult_CVec_SignatureZNoneZ* ret = malloc(sizeof(LDKCResult_CVec_SignatureZNoneZ)); + *ret = CResult_CVec_SignatureZNoneZ_good(arg_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL CResultCVecu8ZPeerHandleErrorZerr(JNIEnv * _env, jclass _b, jlong arg) { + LDKPeerHandleError arg_conv = *(LDKPeerHandleError*)arg; + LDKCResult_CVec_u8ZPeerHandleErrorZ* ret = malloc(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ)); + *ret = CResult_CVec_u8ZPeerHandleErrorZ_err(arg_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL CResultCVecu8ZPeerHandleErrorZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKCResult_CVec_u8ZPeerHandleErrorZ arg_conv = *(LDKCResult_CVec_u8ZPeerHandleErrorZ*)arg; + return CResult_CVec_u8ZPeerHandleErrorZ_free(arg_conv); +} + +JNIEXPORT jlong JNICALL CResultCVecu8ZPeerHandleErrorZgood(JNIEnv * _env, jclass _b, jlong arg) { + LDKCVec_u8Z arg_conv = *(LDKCVec_u8Z*)arg; + LDKCResult_CVec_u8ZPeerHandleErrorZ* ret = malloc(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ)); + *ret = CResult_CVec_u8ZPeerHandleErrorZ_good(arg_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL CResultNoneAPIErrorZerr(JNIEnv * _env, jclass _b, jlong arg) { + LDKAPIError arg_conv = *(LDKAPIError*)arg; + LDKCResult_NoneAPIErrorZ* ret = malloc(sizeof(LDKCResult_NoneAPIErrorZ)); + *ret = CResult_NoneAPIErrorZ_err(arg_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL CResultNoneAPIErrorZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKCResult_NoneAPIErrorZ arg_conv = *(LDKCResult_NoneAPIErrorZ*)arg; + return CResult_NoneAPIErrorZ_free(arg_conv); +} + +JNIEXPORT jlong JNICALL CResultNoneChannelMonitorUpdateErrZerr(JNIEnv * _env, jclass _b, jlong arg) { + LDKChannelMonitorUpdateErr arg_conv = *(LDKChannelMonitorUpdateErr*)arg; + LDKCResult_NoneChannelMonitorUpdateErrZ* ret = malloc(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ)); + *ret = CResult_NoneChannelMonitorUpdateErrZ_err(arg_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL CResultNoneChannelMonitorUpdateErrZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKCResult_NoneChannelMonitorUpdateErrZ arg_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)arg; + return CResult_NoneChannelMonitorUpdateErrZ_free(arg_conv); +} + +JNIEXPORT jlong JNICALL CResultNoneMonitorUpdateErrorZerr(JNIEnv * _env, jclass _b, jlong arg) { + LDKMonitorUpdateError arg_conv = *(LDKMonitorUpdateError*)arg; + LDKCResult_NoneMonitorUpdateErrorZ* ret = malloc(sizeof(LDKCResult_NoneMonitorUpdateErrorZ)); + *ret = CResult_NoneMonitorUpdateErrorZ_err(arg_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL CResultNoneMonitorUpdateErrorZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKCResult_NoneMonitorUpdateErrorZ arg_conv = *(LDKCResult_NoneMonitorUpdateErrorZ*)arg; + return CResult_NoneMonitorUpdateErrorZ_free(arg_conv); +} + +JNIEXPORT jlong JNICALL CResultNonePaymentSendFailureZerr(JNIEnv * _env, jclass _b, jlong arg) { + LDKPaymentSendFailure arg_conv = *(LDKPaymentSendFailure*)arg; + LDKCResult_NonePaymentSendFailureZ* ret = malloc(sizeof(LDKCResult_NonePaymentSendFailureZ)); + *ret = CResult_NonePaymentSendFailureZ_err(arg_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL CResultNonePaymentSendFailureZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKCResult_NonePaymentSendFailureZ arg_conv = *(LDKCResult_NonePaymentSendFailureZ*)arg; + return CResult_NonePaymentSendFailureZ_free(arg_conv); +} + +JNIEXPORT jlong JNICALL CResultNonePeerHandleErrorZerr(JNIEnv * _env, jclass _b, jlong arg) { + LDKPeerHandleError arg_conv = *(LDKPeerHandleError*)arg; + LDKCResult_NonePeerHandleErrorZ* ret = malloc(sizeof(LDKCResult_NonePeerHandleErrorZ)); + *ret = CResult_NonePeerHandleErrorZ_err(arg_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL CResultNonePeerHandleErrorZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKCResult_NonePeerHandleErrorZ arg_conv = *(LDKCResult_NonePeerHandleErrorZ*)arg; + return CResult_NonePeerHandleErrorZ_free(arg_conv); +} + +JNIEXPORT jlong JNICALL CResultRouteLightningErrorZerr(JNIEnv * _env, jclass _b, jlong arg) { + LDKLightningError arg_conv = *(LDKLightningError*)arg; + LDKCResult_RouteLightningErrorZ* ret = malloc(sizeof(LDKCResult_RouteLightningErrorZ)); + *ret = CResult_RouteLightningErrorZ_err(arg_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL CResultRouteLightningErrorZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKCResult_RouteLightningErrorZ arg_conv = *(LDKCResult_RouteLightningErrorZ*)arg; + return CResult_RouteLightningErrorZ_free(arg_conv); +} + +JNIEXPORT jlong JNICALL CResultRouteLightningErrorZgood(JNIEnv * _env, jclass _b, jlong arg) { + LDKRoute arg_conv = *(LDKRoute*)arg; + LDKCResult_RouteLightningErrorZ* ret = malloc(sizeof(LDKCResult_RouteLightningErrorZ)); + *ret = CResult_RouteLightningErrorZ_good(arg_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL CResultSignatureNoneZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKCResult_SignatureNoneZ arg_conv = *(LDKCResult_SignatureNoneZ*)arg; + return CResult_SignatureNoneZ_free(arg_conv); +} + +JNIEXPORT jlong JNICALL CResultSignatureNoneZgood(JNIEnv * _env, jclass _b, jlong arg) { + LDKSignature arg_conv = *(LDKSignature*)arg; + LDKCResult_SignatureNoneZ* ret = malloc(sizeof(LDKCResult_SignatureNoneZ)); + *ret = CResult_SignatureNoneZ_good(arg_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL CResultboolLightningErrorZerr(JNIEnv * _env, jclass _b, jlong arg) { + LDKLightningError arg_conv = *(LDKLightningError*)arg; + LDKCResult_boolLightningErrorZ* ret = malloc(sizeof(LDKCResult_boolLightningErrorZ)); + *ret = CResult_boolLightningErrorZ_err(arg_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL CResultboolLightningErrorZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKCResult_boolLightningErrorZ arg_conv = *(LDKCResult_boolLightningErrorZ*)arg; + return CResult_boolLightningErrorZ_free(arg_conv); +} + +JNIEXPORT jlong JNICALL CResultboolLightningErrorZgood(JNIEnv * _env, jclass _b, jboolean arg) { + LDKCResult_boolLightningErrorZ* ret = malloc(sizeof(LDKCResult_boolLightningErrorZ)); + *ret = CResult_boolLightningErrorZ_good(arg); + return (long)ret; +} + +JNIEXPORT jlong JNICALL CResultboolPeerHandleErrorZerr(JNIEnv * _env, jclass _b, jlong arg) { + LDKPeerHandleError arg_conv = *(LDKPeerHandleError*)arg; + LDKCResult_boolPeerHandleErrorZ* ret = malloc(sizeof(LDKCResult_boolPeerHandleErrorZ)); + *ret = CResult_boolPeerHandleErrorZ_err(arg_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL CResultboolPeerHandleErrorZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKCResult_boolPeerHandleErrorZ arg_conv = *(LDKCResult_boolPeerHandleErrorZ*)arg; + return CResult_boolPeerHandleErrorZ_free(arg_conv); +} + +JNIEXPORT jlong JNICALL CResultboolPeerHandleErrorZgood(JNIEnv * _env, jclass _b, jboolean arg) { + LDKCResult_boolPeerHandleErrorZ* ret = malloc(sizeof(LDKCResult_boolPeerHandleErrorZ)); + *ret = CResult_boolPeerHandleErrorZ_good(arg); + return (long)ret; +} + +JNIEXPORT void JNICALL CVecC3TupleChannelAnnouncementChannelUpdateChannelUpdateZZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ arg_conv = *(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ*)arg; + return CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(arg_conv); +} + +JNIEXPORT void JNICALL CVecCVecRouteHopZZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKCVec_CVec_RouteHopZZ arg_conv = *(LDKCVec_CVec_RouteHopZZ*)arg; + return CVec_CVec_RouteHopZZ_free(arg_conv); +} + +JNIEXPORT void JNICALL CVecChannelDetailsZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKCVec_ChannelDetailsZ arg_conv = *(LDKCVec_ChannelDetailsZ*)arg; + return CVec_ChannelDetailsZ_free(arg_conv); +} + +JNIEXPORT void JNICALL CVecEventZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKCVec_EventZ arg_conv = *(LDKCVec_EventZ*)arg; + return CVec_EventZ_free(arg_conv); +} + +JNIEXPORT void JNICALL CVecHTLCUpdateZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKCVec_HTLCUpdateZ arg_conv = *(LDKCVec_HTLCUpdateZ*)arg; + return CVec_HTLCUpdateZ_free(arg_conv); +} + +JNIEXPORT void JNICALL CVecMessageSendEventZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKCVec_MessageSendEventZ arg_conv = *(LDKCVec_MessageSendEventZ*)arg; + return CVec_MessageSendEventZ_free(arg_conv); +} + +JNIEXPORT void JNICALL CVecNetAddressZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKCVec_NetAddressZ arg_conv = *(LDKCVec_NetAddressZ*)arg; + return CVec_NetAddressZ_free(arg_conv); +} + +JNIEXPORT void JNICALL CVecNodeAnnouncementZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKCVec_NodeAnnouncementZ arg_conv = *(LDKCVec_NodeAnnouncementZ*)arg; + return CVec_NodeAnnouncementZ_free(arg_conv); +} + +JNIEXPORT void JNICALL CVecPublicKeyZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKCVec_PublicKeyZ arg_conv = *(LDKCVec_PublicKeyZ*)arg; + return CVec_PublicKeyZ_free(arg_conv); +} + +JNIEXPORT void JNICALL CVecRouteHopZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKCVec_RouteHopZ arg_conv = *(LDKCVec_RouteHopZ*)arg; + return CVec_RouteHopZ_free(arg_conv); +} + +JNIEXPORT void JNICALL CVecSignatureZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKCVec_SignatureZ arg_conv = *(LDKCVec_SignatureZ*)arg; + return CVec_SignatureZ_free(arg_conv); +} + +JNIEXPORT void JNICALL CVecSpendableOutputDescriptorZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKCVec_SpendableOutputDescriptorZ arg_conv = *(LDKCVec_SpendableOutputDescriptorZ*)arg; + return CVec_SpendableOutputDescriptorZ_free(arg_conv); +} + +JNIEXPORT void JNICALL CVecTransactionZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKCVec_TransactionZ arg_conv = *(LDKCVec_TransactionZ*)arg; + return CVec_TransactionZ_free(arg_conv); +} + +JNIEXPORT void JNICALL CVecUpdateAddHTLCZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKCVec_UpdateAddHTLCZ arg_conv = *(LDKCVec_UpdateAddHTLCZ*)arg; + return CVec_UpdateAddHTLCZ_free(arg_conv); +} + +JNIEXPORT void JNICALL CVecUpdateFailHTLCZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKCVec_UpdateFailHTLCZ arg_conv = *(LDKCVec_UpdateFailHTLCZ*)arg; + return CVec_UpdateFailHTLCZ_free(arg_conv); +} + +JNIEXPORT void JNICALL CVecUpdateFailMalformedHTLCZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKCVec_UpdateFailMalformedHTLCZ arg_conv = *(LDKCVec_UpdateFailMalformedHTLCZ*)arg; + return CVec_UpdateFailMalformedHTLCZ_free(arg_conv); +} + +JNIEXPORT void JNICALL CVecUpdateFulfillHTLCZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKCVec_UpdateFulfillHTLCZ arg_conv = *(LDKCVec_UpdateFulfillHTLCZ*)arg; + return CVec_UpdateFulfillHTLCZ_free(arg_conv); +} + +JNIEXPORT void JNICALL CVecu64Zfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKCVec_u64Z arg_conv = *(LDKCVec_u64Z*)arg; + return CVec_u64Z_free(arg_conv); +} + +JNIEXPORT void JNICALL CVecu8Zfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKCVec_u8Z arg_conv = *(LDKCVec_u8Z*)arg; + return CVec_u8Z_free(arg_conv); +} + +JNIEXPORT void JNICALL CVecusizeZfree(JNIEnv * _env, jclass _b, jlong arg) { + LDKCVec_usizeZ arg_conv = *(LDKCVec_usizeZ*)arg; + return CVec_usizeZ_free(arg_conv); +} + +JNIEXPORT jlong JNICALL C2TupleTxidu32Znew(JNIEnv * _env, jclass _b, jlong a, jint b) { + LDKThirtyTwoBytes a_conv = *(LDKThirtyTwoBytes*)a; + LDKC2Tuple_Txidu32Z* ret = malloc(sizeof(LDKC2Tuple_Txidu32Z)); + *ret = C2Tuple_Txidu32Z_new(a_conv, b); + return (long)ret; +} + +JNIEXPORT jlong JNICALL C2TupleScriptu64Znew(JNIEnv * _env, jclass _b, jlong a, jlong b) { + LDKCVec_u8Z a_conv = *(LDKCVec_u8Z*)a; + LDKC2Tuple_Scriptu64Z* ret = malloc(sizeof(LDKC2Tuple_Scriptu64Z)); + *ret = C2Tuple_Scriptu64Z_new(a_conv, b); + return (long)ret; +} + +JNIEXPORT jlong JNICALL C2Tupleu64u64Znew(JNIEnv * _env, jclass _b, jlong a, jlong b) { + LDKC2Tuple_u64u64Z* ret = malloc(sizeof(LDKC2Tuple_u64u64Z)); + *ret = C2Tuple_u64u64Z_new(a, b); + return (long)ret; +} + +JNIEXPORT jlong JNICALL C2TupleSignatureCVecSignatureZZnew(JNIEnv * _env, jclass _b, jlong a, jlong b) { + LDKSignature a_conv = *(LDKSignature*)a; + LDKCVec_SignatureZ b_conv = *(LDKCVec_SignatureZ*)b; + LDKC2Tuple_SignatureCVec_SignatureZZ* ret = malloc(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ)); + *ret = C2Tuple_SignatureCVec_SignatureZZ_new(a_conv, b_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL CResultC2TupleSignatureCVecSignatureZZNoneZerr(JNIEnv * _env, jclass _b) { + LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret = malloc(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ)); + *ret = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(); + return (long)ret; +} + +JNIEXPORT jlong JNICALL CResultSignatureNoneZerr(JNIEnv * _env, jclass _b) { + LDKCResult_SignatureNoneZ* ret = malloc(sizeof(LDKCResult_SignatureNoneZ)); + *ret = CResult_SignatureNoneZ_err(); + return (long)ret; +} + +JNIEXPORT jlong JNICALL CResultCVecSignatureZNoneZerr(JNIEnv * _env, jclass _b) { + LDKCResult_CVec_SignatureZNoneZ* ret = malloc(sizeof(LDKCResult_CVec_SignatureZNoneZ)); + *ret = CResult_CVec_SignatureZNoneZ_err(); + return (long)ret; +} + +JNIEXPORT jlong JNICALL C2TupleSecretKeyu832Znew(JNIEnv * _env, jclass _b, jlong a, jlong b) { + LDKSecretKey a_conv = *(LDKSecretKey*)a; + LDKThirtyTwoBytes b_conv = *(LDKThirtyTwoBytes*)b; + LDKC2Tuple_SecretKey_u832Z* ret = malloc(sizeof(LDKC2Tuple_SecretKey_u832Z)); + *ret = C2Tuple_SecretKey_u832Z_new(a_conv, b_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL CResultNoneAPIErrorZgood(JNIEnv * _env, jclass _b) { + LDKCResult_NoneAPIErrorZ* ret = malloc(sizeof(LDKCResult_NoneAPIErrorZ)); + *ret = CResult_NoneAPIErrorZ_good(); + return (long)ret; +} + +JNIEXPORT jlong JNICALL CResultNonePaymentSendFailureZgood(JNIEnv * _env, jclass _b) { + LDKCResult_NonePaymentSendFailureZ* ret = malloc(sizeof(LDKCResult_NonePaymentSendFailureZ)); + *ret = CResult_NonePaymentSendFailureZ_good(); + return (long)ret; +} + +JNIEXPORT jlong JNICALL CResultNoneChannelMonitorUpdateErrZgood(JNIEnv * _env, jclass _b) { + LDKCResult_NoneChannelMonitorUpdateErrZ* ret = malloc(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ)); + *ret = CResult_NoneChannelMonitorUpdateErrZ_good(); + return (long)ret; +} + +JNIEXPORT jlong JNICALL CResultNoneMonitorUpdateErrorZgood(JNIEnv * _env, jclass _b) { + LDKCResult_NoneMonitorUpdateErrorZ* ret = malloc(sizeof(LDKCResult_NoneMonitorUpdateErrorZ)); + *ret = CResult_NoneMonitorUpdateErrorZ_good(); + return (long)ret; +} + +JNIEXPORT jlong JNICALL C2TupleOutPointScriptZnew(JNIEnv * _env, jclass _b, jlong a, jlong b) { + LDKOutPoint a_conv = *(LDKOutPoint*)a; + LDKCVec_u8Z b_conv = *(LDKCVec_u8Z*)b; + LDKC2Tuple_OutPointScriptZ* ret = malloc(sizeof(LDKC2Tuple_OutPointScriptZ)); + *ret = C2Tuple_OutPointScriptZ_new(a_conv, b_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL C3TupleChannelAnnouncementChannelUpdateChannelUpdateZnew(JNIEnv * _env, jclass _b, jlong a, jlong b, jlong c) { + LDKChannelAnnouncement a_conv = *(LDKChannelAnnouncement*)a; + LDKChannelUpdate b_conv = *(LDKChannelUpdate*)b; + LDKChannelUpdate c_conv = *(LDKChannelUpdate*)c; + LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret = malloc(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); + *ret = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a_conv, b_conv, c_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL CResultNonePeerHandleErrorZgood(JNIEnv * _env, jclass _b) { + LDKCResult_NonePeerHandleErrorZ* ret = malloc(sizeof(LDKCResult_NonePeerHandleErrorZ)); + *ret = CResult_NonePeerHandleErrorZ_good(); + return (long)ret; +} + +JNIEXPORT void JNICALL Eventfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKEvent this_ptr_conv = *(LDKEvent*)this_ptr; + return Event_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL MessageSendEventfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKMessageSendEvent this_ptr_conv = *(LDKMessageSendEvent*)this_ptr; + return MessageSendEvent_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL MessageSendEventsProviderfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKMessageSendEventsProvider this_ptr_conv = *(LDKMessageSendEventsProvider*)this_ptr; + return MessageSendEventsProvider_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL EventsProviderfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKEventsProvider this_ptr_conv = *(LDKEventsProvider*)this_ptr; + return EventsProvider_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL APIErrorfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKAPIError this_ptr_conv = *(LDKAPIError*)this_ptr; + return APIError_free(this_ptr_conv); +} + +JNIEXPORT jlong JNICALL Levelmax(JNIEnv * _env, jclass _b) { + LDKLevel* ret = malloc(sizeof(LDKLevel)); + *ret = Level_max(); + return (long)ret; +} + +JNIEXPORT void JNICALL Loggerfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKLogger this_ptr_conv = *(LDKLogger*)this_ptr; + return Logger_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL ChannelHandshakeConfigfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelHandshakeConfig this_ptr_conv = *(LDKChannelHandshakeConfig*)this_ptr; + return ChannelHandshakeConfig_free(this_ptr_conv); +} + +JNIEXPORT jint JNICALL ChannelHandshakeConfiggetminimumdepth(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelHandshakeConfig* this_ptr_conv = (LDKChannelHandshakeConfig*)this_ptr; + return ChannelHandshakeConfig_get_minimum_depth(this_ptr_conv); +} + +JNIEXPORT void JNICALL ChannelHandshakeConfigsetminimumdepth(JNIEnv * _env, jclass _b, jlong this_ptr, jint val) { + LDKChannelHandshakeConfig* this_ptr_conv = (LDKChannelHandshakeConfig*)this_ptr; + return ChannelHandshakeConfig_set_minimum_depth(this_ptr_conv, val); +} + +JNIEXPORT jlong JNICALL ChannelHandshakeConfiggetourtoselfdelay(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelHandshakeConfig* this_ptr_conv = (LDKChannelHandshakeConfig*)this_ptr; + uint16_t* ret = malloc(sizeof(uint16_t)); + *ret = ChannelHandshakeConfig_get_our_to_self_delay(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL ChannelHandshakeConfigsetourtoselfdelay(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKChannelHandshakeConfig* this_ptr_conv = (LDKChannelHandshakeConfig*)this_ptr; + uint16_t val_conv = *(uint16_t*)val; + return ChannelHandshakeConfig_set_our_to_self_delay(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL ChannelHandshakeConfiggetourhtlcminimummsat(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelHandshakeConfig* this_ptr_conv = (LDKChannelHandshakeConfig*)this_ptr; + return ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr_conv); +} + +JNIEXPORT void JNICALL ChannelHandshakeConfigsetourhtlcminimummsat(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKChannelHandshakeConfig* this_ptr_conv = (LDKChannelHandshakeConfig*)this_ptr; + return ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr_conv, val); +} + +JNIEXPORT jlong JNICALL ChannelHandshakeConfignew(JNIEnv * _env, jclass _b, jint minimum_depth_arg, jlong our_to_self_delay_arg, jlong our_htlc_minimum_msat_arg) { + uint16_t our_to_self_delay_arg_conv = *(uint16_t*)our_to_self_delay_arg; + LDKChannelHandshakeConfig* ret = malloc(sizeof(LDKChannelHandshakeConfig)); + *ret = ChannelHandshakeConfig_new(minimum_depth_arg, our_to_self_delay_arg_conv, our_htlc_minimum_msat_arg); + return (long)ret; +} + +JNIEXPORT jlong JNICALL ChannelHandshakeConfigdefault(JNIEnv * _env, jclass _b) { + LDKChannelHandshakeConfig* ret = malloc(sizeof(LDKChannelHandshakeConfig)); + *ret = ChannelHandshakeConfig_default(); + return (long)ret; +} + +JNIEXPORT void JNICALL ChannelHandshakeLimitsfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelHandshakeLimits this_ptr_conv = *(LDKChannelHandshakeLimits*)this_ptr; + return ChannelHandshakeLimits_free(this_ptr_conv); +} + +JNIEXPORT jlong JNICALL ChannelHandshakeLimitsgetminfundingsatoshis(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelHandshakeLimits* this_ptr_conv = (LDKChannelHandshakeLimits*)this_ptr; + return ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr_conv); +} + +JNIEXPORT void JNICALL ChannelHandshakeLimitssetminfundingsatoshis(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKChannelHandshakeLimits* this_ptr_conv = (LDKChannelHandshakeLimits*)this_ptr; + return ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr_conv, val); +} + +JNIEXPORT jlong JNICALL ChannelHandshakeLimitsgetmaxhtlcminimummsat(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelHandshakeLimits* this_ptr_conv = (LDKChannelHandshakeLimits*)this_ptr; + return ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr_conv); +} + +JNIEXPORT void JNICALL ChannelHandshakeLimitssetmaxhtlcminimummsat(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKChannelHandshakeLimits* this_ptr_conv = (LDKChannelHandshakeLimits*)this_ptr; + return ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr_conv, val); +} + +JNIEXPORT jlong JNICALL ChannelHandshakeLimitsgetminmaxhtlcvalueinflightmsat(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelHandshakeLimits* this_ptr_conv = (LDKChannelHandshakeLimits*)this_ptr; + return ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr_conv); +} + +JNIEXPORT void JNICALL ChannelHandshakeLimitssetminmaxhtlcvalueinflightmsat(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKChannelHandshakeLimits* this_ptr_conv = (LDKChannelHandshakeLimits*)this_ptr; + return ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr_conv, val); +} + +JNIEXPORT jlong JNICALL ChannelHandshakeLimitsgetmaxchannelreservesatoshis(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelHandshakeLimits* this_ptr_conv = (LDKChannelHandshakeLimits*)this_ptr; + return ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr_conv); +} + +JNIEXPORT void JNICALL ChannelHandshakeLimitssetmaxchannelreservesatoshis(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKChannelHandshakeLimits* this_ptr_conv = (LDKChannelHandshakeLimits*)this_ptr; + return ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr_conv, val); +} + +JNIEXPORT jlong JNICALL ChannelHandshakeLimitsgetminmaxacceptedhtlcs(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelHandshakeLimits* this_ptr_conv = (LDKChannelHandshakeLimits*)this_ptr; + uint16_t* ret = malloc(sizeof(uint16_t)); + *ret = ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL ChannelHandshakeLimitssetminmaxacceptedhtlcs(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKChannelHandshakeLimits* this_ptr_conv = (LDKChannelHandshakeLimits*)this_ptr; + uint16_t val_conv = *(uint16_t*)val; + return ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL ChannelHandshakeLimitsgetmindustlimitsatoshis(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelHandshakeLimits* this_ptr_conv = (LDKChannelHandshakeLimits*)this_ptr; + return ChannelHandshakeLimits_get_min_dust_limit_satoshis(this_ptr_conv); +} + +JNIEXPORT void JNICALL ChannelHandshakeLimitssetmindustlimitsatoshis(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKChannelHandshakeLimits* this_ptr_conv = (LDKChannelHandshakeLimits*)this_ptr; + return ChannelHandshakeLimits_set_min_dust_limit_satoshis(this_ptr_conv, val); +} + +JNIEXPORT jlong JNICALL ChannelHandshakeLimitsgetmaxdustlimitsatoshis(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelHandshakeLimits* this_ptr_conv = (LDKChannelHandshakeLimits*)this_ptr; + return ChannelHandshakeLimits_get_max_dust_limit_satoshis(this_ptr_conv); +} + +JNIEXPORT void JNICALL ChannelHandshakeLimitssetmaxdustlimitsatoshis(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKChannelHandshakeLimits* this_ptr_conv = (LDKChannelHandshakeLimits*)this_ptr; + return ChannelHandshakeLimits_set_max_dust_limit_satoshis(this_ptr_conv, val); +} + +JNIEXPORT jint JNICALL ChannelHandshakeLimitsgetmaxminimumdepth(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelHandshakeLimits* this_ptr_conv = (LDKChannelHandshakeLimits*)this_ptr; + return ChannelHandshakeLimits_get_max_minimum_depth(this_ptr_conv); +} + +JNIEXPORT void JNICALL ChannelHandshakeLimitssetmaxminimumdepth(JNIEnv * _env, jclass _b, jlong this_ptr, jint val) { + LDKChannelHandshakeLimits* this_ptr_conv = (LDKChannelHandshakeLimits*)this_ptr; + return ChannelHandshakeLimits_set_max_minimum_depth(this_ptr_conv, val); +} + +JNIEXPORT jboolean JNICALL ChannelHandshakeLimitsgetforceannouncedchannelpreference(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelHandshakeLimits* this_ptr_conv = (LDKChannelHandshakeLimits*)this_ptr; + return ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr_conv); +} + +JNIEXPORT void JNICALL ChannelHandshakeLimitssetforceannouncedchannelpreference(JNIEnv * _env, jclass _b, jlong this_ptr, jboolean va) { + LDKChannelHandshakeLimits* this_ptr_conv = (LDKChannelHandshakeLimits*)this_ptr; + return ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr_conv, va); +} + +JNIEXPORT jlong JNICALL ChannelHandshakeLimitsgettheirtoselfdelay(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelHandshakeLimits* this_ptr_conv = (LDKChannelHandshakeLimits*)this_ptr; + uint16_t* ret = malloc(sizeof(uint16_t)); + *ret = ChannelHandshakeLimits_get_their_to_self_delay(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL ChannelHandshakeLimitssettheirtoselfdelay(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKChannelHandshakeLimits* this_ptr_conv = (LDKChannelHandshakeLimits*)this_ptr; + uint16_t val_conv = *(uint16_t*)val; + return ChannelHandshakeLimits_set_their_to_self_delay(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL ChannelHandshakeLimitsnew(JNIEnv * _env, jclass _b, jlong min_funding_satoshis_arg, jlong max_htlc_minimum_msat_arg, jlong min_max_htlc_value_in_flight_msat_arg, jlong max_channel_reserve_satoshis_arg, jlong min_max_accepted_htlcs_arg, jlong min_dust_limit_satoshis_arg, jlong max_dust_limit_satoshis_arg, jint max_minimum_depth_arg, jboolean force_announced_channel_preference_arg, jlong their_to_self_delay_arg) { + uint16_t min_max_accepted_htlcs_arg_conv = *(uint16_t*)min_max_accepted_htlcs_arg; + uint16_t their_to_self_delay_arg_conv = *(uint16_t*)their_to_self_delay_arg; + LDKChannelHandshakeLimits* ret = malloc(sizeof(LDKChannelHandshakeLimits)); + *ret = ChannelHandshakeLimits_new(min_funding_satoshis_arg, max_htlc_minimum_msat_arg, min_max_htlc_value_in_flight_msat_arg, max_channel_reserve_satoshis_arg, min_max_accepted_htlcs_arg_conv, min_dust_limit_satoshis_arg, max_dust_limit_satoshis_arg, max_minimum_depth_arg, force_announced_channel_preference_arg, their_to_self_delay_arg_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL ChannelHandshakeLimitsdefault(JNIEnv * _env, jclass _b) { + LDKChannelHandshakeLimits* ret = malloc(sizeof(LDKChannelHandshakeLimits)); + *ret = ChannelHandshakeLimits_default(); + return (long)ret; +} + +JNIEXPORT void JNICALL ChannelConfigfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelConfig this_ptr_conv = *(LDKChannelConfig*)this_ptr; + return ChannelConfig_free(this_ptr_conv); +} + +JNIEXPORT jint JNICALL ChannelConfiggetfeeproportionalmillionths(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelConfig* this_ptr_conv = (LDKChannelConfig*)this_ptr; + return ChannelConfig_get_fee_proportional_millionths(this_ptr_conv); +} + +JNIEXPORT void JNICALL ChannelConfigsetfeeproportionalmillionths(JNIEnv * _env, jclass _b, jlong this_ptr, jint val) { + LDKChannelConfig* this_ptr_conv = (LDKChannelConfig*)this_ptr; + return ChannelConfig_set_fee_proportional_millionths(this_ptr_conv, val); +} + +JNIEXPORT jboolean JNICALL ChannelConfiggetannouncedchannel(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelConfig* this_ptr_conv = (LDKChannelConfig*)this_ptr; + return ChannelConfig_get_announced_channel(this_ptr_conv); +} + +JNIEXPORT void JNICALL ChannelConfigsetannouncedchannel(JNIEnv * _env, jclass _b, jlong this_ptr, jboolean va) { + LDKChannelConfig* this_ptr_conv = (LDKChannelConfig*)this_ptr; + return ChannelConfig_set_announced_channel(this_ptr_conv, va); +} + +JNIEXPORT jboolean JNICALL ChannelConfiggetcommitupfrontshutdownpubkey(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelConfig* this_ptr_conv = (LDKChannelConfig*)this_ptr; + return ChannelConfig_get_commit_upfront_shutdown_pubkey(this_ptr_conv); +} + +JNIEXPORT void JNICALL ChannelConfigsetcommitupfrontshutdownpubkey(JNIEnv * _env, jclass _b, jlong this_ptr, jboolean va) { + LDKChannelConfig* this_ptr_conv = (LDKChannelConfig*)this_ptr; + return ChannelConfig_set_commit_upfront_shutdown_pubkey(this_ptr_conv, va); +} + +JNIEXPORT jlong JNICALL ChannelConfignew(JNIEnv * _env, jclass _b, jint fee_proportional_millionths_arg, jboolean announced_channel_arg, jboolean commit_upfront_shutdown_pubkey_arg) { + LDKChannelConfig* ret = malloc(sizeof(LDKChannelConfig)); + *ret = ChannelConfig_new(fee_proportional_millionths_arg, announced_channel_arg, commit_upfront_shutdown_pubkey_arg); + return (long)ret; +} + +JNIEXPORT jlong JNICALL ChannelConfigdefault(JNIEnv * _env, jclass _b) { + LDKChannelConfig* ret = malloc(sizeof(LDKChannelConfig)); + *ret = ChannelConfig_default(); + return (long)ret; +} + +JNIEXPORT jlong JNICALL ChannelConfigwrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKChannelConfig* obj_conv = (LDKChannelConfig*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = ChannelConfig_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL ChannelConfigread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKChannelConfig* ret = malloc(sizeof(LDKChannelConfig)); + *ret = ChannelConfig_read(ser_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL UserConfigfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKUserConfig this_ptr_conv = *(LDKUserConfig*)this_ptr; + return UserConfig_free(this_ptr_conv); +} + +JNIEXPORT jlong JNICALL UserConfiggetownchannelconfig(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKUserConfig* this_ptr_conv = (LDKUserConfig*)this_ptr; + LDKChannelHandshakeConfig* ret = malloc(sizeof(LDKChannelHandshakeConfig)); + *ret = UserConfig_get_own_channel_config(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL UserConfigsetownchannelconfig(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKUserConfig* this_ptr_conv = (LDKUserConfig*)this_ptr; + LDKChannelHandshakeConfig val_conv = *(LDKChannelHandshakeConfig*)val; + return UserConfig_set_own_channel_config(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL UserConfiggetpeerchannelconfiglimits(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKUserConfig* this_ptr_conv = (LDKUserConfig*)this_ptr; + LDKChannelHandshakeLimits* ret = malloc(sizeof(LDKChannelHandshakeLimits)); + *ret = UserConfig_get_peer_channel_config_limits(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL UserConfigsetpeerchannelconfiglimits(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKUserConfig* this_ptr_conv = (LDKUserConfig*)this_ptr; + LDKChannelHandshakeLimits val_conv = *(LDKChannelHandshakeLimits*)val; + return UserConfig_set_peer_channel_config_limits(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL UserConfiggetchanneloptions(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKUserConfig* this_ptr_conv = (LDKUserConfig*)this_ptr; + LDKChannelConfig* ret = malloc(sizeof(LDKChannelConfig)); + *ret = UserConfig_get_channel_options(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL UserConfigsetchanneloptions(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKUserConfig* this_ptr_conv = (LDKUserConfig*)this_ptr; + LDKChannelConfig val_conv = *(LDKChannelConfig*)val; + return UserConfig_set_channel_options(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL UserConfignew(JNIEnv * _env, jclass _b, jlong own_channel_config_arg, jlong peer_channel_config_limits_arg, jlong channel_options_arg) { + LDKChannelHandshakeConfig own_channel_config_arg_conv = *(LDKChannelHandshakeConfig*)own_channel_config_arg; + LDKChannelHandshakeLimits peer_channel_config_limits_arg_conv = *(LDKChannelHandshakeLimits*)peer_channel_config_limits_arg; + LDKChannelConfig channel_options_arg_conv = *(LDKChannelConfig*)channel_options_arg; + LDKUserConfig* ret = malloc(sizeof(LDKUserConfig)); + *ret = UserConfig_new(own_channel_config_arg_conv, peer_channel_config_limits_arg_conv, channel_options_arg_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL UserConfigdefault(JNIEnv * _env, jclass _b) { + LDKUserConfig* ret = malloc(sizeof(LDKUserConfig)); + *ret = UserConfig_default(); + return (long)ret; +} + +JNIEXPORT void JNICALL ChainWatchInterfacefree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChainWatchInterface this_ptr_conv = *(LDKChainWatchInterface*)this_ptr; + return ChainWatchInterface_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL BroadcasterInterfacefree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKBroadcasterInterface this_ptr_conv = *(LDKBroadcasterInterface*)this_ptr; + return BroadcasterInterface_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL ChainListenerfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChainListener this_ptr_conv = *(LDKChainListener*)this_ptr; + return ChainListener_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL FeeEstimatorfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKFeeEstimator this_ptr_conv = *(LDKFeeEstimator*)this_ptr; + return FeeEstimator_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL ChainWatchedUtilfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChainWatchedUtil this_ptr_conv = *(LDKChainWatchedUtil*)this_ptr; + return ChainWatchedUtil_free(this_ptr_conv); +} + +JNIEXPORT jlong JNICALL ChainWatchedUtilnew(JNIEnv * _env, jclass _b) { + LDKChainWatchedUtil* ret = malloc(sizeof(LDKChainWatchedUtil)); + *ret = ChainWatchedUtil_new(); + return (long)ret; +} + +JNIEXPORT jboolean JNICALL ChainWatchedUtilregistertx(JNIEnv * _env, jclass _b, jlong this_arg, jbyteArray txid, jlong script_pub_key) { + LDKChainWatchedUtil* this_arg_conv = (LDKChainWatchedUtil*)this_arg; + unsigned char txid_arr[32]; + (*_env)->GetByteArrayRegion (_env, txid, 0, 32, txid_arr); + unsigned char (*txid_ref)[32] = &txid_arr; + LDKu8slice script_pub_key_conv = *(LDKu8slice*)script_pub_key; + return ChainWatchedUtil_register_tx(this_arg_conv, txid_ref, script_pub_key_conv); +} + +JNIEXPORT jboolean JNICALL ChainWatchedUtilregisteroutpoint(JNIEnv * _env, jclass _b, jlong this_arg, jlong outpoint, jlong _script_pub_key) { + LDKChainWatchedUtil* this_arg_conv = (LDKChainWatchedUtil*)this_arg; + LDKC2Tuple_Txidu32Z outpoint_conv = *(LDKC2Tuple_Txidu32Z*)outpoint; + LDKu8slice _script_pub_key_conv = *(LDKu8slice*)_script_pub_key; + return ChainWatchedUtil_register_outpoint(this_arg_conv, outpoint_conv, _script_pub_key_conv); +} + +JNIEXPORT jboolean JNICALL ChainWatchedUtilwatchall(JNIEnv * _env, jclass _b, jlong this_arg) { + LDKChainWatchedUtil* this_arg_conv = (LDKChainWatchedUtil*)this_arg; + return ChainWatchedUtil_watch_all(this_arg_conv); +} + +JNIEXPORT jboolean JNICALL ChainWatchedUtildoesmatchtx(JNIEnv * _env, jclass _b, jlong this_arg, jlong tx) { + LDKChainWatchedUtil* this_arg_conv = (LDKChainWatchedUtil*)this_arg; + LDKTransaction tx_conv = *(LDKTransaction*)tx; + return ChainWatchedUtil_does_match_tx(this_arg_conv, tx_conv); +} + +JNIEXPORT void JNICALL BlockNotifierfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKBlockNotifier this_ptr_conv = *(LDKBlockNotifier*)this_ptr; + return BlockNotifier_free(this_ptr_conv); +} + +JNIEXPORT jlong JNICALL BlockNotifiernew(JNIEnv * _env, jclass _b, jlong chain_monitor) { + LDKChainWatchInterface chain_monitor_conv = *(LDKChainWatchInterface*)chain_monitor; + LDKBlockNotifier* ret = malloc(sizeof(LDKBlockNotifier)); + *ret = BlockNotifier_new(chain_monitor_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL BlockNotifierregisterlistener(JNIEnv * _env, jclass _b, jlong this_arg, jlong listener) { + LDKBlockNotifier* this_arg_conv = (LDKBlockNotifier*)this_arg; + LDKChainListener listener_conv = *(LDKChainListener*)listener; + return BlockNotifier_register_listener(this_arg_conv, listener_conv); +} + +JNIEXPORT void JNICALL BlockNotifierblockconnected(JNIEnv * _env, jclass _b, jlong this_arg, jlong block, jint heigh) { + LDKBlockNotifier* this_arg_conv = (LDKBlockNotifier*)this_arg; + LDKu8slice block_conv = *(LDKu8slice*)block; + return BlockNotifier_block_connected(this_arg_conv, block_conv, heigh); +} + +JNIEXPORT jboolean JNICALL BlockNotifierblockconnectedchecked(JNIEnv * _env, jclass _b, jlong this_arg, jbyteArray header, jint heigh, jlong txn_matched, jlong indexes_of_txn_matched) { + LDKBlockNotifier* this_arg_conv = (LDKBlockNotifier*)this_arg; + unsigned char header_arr[80]; + (*_env)->GetByteArrayRegion (_env, header, 0, 80, header_arr); + unsigned char (*header_ref)[80] = &header_arr; + LDKCTransactionSlice txn_matched_conv = *(LDKCTransactionSlice*)txn_matched; + LDKusizeslice indexes_of_txn_matched_conv = *(LDKusizeslice*)indexes_of_txn_matched; + return BlockNotifier_block_connected_checked(this_arg_conv, header_ref, heigh, txn_matched_conv, indexes_of_txn_matched_conv); +} + +JNIEXPORT void JNICALL BlockNotifierblockdisconnected(JNIEnv * _env, jclass _b, jlong this_arg, jbyteArray header, jint disconnected_heigh) { + LDKBlockNotifier* this_arg_conv = (LDKBlockNotifier*)this_arg; + unsigned char header_arr[80]; + (*_env)->GetByteArrayRegion (_env, header, 0, 80, header_arr); + unsigned char (*header_ref)[80] = &header_arr; + return BlockNotifier_block_disconnected(this_arg_conv, header_ref, disconnected_heigh); +} + +JNIEXPORT void JNICALL ChainWatchInterfaceUtilfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChainWatchInterfaceUtil this_ptr_conv = *(LDKChainWatchInterfaceUtil*)this_ptr; + return ChainWatchInterfaceUtil_free(this_ptr_conv); +} + +JNIEXPORT jlong JNICALL ChainWatchInterfaceUtilasChainWatchInterface(JNIEnv * _env, jclass _b, jlong this_arg) { + LDKChainWatchInterfaceUtil* this_arg_conv = (LDKChainWatchInterfaceUtil*)this_arg; + LDKChainWatchInterface* ret = malloc(sizeof(LDKChainWatchInterface)); + *ret = ChainWatchInterfaceUtil_as_ChainWatchInterface(this_arg_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL ChainWatchInterfaceUtilnew(JNIEnv * _env, jclass _b, jlong network) { + LDKNetwork network_conv = *(LDKNetwork*)network; + LDKChainWatchInterfaceUtil* ret = malloc(sizeof(LDKChainWatchInterfaceUtil)); + *ret = ChainWatchInterfaceUtil_new(network_conv); + return (long)ret; +} + +JNIEXPORT jboolean JNICALL ChainWatchInterfaceUtildoesmatchtx(JNIEnv * _env, jclass _b, jlong this_arg, jlong tx) { + LDKChainWatchInterfaceUtil* this_arg_conv = (LDKChainWatchInterfaceUtil*)this_arg; + LDKTransaction tx_conv = *(LDKTransaction*)tx; + return ChainWatchInterfaceUtil_does_match_tx(this_arg_conv, tx_conv); +} + +JNIEXPORT void JNICALL OutPointfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKOutPoint this_ptr_conv = *(LDKOutPoint*)this_ptr; + return OutPoint_free(this_ptr_conv); +} + +JNIEXPORT jbyteArray JNICALL OutPointgettxid(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKOutPoint* this_ptr_conv = (LDKOutPoint*)this_ptr; + jbyteArray ret_arr = (*_env)->NewByteArray(_env, 0); // XXX: len 0 + (*_env)->SetByteArrayRegion(_env, ret_arr, 0, 32, *OutPoint_get_txid(this_ptr_conv)); + return ret_arr; +} + +JNIEXPORT void JNICALL OutPointsettxid(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKOutPoint* this_ptr_conv = (LDKOutPoint*)this_ptr; + LDKThirtyTwoBytes val_conv = *(LDKThirtyTwoBytes*)val; + return OutPoint_set_txid(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL OutPointgetindex(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKOutPoint* this_ptr_conv = (LDKOutPoint*)this_ptr; + uint16_t* ret = malloc(sizeof(uint16_t)); + *ret = OutPoint_get_index(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL OutPointsetindex(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKOutPoint* this_ptr_conv = (LDKOutPoint*)this_ptr; + uint16_t val_conv = *(uint16_t*)val; + return OutPoint_set_index(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL OutPointnew(JNIEnv * _env, jclass _b, jlong txid_arg, jlong index_arg) { + LDKThirtyTwoBytes txid_arg_conv = *(LDKThirtyTwoBytes*)txid_arg; + uint16_t index_arg_conv = *(uint16_t*)index_arg; + LDKOutPoint* ret = malloc(sizeof(LDKOutPoint)); + *ret = OutPoint_new(txid_arg_conv, index_arg_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL OutPointtochannelid(JNIEnv * _env, jclass _b, jlong this_arg) { + LDKOutPoint* this_arg_conv = (LDKOutPoint*)this_arg; + LDKThirtyTwoBytes* ret = malloc(sizeof(LDKThirtyTwoBytes)); + *ret = OutPoint_to_channel_id(this_arg_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL OutPointwrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKOutPoint* obj_conv = (LDKOutPoint*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = OutPoint_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL OutPointread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKOutPoint* ret = malloc(sizeof(LDKOutPoint)); + *ret = OutPoint_read(ser_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL SpendableOutputDescriptorfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKSpendableOutputDescriptor this_ptr_conv = *(LDKSpendableOutputDescriptor*)this_ptr; + return SpendableOutputDescriptor_free(this_ptr_conv); +} + +JNIEXPORT jlong JNICALL SpendableOutputDescriptorwrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKSpendableOutputDescriptor* obj_conv = (LDKSpendableOutputDescriptor*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = SpendableOutputDescriptor_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL SpendableOutputDescriptorread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKSpendableOutputDescriptor* ret = malloc(sizeof(LDKSpendableOutputDescriptor)); + *ret = SpendableOutputDescriptor_read(ser_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL ChannelKeysfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelKeys this_ptr_conv = *(LDKChannelKeys*)this_ptr; + return ChannelKeys_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL KeysInterfacefree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKKeysInterface this_ptr_conv = *(LDKKeysInterface*)this_ptr; + return KeysInterface_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL InMemoryChannelKeysfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKInMemoryChannelKeys this_ptr_conv = *(LDKInMemoryChannelKeys*)this_ptr; + return InMemoryChannelKeys_free(this_ptr_conv); +} + +JNIEXPORT jbyteArray JNICALL InMemoryChannelKeysgetfundingkey(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKInMemoryChannelKeys* this_ptr_conv = (LDKInMemoryChannelKeys*)this_ptr; + jbyteArray ret_arr = (*_env)->NewByteArray(_env, 0); // XXX: len 0 + (*_env)->SetByteArrayRegion(_env, ret_arr, 0, 32, *InMemoryChannelKeys_get_funding_key(this_ptr_conv)); + return ret_arr; +} + +JNIEXPORT void JNICALL InMemoryChannelKeyssetfundingkey(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKInMemoryChannelKeys* this_ptr_conv = (LDKInMemoryChannelKeys*)this_ptr; + LDKSecretKey val_conv = *(LDKSecretKey*)val; + return InMemoryChannelKeys_set_funding_key(this_ptr_conv, val_conv); +} + +JNIEXPORT jbyteArray JNICALL InMemoryChannelKeysgetrevocationbasekey(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKInMemoryChannelKeys* this_ptr_conv = (LDKInMemoryChannelKeys*)this_ptr; + jbyteArray ret_arr = (*_env)->NewByteArray(_env, 0); // XXX: len 0 + (*_env)->SetByteArrayRegion(_env, ret_arr, 0, 32, *InMemoryChannelKeys_get_revocation_base_key(this_ptr_conv)); + return ret_arr; +} + +JNIEXPORT void JNICALL InMemoryChannelKeyssetrevocationbasekey(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKInMemoryChannelKeys* this_ptr_conv = (LDKInMemoryChannelKeys*)this_ptr; + LDKSecretKey val_conv = *(LDKSecretKey*)val; + return InMemoryChannelKeys_set_revocation_base_key(this_ptr_conv, val_conv); +} + +JNIEXPORT jbyteArray JNICALL InMemoryChannelKeysgetpaymentkey(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKInMemoryChannelKeys* this_ptr_conv = (LDKInMemoryChannelKeys*)this_ptr; + jbyteArray ret_arr = (*_env)->NewByteArray(_env, 0); // XXX: len 0 + (*_env)->SetByteArrayRegion(_env, ret_arr, 0, 32, *InMemoryChannelKeys_get_payment_key(this_ptr_conv)); + return ret_arr; +} + +JNIEXPORT void JNICALL InMemoryChannelKeyssetpaymentkey(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKInMemoryChannelKeys* this_ptr_conv = (LDKInMemoryChannelKeys*)this_ptr; + LDKSecretKey val_conv = *(LDKSecretKey*)val; + return InMemoryChannelKeys_set_payment_key(this_ptr_conv, val_conv); +} + +JNIEXPORT jbyteArray JNICALL InMemoryChannelKeysgetdelayedpaymentbasekey(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKInMemoryChannelKeys* this_ptr_conv = (LDKInMemoryChannelKeys*)this_ptr; + jbyteArray ret_arr = (*_env)->NewByteArray(_env, 0); // XXX: len 0 + (*_env)->SetByteArrayRegion(_env, ret_arr, 0, 32, *InMemoryChannelKeys_get_delayed_payment_base_key(this_ptr_conv)); + return ret_arr; +} + +JNIEXPORT void JNICALL InMemoryChannelKeyssetdelayedpaymentbasekey(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKInMemoryChannelKeys* this_ptr_conv = (LDKInMemoryChannelKeys*)this_ptr; + LDKSecretKey val_conv = *(LDKSecretKey*)val; + return InMemoryChannelKeys_set_delayed_payment_base_key(this_ptr_conv, val_conv); +} + +JNIEXPORT jbyteArray JNICALL InMemoryChannelKeysgethtlcbasekey(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKInMemoryChannelKeys* this_ptr_conv = (LDKInMemoryChannelKeys*)this_ptr; + jbyteArray ret_arr = (*_env)->NewByteArray(_env, 0); // XXX: len 0 + (*_env)->SetByteArrayRegion(_env, ret_arr, 0, 32, *InMemoryChannelKeys_get_htlc_base_key(this_ptr_conv)); + return ret_arr; +} + +JNIEXPORT void JNICALL InMemoryChannelKeyssethtlcbasekey(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKInMemoryChannelKeys* this_ptr_conv = (LDKInMemoryChannelKeys*)this_ptr; + LDKSecretKey val_conv = *(LDKSecretKey*)val; + return InMemoryChannelKeys_set_htlc_base_key(this_ptr_conv, val_conv); +} + +JNIEXPORT jbyteArray JNICALL InMemoryChannelKeysgetcommitmentseed(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKInMemoryChannelKeys* this_ptr_conv = (LDKInMemoryChannelKeys*)this_ptr; + jbyteArray ret_arr = (*_env)->NewByteArray(_env, 0); // XXX: len 0 + (*_env)->SetByteArrayRegion(_env, ret_arr, 0, 32, *InMemoryChannelKeys_get_commitment_seed(this_ptr_conv)); + return ret_arr; +} + +JNIEXPORT void JNICALL InMemoryChannelKeyssetcommitmentseed(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKInMemoryChannelKeys* this_ptr_conv = (LDKInMemoryChannelKeys*)this_ptr; + LDKThirtyTwoBytes val_conv = *(LDKThirtyTwoBytes*)val; + return InMemoryChannelKeys_set_commitment_seed(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL InMemoryChannelKeysnew(JNIEnv * _env, jclass _b, jlong funding_key, jlong revocation_base_key, jlong payment_key, jlong delayed_payment_base_key, jlong htlc_base_key, jlong commitment_seed, jlong channel_value_satoshis, jlong key_derivation_params) { + LDKSecretKey funding_key_conv = *(LDKSecretKey*)funding_key; + LDKSecretKey revocation_base_key_conv = *(LDKSecretKey*)revocation_base_key; + LDKSecretKey payment_key_conv = *(LDKSecretKey*)payment_key; + LDKSecretKey delayed_payment_base_key_conv = *(LDKSecretKey*)delayed_payment_base_key; + LDKSecretKey htlc_base_key_conv = *(LDKSecretKey*)htlc_base_key; + LDKThirtyTwoBytes commitment_seed_conv = *(LDKThirtyTwoBytes*)commitment_seed; + LDKC2Tuple_u64u64Z key_derivation_params_conv = *(LDKC2Tuple_u64u64Z*)key_derivation_params; + LDKInMemoryChannelKeys* ret = malloc(sizeof(LDKInMemoryChannelKeys)); + *ret = InMemoryChannelKeys_new(funding_key_conv, revocation_base_key_conv, payment_key_conv, delayed_payment_base_key_conv, htlc_base_key_conv, commitment_seed_conv, channel_value_satoshis, key_derivation_params_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL InMemoryChannelKeysasChannelKeys(JNIEnv * _env, jclass _b, jlong this_arg) { + LDKInMemoryChannelKeys* this_arg_conv = (LDKInMemoryChannelKeys*)this_arg; + LDKChannelKeys* ret = malloc(sizeof(LDKChannelKeys)); + *ret = InMemoryChannelKeys_as_ChannelKeys(this_arg_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL InMemoryChannelKeyswrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKInMemoryChannelKeys* obj_conv = (LDKInMemoryChannelKeys*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = InMemoryChannelKeys_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL InMemoryChannelKeysread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKInMemoryChannelKeys* ret = malloc(sizeof(LDKInMemoryChannelKeys)); + *ret = InMemoryChannelKeys_read(ser_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL KeysManagerfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKKeysManager this_ptr_conv = *(LDKKeysManager*)this_ptr; + return KeysManager_free(this_ptr_conv); +} + +JNIEXPORT jlong JNICALL KeysManagernew(JNIEnv * _env, jclass _b, jbyteArray seed, jlong network, jlong starting_time_secs, jint starting_time_nanos) { + unsigned char seed_arr[32]; + (*_env)->GetByteArrayRegion (_env, seed, 0, 32, seed_arr); + unsigned char (*seed_ref)[32] = &seed_arr; + LDKNetwork network_conv = *(LDKNetwork*)network; + LDKKeysManager* ret = malloc(sizeof(LDKKeysManager)); + *ret = KeysManager_new(seed_ref, network_conv, starting_time_secs, starting_time_nanos); + return (long)ret; +} + +JNIEXPORT jlong JNICALL KeysManagerderivechannelkeys(JNIEnv * _env, jclass _b, jlong this_arg, jlong channel_value_satoshis, jlong params_1, jlong params_2) { + LDKKeysManager* this_arg_conv = (LDKKeysManager*)this_arg; + LDKInMemoryChannelKeys* ret = malloc(sizeof(LDKInMemoryChannelKeys)); + *ret = KeysManager_derive_channel_keys(this_arg_conv, channel_value_satoshis, params_1, params_2); + return (long)ret; +} + +JNIEXPORT jlong JNICALL KeysManagerasKeysInterface(JNIEnv * _env, jclass _b, jlong this_arg) { + LDKKeysManager* this_arg_conv = (LDKKeysManager*)this_arg; + LDKKeysInterface* ret = malloc(sizeof(LDKKeysInterface)); + *ret = KeysManager_as_KeysInterface(this_arg_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL ChannelManagerfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelManager this_ptr_conv = *(LDKChannelManager*)this_ptr; + return ChannelManager_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL ChannelDetailsfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelDetails this_ptr_conv = *(LDKChannelDetails*)this_ptr; + return ChannelDetails_free(this_ptr_conv); +} + +JNIEXPORT jbyteArray JNICALL ChannelDetailsgetchannelid(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelDetails* this_ptr_conv = (LDKChannelDetails*)this_ptr; + jbyteArray ret_arr = (*_env)->NewByteArray(_env, 0); // XXX: len 0 + (*_env)->SetByteArrayRegion(_env, ret_arr, 0, 32, *ChannelDetails_get_channel_id(this_ptr_conv)); + return ret_arr; +} + +JNIEXPORT void JNICALL ChannelDetailssetchannelid(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKChannelDetails* this_ptr_conv = (LDKChannelDetails*)this_ptr; + LDKThirtyTwoBytes val_conv = *(LDKThirtyTwoBytes*)val; + return ChannelDetails_set_channel_id(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL ChannelDetailsgetremotenetworkid(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelDetails* this_ptr_conv = (LDKChannelDetails*)this_ptr; + LDKPublicKey* ret = malloc(sizeof(LDKPublicKey)); + *ret = ChannelDetails_get_remote_network_id(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL ChannelDetailssetremotenetworkid(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKChannelDetails* this_ptr_conv = (LDKChannelDetails*)this_ptr; + LDKPublicKey val_conv = *(LDKPublicKey*)val; + return ChannelDetails_set_remote_network_id(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL ChannelDetailsgetcounterpartyfeatures(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelDetails* this_ptr_conv = (LDKChannelDetails*)this_ptr; + LDKInitFeatures* ret = malloc(sizeof(LDKInitFeatures)); + *ret = ChannelDetails_get_counterparty_features(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL ChannelDetailssetcounterpartyfeatures(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKChannelDetails* this_ptr_conv = (LDKChannelDetails*)this_ptr; + LDKInitFeatures val_conv = *(LDKInitFeatures*)val; + return ChannelDetails_set_counterparty_features(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL ChannelDetailsgetchannelvaluesatoshis(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelDetails* this_ptr_conv = (LDKChannelDetails*)this_ptr; + return ChannelDetails_get_channel_value_satoshis(this_ptr_conv); +} + +JNIEXPORT void JNICALL ChannelDetailssetchannelvaluesatoshis(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKChannelDetails* this_ptr_conv = (LDKChannelDetails*)this_ptr; + return ChannelDetails_set_channel_value_satoshis(this_ptr_conv, val); +} + +JNIEXPORT jlong JNICALL ChannelDetailsgetuserid(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelDetails* this_ptr_conv = (LDKChannelDetails*)this_ptr; + return ChannelDetails_get_user_id(this_ptr_conv); +} + +JNIEXPORT void JNICALL ChannelDetailssetuserid(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKChannelDetails* this_ptr_conv = (LDKChannelDetails*)this_ptr; + return ChannelDetails_set_user_id(this_ptr_conv, val); +} + +JNIEXPORT jlong JNICALL ChannelDetailsgetoutboundcapacitymsat(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelDetails* this_ptr_conv = (LDKChannelDetails*)this_ptr; + return ChannelDetails_get_outbound_capacity_msat(this_ptr_conv); +} + +JNIEXPORT void JNICALL ChannelDetailssetoutboundcapacitymsat(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKChannelDetails* this_ptr_conv = (LDKChannelDetails*)this_ptr; + return ChannelDetails_set_outbound_capacity_msat(this_ptr_conv, val); +} + +JNIEXPORT jlong JNICALL ChannelDetailsgetinboundcapacitymsat(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelDetails* this_ptr_conv = (LDKChannelDetails*)this_ptr; + return ChannelDetails_get_inbound_capacity_msat(this_ptr_conv); +} + +JNIEXPORT void JNICALL ChannelDetailssetinboundcapacitymsat(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKChannelDetails* this_ptr_conv = (LDKChannelDetails*)this_ptr; + return ChannelDetails_set_inbound_capacity_msat(this_ptr_conv, val); +} + +JNIEXPORT jboolean JNICALL ChannelDetailsgetislive(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelDetails* this_ptr_conv = (LDKChannelDetails*)this_ptr; + return ChannelDetails_get_is_live(this_ptr_conv); +} + +JNIEXPORT void JNICALL ChannelDetailssetislive(JNIEnv * _env, jclass _b, jlong this_ptr, jboolean va) { + LDKChannelDetails* this_ptr_conv = (LDKChannelDetails*)this_ptr; + return ChannelDetails_set_is_live(this_ptr_conv, va); +} + +JNIEXPORT void JNICALL PaymentSendFailurefree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKPaymentSendFailure this_ptr_conv = *(LDKPaymentSendFailure*)this_ptr; + return PaymentSendFailure_free(this_ptr_conv); +} + +JNIEXPORT jlong JNICALL ChannelManagernew(JNIEnv * _env, jclass _b, jlong network, jlong fee_est, jlong monitor, jlong tx_broadcaster, jlong logger, jlong keys_manager, jlong config, jlong current_blockchain_height) { + LDKNetwork network_conv = *(LDKNetwork*)network; + LDKFeeEstimator fee_est_conv = *(LDKFeeEstimator*)fee_est; + LDKManyChannelMonitor monitor_conv = *(LDKManyChannelMonitor*)monitor; + LDKBroadcasterInterface tx_broadcaster_conv = *(LDKBroadcasterInterface*)tx_broadcaster; + LDKLogger logger_conv = *(LDKLogger*)logger; + LDKKeysInterface keys_manager_conv = *(LDKKeysInterface*)keys_manager; + LDKUserConfig config_conv = *(LDKUserConfig*)config; + uintptr_t current_blockchain_height_conv = *(uintptr_t*)current_blockchain_height; + LDKChannelManager* ret = malloc(sizeof(LDKChannelManager)); + *ret = ChannelManager_new(network_conv, fee_est_conv, monitor_conv, tx_broadcaster_conv, logger_conv, keys_manager_conv, config_conv, current_blockchain_height_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL ChannelManagercreatechannel(JNIEnv * _env, jclass _b, jlong this_arg, jlong their_network_key, jlong channel_value_satoshis, jlong push_msa, jlong ser_id, jlong override_config) { + LDKChannelManager* this_arg_conv = (LDKChannelManager*)this_arg; + LDKPublicKey their_network_key_conv = *(LDKPublicKey*)their_network_key; + LDKUserConfig override_config_conv = *(LDKUserConfig*)override_config; + LDKCResult_NoneAPIErrorZ* ret = malloc(sizeof(LDKCResult_NoneAPIErrorZ)); + *ret = ChannelManager_create_channel(this_arg_conv, their_network_key_conv, channel_value_satoshis, push_msa, ser_id, override_config_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL ChannelManagerlistchannels(JNIEnv * _env, jclass _b, jlong this_arg) { + LDKChannelManager* this_arg_conv = (LDKChannelManager*)this_arg; + LDKCVec_ChannelDetailsZ* ret = malloc(sizeof(LDKCVec_ChannelDetailsZ)); + *ret = ChannelManager_list_channels(this_arg_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL ChannelManagerlistusablechannels(JNIEnv * _env, jclass _b, jlong this_arg) { + LDKChannelManager* this_arg_conv = (LDKChannelManager*)this_arg; + LDKCVec_ChannelDetailsZ* ret = malloc(sizeof(LDKCVec_ChannelDetailsZ)); + *ret = ChannelManager_list_usable_channels(this_arg_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL ChannelManagerclosechannel(JNIEnv * _env, jclass _b, jlong this_arg, jbyteArray channel_id) { + LDKChannelManager* this_arg_conv = (LDKChannelManager*)this_arg; + unsigned char channel_id_arr[32]; + (*_env)->GetByteArrayRegion (_env, channel_id, 0, 32, channel_id_arr); + unsigned char (*channel_id_ref)[32] = &channel_id_arr; + LDKCResult_NoneAPIErrorZ* ret = malloc(sizeof(LDKCResult_NoneAPIErrorZ)); + *ret = ChannelManager_close_channel(this_arg_conv, channel_id_ref); + return (long)ret; +} + +JNIEXPORT void JNICALL ChannelManagerforceclosechannel(JNIEnv * _env, jclass _b, jlong this_arg, jbyteArray channel_id) { + LDKChannelManager* this_arg_conv = (LDKChannelManager*)this_arg; + unsigned char channel_id_arr[32]; + (*_env)->GetByteArrayRegion (_env, channel_id, 0, 32, channel_id_arr); + unsigned char (*channel_id_ref)[32] = &channel_id_arr; + return ChannelManager_force_close_channel(this_arg_conv, channel_id_ref); +} + +JNIEXPORT void JNICALL ChannelManagerforcecloseallchannels(JNIEnv * _env, jclass _b, jlong this_arg) { + LDKChannelManager* this_arg_conv = (LDKChannelManager*)this_arg; + return ChannelManager_force_close_all_channels(this_arg_conv); +} + +JNIEXPORT jlong JNICALL ChannelManagersendpayment(JNIEnv * _env, jclass _b, jlong this_arg, jlong route, jlong payment_hash, jlong payment_secret) { + LDKChannelManager* this_arg_conv = (LDKChannelManager*)this_arg; + LDKRoute* route_conv = (LDKRoute*)route; + LDKThirtyTwoBytes payment_hash_conv = *(LDKThirtyTwoBytes*)payment_hash; + LDKThirtyTwoBytes payment_secret_conv = *(LDKThirtyTwoBytes*)payment_secret; + LDKCResult_NonePaymentSendFailureZ* ret = malloc(sizeof(LDKCResult_NonePaymentSendFailureZ)); + *ret = ChannelManager_send_payment(this_arg_conv, route_conv, payment_hash_conv, payment_secret_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL ChannelManagerfundingtransactiongenerated(JNIEnv * _env, jclass _b, jlong this_arg, jbyteArray temporary_channel_id, jlong funding_txo) { + LDKChannelManager* this_arg_conv = (LDKChannelManager*)this_arg; + unsigned char temporary_channel_id_arr[32]; + (*_env)->GetByteArrayRegion (_env, temporary_channel_id, 0, 32, temporary_channel_id_arr); + unsigned char (*temporary_channel_id_ref)[32] = &temporary_channel_id_arr; + LDKOutPoint funding_txo_conv = *(LDKOutPoint*)funding_txo; + return ChannelManager_funding_transaction_generated(this_arg_conv, temporary_channel_id_ref, funding_txo_conv); +} + +JNIEXPORT void JNICALL ChannelManagerbroadcastnodeannouncement(JNIEnv * _env, jclass _b, jlong this_arg, jlong rgb, jlong alias, jlong addresses) { + LDKChannelManager* this_arg_conv = (LDKChannelManager*)this_arg; + LDKThreeBytes rgb_conv = *(LDKThreeBytes*)rgb; + LDKThirtyTwoBytes alias_conv = *(LDKThirtyTwoBytes*)alias; + LDKCVec_NetAddressZ addresses_conv = *(LDKCVec_NetAddressZ*)addresses; + return ChannelManager_broadcast_node_announcement(this_arg_conv, rgb_conv, alias_conv, addresses_conv); +} + +JNIEXPORT void JNICALL ChannelManagerprocesspendinghtlcforwards(JNIEnv * _env, jclass _b, jlong this_arg) { + LDKChannelManager* this_arg_conv = (LDKChannelManager*)this_arg; + return ChannelManager_process_pending_htlc_forwards(this_arg_conv); +} + +JNIEXPORT void JNICALL ChannelManagertimerchanfreshnesseverymin(JNIEnv * _env, jclass _b, jlong this_arg) { + LDKChannelManager* this_arg_conv = (LDKChannelManager*)this_arg; + return ChannelManager_timer_chan_freshness_every_min(this_arg_conv); +} + +JNIEXPORT jboolean JNICALL ChannelManagerfailhtlcbackwards(JNIEnv * _env, jclass _b, jlong this_arg, jbyteArray payment_hash, jlong payment_secret) { + LDKChannelManager* this_arg_conv = (LDKChannelManager*)this_arg; + unsigned char payment_hash_arr[32]; + (*_env)->GetByteArrayRegion (_env, payment_hash, 0, 32, payment_hash_arr); + unsigned char (*payment_hash_ref)[32] = &payment_hash_arr; + LDKThirtyTwoBytes payment_secret_conv = *(LDKThirtyTwoBytes*)payment_secret; + return ChannelManager_fail_htlc_backwards(this_arg_conv, payment_hash_ref, payment_secret_conv); +} + +JNIEXPORT jboolean JNICALL ChannelManagerclaimfunds(JNIEnv * _env, jclass _b, jlong this_arg, jlong payment_preimage, jlong payment_secret, jlong expected_amo) { + LDKChannelManager* this_arg_conv = (LDKChannelManager*)this_arg; + LDKThirtyTwoBytes payment_preimage_conv = *(LDKThirtyTwoBytes*)payment_preimage; + LDKThirtyTwoBytes payment_secret_conv = *(LDKThirtyTwoBytes*)payment_secret; + return ChannelManager_claim_funds(this_arg_conv, payment_preimage_conv, payment_secret_conv, expected_amo); +} + +JNIEXPORT jlong JNICALL ChannelManagergetournodeid(JNIEnv * _env, jclass _b, jlong this_arg) { + LDKChannelManager* this_arg_conv = (LDKChannelManager*)this_arg; + LDKPublicKey* ret = malloc(sizeof(LDKPublicKey)); + *ret = ChannelManager_get_our_node_id(this_arg_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL ChannelManagerchannelmonitorupdated(JNIEnv * _env, jclass _b, jlong this_arg, jlong funding_txo, jlong highest_applied_update_id) { + LDKChannelManager* this_arg_conv = (LDKChannelManager*)this_arg; + LDKOutPoint* funding_txo_conv = (LDKOutPoint*)funding_txo; + return ChannelManager_channel_monitor_updated(this_arg_conv, funding_txo_conv, highest_applied_update_id); +} + +JNIEXPORT jlong JNICALL ChannelManagerasMessageSendEventsProvider(JNIEnv * _env, jclass _b, jlong this_arg) { + LDKChannelManager* this_arg_conv = (LDKChannelManager*)this_arg; + LDKMessageSendEventsProvider* ret = malloc(sizeof(LDKMessageSendEventsProvider)); + *ret = ChannelManager_as_MessageSendEventsProvider(this_arg_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL ChannelManagerasEventsProvider(JNIEnv * _env, jclass _b, jlong this_arg) { + LDKChannelManager* this_arg_conv = (LDKChannelManager*)this_arg; + LDKEventsProvider* ret = malloc(sizeof(LDKEventsProvider)); + *ret = ChannelManager_as_EventsProvider(this_arg_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL ChannelManagerasChainListener(JNIEnv * _env, jclass _b, jlong this_arg) { + LDKChannelManager* this_arg_conv = (LDKChannelManager*)this_arg; + LDKChainListener* ret = malloc(sizeof(LDKChainListener)); + *ret = ChannelManager_as_ChainListener(this_arg_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL ChannelManagerasChannelMessageHandler(JNIEnv * _env, jclass _b, jlong this_arg) { + LDKChannelManager* this_arg_conv = (LDKChannelManager*)this_arg; + LDKChannelMessageHandler* ret = malloc(sizeof(LDKChannelMessageHandler)); + *ret = ChannelManager_as_ChannelMessageHandler(this_arg_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL ChannelMonitorUpdatefree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelMonitorUpdate this_ptr_conv = *(LDKChannelMonitorUpdate*)this_ptr; + return ChannelMonitorUpdate_free(this_ptr_conv); +} + +JNIEXPORT jlong JNICALL ChannelMonitorUpdategetupdateid(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelMonitorUpdate* this_ptr_conv = (LDKChannelMonitorUpdate*)this_ptr; + return ChannelMonitorUpdate_get_update_id(this_ptr_conv); +} + +JNIEXPORT void JNICALL ChannelMonitorUpdatesetupdateid(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKChannelMonitorUpdate* this_ptr_conv = (LDKChannelMonitorUpdate*)this_ptr; + return ChannelMonitorUpdate_set_update_id(this_ptr_conv, val); +} + +JNIEXPORT jlong JNICALL ChannelMonitorUpdatewrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKChannelMonitorUpdate* obj_conv = (LDKChannelMonitorUpdate*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = ChannelMonitorUpdate_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL ChannelMonitorUpdateread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKChannelMonitorUpdate* ret = malloc(sizeof(LDKChannelMonitorUpdate)); + *ret = ChannelMonitorUpdate_read(ser_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL MonitorUpdateErrorfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKMonitorUpdateError this_ptr_conv = *(LDKMonitorUpdateError*)this_ptr; + return MonitorUpdateError_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL HTLCUpdatefree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKHTLCUpdate this_ptr_conv = *(LDKHTLCUpdate*)this_ptr; + return HTLCUpdate_free(this_ptr_conv); +} + +JNIEXPORT jlong JNICALL HTLCUpdatewrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKHTLCUpdate* obj_conv = (LDKHTLCUpdate*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = HTLCUpdate_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL HTLCUpdateread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKHTLCUpdate* ret = malloc(sizeof(LDKHTLCUpdate)); + *ret = HTLCUpdate_read(ser_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL ChannelMonitorfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelMonitor this_ptr_conv = *(LDKChannelMonitor*)this_ptr; + return ChannelMonitor_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL ManyChannelMonitorfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKManyChannelMonitor this_ptr_conv = *(LDKManyChannelMonitor*)this_ptr; + return ManyChannelMonitor_free(this_ptr_conv); +} + +JNIEXPORT jlong JNICALL ChannelMonitorupdatemonitor(JNIEnv * _env, jclass _b, jlong this_arg, jlong updates, jlong broadcaster, jlong logger) { + LDKChannelMonitor* this_arg_conv = (LDKChannelMonitor*)this_arg; + LDKChannelMonitorUpdate updates_conv = *(LDKChannelMonitorUpdate*)updates; + LDKBroadcasterInterface* broadcaster_conv = (LDKBroadcasterInterface*)broadcaster; + LDKLogger* logger_conv = (LDKLogger*)logger; + LDKCResult_NoneMonitorUpdateErrorZ* ret = malloc(sizeof(LDKCResult_NoneMonitorUpdateErrorZ)); + *ret = ChannelMonitor_update_monitor(this_arg_conv, updates_conv, broadcaster_conv, logger_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL ChannelMonitorgetlatestupdateid(JNIEnv * _env, jclass _b, jlong this_arg) { + LDKChannelMonitor* this_arg_conv = (LDKChannelMonitor*)this_arg; + return ChannelMonitor_get_latest_update_id(this_arg_conv); +} + +JNIEXPORT jlong JNICALL ChannelMonitorgetfundingtxo(JNIEnv * _env, jclass _b, jlong this_arg) { + LDKChannelMonitor* this_arg_conv = (LDKChannelMonitor*)this_arg; + LDKC2Tuple_OutPointScriptZ* ret = malloc(sizeof(LDKC2Tuple_OutPointScriptZ)); + *ret = ChannelMonitor_get_funding_txo(this_arg_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL ChannelMonitorgetandclearpendinghtlcsupdated(JNIEnv * _env, jclass _b, jlong this_arg) { + LDKChannelMonitor* this_arg_conv = (LDKChannelMonitor*)this_arg; + LDKCVec_HTLCUpdateZ* ret = malloc(sizeof(LDKCVec_HTLCUpdateZ)); + *ret = ChannelMonitor_get_and_clear_pending_htlcs_updated(this_arg_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL ChannelMonitorgetandclearpendingevents(JNIEnv * _env, jclass _b, jlong this_arg) { + LDKChannelMonitor* this_arg_conv = (LDKChannelMonitor*)this_arg; + LDKCVec_EventZ* ret = malloc(sizeof(LDKCVec_EventZ)); + *ret = ChannelMonitor_get_and_clear_pending_events(this_arg_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL ChannelMonitorgetlatestlocalcommitmenttxn(JNIEnv * _env, jclass _b, jlong this_arg, jlong logger) { + LDKChannelMonitor* this_arg_conv = (LDKChannelMonitor*)this_arg; + LDKLogger* logger_conv = (LDKLogger*)logger; + LDKCVec_TransactionZ* ret = malloc(sizeof(LDKCVec_TransactionZ)); + *ret = ChannelMonitor_get_latest_local_commitment_txn(this_arg_conv, logger_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL DecodeErrorfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKDecodeError this_ptr_conv = *(LDKDecodeError*)this_ptr; + return DecodeError_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL Initfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKInit this_ptr_conv = *(LDKInit*)this_ptr; + return Init_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL ErrorMessagefree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKErrorMessage this_ptr_conv = *(LDKErrorMessage*)this_ptr; + return ErrorMessage_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL Pingfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKPing this_ptr_conv = *(LDKPing*)this_ptr; + return Ping_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL Pongfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKPong this_ptr_conv = *(LDKPong*)this_ptr; + return Pong_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL OpenChannelfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKOpenChannel this_ptr_conv = *(LDKOpenChannel*)this_ptr; + return OpenChannel_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL AcceptChannelfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKAcceptChannel this_ptr_conv = *(LDKAcceptChannel*)this_ptr; + return AcceptChannel_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL FundingCreatedfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKFundingCreated this_ptr_conv = *(LDKFundingCreated*)this_ptr; + return FundingCreated_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL FundingSignedfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKFundingSigned this_ptr_conv = *(LDKFundingSigned*)this_ptr; + return FundingSigned_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL FundingLockedfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKFundingLocked this_ptr_conv = *(LDKFundingLocked*)this_ptr; + return FundingLocked_free(this_ptr_conv); +} + +JNIEXPORT jbyteArray JNICALL FundingLockedgetchannelid(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKFundingLocked* this_ptr_conv = (LDKFundingLocked*)this_ptr; + jbyteArray ret_arr = (*_env)->NewByteArray(_env, 0); // XXX: len 0 + (*_env)->SetByteArrayRegion(_env, ret_arr, 0, 32, *FundingLocked_get_channel_id(this_ptr_conv)); + return ret_arr; +} + +JNIEXPORT void JNICALL FundingLockedsetchannelid(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKFundingLocked* this_ptr_conv = (LDKFundingLocked*)this_ptr; + LDKThirtyTwoBytes val_conv = *(LDKThirtyTwoBytes*)val; + return FundingLocked_set_channel_id(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL FundingLockedgetnextpercommitmentpoint(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKFundingLocked* this_ptr_conv = (LDKFundingLocked*)this_ptr; + LDKPublicKey* ret = malloc(sizeof(LDKPublicKey)); + *ret = FundingLocked_get_next_per_commitment_point(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL FundingLockedsetnextpercommitmentpoint(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKFundingLocked* this_ptr_conv = (LDKFundingLocked*)this_ptr; + LDKPublicKey val_conv = *(LDKPublicKey*)val; + return FundingLocked_set_next_per_commitment_point(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL FundingLockednew(JNIEnv * _env, jclass _b, jlong channel_id_arg, jlong next_per_commitment_point_arg) { + LDKThirtyTwoBytes channel_id_arg_conv = *(LDKThirtyTwoBytes*)channel_id_arg; + LDKPublicKey next_per_commitment_point_arg_conv = *(LDKPublicKey*)next_per_commitment_point_arg; + LDKFundingLocked* ret = malloc(sizeof(LDKFundingLocked)); + *ret = FundingLocked_new(channel_id_arg_conv, next_per_commitment_point_arg_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL Shutdownfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKShutdown this_ptr_conv = *(LDKShutdown*)this_ptr; + return Shutdown_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL ClosingSignedfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKClosingSigned this_ptr_conv = *(LDKClosingSigned*)this_ptr; + return ClosingSigned_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL UpdateAddHTLCfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKUpdateAddHTLC this_ptr_conv = *(LDKUpdateAddHTLC*)this_ptr; + return UpdateAddHTLC_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL UpdateFulfillHTLCfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKUpdateFulfillHTLC this_ptr_conv = *(LDKUpdateFulfillHTLC*)this_ptr; + return UpdateFulfillHTLC_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL UpdateFailHTLCfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKUpdateFailHTLC this_ptr_conv = *(LDKUpdateFailHTLC*)this_ptr; + return UpdateFailHTLC_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL UpdateFailMalformedHTLCfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKUpdateFailMalformedHTLC this_ptr_conv = *(LDKUpdateFailMalformedHTLC*)this_ptr; + return UpdateFailMalformedHTLC_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL CommitmentSignedfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKCommitmentSigned this_ptr_conv = *(LDKCommitmentSigned*)this_ptr; + return CommitmentSigned_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL RevokeAndACKfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKRevokeAndACK this_ptr_conv = *(LDKRevokeAndACK*)this_ptr; + return RevokeAndACK_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL UpdateFeefree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKUpdateFee this_ptr_conv = *(LDKUpdateFee*)this_ptr; + return UpdateFee_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL ChannelReestablishfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelReestablish this_ptr_conv = *(LDKChannelReestablish*)this_ptr; + return ChannelReestablish_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL AnnouncementSignaturesfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKAnnouncementSignatures this_ptr_conv = *(LDKAnnouncementSignatures*)this_ptr; + return AnnouncementSignatures_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL NetAddressfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKNetAddress this_ptr_conv = *(LDKNetAddress*)this_ptr; + return NetAddress_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL UnsignedNodeAnnouncementfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKUnsignedNodeAnnouncement this_ptr_conv = *(LDKUnsignedNodeAnnouncement*)this_ptr; + return UnsignedNodeAnnouncement_free(this_ptr_conv); +} + +JNIEXPORT jlong JNICALL UnsignedNodeAnnouncementgetnodeid(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKUnsignedNodeAnnouncement* this_ptr_conv = (LDKUnsignedNodeAnnouncement*)this_ptr; + LDKPublicKey* ret = malloc(sizeof(LDKPublicKey)); + *ret = UnsignedNodeAnnouncement_get_node_id(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL UnsignedNodeAnnouncementsetnodeid(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKUnsignedNodeAnnouncement* this_ptr_conv = (LDKUnsignedNodeAnnouncement*)this_ptr; + LDKPublicKey val_conv = *(LDKPublicKey*)val; + return UnsignedNodeAnnouncement_set_node_id(this_ptr_conv, val_conv); +} + +JNIEXPORT void JNICALL NodeAnnouncementfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKNodeAnnouncement this_ptr_conv = *(LDKNodeAnnouncement*)this_ptr; + return NodeAnnouncement_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL UnsignedChannelAnnouncementfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKUnsignedChannelAnnouncement this_ptr_conv = *(LDKUnsignedChannelAnnouncement*)this_ptr; + return UnsignedChannelAnnouncement_free(this_ptr_conv); +} + +JNIEXPORT jlong JNICALL UnsignedChannelAnnouncementgetnodeid1(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKUnsignedChannelAnnouncement* this_ptr_conv = (LDKUnsignedChannelAnnouncement*)this_ptr; + LDKPublicKey* ret = malloc(sizeof(LDKPublicKey)); + *ret = UnsignedChannelAnnouncement_get_node_id_1(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL UnsignedChannelAnnouncementsetnodeid1(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKUnsignedChannelAnnouncement* this_ptr_conv = (LDKUnsignedChannelAnnouncement*)this_ptr; + LDKPublicKey val_conv = *(LDKPublicKey*)val; + return UnsignedChannelAnnouncement_set_node_id_1(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL UnsignedChannelAnnouncementgetnodeid2(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKUnsignedChannelAnnouncement* this_ptr_conv = (LDKUnsignedChannelAnnouncement*)this_ptr; + LDKPublicKey* ret = malloc(sizeof(LDKPublicKey)); + *ret = UnsignedChannelAnnouncement_get_node_id_2(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL UnsignedChannelAnnouncementsetnodeid2(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKUnsignedChannelAnnouncement* this_ptr_conv = (LDKUnsignedChannelAnnouncement*)this_ptr; + LDKPublicKey val_conv = *(LDKPublicKey*)val; + return UnsignedChannelAnnouncement_set_node_id_2(this_ptr_conv, val_conv); +} + +JNIEXPORT void JNICALL ChannelAnnouncementfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelAnnouncement this_ptr_conv = *(LDKChannelAnnouncement*)this_ptr; + return ChannelAnnouncement_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL ChannelUpdatefree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelUpdate this_ptr_conv = *(LDKChannelUpdate*)this_ptr; + return ChannelUpdate_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL ErrorActionfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKErrorAction this_ptr_conv = *(LDKErrorAction*)this_ptr; + return ErrorAction_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL LightningErrorfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKLightningError this_ptr_conv = *(LDKLightningError*)this_ptr; + return LightningError_free(this_ptr_conv); +} + +JNIEXPORT jlong JNICALL LightningErrorgeterr(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKLightningError* this_ptr_conv = (LDKLightningError*)this_ptr; + LDKStr* ret = malloc(sizeof(LDKStr)); + *ret = LightningError_get_err(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL LightningErrorseterr(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKLightningError* this_ptr_conv = (LDKLightningError*)this_ptr; + LDKCVec_u8Z val_conv = *(LDKCVec_u8Z*)val; + return LightningError_set_err(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL LightningErrorgetaction(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKLightningError* this_ptr_conv = (LDKLightningError*)this_ptr; + LDKErrorAction* ret = malloc(sizeof(LDKErrorAction)); + *ret = LightningError_get_action(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL LightningErrorsetaction(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKLightningError* this_ptr_conv = (LDKLightningError*)this_ptr; + LDKErrorAction val_conv = *(LDKErrorAction*)val; + return LightningError_set_action(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL LightningErrornew(JNIEnv * _env, jclass _b, jlong err_arg, jlong action_arg) { + LDKCVec_u8Z err_arg_conv = *(LDKCVec_u8Z*)err_arg; + LDKErrorAction action_arg_conv = *(LDKErrorAction*)action_arg; + LDKLightningError* ret = malloc(sizeof(LDKLightningError)); + *ret = LightningError_new(err_arg_conv, action_arg_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL CommitmentUpdatefree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKCommitmentUpdate this_ptr_conv = *(LDKCommitmentUpdate*)this_ptr; + return CommitmentUpdate_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL CommitmentUpdatesetupdateaddhtlcs(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKCommitmentUpdate* this_ptr_conv = (LDKCommitmentUpdate*)this_ptr; + LDKCVec_UpdateAddHTLCZ val_conv = *(LDKCVec_UpdateAddHTLCZ*)val; + return CommitmentUpdate_set_update_add_htlcs(this_ptr_conv, val_conv); +} + +JNIEXPORT void JNICALL CommitmentUpdatesetupdatefulfillhtlcs(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKCommitmentUpdate* this_ptr_conv = (LDKCommitmentUpdate*)this_ptr; + LDKCVec_UpdateFulfillHTLCZ val_conv = *(LDKCVec_UpdateFulfillHTLCZ*)val; + return CommitmentUpdate_set_update_fulfill_htlcs(this_ptr_conv, val_conv); +} + +JNIEXPORT void JNICALL CommitmentUpdatesetupdatefailhtlcs(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKCommitmentUpdate* this_ptr_conv = (LDKCommitmentUpdate*)this_ptr; + LDKCVec_UpdateFailHTLCZ val_conv = *(LDKCVec_UpdateFailHTLCZ*)val; + return CommitmentUpdate_set_update_fail_htlcs(this_ptr_conv, val_conv); +} + +JNIEXPORT void JNICALL CommitmentUpdatesetupdatefailmalformedhtlcs(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKCommitmentUpdate* this_ptr_conv = (LDKCommitmentUpdate*)this_ptr; + LDKCVec_UpdateFailMalformedHTLCZ val_conv = *(LDKCVec_UpdateFailMalformedHTLCZ*)val; + return CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL CommitmentUpdategetupdatefee(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKCommitmentUpdate* this_ptr_conv = (LDKCommitmentUpdate*)this_ptr; + LDKUpdateFee* ret = malloc(sizeof(LDKUpdateFee)); + *ret = CommitmentUpdate_get_update_fee(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL CommitmentUpdatesetupdatefee(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKCommitmentUpdate* this_ptr_conv = (LDKCommitmentUpdate*)this_ptr; + LDKUpdateFee val_conv = *(LDKUpdateFee*)val; + return CommitmentUpdate_set_update_fee(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL CommitmentUpdategetcommitmentsigned(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKCommitmentUpdate* this_ptr_conv = (LDKCommitmentUpdate*)this_ptr; + LDKCommitmentSigned* ret = malloc(sizeof(LDKCommitmentSigned)); + *ret = CommitmentUpdate_get_commitment_signed(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL CommitmentUpdatesetcommitmentsigned(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKCommitmentUpdate* this_ptr_conv = (LDKCommitmentUpdate*)this_ptr; + LDKCommitmentSigned val_conv = *(LDKCommitmentSigned*)val; + return CommitmentUpdate_set_commitment_signed(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL CommitmentUpdatenew(JNIEnv * _env, jclass _b, jlong update_add_htlcs_arg, jlong update_fulfill_htlcs_arg, jlong update_fail_htlcs_arg, jlong update_fail_malformed_htlcs_arg, jlong update_fee_arg, jlong commitment_signed_arg) { + LDKCVec_UpdateAddHTLCZ update_add_htlcs_arg_conv = *(LDKCVec_UpdateAddHTLCZ*)update_add_htlcs_arg; + LDKCVec_UpdateFulfillHTLCZ update_fulfill_htlcs_arg_conv = *(LDKCVec_UpdateFulfillHTLCZ*)update_fulfill_htlcs_arg; + LDKCVec_UpdateFailHTLCZ update_fail_htlcs_arg_conv = *(LDKCVec_UpdateFailHTLCZ*)update_fail_htlcs_arg; + LDKCVec_UpdateFailMalformedHTLCZ update_fail_malformed_htlcs_arg_conv = *(LDKCVec_UpdateFailMalformedHTLCZ*)update_fail_malformed_htlcs_arg; + LDKUpdateFee update_fee_arg_conv = *(LDKUpdateFee*)update_fee_arg; + LDKCommitmentSigned commitment_signed_arg_conv = *(LDKCommitmentSigned*)commitment_signed_arg; + LDKCommitmentUpdate* ret = malloc(sizeof(LDKCommitmentUpdate)); + *ret = CommitmentUpdate_new(update_add_htlcs_arg_conv, update_fulfill_htlcs_arg_conv, update_fail_htlcs_arg_conv, update_fail_malformed_htlcs_arg_conv, update_fee_arg_conv, commitment_signed_arg_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL HTLCFailChannelUpdatefree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKHTLCFailChannelUpdate this_ptr_conv = *(LDKHTLCFailChannelUpdate*)this_ptr; + return HTLCFailChannelUpdate_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL ChannelMessageHandlerfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelMessageHandler this_ptr_conv = *(LDKChannelMessageHandler*)this_ptr; + return ChannelMessageHandler_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL RoutingMessageHandlerfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKRoutingMessageHandler this_ptr_conv = *(LDKRoutingMessageHandler*)this_ptr; + return RoutingMessageHandler_free(this_ptr_conv); +} + +JNIEXPORT jlong JNICALL AcceptChannelwrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKAcceptChannel* obj_conv = (LDKAcceptChannel*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = AcceptChannel_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL AcceptChannelread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKAcceptChannel* ret = malloc(sizeof(LDKAcceptChannel)); + *ret = AcceptChannel_read(ser_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL AnnouncementSignatureswrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKAnnouncementSignatures* obj_conv = (LDKAnnouncementSignatures*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = AnnouncementSignatures_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL AnnouncementSignaturesread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKAnnouncementSignatures* ret = malloc(sizeof(LDKAnnouncementSignatures)); + *ret = AnnouncementSignatures_read(ser_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL ChannelReestablishwrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKChannelReestablish* obj_conv = (LDKChannelReestablish*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = ChannelReestablish_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL ChannelReestablishread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKChannelReestablish* ret = malloc(sizeof(LDKChannelReestablish)); + *ret = ChannelReestablish_read(ser_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL ClosingSignedwrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKClosingSigned* obj_conv = (LDKClosingSigned*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = ClosingSigned_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL ClosingSignedread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKClosingSigned* ret = malloc(sizeof(LDKClosingSigned)); + *ret = ClosingSigned_read(ser_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL CommitmentSignedwrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKCommitmentSigned* obj_conv = (LDKCommitmentSigned*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = CommitmentSigned_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL CommitmentSignedread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKCommitmentSigned* ret = malloc(sizeof(LDKCommitmentSigned)); + *ret = CommitmentSigned_read(ser_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL FundingCreatedwrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKFundingCreated* obj_conv = (LDKFundingCreated*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = FundingCreated_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL FundingCreatedread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKFundingCreated* ret = malloc(sizeof(LDKFundingCreated)); + *ret = FundingCreated_read(ser_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL FundingSignedwrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKFundingSigned* obj_conv = (LDKFundingSigned*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = FundingSigned_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL FundingSignedread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKFundingSigned* ret = malloc(sizeof(LDKFundingSigned)); + *ret = FundingSigned_read(ser_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL FundingLockedwrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKFundingLocked* obj_conv = (LDKFundingLocked*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = FundingLocked_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL FundingLockedread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKFundingLocked* ret = malloc(sizeof(LDKFundingLocked)); + *ret = FundingLocked_read(ser_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL Initwrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKInit* obj_conv = (LDKInit*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = Init_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL Initread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKInit* ret = malloc(sizeof(LDKInit)); + *ret = Init_read(ser_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL OpenChannelwrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKOpenChannel* obj_conv = (LDKOpenChannel*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = OpenChannel_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL OpenChannelread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKOpenChannel* ret = malloc(sizeof(LDKOpenChannel)); + *ret = OpenChannel_read(ser_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL RevokeAndACKwrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKRevokeAndACK* obj_conv = (LDKRevokeAndACK*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = RevokeAndACK_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL RevokeAndACKread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKRevokeAndACK* ret = malloc(sizeof(LDKRevokeAndACK)); + *ret = RevokeAndACK_read(ser_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL Shutdownwrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKShutdown* obj_conv = (LDKShutdown*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = Shutdown_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL Shutdownread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKShutdown* ret = malloc(sizeof(LDKShutdown)); + *ret = Shutdown_read(ser_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL UpdateFailHTLCwrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKUpdateFailHTLC* obj_conv = (LDKUpdateFailHTLC*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = UpdateFailHTLC_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL UpdateFailHTLCread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKUpdateFailHTLC* ret = malloc(sizeof(LDKUpdateFailHTLC)); + *ret = UpdateFailHTLC_read(ser_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL UpdateFailMalformedHTLCwrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKUpdateFailMalformedHTLC* obj_conv = (LDKUpdateFailMalformedHTLC*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = UpdateFailMalformedHTLC_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL UpdateFailMalformedHTLCread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKUpdateFailMalformedHTLC* ret = malloc(sizeof(LDKUpdateFailMalformedHTLC)); + *ret = UpdateFailMalformedHTLC_read(ser_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL UpdateFeewrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKUpdateFee* obj_conv = (LDKUpdateFee*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = UpdateFee_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL UpdateFeeread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKUpdateFee* ret = malloc(sizeof(LDKUpdateFee)); + *ret = UpdateFee_read(ser_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL UpdateFulfillHTLCwrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKUpdateFulfillHTLC* obj_conv = (LDKUpdateFulfillHTLC*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = UpdateFulfillHTLC_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL UpdateFulfillHTLCread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKUpdateFulfillHTLC* ret = malloc(sizeof(LDKUpdateFulfillHTLC)); + *ret = UpdateFulfillHTLC_read(ser_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL UpdateAddHTLCwrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKUpdateAddHTLC* obj_conv = (LDKUpdateAddHTLC*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = UpdateAddHTLC_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL UpdateAddHTLCread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKUpdateAddHTLC* ret = malloc(sizeof(LDKUpdateAddHTLC)); + *ret = UpdateAddHTLC_read(ser_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL Pingwrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKPing* obj_conv = (LDKPing*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = Ping_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL Pingread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKPing* ret = malloc(sizeof(LDKPing)); + *ret = Ping_read(ser_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL Pongwrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKPong* obj_conv = (LDKPong*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = Pong_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL Pongread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKPong* ret = malloc(sizeof(LDKPong)); + *ret = Pong_read(ser_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL UnsignedChannelAnnouncementwrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKUnsignedChannelAnnouncement* obj_conv = (LDKUnsignedChannelAnnouncement*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = UnsignedChannelAnnouncement_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL UnsignedChannelAnnouncementread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKUnsignedChannelAnnouncement* ret = malloc(sizeof(LDKUnsignedChannelAnnouncement)); + *ret = UnsignedChannelAnnouncement_read(ser_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL ChannelAnnouncementwrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKChannelAnnouncement* obj_conv = (LDKChannelAnnouncement*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = ChannelAnnouncement_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL ChannelAnnouncementread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKChannelAnnouncement* ret = malloc(sizeof(LDKChannelAnnouncement)); + *ret = ChannelAnnouncement_read(ser_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL ChannelUpdatewrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKChannelUpdate* obj_conv = (LDKChannelUpdate*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = ChannelUpdate_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL ChannelUpdateread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKChannelUpdate* ret = malloc(sizeof(LDKChannelUpdate)); + *ret = ChannelUpdate_read(ser_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL ErrorMessagewrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKErrorMessage* obj_conv = (LDKErrorMessage*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = ErrorMessage_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL ErrorMessageread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKErrorMessage* ret = malloc(sizeof(LDKErrorMessage)); + *ret = ErrorMessage_read(ser_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL UnsignedNodeAnnouncementwrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKUnsignedNodeAnnouncement* obj_conv = (LDKUnsignedNodeAnnouncement*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = UnsignedNodeAnnouncement_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL UnsignedNodeAnnouncementread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKUnsignedNodeAnnouncement* ret = malloc(sizeof(LDKUnsignedNodeAnnouncement)); + *ret = UnsignedNodeAnnouncement_read(ser_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL NodeAnnouncementwrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKNodeAnnouncement* obj_conv = (LDKNodeAnnouncement*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = NodeAnnouncement_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL NodeAnnouncementread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKNodeAnnouncement* ret = malloc(sizeof(LDKNodeAnnouncement)); + *ret = NodeAnnouncement_read(ser_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL MessageHandlerfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKMessageHandler this_ptr_conv = *(LDKMessageHandler*)this_ptr; + return MessageHandler_free(this_ptr_conv); +} + +JNIEXPORT jlong JNICALL MessageHandlergetchanhandler(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKMessageHandler* this_ptr_conv = (LDKMessageHandler*)this_ptr; + return (long) MessageHandler_get_chan_handler(this_ptr_conv); +} + +JNIEXPORT void JNICALL MessageHandlersetchanhandler(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKMessageHandler* this_ptr_conv = (LDKMessageHandler*)this_ptr; + LDKChannelMessageHandler val_conv = *(LDKChannelMessageHandler*)val; + return MessageHandler_set_chan_handler(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL MessageHandlergetroutehandler(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKMessageHandler* this_ptr_conv = (LDKMessageHandler*)this_ptr; + return (long) MessageHandler_get_route_handler(this_ptr_conv); +} + +JNIEXPORT void JNICALL MessageHandlersetroutehandler(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKMessageHandler* this_ptr_conv = (LDKMessageHandler*)this_ptr; + LDKRoutingMessageHandler val_conv = *(LDKRoutingMessageHandler*)val; + return MessageHandler_set_route_handler(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL MessageHandlernew(JNIEnv * _env, jclass _b, jlong chan_handler_arg, jlong route_handler_arg) { + LDKChannelMessageHandler chan_handler_arg_conv = *(LDKChannelMessageHandler*)chan_handler_arg; + LDKRoutingMessageHandler route_handler_arg_conv = *(LDKRoutingMessageHandler*)route_handler_arg; + LDKMessageHandler* ret = malloc(sizeof(LDKMessageHandler)); + *ret = MessageHandler_new(chan_handler_arg_conv, route_handler_arg_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL SocketDescriptorfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKSocketDescriptor this_ptr_conv = *(LDKSocketDescriptor*)this_ptr; + return SocketDescriptor_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL PeerHandleErrorfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKPeerHandleError this_ptr_conv = *(LDKPeerHandleError*)this_ptr; + return PeerHandleError_free(this_ptr_conv); +} + +JNIEXPORT jboolean JNICALL PeerHandleErrorgetnoconnectionpossible(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKPeerHandleError* this_ptr_conv = (LDKPeerHandleError*)this_ptr; + return PeerHandleError_get_no_connection_possible(this_ptr_conv); +} + +JNIEXPORT void JNICALL PeerHandleErrorsetnoconnectionpossible(JNIEnv * _env, jclass _b, jlong this_ptr, jboolean va) { + LDKPeerHandleError* this_ptr_conv = (LDKPeerHandleError*)this_ptr; + return PeerHandleError_set_no_connection_possible(this_ptr_conv, va); +} + +JNIEXPORT jlong JNICALL PeerHandleErrornew(JNIEnv * _env, jclass _b, jboolean no_connection_possible_arg) { + LDKPeerHandleError* ret = malloc(sizeof(LDKPeerHandleError)); + *ret = PeerHandleError_new(no_connection_possible_arg); + return (long)ret; +} + +JNIEXPORT void JNICALL PeerManagerfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKPeerManager this_ptr_conv = *(LDKPeerManager*)this_ptr; + return PeerManager_free(this_ptr_conv); +} + +JNIEXPORT jlong JNICALL PeerManagernew(JNIEnv * _env, jclass _b, jlong message_handler, jlong our_node_secret, jbyteArray ephemeral_random_data, jlong logger) { + LDKMessageHandler message_handler_conv = *(LDKMessageHandler*)message_handler; + LDKSecretKey our_node_secret_conv = *(LDKSecretKey*)our_node_secret; + unsigned char ephemeral_random_data_arr[32]; + (*_env)->GetByteArrayRegion (_env, ephemeral_random_data, 0, 32, ephemeral_random_data_arr); + unsigned char (*ephemeral_random_data_ref)[32] = &ephemeral_random_data_arr; + LDKLogger logger_conv = *(LDKLogger*)logger; + LDKPeerManager* ret = malloc(sizeof(LDKPeerManager)); + *ret = PeerManager_new(message_handler_conv, our_node_secret_conv, ephemeral_random_data_ref, logger_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL PeerManagergetpeernodeids(JNIEnv * _env, jclass _b, jlong this_arg) { + LDKPeerManager* this_arg_conv = (LDKPeerManager*)this_arg; + LDKCVec_PublicKeyZ* ret = malloc(sizeof(LDKCVec_PublicKeyZ)); + *ret = PeerManager_get_peer_node_ids(this_arg_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL PeerManagernewoutboundconnection(JNIEnv * _env, jclass _b, jlong this_arg, jlong their_node_id, jlong descriptor) { + LDKPeerManager* this_arg_conv = (LDKPeerManager*)this_arg; + LDKPublicKey their_node_id_conv = *(LDKPublicKey*)their_node_id; + LDKSocketDescriptor descriptor_conv = *(LDKSocketDescriptor*)descriptor; + LDKCResult_CVec_u8ZPeerHandleErrorZ* ret = malloc(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ)); + *ret = PeerManager_new_outbound_connection(this_arg_conv, their_node_id_conv, descriptor_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL PeerManagernewinboundconnection(JNIEnv * _env, jclass _b, jlong this_arg, jlong descriptor) { + LDKPeerManager* this_arg_conv = (LDKPeerManager*)this_arg; + LDKSocketDescriptor descriptor_conv = *(LDKSocketDescriptor*)descriptor; + LDKCResult_NonePeerHandleErrorZ* ret = malloc(sizeof(LDKCResult_NonePeerHandleErrorZ)); + *ret = PeerManager_new_inbound_connection(this_arg_conv, descriptor_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL PeerManagerwritebufferspaceavail(JNIEnv * _env, jclass _b, jlong this_arg, jlong descriptor) { + LDKPeerManager* this_arg_conv = (LDKPeerManager*)this_arg; + LDKSocketDescriptor* descriptor_conv = (LDKSocketDescriptor*)descriptor; + LDKCResult_NonePeerHandleErrorZ* ret = malloc(sizeof(LDKCResult_NonePeerHandleErrorZ)); + *ret = PeerManager_write_buffer_space_avail(this_arg_conv, descriptor_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL PeerManagerreadevent(JNIEnv * _env, jclass _b, jlong this_arg, jlong peer_descriptor, jlong data) { + LDKPeerManager* this_arg_conv = (LDKPeerManager*)this_arg; + LDKSocketDescriptor* peer_descriptor_conv = (LDKSocketDescriptor*)peer_descriptor; + LDKu8slice data_conv = *(LDKu8slice*)data; + LDKCResult_boolPeerHandleErrorZ* ret = malloc(sizeof(LDKCResult_boolPeerHandleErrorZ)); + *ret = PeerManager_read_event(this_arg_conv, peer_descriptor_conv, data_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL PeerManagerprocessevents(JNIEnv * _env, jclass _b, jlong this_arg) { + LDKPeerManager* this_arg_conv = (LDKPeerManager*)this_arg; + return PeerManager_process_events(this_arg_conv); +} + +JNIEXPORT void JNICALL PeerManagersocketdisconnected(JNIEnv * _env, jclass _b, jlong this_arg, jlong descriptor) { + LDKPeerManager* this_arg_conv = (LDKPeerManager*)this_arg; + LDKSocketDescriptor* descriptor_conv = (LDKSocketDescriptor*)descriptor; + return PeerManager_socket_disconnected(this_arg_conv, descriptor_conv); +} + +JNIEXPORT void JNICALL PeerManagertimertickoccured(JNIEnv * _env, jclass _b, jlong this_arg) { + LDKPeerManager* this_arg_conv = (LDKPeerManager*)this_arg; + return PeerManager_timer_tick_occured(this_arg_conv); +} + +JNIEXPORT jlong JNICALL buildcommitmentsecret(JNIEnv * _env, jclass _b, jbyteArray commitment_seed, jlong dx) { + unsigned char commitment_seed_arr[32]; + (*_env)->GetByteArrayRegion (_env, commitment_seed, 0, 32, commitment_seed_arr); + unsigned char (*commitment_seed_ref)[32] = &commitment_seed_arr; + LDKThirtyTwoBytes* ret = malloc(sizeof(LDKThirtyTwoBytes)); + *ret = build_commitment_secret(commitment_seed_ref, dx); + return (long)ret; +} + +JNIEXPORT void JNICALL TxCreationKeysfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKTxCreationKeys this_ptr_conv = *(LDKTxCreationKeys*)this_ptr; + return TxCreationKeys_free(this_ptr_conv); +} + +JNIEXPORT jlong JNICALL TxCreationKeysgetpercommitmentpoint(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKTxCreationKeys* this_ptr_conv = (LDKTxCreationKeys*)this_ptr; + LDKPublicKey* ret = malloc(sizeof(LDKPublicKey)); + *ret = TxCreationKeys_get_per_commitment_point(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL TxCreationKeyssetpercommitmentpoint(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKTxCreationKeys* this_ptr_conv = (LDKTxCreationKeys*)this_ptr; + LDKPublicKey val_conv = *(LDKPublicKey*)val; + return TxCreationKeys_set_per_commitment_point(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL TxCreationKeyswrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKTxCreationKeys* obj_conv = (LDKTxCreationKeys*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = TxCreationKeys_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL TxCreationKeysread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKTxCreationKeys* ret = malloc(sizeof(LDKTxCreationKeys)); + *ret = TxCreationKeys_read(ser_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL ChannelPublicKeysfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelPublicKeys this_ptr_conv = *(LDKChannelPublicKeys*)this_ptr; + return ChannelPublicKeys_free(this_ptr_conv); +} + +JNIEXPORT jlong JNICALL ChannelPublicKeysgetfundingpubkey(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelPublicKeys* this_ptr_conv = (LDKChannelPublicKeys*)this_ptr; + LDKPublicKey* ret = malloc(sizeof(LDKPublicKey)); + *ret = ChannelPublicKeys_get_funding_pubkey(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL ChannelPublicKeyssetfundingpubkey(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKChannelPublicKeys* this_ptr_conv = (LDKChannelPublicKeys*)this_ptr; + LDKPublicKey val_conv = *(LDKPublicKey*)val; + return ChannelPublicKeys_set_funding_pubkey(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL ChannelPublicKeysgetrevocationbasepoint(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelPublicKeys* this_ptr_conv = (LDKChannelPublicKeys*)this_ptr; + LDKPublicKey* ret = malloc(sizeof(LDKPublicKey)); + *ret = ChannelPublicKeys_get_revocation_basepoint(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL ChannelPublicKeyssetrevocationbasepoint(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKChannelPublicKeys* this_ptr_conv = (LDKChannelPublicKeys*)this_ptr; + LDKPublicKey val_conv = *(LDKPublicKey*)val; + return ChannelPublicKeys_set_revocation_basepoint(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL ChannelPublicKeysgetpaymentpoint(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelPublicKeys* this_ptr_conv = (LDKChannelPublicKeys*)this_ptr; + LDKPublicKey* ret = malloc(sizeof(LDKPublicKey)); + *ret = ChannelPublicKeys_get_payment_point(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL ChannelPublicKeyssetpaymentpoint(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKChannelPublicKeys* this_ptr_conv = (LDKChannelPublicKeys*)this_ptr; + LDKPublicKey val_conv = *(LDKPublicKey*)val; + return ChannelPublicKeys_set_payment_point(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL ChannelPublicKeysgetdelayedpaymentbasepoint(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelPublicKeys* this_ptr_conv = (LDKChannelPublicKeys*)this_ptr; + LDKPublicKey* ret = malloc(sizeof(LDKPublicKey)); + *ret = ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL ChannelPublicKeyssetdelayedpaymentbasepoint(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKChannelPublicKeys* this_ptr_conv = (LDKChannelPublicKeys*)this_ptr; + LDKPublicKey val_conv = *(LDKPublicKey*)val; + return ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL ChannelPublicKeysgethtlcbasepoint(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelPublicKeys* this_ptr_conv = (LDKChannelPublicKeys*)this_ptr; + LDKPublicKey* ret = malloc(sizeof(LDKPublicKey)); + *ret = ChannelPublicKeys_get_htlc_basepoint(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL ChannelPublicKeyssethtlcbasepoint(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKChannelPublicKeys* this_ptr_conv = (LDKChannelPublicKeys*)this_ptr; + LDKPublicKey val_conv = *(LDKPublicKey*)val; + return ChannelPublicKeys_set_htlc_basepoint(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL ChannelPublicKeysnew(JNIEnv * _env, jclass _b, jlong funding_pubkey_arg, jlong revocation_basepoint_arg, jlong payment_point_arg, jlong delayed_payment_basepoint_arg, jlong htlc_basepoint_arg) { + LDKPublicKey funding_pubkey_arg_conv = *(LDKPublicKey*)funding_pubkey_arg; + LDKPublicKey revocation_basepoint_arg_conv = *(LDKPublicKey*)revocation_basepoint_arg; + LDKPublicKey payment_point_arg_conv = *(LDKPublicKey*)payment_point_arg; + LDKPublicKey delayed_payment_basepoint_arg_conv = *(LDKPublicKey*)delayed_payment_basepoint_arg; + LDKPublicKey htlc_basepoint_arg_conv = *(LDKPublicKey*)htlc_basepoint_arg; + LDKChannelPublicKeys* ret = malloc(sizeof(LDKChannelPublicKeys)); + *ret = ChannelPublicKeys_new(funding_pubkey_arg_conv, revocation_basepoint_arg_conv, payment_point_arg_conv, delayed_payment_basepoint_arg_conv, htlc_basepoint_arg_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL ChannelPublicKeyswrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKChannelPublicKeys* obj_conv = (LDKChannelPublicKeys*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = ChannelPublicKeys_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL ChannelPublicKeysread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKChannelPublicKeys* ret = malloc(sizeof(LDKChannelPublicKeys)); + *ret = ChannelPublicKeys_read(ser_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL getrevokeableredeemscript(JNIEnv * _env, jclass _b, jlong revocation_key, jlong to_self_delay, jlong delayed_payment_key) { + LDKPublicKey revocation_key_conv = *(LDKPublicKey*)revocation_key; + uint16_t to_self_delay_conv = *(uint16_t*)to_self_delay; + LDKPublicKey delayed_payment_key_conv = *(LDKPublicKey*)delayed_payment_key; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = get_revokeable_redeemscript(revocation_key_conv, to_self_delay_conv, delayed_payment_key_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL HTLCOutputInCommitmentfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKHTLCOutputInCommitment this_ptr_conv = *(LDKHTLCOutputInCommitment*)this_ptr; + return HTLCOutputInCommitment_free(this_ptr_conv); +} + +JNIEXPORT jboolean JNICALL HTLCOutputInCommitmentgetoffered(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKHTLCOutputInCommitment* this_ptr_conv = (LDKHTLCOutputInCommitment*)this_ptr; + return HTLCOutputInCommitment_get_offered(this_ptr_conv); +} + +JNIEXPORT void JNICALL HTLCOutputInCommitmentsetoffered(JNIEnv * _env, jclass _b, jlong this_ptr, jboolean va) { + LDKHTLCOutputInCommitment* this_ptr_conv = (LDKHTLCOutputInCommitment*)this_ptr; + return HTLCOutputInCommitment_set_offered(this_ptr_conv, va); +} + +JNIEXPORT jlong JNICALL HTLCOutputInCommitmentgetamountmsat(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKHTLCOutputInCommitment* this_ptr_conv = (LDKHTLCOutputInCommitment*)this_ptr; + return HTLCOutputInCommitment_get_amount_msat(this_ptr_conv); +} + +JNIEXPORT void JNICALL HTLCOutputInCommitmentsetamountmsat(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKHTLCOutputInCommitment* this_ptr_conv = (LDKHTLCOutputInCommitment*)this_ptr; + return HTLCOutputInCommitment_set_amount_msat(this_ptr_conv, val); +} + +JNIEXPORT jint JNICALL HTLCOutputInCommitmentgetcltvexpiry(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKHTLCOutputInCommitment* this_ptr_conv = (LDKHTLCOutputInCommitment*)this_ptr; + return HTLCOutputInCommitment_get_cltv_expiry(this_ptr_conv); +} + +JNIEXPORT void JNICALL HTLCOutputInCommitmentsetcltvexpiry(JNIEnv * _env, jclass _b, jlong this_ptr, jint val) { + LDKHTLCOutputInCommitment* this_ptr_conv = (LDKHTLCOutputInCommitment*)this_ptr; + return HTLCOutputInCommitment_set_cltv_expiry(this_ptr_conv, val); +} + +JNIEXPORT jbyteArray JNICALL HTLCOutputInCommitmentgetpaymenthash(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKHTLCOutputInCommitment* this_ptr_conv = (LDKHTLCOutputInCommitment*)this_ptr; + jbyteArray ret_arr = (*_env)->NewByteArray(_env, 0); // XXX: len 0 + (*_env)->SetByteArrayRegion(_env, ret_arr, 0, 32, *HTLCOutputInCommitment_get_payment_hash(this_ptr_conv)); + return ret_arr; +} + +JNIEXPORT void JNICALL HTLCOutputInCommitmentsetpaymenthash(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKHTLCOutputInCommitment* this_ptr_conv = (LDKHTLCOutputInCommitment*)this_ptr; + LDKThirtyTwoBytes val_conv = *(LDKThirtyTwoBytes*)val; + return HTLCOutputInCommitment_set_payment_hash(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL HTLCOutputInCommitmentwrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKHTLCOutputInCommitment* obj_conv = (LDKHTLCOutputInCommitment*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = HTLCOutputInCommitment_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL HTLCOutputInCommitmentread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKHTLCOutputInCommitment* ret = malloc(sizeof(LDKHTLCOutputInCommitment)); + *ret = HTLCOutputInCommitment_read(ser_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL gethtlcredeemscript(JNIEnv * _env, jclass _b, jlong htlc, jlong keys) { + LDKHTLCOutputInCommitment* htlc_conv = (LDKHTLCOutputInCommitment*)htlc; + LDKTxCreationKeys* keys_conv = (LDKTxCreationKeys*)keys; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = get_htlc_redeemscript(htlc_conv, keys_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL makefundingredeemscript(JNIEnv * _env, jclass _b, jlong a, jlong b) { + LDKPublicKey a_conv = *(LDKPublicKey*)a; + LDKPublicKey b_conv = *(LDKPublicKey*)b; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = make_funding_redeemscript(a_conv, b_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL buildhtlctransaction(JNIEnv * _env, jclass _b, jbyteArray prev_hash, jint feerate_per_kw, jlong to_self_delay, jlong htlc, jlong a_delayed_payment_key, jlong revocation_key) { + unsigned char prev_hash_arr[32]; + (*_env)->GetByteArrayRegion (_env, prev_hash, 0, 32, prev_hash_arr); + unsigned char (*prev_hash_ref)[32] = &prev_hash_arr; + uint16_t to_self_delay_conv = *(uint16_t*)to_self_delay; + LDKHTLCOutputInCommitment* htlc_conv = (LDKHTLCOutputInCommitment*)htlc; + LDKPublicKey a_delayed_payment_key_conv = *(LDKPublicKey*)a_delayed_payment_key; + LDKPublicKey revocation_key_conv = *(LDKPublicKey*)revocation_key; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = build_htlc_transaction(prev_hash_ref, feerate_per_kw, to_self_delay_conv, htlc_conv, a_delayed_payment_key_conv, revocation_key_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL LocalCommitmentTransactionfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKLocalCommitmentTransaction this_ptr_conv = *(LDKLocalCommitmentTransaction*)this_ptr; + return LocalCommitmentTransaction_free(this_ptr_conv); +} + +JNIEXPORT jlong JNICALL LocalCommitmentTransactiongetunsignedtx(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKLocalCommitmentTransaction* this_ptr_conv = (LDKLocalCommitmentTransaction*)this_ptr; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = LocalCommitmentTransaction_get_unsigned_tx(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL LocalCommitmentTransactionsetunsignedtx(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKLocalCommitmentTransaction* this_ptr_conv = (LDKLocalCommitmentTransaction*)this_ptr; + LDKCVec_u8Z val_conv = *(LDKCVec_u8Z*)val; + return LocalCommitmentTransaction_set_unsigned_tx(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL LocalCommitmentTransactiongettheirsig(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKLocalCommitmentTransaction* this_ptr_conv = (LDKLocalCommitmentTransaction*)this_ptr; + LDKSignature* ret = malloc(sizeof(LDKSignature)); + *ret = LocalCommitmentTransaction_get_their_sig(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL LocalCommitmentTransactionsettheirsig(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKLocalCommitmentTransaction* this_ptr_conv = (LDKLocalCommitmentTransaction*)this_ptr; + LDKSignature val_conv = *(LDKSignature*)val; + return LocalCommitmentTransaction_set_their_sig(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL LocalCommitmentTransactiongetlocalkeys(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKLocalCommitmentTransaction* this_ptr_conv = (LDKLocalCommitmentTransaction*)this_ptr; + LDKTxCreationKeys* ret = malloc(sizeof(LDKTxCreationKeys)); + *ret = LocalCommitmentTransaction_get_local_keys(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL LocalCommitmentTransactionsetlocalkeys(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKLocalCommitmentTransaction* this_ptr_conv = (LDKLocalCommitmentTransaction*)this_ptr; + LDKTxCreationKeys val_conv = *(LDKTxCreationKeys*)val; + return LocalCommitmentTransaction_set_local_keys(this_ptr_conv, val_conv); +} + +JNIEXPORT jint JNICALL LocalCommitmentTransactiongetfeerateperkw(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKLocalCommitmentTransaction* this_ptr_conv = (LDKLocalCommitmentTransaction*)this_ptr; + return LocalCommitmentTransaction_get_feerate_per_kw(this_ptr_conv); +} + +JNIEXPORT void JNICALL LocalCommitmentTransactionsetfeerateperkw(JNIEnv * _env, jclass _b, jlong this_ptr, jint val) { + LDKLocalCommitmentTransaction* this_ptr_conv = (LDKLocalCommitmentTransaction*)this_ptr; + return LocalCommitmentTransaction_set_feerate_per_kw(this_ptr_conv, val); +} + +JNIEXPORT jlong JNICALL LocalCommitmentTransactiontxid(JNIEnv * _env, jclass _b, jlong this_arg) { + LDKLocalCommitmentTransaction* this_arg_conv = (LDKLocalCommitmentTransaction*)this_arg; + LDKThirtyTwoBytes* ret = malloc(sizeof(LDKThirtyTwoBytes)); + *ret = LocalCommitmentTransaction_txid(this_arg_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL LocalCommitmentTransactiongetlocalsig(JNIEnv * _env, jclass _b, jlong this_arg, jbyteArray funding_key, jlong funding_redeemscript, jlong channel_value_satoshis) { + LDKLocalCommitmentTransaction* this_arg_conv = (LDKLocalCommitmentTransaction*)this_arg; + unsigned char funding_key_arr[32]; + (*_env)->GetByteArrayRegion (_env, funding_key, 0, 32, funding_key_arr); + unsigned char (*funding_key_ref)[32] = &funding_key_arr; + LDKu8slice funding_redeemscript_conv = *(LDKu8slice*)funding_redeemscript; + LDKSignature* ret = malloc(sizeof(LDKSignature)); + *ret = LocalCommitmentTransaction_get_local_sig(this_arg_conv, funding_key_ref, funding_redeemscript_conv, channel_value_satoshis); + return (long)ret; +} + +JNIEXPORT jlong JNICALL LocalCommitmentTransactionwrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKLocalCommitmentTransaction* obj_conv = (LDKLocalCommitmentTransaction*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = LocalCommitmentTransaction_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL LocalCommitmentTransactionread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKLocalCommitmentTransaction* ret = malloc(sizeof(LDKLocalCommitmentTransaction)); + *ret = LocalCommitmentTransaction_read(ser_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL InitFeaturesfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKInitFeatures this_ptr_conv = *(LDKInitFeatures*)this_ptr; + return InitFeatures_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL NodeFeaturesfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKNodeFeatures this_ptr_conv = *(LDKNodeFeatures*)this_ptr; + return NodeFeatures_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL ChannelFeaturesfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelFeatures this_ptr_conv = *(LDKChannelFeatures*)this_ptr; + return ChannelFeatures_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL RouteHopfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKRouteHop this_ptr_conv = *(LDKRouteHop*)this_ptr; + return RouteHop_free(this_ptr_conv); +} + +JNIEXPORT jlong JNICALL RouteHopgetpubkey(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKRouteHop* this_ptr_conv = (LDKRouteHop*)this_ptr; + LDKPublicKey* ret = malloc(sizeof(LDKPublicKey)); + *ret = RouteHop_get_pubkey(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL RouteHopsetpubkey(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKRouteHop* this_ptr_conv = (LDKRouteHop*)this_ptr; + LDKPublicKey val_conv = *(LDKPublicKey*)val; + return RouteHop_set_pubkey(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL RouteHopgetshortchannelid(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKRouteHop* this_ptr_conv = (LDKRouteHop*)this_ptr; + return RouteHop_get_short_channel_id(this_ptr_conv); +} + +JNIEXPORT void JNICALL RouteHopsetshortchannelid(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKRouteHop* this_ptr_conv = (LDKRouteHop*)this_ptr; + return RouteHop_set_short_channel_id(this_ptr_conv, val); +} + +JNIEXPORT jlong JNICALL RouteHopgetfeemsat(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKRouteHop* this_ptr_conv = (LDKRouteHop*)this_ptr; + return RouteHop_get_fee_msat(this_ptr_conv); +} + +JNIEXPORT void JNICALL RouteHopsetfeemsat(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKRouteHop* this_ptr_conv = (LDKRouteHop*)this_ptr; + return RouteHop_set_fee_msat(this_ptr_conv, val); +} + +JNIEXPORT jint JNICALL RouteHopgetcltvexpirydelta(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKRouteHop* this_ptr_conv = (LDKRouteHop*)this_ptr; + return RouteHop_get_cltv_expiry_delta(this_ptr_conv); +} + +JNIEXPORT void JNICALL RouteHopsetcltvexpirydelta(JNIEnv * _env, jclass _b, jlong this_ptr, jint val) { + LDKRouteHop* this_ptr_conv = (LDKRouteHop*)this_ptr; + return RouteHop_set_cltv_expiry_delta(this_ptr_conv, val); +} + +JNIEXPORT void JNICALL Routefree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKRoute this_ptr_conv = *(LDKRoute*)this_ptr; + return Route_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL Routesetpaths(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKRoute* this_ptr_conv = (LDKRoute*)this_ptr; + LDKCVec_CVec_RouteHopZZ val_conv = *(LDKCVec_CVec_RouteHopZZ*)val; + return Route_set_paths(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL Routenew(JNIEnv * _env, jclass _b, jlong paths_arg) { + LDKCVec_CVec_RouteHopZZ paths_arg_conv = *(LDKCVec_CVec_RouteHopZZ*)paths_arg; + LDKRoute* ret = malloc(sizeof(LDKRoute)); + *ret = Route_new(paths_arg_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL Routewrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKRoute* obj_conv = (LDKRoute*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = Route_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL Routeread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKRoute* ret = malloc(sizeof(LDKRoute)); + *ret = Route_read(ser_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL RouteHintfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKRouteHint this_ptr_conv = *(LDKRouteHint*)this_ptr; + return RouteHint_free(this_ptr_conv); +} + +JNIEXPORT jlong JNICALL RouteHintgetsrcnodeid(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKRouteHint* this_ptr_conv = (LDKRouteHint*)this_ptr; + LDKPublicKey* ret = malloc(sizeof(LDKPublicKey)); + *ret = RouteHint_get_src_node_id(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL RouteHintsetsrcnodeid(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKRouteHint* this_ptr_conv = (LDKRouteHint*)this_ptr; + LDKPublicKey val_conv = *(LDKPublicKey*)val; + return RouteHint_set_src_node_id(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL RouteHintgetshortchannelid(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKRouteHint* this_ptr_conv = (LDKRouteHint*)this_ptr; + return RouteHint_get_short_channel_id(this_ptr_conv); +} + +JNIEXPORT void JNICALL RouteHintsetshortchannelid(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKRouteHint* this_ptr_conv = (LDKRouteHint*)this_ptr; + return RouteHint_set_short_channel_id(this_ptr_conv, val); +} + +JNIEXPORT jlong JNICALL RouteHintgetfees(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKRouteHint* this_ptr_conv = (LDKRouteHint*)this_ptr; + LDKRoutingFees* ret = malloc(sizeof(LDKRoutingFees)); + *ret = RouteHint_get_fees(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL RouteHintsetfees(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKRouteHint* this_ptr_conv = (LDKRouteHint*)this_ptr; + LDKRoutingFees val_conv = *(LDKRoutingFees*)val; + return RouteHint_set_fees(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL RouteHintgetcltvexpirydelta(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKRouteHint* this_ptr_conv = (LDKRouteHint*)this_ptr; + uint16_t* ret = malloc(sizeof(uint16_t)); + *ret = RouteHint_get_cltv_expiry_delta(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL RouteHintsetcltvexpirydelta(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKRouteHint* this_ptr_conv = (LDKRouteHint*)this_ptr; + uint16_t val_conv = *(uint16_t*)val; + return RouteHint_set_cltv_expiry_delta(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL RouteHintgethtlcminimummsat(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKRouteHint* this_ptr_conv = (LDKRouteHint*)this_ptr; + return RouteHint_get_htlc_minimum_msat(this_ptr_conv); +} + +JNIEXPORT void JNICALL RouteHintsethtlcminimummsat(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKRouteHint* this_ptr_conv = (LDKRouteHint*)this_ptr; + return RouteHint_set_htlc_minimum_msat(this_ptr_conv, val); +} + +JNIEXPORT jlong JNICALL RouteHintnew(JNIEnv * _env, jclass _b, jlong src_node_id_arg, jlong short_channel_id_arg, jlong fees_arg, jlong cltv_expiry_delta_arg, jlong htlc_minimum_msat_arg) { + LDKPublicKey src_node_id_arg_conv = *(LDKPublicKey*)src_node_id_arg; + LDKRoutingFees fees_arg_conv = *(LDKRoutingFees*)fees_arg; + uint16_t cltv_expiry_delta_arg_conv = *(uint16_t*)cltv_expiry_delta_arg; + LDKRouteHint* ret = malloc(sizeof(LDKRouteHint)); + *ret = RouteHint_new(src_node_id_arg_conv, short_channel_id_arg, fees_arg_conv, cltv_expiry_delta_arg_conv, htlc_minimum_msat_arg); + return (long)ret; +} + +JNIEXPORT jlong JNICALL getroute(JNIEnv * _env, jclass _b, jlong our_node_id, jlong network, jlong target, jlong first_hops, jlong last_hops, jlong final_value_msa, jint final_cltv, jlong logger) { + LDKPublicKey our_node_id_conv = *(LDKPublicKey*)our_node_id; + LDKNetworkGraph* network_conv = (LDKNetworkGraph*)network; + LDKPublicKey target_conv = *(LDKPublicKey*)target; + LDKCChannelDetailsSlice* first_hops_conv = (LDKCChannelDetailsSlice*)first_hops; + LDKCRouteHintSlice last_hops_conv = *(LDKCRouteHintSlice*)last_hops; + LDKLogger logger_conv = *(LDKLogger*)logger; + LDKCResult_RouteLightningErrorZ* ret = malloc(sizeof(LDKCResult_RouteLightningErrorZ)); + *ret = get_route(our_node_id_conv, network_conv, target_conv, first_hops_conv, last_hops_conv, final_value_msa, final_cltv, logger_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL NetworkGraphfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKNetworkGraph this_ptr_conv = *(LDKNetworkGraph*)this_ptr; + return NetworkGraph_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL NetGraphMsgHandlerfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKNetGraphMsgHandler this_ptr_conv = *(LDKNetGraphMsgHandler*)this_ptr; + return NetGraphMsgHandler_free(this_ptr_conv); +} + +JNIEXPORT jlong JNICALL NetGraphMsgHandlernew(JNIEnv * _env, jclass _b, jlong chain_monitor, jlong logger) { + LDKChainWatchInterface chain_monitor_conv = *(LDKChainWatchInterface*)chain_monitor; + LDKLogger logger_conv = *(LDKLogger*)logger; + LDKNetGraphMsgHandler* ret = malloc(sizeof(LDKNetGraphMsgHandler)); + *ret = NetGraphMsgHandler_new(chain_monitor_conv, logger_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL NetGraphMsgHandlerfromnetgraph(JNIEnv * _env, jclass _b, jlong chain_monitor, jlong logger, jlong network_graph) { + LDKChainWatchInterface chain_monitor_conv = *(LDKChainWatchInterface*)chain_monitor; + LDKLogger logger_conv = *(LDKLogger*)logger; + LDKNetworkGraph network_graph_conv = *(LDKNetworkGraph*)network_graph; + LDKNetGraphMsgHandler* ret = malloc(sizeof(LDKNetGraphMsgHandler)); + *ret = NetGraphMsgHandler_from_net_graph(chain_monitor_conv, logger_conv, network_graph_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL NetGraphMsgHandlerasRoutingMessageHandler(JNIEnv * _env, jclass _b, jlong this_arg) { + LDKNetGraphMsgHandler* this_arg_conv = (LDKNetGraphMsgHandler*)this_arg; + LDKRoutingMessageHandler* ret = malloc(sizeof(LDKRoutingMessageHandler)); + *ret = NetGraphMsgHandler_as_RoutingMessageHandler(this_arg_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL DirectionalChannelInfofree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKDirectionalChannelInfo this_ptr_conv = *(LDKDirectionalChannelInfo*)this_ptr; + return DirectionalChannelInfo_free(this_ptr_conv); +} + +JNIEXPORT jint JNICALL DirectionalChannelInfogetlastupdate(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKDirectionalChannelInfo* this_ptr_conv = (LDKDirectionalChannelInfo*)this_ptr; + return DirectionalChannelInfo_get_last_update(this_ptr_conv); +} + +JNIEXPORT void JNICALL DirectionalChannelInfosetlastupdate(JNIEnv * _env, jclass _b, jlong this_ptr, jint val) { + LDKDirectionalChannelInfo* this_ptr_conv = (LDKDirectionalChannelInfo*)this_ptr; + return DirectionalChannelInfo_set_last_update(this_ptr_conv, val); +} + +JNIEXPORT jboolean JNICALL DirectionalChannelInfogetenabled(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKDirectionalChannelInfo* this_ptr_conv = (LDKDirectionalChannelInfo*)this_ptr; + return DirectionalChannelInfo_get_enabled(this_ptr_conv); +} + +JNIEXPORT void JNICALL DirectionalChannelInfosetenabled(JNIEnv * _env, jclass _b, jlong this_ptr, jboolean va) { + LDKDirectionalChannelInfo* this_ptr_conv = (LDKDirectionalChannelInfo*)this_ptr; + return DirectionalChannelInfo_set_enabled(this_ptr_conv, va); +} + +JNIEXPORT jlong JNICALL DirectionalChannelInfogetcltvexpirydelta(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKDirectionalChannelInfo* this_ptr_conv = (LDKDirectionalChannelInfo*)this_ptr; + uint16_t* ret = malloc(sizeof(uint16_t)); + *ret = DirectionalChannelInfo_get_cltv_expiry_delta(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL DirectionalChannelInfosetcltvexpirydelta(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKDirectionalChannelInfo* this_ptr_conv = (LDKDirectionalChannelInfo*)this_ptr; + uint16_t val_conv = *(uint16_t*)val; + return DirectionalChannelInfo_set_cltv_expiry_delta(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL DirectionalChannelInfogethtlcminimummsat(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKDirectionalChannelInfo* this_ptr_conv = (LDKDirectionalChannelInfo*)this_ptr; + return DirectionalChannelInfo_get_htlc_minimum_msat(this_ptr_conv); +} + +JNIEXPORT void JNICALL DirectionalChannelInfosethtlcminimummsat(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKDirectionalChannelInfo* this_ptr_conv = (LDKDirectionalChannelInfo*)this_ptr; + return DirectionalChannelInfo_set_htlc_minimum_msat(this_ptr_conv, val); +} + +JNIEXPORT jlong JNICALL DirectionalChannelInfowrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKDirectionalChannelInfo* obj_conv = (LDKDirectionalChannelInfo*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = DirectionalChannelInfo_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL DirectionalChannelInforead(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKDirectionalChannelInfo* ret = malloc(sizeof(LDKDirectionalChannelInfo)); + *ret = DirectionalChannelInfo_read(ser_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL ChannelInfofree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelInfo this_ptr_conv = *(LDKChannelInfo*)this_ptr; + return ChannelInfo_free(this_ptr_conv); +} + +JNIEXPORT jlong JNICALL ChannelInfogetnodeone(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelInfo* this_ptr_conv = (LDKChannelInfo*)this_ptr; + LDKPublicKey* ret = malloc(sizeof(LDKPublicKey)); + *ret = ChannelInfo_get_node_one(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL ChannelInfosetnodeone(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKChannelInfo* this_ptr_conv = (LDKChannelInfo*)this_ptr; + LDKPublicKey val_conv = *(LDKPublicKey*)val; + return ChannelInfo_set_node_one(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL ChannelInfogetonetotwo(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelInfo* this_ptr_conv = (LDKChannelInfo*)this_ptr; + LDKDirectionalChannelInfo* ret = malloc(sizeof(LDKDirectionalChannelInfo)); + *ret = ChannelInfo_get_one_to_two(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL ChannelInfosetonetotwo(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKChannelInfo* this_ptr_conv = (LDKChannelInfo*)this_ptr; + LDKDirectionalChannelInfo val_conv = *(LDKDirectionalChannelInfo*)val; + return ChannelInfo_set_one_to_two(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL ChannelInfogetnodetwo(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelInfo* this_ptr_conv = (LDKChannelInfo*)this_ptr; + LDKPublicKey* ret = malloc(sizeof(LDKPublicKey)); + *ret = ChannelInfo_get_node_two(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL ChannelInfosetnodetwo(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKChannelInfo* this_ptr_conv = (LDKChannelInfo*)this_ptr; + LDKPublicKey val_conv = *(LDKPublicKey*)val; + return ChannelInfo_set_node_two(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL ChannelInfogettwotoone(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKChannelInfo* this_ptr_conv = (LDKChannelInfo*)this_ptr; + LDKDirectionalChannelInfo* ret = malloc(sizeof(LDKDirectionalChannelInfo)); + *ret = ChannelInfo_get_two_to_one(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL ChannelInfosettwotoone(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKChannelInfo* this_ptr_conv = (LDKChannelInfo*)this_ptr; + LDKDirectionalChannelInfo val_conv = *(LDKDirectionalChannelInfo*)val; + return ChannelInfo_set_two_to_one(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL ChannelInfowrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKChannelInfo* obj_conv = (LDKChannelInfo*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = ChannelInfo_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL ChannelInforead(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKChannelInfo* ret = malloc(sizeof(LDKChannelInfo)); + *ret = ChannelInfo_read(ser_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL RoutingFeesfree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKRoutingFees this_ptr_conv = *(LDKRoutingFees*)this_ptr; + return RoutingFees_free(this_ptr_conv); +} + +JNIEXPORT jint JNICALL RoutingFeesgetbasemsat(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKRoutingFees* this_ptr_conv = (LDKRoutingFees*)this_ptr; + return RoutingFees_get_base_msat(this_ptr_conv); +} + +JNIEXPORT void JNICALL RoutingFeessetbasemsat(JNIEnv * _env, jclass _b, jlong this_ptr, jint val) { + LDKRoutingFees* this_ptr_conv = (LDKRoutingFees*)this_ptr; + return RoutingFees_set_base_msat(this_ptr_conv, val); +} + +JNIEXPORT jint JNICALL RoutingFeesgetproportionalmillionths(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKRoutingFees* this_ptr_conv = (LDKRoutingFees*)this_ptr; + return RoutingFees_get_proportional_millionths(this_ptr_conv); +} + +JNIEXPORT void JNICALL RoutingFeessetproportionalmillionths(JNIEnv * _env, jclass _b, jlong this_ptr, jint val) { + LDKRoutingFees* this_ptr_conv = (LDKRoutingFees*)this_ptr; + return RoutingFees_set_proportional_millionths(this_ptr_conv, val); +} + +JNIEXPORT jlong JNICALL RoutingFeesnew(JNIEnv * _env, jclass _b, jint base_msat_arg, jint proportional_millionths_arg) { + LDKRoutingFees* ret = malloc(sizeof(LDKRoutingFees)); + *ret = RoutingFees_new(base_msat_arg, proportional_millionths_arg); + return (long)ret; +} + +JNIEXPORT jlong JNICALL RoutingFeesread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKRoutingFees* ret = malloc(sizeof(LDKRoutingFees)); + *ret = RoutingFees_read(ser_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL RoutingFeeswrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKRoutingFees* obj_conv = (LDKRoutingFees*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = RoutingFees_write(obj_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL NodeAnnouncementInfofree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKNodeAnnouncementInfo this_ptr_conv = *(LDKNodeAnnouncementInfo*)this_ptr; + return NodeAnnouncementInfo_free(this_ptr_conv); +} + +JNIEXPORT jint JNICALL NodeAnnouncementInfogetlastupdate(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKNodeAnnouncementInfo* this_ptr_conv = (LDKNodeAnnouncementInfo*)this_ptr; + return NodeAnnouncementInfo_get_last_update(this_ptr_conv); +} + +JNIEXPORT void JNICALL NodeAnnouncementInfosetlastupdate(JNIEnv * _env, jclass _b, jlong this_ptr, jint val) { + LDKNodeAnnouncementInfo* this_ptr_conv = (LDKNodeAnnouncementInfo*)this_ptr; + return NodeAnnouncementInfo_set_last_update(this_ptr_conv, val); +} + +JNIEXPORT jbyteArray JNICALL NodeAnnouncementInfogetrgb(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKNodeAnnouncementInfo* this_ptr_conv = (LDKNodeAnnouncementInfo*)this_ptr; + jbyteArray ret_arr = (*_env)->NewByteArray(_env, 0); // XXX: len 0 + (*_env)->SetByteArrayRegion(_env, ret_arr, 0, 3, *NodeAnnouncementInfo_get_rgb(this_ptr_conv)); + return ret_arr; +} + +JNIEXPORT void JNICALL NodeAnnouncementInfosetrgb(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKNodeAnnouncementInfo* this_ptr_conv = (LDKNodeAnnouncementInfo*)this_ptr; + LDKThreeBytes val_conv = *(LDKThreeBytes*)val; + return NodeAnnouncementInfo_set_rgb(this_ptr_conv, val_conv); +} + +JNIEXPORT jbyteArray JNICALL NodeAnnouncementInfogetalias(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKNodeAnnouncementInfo* this_ptr_conv = (LDKNodeAnnouncementInfo*)this_ptr; + jbyteArray ret_arr = (*_env)->NewByteArray(_env, 0); // XXX: len 0 + (*_env)->SetByteArrayRegion(_env, ret_arr, 0, 32, *NodeAnnouncementInfo_get_alias(this_ptr_conv)); + return ret_arr; +} + +JNIEXPORT void JNICALL NodeAnnouncementInfosetalias(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKNodeAnnouncementInfo* this_ptr_conv = (LDKNodeAnnouncementInfo*)this_ptr; + LDKThirtyTwoBytes val_conv = *(LDKThirtyTwoBytes*)val; + return NodeAnnouncementInfo_set_alias(this_ptr_conv, val_conv); +} + +JNIEXPORT void JNICALL NodeAnnouncementInfosetaddresses(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKNodeAnnouncementInfo* this_ptr_conv = (LDKNodeAnnouncementInfo*)this_ptr; + LDKCVec_NetAddressZ val_conv = *(LDKCVec_NetAddressZ*)val; + return NodeAnnouncementInfo_set_addresses(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL NodeAnnouncementInfowrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKNodeAnnouncementInfo* obj_conv = (LDKNodeAnnouncementInfo*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = NodeAnnouncementInfo_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL NodeAnnouncementInforead(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKNodeAnnouncementInfo* ret = malloc(sizeof(LDKNodeAnnouncementInfo)); + *ret = NodeAnnouncementInfo_read(ser_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL NodeInfofree(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKNodeInfo this_ptr_conv = *(LDKNodeInfo*)this_ptr; + return NodeInfo_free(this_ptr_conv); +} + +JNIEXPORT void JNICALL NodeInfosetchannels(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKNodeInfo* this_ptr_conv = (LDKNodeInfo*)this_ptr; + LDKCVec_u64Z val_conv = *(LDKCVec_u64Z*)val; + return NodeInfo_set_channels(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL NodeInfogetlowestinboundchannelfees(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKNodeInfo* this_ptr_conv = (LDKNodeInfo*)this_ptr; + LDKRoutingFees* ret = malloc(sizeof(LDKRoutingFees)); + *ret = NodeInfo_get_lowest_inbound_channel_fees(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL NodeInfosetlowestinboundchannelfees(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKNodeInfo* this_ptr_conv = (LDKNodeInfo*)this_ptr; + LDKRoutingFees val_conv = *(LDKRoutingFees*)val; + return NodeInfo_set_lowest_inbound_channel_fees(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL NodeInfogetannouncementinfo(JNIEnv * _env, jclass _b, jlong this_ptr) { + LDKNodeInfo* this_ptr_conv = (LDKNodeInfo*)this_ptr; + LDKNodeAnnouncementInfo* ret = malloc(sizeof(LDKNodeAnnouncementInfo)); + *ret = NodeInfo_get_announcement_info(this_ptr_conv); + return (long)ret; +} + +JNIEXPORT void JNICALL NodeInfosetannouncementinfo(JNIEnv * _env, jclass _b, jlong this_ptr, jlong val) { + LDKNodeInfo* this_ptr_conv = (LDKNodeInfo*)this_ptr; + LDKNodeAnnouncementInfo val_conv = *(LDKNodeAnnouncementInfo*)val; + return NodeInfo_set_announcement_info(this_ptr_conv, val_conv); +} + +JNIEXPORT jlong JNICALL NodeInfonew(JNIEnv * _env, jclass _b, jlong channels_arg, jlong lowest_inbound_channel_fees_arg, jlong announcement_info_arg) { + LDKCVec_u64Z channels_arg_conv = *(LDKCVec_u64Z*)channels_arg; + LDKRoutingFees lowest_inbound_channel_fees_arg_conv = *(LDKRoutingFees*)lowest_inbound_channel_fees_arg; + LDKNodeAnnouncementInfo announcement_info_arg_conv = *(LDKNodeAnnouncementInfo*)announcement_info_arg; + LDKNodeInfo* ret = malloc(sizeof(LDKNodeInfo)); + *ret = NodeInfo_new(channels_arg_conv, lowest_inbound_channel_fees_arg_conv, announcement_info_arg_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL NodeInfowrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKNodeInfo* obj_conv = (LDKNodeInfo*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = NodeInfo_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL NodeInforead(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKNodeInfo* ret = malloc(sizeof(LDKNodeInfo)); + *ret = NodeInfo_read(ser_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL NetworkGraphwrite(JNIEnv * _env, jclass _b, jlong obj) { + LDKNetworkGraph* obj_conv = (LDKNetworkGraph*)obj; + LDKCVec_u8Z* ret = malloc(sizeof(LDKCVec_u8Z)); + *ret = NetworkGraph_write(obj_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL NetworkGraphread(JNIEnv * _env, jclass _b, jlong ser) { + LDKu8slice ser_conv = *(LDKu8slice*)ser; + LDKNetworkGraph* ret = malloc(sizeof(LDKNetworkGraph)); + *ret = NetworkGraph_read(ser_conv); + return (long)ret; +} + +JNIEXPORT jlong JNICALL NetworkGraphnew(JNIEnv * _env, jclass _b) { + LDKNetworkGraph* ret = malloc(sizeof(LDKNetworkGraph)); + *ret = NetworkGraph_new(); + return (long)ret; +} + +JNIEXPORT void JNICALL NetworkGraphclosechannelfromupdate(JNIEnv * _env, jclass _b, jlong this_arg, jlong short_channel_id, jboolean is_permanent) { + LDKNetworkGraph* this_arg_conv = (LDKNetworkGraph*)this_arg; + return NetworkGraph_close_channel_from_update(this_arg_conv, short_channel_id, is_permanent); +} + diff --git a/src/main/jni/org_ldk_bindings.h b/src/main/jni/org_ldk_bindings.h new file mode 100644 index 00000000..207160d1 --- /dev/null +++ b/src/main/jni/org_ldk_bindings.h @@ -0,0 +1,4077 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_ldk_bindings */ + +#ifndef _Included_org_ldk_bindings +#define _Included_org_ldk_bindings +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_ldk_bindings + * Method: C2TupleOutPointScriptZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_C2TupleOutPointScriptZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: C2TupleScriptu64Zfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_C2TupleScriptu64Zfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: C2TupleSecretKeyu832Zfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_C2TupleSecretKeyu832Zfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: C2TupleSignatureCVecSignatureZZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_C2TupleSignatureCVecSignatureZZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: C2TupleTxidu32Zfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_C2TupleTxidu32Zfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: C2Tupleu64u64Zfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_C2Tupleu64u64Zfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: C3TupleChannelAnnouncementChannelUpdateChannelUpdateZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_C3TupleChannelAnnouncementChannelUpdateChannelUpdateZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CResultC2TupleScriptu64ZChainErrorZerr + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_CResultC2TupleScriptu64ZChainErrorZerr + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CResultC2TupleScriptu64ZChainErrorZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CResultC2TupleScriptu64ZChainErrorZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CResultC2TupleScriptu64ZChainErrorZgood + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_CResultC2TupleScriptu64ZChainErrorZgood + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CResultC2TupleSignatureCVecSignatureZZNoneZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CResultC2TupleSignatureCVecSignatureZZNoneZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CResultC2TupleSignatureCVecSignatureZZNoneZgood + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_CResultC2TupleSignatureCVecSignatureZZNoneZgood + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CResultCVecSignatureZNoneZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CResultCVecSignatureZNoneZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CResultCVecSignatureZNoneZgood + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_CResultCVecSignatureZNoneZgood + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CResultCVecu8ZPeerHandleErrorZerr + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_CResultCVecu8ZPeerHandleErrorZerr + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CResultCVecu8ZPeerHandleErrorZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CResultCVecu8ZPeerHandleErrorZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CResultCVecu8ZPeerHandleErrorZgood + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_CResultCVecu8ZPeerHandleErrorZgood + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CResultNoneAPIErrorZerr + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_CResultNoneAPIErrorZerr + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CResultNoneAPIErrorZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CResultNoneAPIErrorZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CResultNoneChannelMonitorUpdateErrZerr + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_CResultNoneChannelMonitorUpdateErrZerr + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CResultNoneChannelMonitorUpdateErrZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CResultNoneChannelMonitorUpdateErrZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CResultNoneMonitorUpdateErrorZerr + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_CResultNoneMonitorUpdateErrorZerr + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CResultNoneMonitorUpdateErrorZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CResultNoneMonitorUpdateErrorZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CResultNonePaymentSendFailureZerr + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_CResultNonePaymentSendFailureZerr + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CResultNonePaymentSendFailureZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CResultNonePaymentSendFailureZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CResultNonePeerHandleErrorZerr + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_CResultNonePeerHandleErrorZerr + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CResultNonePeerHandleErrorZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CResultNonePeerHandleErrorZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CResultRouteLightningErrorZerr + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_CResultRouteLightningErrorZerr + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CResultRouteLightningErrorZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CResultRouteLightningErrorZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CResultRouteLightningErrorZgood + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_CResultRouteLightningErrorZgood + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CResultSignatureNoneZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CResultSignatureNoneZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CResultSignatureNoneZgood + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_CResultSignatureNoneZgood + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CResultboolLightningErrorZerr + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_CResultboolLightningErrorZerr + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CResultboolLightningErrorZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CResultboolLightningErrorZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CResultboolLightningErrorZgood + * Signature: (Z)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_CResultboolLightningErrorZgood + (JNIEnv *, jclass, jboolean); + +/* + * Class: org_ldk_bindings + * Method: CResultboolPeerHandleErrorZerr + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_CResultboolPeerHandleErrorZerr + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CResultboolPeerHandleErrorZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CResultboolPeerHandleErrorZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CResultboolPeerHandleErrorZgood + * Signature: (Z)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_CResultboolPeerHandleErrorZgood + (JNIEnv *, jclass, jboolean); + +/* + * Class: org_ldk_bindings + * Method: CVecC3TupleChannelAnnouncementChannelUpdateChannelUpdateZZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CVecC3TupleChannelAnnouncementChannelUpdateChannelUpdateZZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CVecCVecRouteHopZZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CVecCVecRouteHopZZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CVecChannelDetailsZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CVecChannelDetailsZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CVecEventZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CVecEventZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CVecHTLCUpdateZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CVecHTLCUpdateZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CVecMessageSendEventZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CVecMessageSendEventZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CVecNetAddressZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CVecNetAddressZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CVecNodeAnnouncementZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CVecNodeAnnouncementZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CVecPublicKeyZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CVecPublicKeyZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CVecRouteHopZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CVecRouteHopZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CVecSignatureZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CVecSignatureZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CVecSpendableOutputDescriptorZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CVecSpendableOutputDescriptorZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CVecTransactionZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CVecTransactionZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CVecUpdateAddHTLCZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CVecUpdateAddHTLCZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CVecUpdateFailHTLCZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CVecUpdateFailHTLCZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CVecUpdateFailMalformedHTLCZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CVecUpdateFailMalformedHTLCZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CVecUpdateFulfillHTLCZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CVecUpdateFulfillHTLCZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CVecu64Zfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CVecu64Zfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CVecu8Zfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CVecu8Zfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CVecusizeZfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CVecusizeZfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: C2TupleTxidu32Znew + * Signature: (JI)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_C2TupleTxidu32Znew + (JNIEnv *, jclass, jlong, jint); + +/* + * Class: org_ldk_bindings + * Method: C2TupleScriptu64Znew + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_C2TupleScriptu64Znew + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: C2Tupleu64u64Znew + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_C2Tupleu64u64Znew + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: C2TupleSignatureCVecSignatureZZnew + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_C2TupleSignatureCVecSignatureZZnew + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: CResultC2TupleSignatureCVecSignatureZZNoneZerr + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_CResultC2TupleSignatureCVecSignatureZZNoneZerr + (JNIEnv *, jclass); + +/* + * Class: org_ldk_bindings + * Method: CResultSignatureNoneZerr + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_CResultSignatureNoneZerr + (JNIEnv *, jclass); + +/* + * Class: org_ldk_bindings + * Method: CResultCVecSignatureZNoneZerr + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_CResultCVecSignatureZNoneZerr + (JNIEnv *, jclass); + +/* + * Class: org_ldk_bindings + * Method: C2TupleSecretKeyu832Znew + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_C2TupleSecretKeyu832Znew + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: CResultNoneAPIErrorZgood + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_CResultNoneAPIErrorZgood + (JNIEnv *, jclass); + +/* + * Class: org_ldk_bindings + * Method: CResultNonePaymentSendFailureZgood + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_CResultNonePaymentSendFailureZgood + (JNIEnv *, jclass); + +/* + * Class: org_ldk_bindings + * Method: CResultNoneChannelMonitorUpdateErrZgood + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_CResultNoneChannelMonitorUpdateErrZgood + (JNIEnv *, jclass); + +/* + * Class: org_ldk_bindings + * Method: CResultNoneMonitorUpdateErrorZgood + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_CResultNoneMonitorUpdateErrorZgood + (JNIEnv *, jclass); + +/* + * Class: org_ldk_bindings + * Method: C2TupleOutPointScriptZnew + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_C2TupleOutPointScriptZnew + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: C3TupleChannelAnnouncementChannelUpdateChannelUpdateZnew + * Signature: (JJJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_C3TupleChannelAnnouncementChannelUpdateChannelUpdateZnew + (JNIEnv *, jclass, jlong, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: CResultNonePeerHandleErrorZgood + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_CResultNonePeerHandleErrorZgood + (JNIEnv *, jclass); + +/* + * Class: org_ldk_bindings + * Method: Eventfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_Eventfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: MessageSendEventfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_MessageSendEventfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: MessageSendEventsProviderfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_MessageSendEventsProviderfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: EventsProviderfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_EventsProviderfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: APIErrorfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_APIErrorfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: Levelmax + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_Levelmax + (JNIEnv *, jclass); + +/* + * Class: org_ldk_bindings + * Method: Loggerfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_Loggerfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelHandshakeConfigfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelHandshakeConfigfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelHandshakeConfiggetminimumdepth + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_ldk_bindings_ChannelHandshakeConfiggetminimumdepth + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelHandshakeConfigsetminimumdepth + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelHandshakeConfigsetminimumdepth + (JNIEnv *, jclass, jlong, jint); + +/* + * Class: org_ldk_bindings + * Method: ChannelHandshakeConfiggetourtoselfdelay + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelHandshakeConfiggetourtoselfdelay + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelHandshakeConfigsetourtoselfdelay + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelHandshakeConfigsetourtoselfdelay + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelHandshakeConfiggetourhtlcminimummsat + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelHandshakeConfiggetourhtlcminimummsat + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelHandshakeConfigsetourhtlcminimummsat + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelHandshakeConfigsetourhtlcminimummsat + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelHandshakeConfignew + * Signature: (IJJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelHandshakeConfignew + (JNIEnv *, jclass, jint, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelHandshakeConfigdefault + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelHandshakeConfigdefault + (JNIEnv *, jclass); + +/* + * Class: org_ldk_bindings + * Method: ChannelHandshakeLimitsfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelHandshakeLimitsfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelHandshakeLimitsgetminfundingsatoshis + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelHandshakeLimitsgetminfundingsatoshis + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelHandshakeLimitssetminfundingsatoshis + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelHandshakeLimitssetminfundingsatoshis + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelHandshakeLimitsgetmaxhtlcminimummsat + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelHandshakeLimitsgetmaxhtlcminimummsat + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelHandshakeLimitssetmaxhtlcminimummsat + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelHandshakeLimitssetmaxhtlcminimummsat + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelHandshakeLimitsgetminmaxhtlcvalueinflightmsat + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelHandshakeLimitsgetminmaxhtlcvalueinflightmsat + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelHandshakeLimitssetminmaxhtlcvalueinflightmsat + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelHandshakeLimitssetminmaxhtlcvalueinflightmsat + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelHandshakeLimitsgetmaxchannelreservesatoshis + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelHandshakeLimitsgetmaxchannelreservesatoshis + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelHandshakeLimitssetmaxchannelreservesatoshis + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelHandshakeLimitssetmaxchannelreservesatoshis + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelHandshakeLimitsgetminmaxacceptedhtlcs + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelHandshakeLimitsgetminmaxacceptedhtlcs + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelHandshakeLimitssetminmaxacceptedhtlcs + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelHandshakeLimitssetminmaxacceptedhtlcs + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelHandshakeLimitsgetmindustlimitsatoshis + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelHandshakeLimitsgetmindustlimitsatoshis + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelHandshakeLimitssetmindustlimitsatoshis + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelHandshakeLimitssetmindustlimitsatoshis + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelHandshakeLimitsgetmaxdustlimitsatoshis + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelHandshakeLimitsgetmaxdustlimitsatoshis + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelHandshakeLimitssetmaxdustlimitsatoshis + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelHandshakeLimitssetmaxdustlimitsatoshis + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelHandshakeLimitsgetmaxminimumdepth + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_ldk_bindings_ChannelHandshakeLimitsgetmaxminimumdepth + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelHandshakeLimitssetmaxminimumdepth + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelHandshakeLimitssetmaxminimumdepth + (JNIEnv *, jclass, jlong, jint); + +/* + * Class: org_ldk_bindings + * Method: ChannelHandshakeLimitsgetforceannouncedchannelpreference + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_ldk_bindings_ChannelHandshakeLimitsgetforceannouncedchannelpreference + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelHandshakeLimitssetforceannouncedchannelpreference + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelHandshakeLimitssetforceannouncedchannelpreference + (JNIEnv *, jclass, jlong, jboolean); + +/* + * Class: org_ldk_bindings + * Method: ChannelHandshakeLimitsgettheirtoselfdelay + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelHandshakeLimitsgettheirtoselfdelay + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelHandshakeLimitssettheirtoselfdelay + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelHandshakeLimitssettheirtoselfdelay + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelHandshakeLimitsnew + * Signature: (JJJJJJJIZJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelHandshakeLimitsnew + (JNIEnv *, jclass, jlong, jlong, jlong, jlong, jlong, jlong, jlong, jint, jboolean, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelHandshakeLimitsdefault + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelHandshakeLimitsdefault + (JNIEnv *, jclass); + +/* + * Class: org_ldk_bindings + * Method: ChannelConfigfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelConfigfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelConfiggetfeeproportionalmillionths + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_ldk_bindings_ChannelConfiggetfeeproportionalmillionths + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelConfigsetfeeproportionalmillionths + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelConfigsetfeeproportionalmillionths + (JNIEnv *, jclass, jlong, jint); + +/* + * Class: org_ldk_bindings + * Method: ChannelConfiggetannouncedchannel + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_ldk_bindings_ChannelConfiggetannouncedchannel + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelConfigsetannouncedchannel + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelConfigsetannouncedchannel + (JNIEnv *, jclass, jlong, jboolean); + +/* + * Class: org_ldk_bindings + * Method: ChannelConfiggetcommitupfrontshutdownpubkey + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_ldk_bindings_ChannelConfiggetcommitupfrontshutdownpubkey + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelConfigsetcommitupfrontshutdownpubkey + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelConfigsetcommitupfrontshutdownpubkey + (JNIEnv *, jclass, jlong, jboolean); + +/* + * Class: org_ldk_bindings + * Method: ChannelConfignew + * Signature: (IZZ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelConfignew + (JNIEnv *, jclass, jint, jboolean, jboolean); + +/* + * Class: org_ldk_bindings + * Method: ChannelConfigdefault + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelConfigdefault + (JNIEnv *, jclass); + +/* + * Class: org_ldk_bindings + * Method: ChannelConfigwrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelConfigwrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelConfigread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelConfigread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: UserConfigfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_UserConfigfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: UserConfiggetownchannelconfig + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_UserConfiggetownchannelconfig + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: UserConfigsetownchannelconfig + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_UserConfigsetownchannelconfig + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: UserConfiggetpeerchannelconfiglimits + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_UserConfiggetpeerchannelconfiglimits + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: UserConfigsetpeerchannelconfiglimits + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_UserConfigsetpeerchannelconfiglimits + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: UserConfiggetchanneloptions + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_UserConfiggetchanneloptions + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: UserConfigsetchanneloptions + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_UserConfigsetchanneloptions + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: UserConfignew + * Signature: (JJJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_UserConfignew + (JNIEnv *, jclass, jlong, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: UserConfigdefault + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_UserConfigdefault + (JNIEnv *, jclass); + +/* + * Class: org_ldk_bindings + * Method: ChainWatchInterfacefree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChainWatchInterfacefree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: BroadcasterInterfacefree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_BroadcasterInterfacefree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChainListenerfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChainListenerfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: FeeEstimatorfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_FeeEstimatorfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChainWatchedUtilfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChainWatchedUtilfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChainWatchedUtilnew + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChainWatchedUtilnew + (JNIEnv *, jclass); + +/* + * Class: org_ldk_bindings + * Method: ChainWatchedUtilregistertx + * Signature: (J[BJ)Z + */ +JNIEXPORT jboolean JNICALL Java_org_ldk_bindings_ChainWatchedUtilregistertx + (JNIEnv *, jclass, jlong, jbyteArray, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChainWatchedUtilregisteroutpoint + * Signature: (JJJ)Z + */ +JNIEXPORT jboolean JNICALL Java_org_ldk_bindings_ChainWatchedUtilregisteroutpoint + (JNIEnv *, jclass, jlong, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChainWatchedUtilwatchall + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_ldk_bindings_ChainWatchedUtilwatchall + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChainWatchedUtildoesmatchtx + * Signature: (JJ)Z + */ +JNIEXPORT jboolean JNICALL Java_org_ldk_bindings_ChainWatchedUtildoesmatchtx + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: BlockNotifierfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_BlockNotifierfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: BlockNotifiernew + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_BlockNotifiernew + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: BlockNotifierregisterlistener + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_BlockNotifierregisterlistener + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: BlockNotifierblockconnected + * Signature: (JJI)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_BlockNotifierblockconnected + (JNIEnv *, jclass, jlong, jlong, jint); + +/* + * Class: org_ldk_bindings + * Method: BlockNotifierblockconnectedchecked + * Signature: (J[BIJJ)Z + */ +JNIEXPORT jboolean JNICALL Java_org_ldk_bindings_BlockNotifierblockconnectedchecked + (JNIEnv *, jclass, jlong, jbyteArray, jint, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: BlockNotifierblockdisconnected + * Signature: (J[BI)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_BlockNotifierblockdisconnected + (JNIEnv *, jclass, jlong, jbyteArray, jint); + +/* + * Class: org_ldk_bindings + * Method: ChainWatchInterfaceUtilfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChainWatchInterfaceUtilfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChainWatchInterfaceUtilasChainWatchInterface + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChainWatchInterfaceUtilasChainWatchInterface + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChainWatchInterfaceUtilnew + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChainWatchInterfaceUtilnew + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChainWatchInterfaceUtildoesmatchtx + * Signature: (JJ)Z + */ +JNIEXPORT jboolean JNICALL Java_org_ldk_bindings_ChainWatchInterfaceUtildoesmatchtx + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: OutPointfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_OutPointfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: OutPointgettxid + * Signature: (J)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_ldk_bindings_OutPointgettxid + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: OutPointsettxid + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_OutPointsettxid + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: OutPointgetindex + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_OutPointgetindex + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: OutPointsetindex + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_OutPointsetindex + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: OutPointnew + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_OutPointnew + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: OutPointtochannelid + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_OutPointtochannelid + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: OutPointwrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_OutPointwrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: OutPointread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_OutPointread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: SpendableOutputDescriptorfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_SpendableOutputDescriptorfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: SpendableOutputDescriptorwrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_SpendableOutputDescriptorwrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: SpendableOutputDescriptorread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_SpendableOutputDescriptorread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelKeysfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelKeysfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: KeysInterfacefree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_KeysInterfacefree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: InMemoryChannelKeysfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_InMemoryChannelKeysfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: InMemoryChannelKeysgetfundingkey + * Signature: (J)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_ldk_bindings_InMemoryChannelKeysgetfundingkey + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: InMemoryChannelKeyssetfundingkey + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_InMemoryChannelKeyssetfundingkey + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: InMemoryChannelKeysgetrevocationbasekey + * Signature: (J)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_ldk_bindings_InMemoryChannelKeysgetrevocationbasekey + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: InMemoryChannelKeyssetrevocationbasekey + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_InMemoryChannelKeyssetrevocationbasekey + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: InMemoryChannelKeysgetpaymentkey + * Signature: (J)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_ldk_bindings_InMemoryChannelKeysgetpaymentkey + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: InMemoryChannelKeyssetpaymentkey + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_InMemoryChannelKeyssetpaymentkey + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: InMemoryChannelKeysgetdelayedpaymentbasekey + * Signature: (J)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_ldk_bindings_InMemoryChannelKeysgetdelayedpaymentbasekey + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: InMemoryChannelKeyssetdelayedpaymentbasekey + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_InMemoryChannelKeyssetdelayedpaymentbasekey + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: InMemoryChannelKeysgethtlcbasekey + * Signature: (J)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_ldk_bindings_InMemoryChannelKeysgethtlcbasekey + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: InMemoryChannelKeyssethtlcbasekey + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_InMemoryChannelKeyssethtlcbasekey + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: InMemoryChannelKeysgetcommitmentseed + * Signature: (J)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_ldk_bindings_InMemoryChannelKeysgetcommitmentseed + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: InMemoryChannelKeyssetcommitmentseed + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_InMemoryChannelKeyssetcommitmentseed + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: InMemoryChannelKeysnew + * Signature: (JJJJJJJJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_InMemoryChannelKeysnew + (JNIEnv *, jclass, jlong, jlong, jlong, jlong, jlong, jlong, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: InMemoryChannelKeysasChannelKeys + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_InMemoryChannelKeysasChannelKeys + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: InMemoryChannelKeyswrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_InMemoryChannelKeyswrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: InMemoryChannelKeysread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_InMemoryChannelKeysread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: KeysManagerfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_KeysManagerfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: KeysManagernew + * Signature: ([BJJI)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_KeysManagernew + (JNIEnv *, jclass, jbyteArray, jlong, jlong, jint); + +/* + * Class: org_ldk_bindings + * Method: KeysManagerderivechannelkeys + * Signature: (JJJJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_KeysManagerderivechannelkeys + (JNIEnv *, jclass, jlong, jlong, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: KeysManagerasKeysInterface + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_KeysManagerasKeysInterface + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelManagerfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelManagerfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelDetailsfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelDetailsfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelDetailsgetchannelid + * Signature: (J)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_ldk_bindings_ChannelDetailsgetchannelid + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelDetailssetchannelid + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelDetailssetchannelid + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelDetailsgetremotenetworkid + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelDetailsgetremotenetworkid + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelDetailssetremotenetworkid + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelDetailssetremotenetworkid + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelDetailsgetcounterpartyfeatures + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelDetailsgetcounterpartyfeatures + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelDetailssetcounterpartyfeatures + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelDetailssetcounterpartyfeatures + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelDetailsgetchannelvaluesatoshis + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelDetailsgetchannelvaluesatoshis + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelDetailssetchannelvaluesatoshis + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelDetailssetchannelvaluesatoshis + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelDetailsgetuserid + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelDetailsgetuserid + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelDetailssetuserid + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelDetailssetuserid + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelDetailsgetoutboundcapacitymsat + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelDetailsgetoutboundcapacitymsat + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelDetailssetoutboundcapacitymsat + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelDetailssetoutboundcapacitymsat + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelDetailsgetinboundcapacitymsat + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelDetailsgetinboundcapacitymsat + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelDetailssetinboundcapacitymsat + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelDetailssetinboundcapacitymsat + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelDetailsgetislive + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_ldk_bindings_ChannelDetailsgetislive + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelDetailssetislive + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelDetailssetislive + (JNIEnv *, jclass, jlong, jboolean); + +/* + * Class: org_ldk_bindings + * Method: PaymentSendFailurefree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_PaymentSendFailurefree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelManagernew + * Signature: (JJJJJJJJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelManagernew + (JNIEnv *, jclass, jlong, jlong, jlong, jlong, jlong, jlong, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelManagercreatechannel + * Signature: (JJJJJJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelManagercreatechannel + (JNIEnv *, jclass, jlong, jlong, jlong, jlong, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelManagerlistchannels + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelManagerlistchannels + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelManagerlistusablechannels + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelManagerlistusablechannels + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelManagerclosechannel + * Signature: (J[B)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelManagerclosechannel + (JNIEnv *, jclass, jlong, jbyteArray); + +/* + * Class: org_ldk_bindings + * Method: ChannelManagerforceclosechannel + * Signature: (J[B)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelManagerforceclosechannel + (JNIEnv *, jclass, jlong, jbyteArray); + +/* + * Class: org_ldk_bindings + * Method: ChannelManagerforcecloseallchannels + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelManagerforcecloseallchannels + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelManagersendpayment + * Signature: (JJJJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelManagersendpayment + (JNIEnv *, jclass, jlong, jlong, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelManagerfundingtransactiongenerated + * Signature: (J[BJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelManagerfundingtransactiongenerated + (JNIEnv *, jclass, jlong, jbyteArray, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelManagerbroadcastnodeannouncement + * Signature: (JJJJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelManagerbroadcastnodeannouncement + (JNIEnv *, jclass, jlong, jlong, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelManagerprocesspendinghtlcforwards + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelManagerprocesspendinghtlcforwards + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelManagertimerchanfreshnesseverymin + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelManagertimerchanfreshnesseverymin + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelManagerfailhtlcbackwards + * Signature: (J[BJ)Z + */ +JNIEXPORT jboolean JNICALL Java_org_ldk_bindings_ChannelManagerfailhtlcbackwards + (JNIEnv *, jclass, jlong, jbyteArray, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelManagerclaimfunds + * Signature: (JJJJ)Z + */ +JNIEXPORT jboolean JNICALL Java_org_ldk_bindings_ChannelManagerclaimfunds + (JNIEnv *, jclass, jlong, jlong, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelManagergetournodeid + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelManagergetournodeid + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelManagerchannelmonitorupdated + * Signature: (JJJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelManagerchannelmonitorupdated + (JNIEnv *, jclass, jlong, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelManagerasMessageSendEventsProvider + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelManagerasMessageSendEventsProvider + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelManagerasEventsProvider + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelManagerasEventsProvider + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelManagerasChainListener + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelManagerasChainListener + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelManagerasChannelMessageHandler + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelManagerasChannelMessageHandler + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelMonitorUpdatefree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelMonitorUpdatefree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelMonitorUpdategetupdateid + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelMonitorUpdategetupdateid + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelMonitorUpdatesetupdateid + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelMonitorUpdatesetupdateid + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelMonitorUpdatewrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelMonitorUpdatewrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelMonitorUpdateread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelMonitorUpdateread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: MonitorUpdateErrorfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_MonitorUpdateErrorfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: HTLCUpdatefree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_HTLCUpdatefree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: HTLCUpdatewrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_HTLCUpdatewrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: HTLCUpdateread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_HTLCUpdateread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelMonitorfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelMonitorfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ManyChannelMonitorfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ManyChannelMonitorfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelMonitorupdatemonitor + * Signature: (JJJJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelMonitorupdatemonitor + (JNIEnv *, jclass, jlong, jlong, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelMonitorgetlatestupdateid + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelMonitorgetlatestupdateid + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelMonitorgetfundingtxo + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelMonitorgetfundingtxo + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelMonitorgetandclearpendinghtlcsupdated + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelMonitorgetandclearpendinghtlcsupdated + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelMonitorgetandclearpendingevents + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelMonitorgetandclearpendingevents + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelMonitorgetlatestlocalcommitmenttxn + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelMonitorgetlatestlocalcommitmenttxn + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: DecodeErrorfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_DecodeErrorfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: Initfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_Initfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ErrorMessagefree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ErrorMessagefree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: Pingfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_Pingfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: Pongfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_Pongfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: OpenChannelfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_OpenChannelfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: AcceptChannelfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_AcceptChannelfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: FundingCreatedfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_FundingCreatedfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: FundingSignedfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_FundingSignedfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: FundingLockedfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_FundingLockedfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: FundingLockedgetchannelid + * Signature: (J)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_ldk_bindings_FundingLockedgetchannelid + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: FundingLockedsetchannelid + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_FundingLockedsetchannelid + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: FundingLockedgetnextpercommitmentpoint + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_FundingLockedgetnextpercommitmentpoint + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: FundingLockedsetnextpercommitmentpoint + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_FundingLockedsetnextpercommitmentpoint + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: FundingLockednew + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_FundingLockednew + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: Shutdownfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_Shutdownfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ClosingSignedfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ClosingSignedfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: UpdateAddHTLCfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_UpdateAddHTLCfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: UpdateFulfillHTLCfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_UpdateFulfillHTLCfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: UpdateFailHTLCfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_UpdateFailHTLCfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: UpdateFailMalformedHTLCfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_UpdateFailMalformedHTLCfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CommitmentSignedfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CommitmentSignedfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: RevokeAndACKfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_RevokeAndACKfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: UpdateFeefree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_UpdateFeefree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelReestablishfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelReestablishfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: AnnouncementSignaturesfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_AnnouncementSignaturesfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: NetAddressfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_NetAddressfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: UnsignedNodeAnnouncementfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_UnsignedNodeAnnouncementfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: UnsignedNodeAnnouncementgetnodeid + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_UnsignedNodeAnnouncementgetnodeid + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: UnsignedNodeAnnouncementsetnodeid + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_UnsignedNodeAnnouncementsetnodeid + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: NodeAnnouncementfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_NodeAnnouncementfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: UnsignedChannelAnnouncementfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_UnsignedChannelAnnouncementfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: UnsignedChannelAnnouncementgetnodeid1 + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_UnsignedChannelAnnouncementgetnodeid1 + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: UnsignedChannelAnnouncementsetnodeid1 + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_UnsignedChannelAnnouncementsetnodeid1 + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: UnsignedChannelAnnouncementgetnodeid2 + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_UnsignedChannelAnnouncementgetnodeid2 + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: UnsignedChannelAnnouncementsetnodeid2 + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_UnsignedChannelAnnouncementsetnodeid2 + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelAnnouncementfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelAnnouncementfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelUpdatefree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelUpdatefree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ErrorActionfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ErrorActionfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: LightningErrorfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_LightningErrorfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: LightningErrorgeterr + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_LightningErrorgeterr + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: LightningErrorseterr + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_LightningErrorseterr + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: LightningErrorgetaction + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_LightningErrorgetaction + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: LightningErrorsetaction + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_LightningErrorsetaction + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: LightningErrornew + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_LightningErrornew + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: CommitmentUpdatefree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CommitmentUpdatefree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CommitmentUpdatesetupdateaddhtlcs + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CommitmentUpdatesetupdateaddhtlcs + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: CommitmentUpdatesetupdatefulfillhtlcs + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CommitmentUpdatesetupdatefulfillhtlcs + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: CommitmentUpdatesetupdatefailhtlcs + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CommitmentUpdatesetupdatefailhtlcs + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: CommitmentUpdatesetupdatefailmalformedhtlcs + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CommitmentUpdatesetupdatefailmalformedhtlcs + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: CommitmentUpdategetupdatefee + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_CommitmentUpdategetupdatefee + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CommitmentUpdatesetupdatefee + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CommitmentUpdatesetupdatefee + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: CommitmentUpdategetcommitmentsigned + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_CommitmentUpdategetcommitmentsigned + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CommitmentUpdatesetcommitmentsigned + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_CommitmentUpdatesetcommitmentsigned + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: CommitmentUpdatenew + * Signature: (JJJJJJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_CommitmentUpdatenew + (JNIEnv *, jclass, jlong, jlong, jlong, jlong, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: HTLCFailChannelUpdatefree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_HTLCFailChannelUpdatefree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelMessageHandlerfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelMessageHandlerfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: RoutingMessageHandlerfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_RoutingMessageHandlerfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: AcceptChannelwrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_AcceptChannelwrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: AcceptChannelread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_AcceptChannelread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: AnnouncementSignatureswrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_AnnouncementSignatureswrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: AnnouncementSignaturesread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_AnnouncementSignaturesread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelReestablishwrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelReestablishwrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelReestablishread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelReestablishread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ClosingSignedwrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ClosingSignedwrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ClosingSignedread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ClosingSignedread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CommitmentSignedwrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_CommitmentSignedwrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: CommitmentSignedread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_CommitmentSignedread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: FundingCreatedwrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_FundingCreatedwrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: FundingCreatedread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_FundingCreatedread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: FundingSignedwrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_FundingSignedwrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: FundingSignedread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_FundingSignedread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: FundingLockedwrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_FundingLockedwrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: FundingLockedread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_FundingLockedread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: Initwrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_Initwrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: Initread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_Initread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: OpenChannelwrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_OpenChannelwrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: OpenChannelread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_OpenChannelread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: RevokeAndACKwrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_RevokeAndACKwrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: RevokeAndACKread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_RevokeAndACKread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: Shutdownwrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_Shutdownwrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: Shutdownread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_Shutdownread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: UpdateFailHTLCwrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_UpdateFailHTLCwrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: UpdateFailHTLCread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_UpdateFailHTLCread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: UpdateFailMalformedHTLCwrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_UpdateFailMalformedHTLCwrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: UpdateFailMalformedHTLCread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_UpdateFailMalformedHTLCread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: UpdateFeewrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_UpdateFeewrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: UpdateFeeread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_UpdateFeeread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: UpdateFulfillHTLCwrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_UpdateFulfillHTLCwrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: UpdateFulfillHTLCread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_UpdateFulfillHTLCread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: UpdateAddHTLCwrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_UpdateAddHTLCwrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: UpdateAddHTLCread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_UpdateAddHTLCread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: Pingwrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_Pingwrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: Pingread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_Pingread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: Pongwrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_Pongwrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: Pongread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_Pongread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: UnsignedChannelAnnouncementwrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_UnsignedChannelAnnouncementwrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: UnsignedChannelAnnouncementread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_UnsignedChannelAnnouncementread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelAnnouncementwrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelAnnouncementwrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelAnnouncementread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelAnnouncementread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelUpdatewrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelUpdatewrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelUpdateread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelUpdateread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ErrorMessagewrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ErrorMessagewrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ErrorMessageread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ErrorMessageread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: UnsignedNodeAnnouncementwrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_UnsignedNodeAnnouncementwrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: UnsignedNodeAnnouncementread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_UnsignedNodeAnnouncementread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: NodeAnnouncementwrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_NodeAnnouncementwrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: NodeAnnouncementread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_NodeAnnouncementread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: MessageHandlerfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_MessageHandlerfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: MessageHandlergetchanhandler + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_MessageHandlergetchanhandler + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: MessageHandlersetchanhandler + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_MessageHandlersetchanhandler + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: MessageHandlergetroutehandler + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_MessageHandlergetroutehandler + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: MessageHandlersetroutehandler + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_MessageHandlersetroutehandler + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: MessageHandlernew + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_MessageHandlernew + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: SocketDescriptorfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_SocketDescriptorfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: PeerHandleErrorfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_PeerHandleErrorfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: PeerHandleErrorgetnoconnectionpossible + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_ldk_bindings_PeerHandleErrorgetnoconnectionpossible + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: PeerHandleErrorsetnoconnectionpossible + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_PeerHandleErrorsetnoconnectionpossible + (JNIEnv *, jclass, jlong, jboolean); + +/* + * Class: org_ldk_bindings + * Method: PeerHandleErrornew + * Signature: (Z)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_PeerHandleErrornew + (JNIEnv *, jclass, jboolean); + +/* + * Class: org_ldk_bindings + * Method: PeerManagerfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_PeerManagerfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: PeerManagernew + * Signature: (JJ[BJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_PeerManagernew + (JNIEnv *, jclass, jlong, jlong, jbyteArray, jlong); + +/* + * Class: org_ldk_bindings + * Method: PeerManagergetpeernodeids + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_PeerManagergetpeernodeids + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: PeerManagernewoutboundconnection + * Signature: (JJJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_PeerManagernewoutboundconnection + (JNIEnv *, jclass, jlong, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: PeerManagernewinboundconnection + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_PeerManagernewinboundconnection + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: PeerManagerwritebufferspaceavail + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_PeerManagerwritebufferspaceavail + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: PeerManagerreadevent + * Signature: (JJJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_PeerManagerreadevent + (JNIEnv *, jclass, jlong, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: PeerManagerprocessevents + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_PeerManagerprocessevents + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: PeerManagersocketdisconnected + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_PeerManagersocketdisconnected + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: PeerManagertimertickoccured + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_PeerManagertimertickoccured + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: buildcommitmentsecret + * Signature: ([BJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_buildcommitmentsecret + (JNIEnv *, jclass, jbyteArray, jlong); + +/* + * Class: org_ldk_bindings + * Method: TxCreationKeysfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_TxCreationKeysfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: TxCreationKeysgetpercommitmentpoint + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_TxCreationKeysgetpercommitmentpoint + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: TxCreationKeyssetpercommitmentpoint + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_TxCreationKeyssetpercommitmentpoint + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: TxCreationKeyswrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_TxCreationKeyswrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: TxCreationKeysread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_TxCreationKeysread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelPublicKeysfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelPublicKeysfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelPublicKeysgetfundingpubkey + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelPublicKeysgetfundingpubkey + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelPublicKeyssetfundingpubkey + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelPublicKeyssetfundingpubkey + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelPublicKeysgetrevocationbasepoint + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelPublicKeysgetrevocationbasepoint + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelPublicKeyssetrevocationbasepoint + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelPublicKeyssetrevocationbasepoint + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelPublicKeysgetpaymentpoint + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelPublicKeysgetpaymentpoint + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelPublicKeyssetpaymentpoint + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelPublicKeyssetpaymentpoint + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelPublicKeysgetdelayedpaymentbasepoint + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelPublicKeysgetdelayedpaymentbasepoint + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelPublicKeyssetdelayedpaymentbasepoint + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelPublicKeyssetdelayedpaymentbasepoint + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelPublicKeysgethtlcbasepoint + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelPublicKeysgethtlcbasepoint + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelPublicKeyssethtlcbasepoint + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelPublicKeyssethtlcbasepoint + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelPublicKeysnew + * Signature: (JJJJJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelPublicKeysnew + (JNIEnv *, jclass, jlong, jlong, jlong, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelPublicKeyswrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelPublicKeyswrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelPublicKeysread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelPublicKeysread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: getrevokeableredeemscript + * Signature: (JJJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_getrevokeableredeemscript + (JNIEnv *, jclass, jlong, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: HTLCOutputInCommitmentfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_HTLCOutputInCommitmentfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: HTLCOutputInCommitmentgetoffered + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_ldk_bindings_HTLCOutputInCommitmentgetoffered + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: HTLCOutputInCommitmentsetoffered + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_HTLCOutputInCommitmentsetoffered + (JNIEnv *, jclass, jlong, jboolean); + +/* + * Class: org_ldk_bindings + * Method: HTLCOutputInCommitmentgetamountmsat + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_HTLCOutputInCommitmentgetamountmsat + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: HTLCOutputInCommitmentsetamountmsat + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_HTLCOutputInCommitmentsetamountmsat + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: HTLCOutputInCommitmentgetcltvexpiry + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_ldk_bindings_HTLCOutputInCommitmentgetcltvexpiry + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: HTLCOutputInCommitmentsetcltvexpiry + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_HTLCOutputInCommitmentsetcltvexpiry + (JNIEnv *, jclass, jlong, jint); + +/* + * Class: org_ldk_bindings + * Method: HTLCOutputInCommitmentgetpaymenthash + * Signature: (J)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_ldk_bindings_HTLCOutputInCommitmentgetpaymenthash + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: HTLCOutputInCommitmentsetpaymenthash + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_HTLCOutputInCommitmentsetpaymenthash + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: HTLCOutputInCommitmentwrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_HTLCOutputInCommitmentwrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: HTLCOutputInCommitmentread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_HTLCOutputInCommitmentread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: gethtlcredeemscript + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_gethtlcredeemscript + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: makefundingredeemscript + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_makefundingredeemscript + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: buildhtlctransaction + * Signature: ([BIJJJJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_buildhtlctransaction + (JNIEnv *, jclass, jbyteArray, jint, jlong, jlong, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: LocalCommitmentTransactionfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_LocalCommitmentTransactionfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: LocalCommitmentTransactiongetunsignedtx + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_LocalCommitmentTransactiongetunsignedtx + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: LocalCommitmentTransactionsetunsignedtx + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_LocalCommitmentTransactionsetunsignedtx + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: LocalCommitmentTransactiongettheirsig + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_LocalCommitmentTransactiongettheirsig + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: LocalCommitmentTransactionsettheirsig + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_LocalCommitmentTransactionsettheirsig + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: LocalCommitmentTransactiongetlocalkeys + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_LocalCommitmentTransactiongetlocalkeys + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: LocalCommitmentTransactionsetlocalkeys + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_LocalCommitmentTransactionsetlocalkeys + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: LocalCommitmentTransactiongetfeerateperkw + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_ldk_bindings_LocalCommitmentTransactiongetfeerateperkw + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: LocalCommitmentTransactionsetfeerateperkw + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_LocalCommitmentTransactionsetfeerateperkw + (JNIEnv *, jclass, jlong, jint); + +/* + * Class: org_ldk_bindings + * Method: LocalCommitmentTransactiontxid + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_LocalCommitmentTransactiontxid + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: LocalCommitmentTransactiongetlocalsig + * Signature: (J[BJJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_LocalCommitmentTransactiongetlocalsig + (JNIEnv *, jclass, jlong, jbyteArray, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: LocalCommitmentTransactionwrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_LocalCommitmentTransactionwrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: LocalCommitmentTransactionread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_LocalCommitmentTransactionread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: InitFeaturesfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_InitFeaturesfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: NodeFeaturesfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_NodeFeaturesfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelFeaturesfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelFeaturesfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: RouteHopfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_RouteHopfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: RouteHopgetpubkey + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_RouteHopgetpubkey + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: RouteHopsetpubkey + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_RouteHopsetpubkey + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: RouteHopgetshortchannelid + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_RouteHopgetshortchannelid + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: RouteHopsetshortchannelid + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_RouteHopsetshortchannelid + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: RouteHopgetfeemsat + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_RouteHopgetfeemsat + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: RouteHopsetfeemsat + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_RouteHopsetfeemsat + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: RouteHopgetcltvexpirydelta + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_ldk_bindings_RouteHopgetcltvexpirydelta + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: RouteHopsetcltvexpirydelta + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_RouteHopsetcltvexpirydelta + (JNIEnv *, jclass, jlong, jint); + +/* + * Class: org_ldk_bindings + * Method: Routefree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_Routefree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: Routesetpaths + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_Routesetpaths + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: Routenew + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_Routenew + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: Routewrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_Routewrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: Routeread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_Routeread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: RouteHintfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_RouteHintfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: RouteHintgetsrcnodeid + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_RouteHintgetsrcnodeid + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: RouteHintsetsrcnodeid + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_RouteHintsetsrcnodeid + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: RouteHintgetshortchannelid + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_RouteHintgetshortchannelid + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: RouteHintsetshortchannelid + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_RouteHintsetshortchannelid + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: RouteHintgetfees + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_RouteHintgetfees + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: RouteHintsetfees + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_RouteHintsetfees + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: RouteHintgetcltvexpirydelta + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_RouteHintgetcltvexpirydelta + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: RouteHintsetcltvexpirydelta + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_RouteHintsetcltvexpirydelta + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: RouteHintgethtlcminimummsat + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_RouteHintgethtlcminimummsat + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: RouteHintsethtlcminimummsat + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_RouteHintsethtlcminimummsat + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: RouteHintnew + * Signature: (JJJJJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_RouteHintnew + (JNIEnv *, jclass, jlong, jlong, jlong, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: getroute + * Signature: (JJJJJJIJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_getroute + (JNIEnv *, jclass, jlong, jlong, jlong, jlong, jlong, jlong, jint, jlong); + +/* + * Class: org_ldk_bindings + * Method: NetworkGraphfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_NetworkGraphfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: NetGraphMsgHandlerfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_NetGraphMsgHandlerfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: NetGraphMsgHandlernew + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_NetGraphMsgHandlernew + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: NetGraphMsgHandlerfromnetgraph + * Signature: (JJJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_NetGraphMsgHandlerfromnetgraph + (JNIEnv *, jclass, jlong, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: NetGraphMsgHandlerasRoutingMessageHandler + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_NetGraphMsgHandlerasRoutingMessageHandler + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: DirectionalChannelInfofree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_DirectionalChannelInfofree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: DirectionalChannelInfogetlastupdate + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_ldk_bindings_DirectionalChannelInfogetlastupdate + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: DirectionalChannelInfosetlastupdate + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_DirectionalChannelInfosetlastupdate + (JNIEnv *, jclass, jlong, jint); + +/* + * Class: org_ldk_bindings + * Method: DirectionalChannelInfogetenabled + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_ldk_bindings_DirectionalChannelInfogetenabled + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: DirectionalChannelInfosetenabled + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_DirectionalChannelInfosetenabled + (JNIEnv *, jclass, jlong, jboolean); + +/* + * Class: org_ldk_bindings + * Method: DirectionalChannelInfogetcltvexpirydelta + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_DirectionalChannelInfogetcltvexpirydelta + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: DirectionalChannelInfosetcltvexpirydelta + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_DirectionalChannelInfosetcltvexpirydelta + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: DirectionalChannelInfogethtlcminimummsat + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_DirectionalChannelInfogethtlcminimummsat + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: DirectionalChannelInfosethtlcminimummsat + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_DirectionalChannelInfosethtlcminimummsat + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: DirectionalChannelInfowrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_DirectionalChannelInfowrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: DirectionalChannelInforead + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_DirectionalChannelInforead + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelInfofree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelInfofree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelInfogetnodeone + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelInfogetnodeone + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelInfosetnodeone + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelInfosetnodeone + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelInfogetonetotwo + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelInfogetonetotwo + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelInfosetonetotwo + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelInfosetonetotwo + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelInfogetnodetwo + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelInfogetnodetwo + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelInfosetnodetwo + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelInfosetnodetwo + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelInfogettwotoone + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelInfogettwotoone + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelInfosettwotoone + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_ChannelInfosettwotoone + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelInfowrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelInfowrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: ChannelInforead + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_ChannelInforead + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: RoutingFeesfree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_RoutingFeesfree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: RoutingFeesgetbasemsat + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_ldk_bindings_RoutingFeesgetbasemsat + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: RoutingFeessetbasemsat + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_RoutingFeessetbasemsat + (JNIEnv *, jclass, jlong, jint); + +/* + * Class: org_ldk_bindings + * Method: RoutingFeesgetproportionalmillionths + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_ldk_bindings_RoutingFeesgetproportionalmillionths + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: RoutingFeessetproportionalmillionths + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_RoutingFeessetproportionalmillionths + (JNIEnv *, jclass, jlong, jint); + +/* + * Class: org_ldk_bindings + * Method: RoutingFeesnew + * Signature: (II)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_RoutingFeesnew + (JNIEnv *, jclass, jint, jint); + +/* + * Class: org_ldk_bindings + * Method: RoutingFeesread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_RoutingFeesread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: RoutingFeeswrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_RoutingFeeswrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: NodeAnnouncementInfofree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_NodeAnnouncementInfofree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: NodeAnnouncementInfogetlastupdate + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_ldk_bindings_NodeAnnouncementInfogetlastupdate + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: NodeAnnouncementInfosetlastupdate + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_NodeAnnouncementInfosetlastupdate + (JNIEnv *, jclass, jlong, jint); + +/* + * Class: org_ldk_bindings + * Method: NodeAnnouncementInfogetrgb + * Signature: (J)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_ldk_bindings_NodeAnnouncementInfogetrgb + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: NodeAnnouncementInfosetrgb + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_NodeAnnouncementInfosetrgb + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: NodeAnnouncementInfogetalias + * Signature: (J)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_ldk_bindings_NodeAnnouncementInfogetalias + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: NodeAnnouncementInfosetalias + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_NodeAnnouncementInfosetalias + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: NodeAnnouncementInfosetaddresses + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_NodeAnnouncementInfosetaddresses + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: NodeAnnouncementInfowrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_NodeAnnouncementInfowrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: NodeAnnouncementInforead + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_NodeAnnouncementInforead + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: NodeInfofree + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_NodeInfofree + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: NodeInfosetchannels + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_NodeInfosetchannels + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: NodeInfogetlowestinboundchannelfees + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_NodeInfogetlowestinboundchannelfees + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: NodeInfosetlowestinboundchannelfees + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_NodeInfosetlowestinboundchannelfees + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: NodeInfogetannouncementinfo + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_NodeInfogetannouncementinfo + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: NodeInfosetannouncementinfo + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_NodeInfosetannouncementinfo + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: NodeInfonew + * Signature: (JJJ)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_NodeInfonew + (JNIEnv *, jclass, jlong, jlong, jlong); + +/* + * Class: org_ldk_bindings + * Method: NodeInfowrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_NodeInfowrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: NodeInforead + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_NodeInforead + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: NetworkGraphwrite + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_NetworkGraphwrite + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: NetworkGraphread + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_NetworkGraphread + (JNIEnv *, jclass, jlong); + +/* + * Class: org_ldk_bindings + * Method: NetworkGraphnew + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_ldk_bindings_NetworkGraphnew + (JNIEnv *, jclass); + +/* + * Class: org_ldk_bindings + * Method: NetworkGraphclosechannelfromupdate + * Signature: (JJZ)V + */ +JNIEXPORT void JNICALL Java_org_ldk_bindings_NetworkGraphclosechannelfromupdate + (JNIEnv *, jclass, jlong, jlong, jboolean); + +#ifdef __cplusplus +} +#endif +#endif