}
}
+struct LDKThirtyTwoBytes BigEndianScalar_get_bytes (struct LDKBigEndianScalar* thing) {
+ LDKThirtyTwoBytes ret = { .data = *thing->big_endian_bytes };
+ return ret;
+}
+JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_BigEndianScalar_1get_1bytes(JNIEnv *env, jclass clz, int64_t thing) {
+ LDKBigEndianScalar* thing_conv = (LDKBigEndianScalar*)untag_ptr(thing);
+ int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
+ (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, BigEndianScalar_get_bytes(thing_conv).data);
+ return ret_arr;
+}
+
+static void BigEndianScalar_free (struct LDKBigEndianScalar thing) {}
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_BigEndianScalar_1free(JNIEnv *env, jclass clz, int64_t thing) {
+ if (!ptr_is_owned(thing)) return;
+ void* thing_ptr = untag_ptr(thing);
+ CHECK_ACCESS(thing_ptr);
+ LDKBigEndianScalar thing_conv = *(LDKBigEndianScalar*)(thing_ptr);
+ FREE(untag_ptr(thing));
+ BigEndianScalar_free(thing_conv);
+}
+
static jclass LDKBech32Error_MissingSeparator_class = NULL;
static jmethodID LDKBech32Error_MissingSeparator_meth = NULL;
static jclass LDKBech32Error_InvalidChecksum_class = NULL;
return ret_conv;
}
+static inline struct LDKBlindedRoute CResult_BlindedRouteNoneZ_get_ok(LDKCResult_BlindedRouteNoneZ *NONNULL_PTR owner){
+ LDKBlindedRoute ret = *owner->contents.result;
+ ret.is_owned = false;
+ return ret;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1BlindedRouteNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t owner) {
+ LDKCResult_BlindedRouteNoneZ* owner_conv = (LDKCResult_BlindedRouteNoneZ*)untag_ptr(owner);
+ LDKBlindedRoute ret_var = CResult_BlindedRouteNoneZ_get_ok(owner_conv);
+ int64_t ret_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
+ return ret_ref;
+}
+
+static inline void CResult_BlindedRouteNoneZ_get_err(LDKCResult_BlindedRouteNoneZ *NONNULL_PTR owner){
+CHECK(!owner->result_ok);
+ return *owner->contents.err;
+}
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1BlindedRouteNoneZ_1get_1err(JNIEnv *env, jclass clz, int64_t owner) {
+ LDKCResult_BlindedRouteNoneZ* owner_conv = (LDKCResult_BlindedRouteNoneZ*)untag_ptr(owner);
+ CResult_BlindedRouteNoneZ_get_err(owner_conv);
+}
+
+static inline struct LDKBlindedRoute CResult_BlindedRouteDecodeErrorZ_get_ok(LDKCResult_BlindedRouteDecodeErrorZ *NONNULL_PTR owner){
+ LDKBlindedRoute ret = *owner->contents.result;
+ ret.is_owned = false;
+ return ret;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1BlindedRouteDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t owner) {
+ LDKCResult_BlindedRouteDecodeErrorZ* owner_conv = (LDKCResult_BlindedRouteDecodeErrorZ*)untag_ptr(owner);
+ LDKBlindedRoute ret_var = CResult_BlindedRouteDecodeErrorZ_get_ok(owner_conv);
+ int64_t ret_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
+ return ret_ref;
+}
+
+static inline struct LDKDecodeError CResult_BlindedRouteDecodeErrorZ_get_err(LDKCResult_BlindedRouteDecodeErrorZ *NONNULL_PTR owner){
+ LDKDecodeError ret = *owner->contents.err;
+ ret.is_owned = false;
+ return ret;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1BlindedRouteDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t owner) {
+ LDKCResult_BlindedRouteDecodeErrorZ* owner_conv = (LDKCResult_BlindedRouteDecodeErrorZ*)untag_ptr(owner);
+ LDKDecodeError ret_var = CResult_BlindedRouteDecodeErrorZ_get_err(owner_conv);
+ int64_t ret_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
+ return ret_ref;
+}
+
+static inline struct LDKBlindedHop CResult_BlindedHopDecodeErrorZ_get_ok(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner){
+ LDKBlindedHop ret = *owner->contents.result;
+ ret.is_owned = false;
+ return ret;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1BlindedHopDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t owner) {
+ LDKCResult_BlindedHopDecodeErrorZ* owner_conv = (LDKCResult_BlindedHopDecodeErrorZ*)untag_ptr(owner);
+ LDKBlindedHop ret_var = CResult_BlindedHopDecodeErrorZ_get_ok(owner_conv);
+ int64_t ret_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
+ return ret_ref;
+}
+
+static inline struct LDKDecodeError CResult_BlindedHopDecodeErrorZ_get_err(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner){
+ LDKDecodeError ret = *owner->contents.err;
+ ret.is_owned = false;
+ return ret;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1BlindedHopDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t owner) {
+ LDKCResult_BlindedHopDecodeErrorZ* owner_conv = (LDKCResult_BlindedHopDecodeErrorZ*)untag_ptr(owner);
+ LDKDecodeError ret_var = CResult_BlindedHopDecodeErrorZ_get_err(owner_conv);
+ int64_t ret_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
+ return ret_ref;
+}
+
static inline void CResult_NoneNoneZ_get_ok(LDKCResult_NoneNoneZ *NONNULL_PTR owner){
CHECK(owner->result_ok);
return *owner->contents.result;
return ret_ref;
}
+static inline LDKCVec_RouteHopZ CVec_RouteHopZ_clone(const LDKCVec_RouteHopZ *orig) {
+ LDKCVec_RouteHopZ ret = { .data = MALLOC(sizeof(LDKRouteHop) * orig->datalen, "LDKCVec_RouteHopZ clone bytes"), .datalen = orig->datalen };
+ for (size_t i = 0; i < ret.datalen; i++) {
+ ret.data[i] = RouteHop_clone(&orig->data[i]);
+ }
+ return ret;
+}
+typedef struct LDKScore_JCalls {
+ atomic_size_t refcnt;
+ JavaVM *vm;
+ jweak o;
+ jmethodID channel_penalty_msat_meth;
+ jmethodID payment_path_failed_meth;
+ jmethodID payment_path_successful_meth;
+ jmethodID probe_failed_meth;
+ jmethodID probe_successful_meth;
+ jmethodID write_meth;
+} LDKScore_JCalls;
+static void LDKScore_JCalls_free(void* this_arg) {
+ LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
+ if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
+ JNIEnv *env;
+ jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
+ } else {
+ DO_ASSERT(get_jenv_res == JNI_OK);
+ }
+ (*env)->DeleteWeakGlobalRef(env, j_calls->o);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
+ }
+ FREE(j_calls);
+ }
+}
+uint64_t channel_penalty_msat_LDKScore_jcall(const void* this_arg, uint64_t short_channel_id, const LDKNodeId * source, const LDKNodeId * target, LDKChannelUsage usage) {
+ LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
+ JNIEnv *env;
+ jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
+ } else {
+ DO_ASSERT(get_jenv_res == JNI_OK);
+ }
+ int64_t short_channel_id_conv = short_channel_id;
+ LDKNodeId source_var = *source;
+ int64_t source_ref = 0;
+ source_var = NodeId_clone(&source_var);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(source_var);
+ source_ref = tag_ptr(source_var.inner, source_var.is_owned);
+ LDKNodeId target_var = *target;
+ int64_t target_ref = 0;
+ target_var = NodeId_clone(&target_var);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(target_var);
+ target_ref = tag_ptr(target_var.inner, target_var.is_owned);
+ LDKChannelUsage usage_var = usage;
+ int64_t usage_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(usage_var);
+ usage_ref = tag_ptr(usage_var.inner, usage_var.is_owned);
+ jobject obj = (*env)->NewLocalRef(env, j_calls->o);
+ CHECK(obj != NULL);
+ int64_t ret = (*env)->CallLongMethod(env, obj, j_calls->channel_penalty_msat_meth, short_channel_id_conv, source_ref, target_ref, usage_ref);
+ if (UNLIKELY((*env)->ExceptionCheck(env))) {
+ (*env)->ExceptionDescribe(env);
+ (*env)->FatalError(env, "A call to channel_penalty_msat in LDKScore from rust threw an exception.");
+ }
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
+ }
+ return ret;
+}
+void payment_path_failed_LDKScore_jcall(void* this_arg, LDKCVec_RouteHopZ path, uint64_t short_channel_id) {
+ LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
+ JNIEnv *env;
+ jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
+ } else {
+ DO_ASSERT(get_jenv_res == JNI_OK);
+ }
+ LDKCVec_RouteHopZ path_var = path;
+ int64_tArray path_arr = NULL;
+ path_arr = (*env)->NewLongArray(env, path_var.datalen);
+ int64_t *path_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, path_arr, NULL);
+ for (size_t k = 0; k < path_var.datalen; k++) {
+ LDKRouteHop path_conv_10_var = path_var.data[k];
+ int64_t path_conv_10_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
+ path_conv_10_ref = tag_ptr(path_conv_10_var.inner, path_conv_10_var.is_owned);
+ path_arr_ptr[k] = path_conv_10_ref;
+ }
+ (*env)->ReleasePrimitiveArrayCritical(env, path_arr, path_arr_ptr, 0);
+ FREE(path_var.data);
+ int64_t short_channel_id_conv = short_channel_id;
+ jobject obj = (*env)->NewLocalRef(env, j_calls->o);
+ CHECK(obj != NULL);
+ (*env)->CallVoidMethod(env, obj, j_calls->payment_path_failed_meth, path_arr, short_channel_id_conv);
+ if (UNLIKELY((*env)->ExceptionCheck(env))) {
+ (*env)->ExceptionDescribe(env);
+ (*env)->FatalError(env, "A call to payment_path_failed in LDKScore from rust threw an exception.");
+ }
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
+ }
+}
+void payment_path_successful_LDKScore_jcall(void* this_arg, LDKCVec_RouteHopZ path) {
+ LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
+ JNIEnv *env;
+ jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
+ } else {
+ DO_ASSERT(get_jenv_res == JNI_OK);
+ }
+ LDKCVec_RouteHopZ path_var = path;
+ int64_tArray path_arr = NULL;
+ path_arr = (*env)->NewLongArray(env, path_var.datalen);
+ int64_t *path_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, path_arr, NULL);
+ for (size_t k = 0; k < path_var.datalen; k++) {
+ LDKRouteHop path_conv_10_var = path_var.data[k];
+ int64_t path_conv_10_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
+ path_conv_10_ref = tag_ptr(path_conv_10_var.inner, path_conv_10_var.is_owned);
+ path_arr_ptr[k] = path_conv_10_ref;
+ }
+ (*env)->ReleasePrimitiveArrayCritical(env, path_arr, path_arr_ptr, 0);
+ FREE(path_var.data);
+ jobject obj = (*env)->NewLocalRef(env, j_calls->o);
+ CHECK(obj != NULL);
+ (*env)->CallVoidMethod(env, obj, j_calls->payment_path_successful_meth, path_arr);
+ if (UNLIKELY((*env)->ExceptionCheck(env))) {
+ (*env)->ExceptionDescribe(env);
+ (*env)->FatalError(env, "A call to payment_path_successful in LDKScore from rust threw an exception.");
+ }
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
+ }
+}
+void probe_failed_LDKScore_jcall(void* this_arg, LDKCVec_RouteHopZ path, uint64_t short_channel_id) {
+ LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
+ JNIEnv *env;
+ jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
+ } else {
+ DO_ASSERT(get_jenv_res == JNI_OK);
+ }
+ LDKCVec_RouteHopZ path_var = path;
+ int64_tArray path_arr = NULL;
+ path_arr = (*env)->NewLongArray(env, path_var.datalen);
+ int64_t *path_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, path_arr, NULL);
+ for (size_t k = 0; k < path_var.datalen; k++) {
+ LDKRouteHop path_conv_10_var = path_var.data[k];
+ int64_t path_conv_10_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
+ path_conv_10_ref = tag_ptr(path_conv_10_var.inner, path_conv_10_var.is_owned);
+ path_arr_ptr[k] = path_conv_10_ref;
+ }
+ (*env)->ReleasePrimitiveArrayCritical(env, path_arr, path_arr_ptr, 0);
+ FREE(path_var.data);
+ int64_t short_channel_id_conv = short_channel_id;
+ jobject obj = (*env)->NewLocalRef(env, j_calls->o);
+ CHECK(obj != NULL);
+ (*env)->CallVoidMethod(env, obj, j_calls->probe_failed_meth, path_arr, short_channel_id_conv);
+ if (UNLIKELY((*env)->ExceptionCheck(env))) {
+ (*env)->ExceptionDescribe(env);
+ (*env)->FatalError(env, "A call to probe_failed in LDKScore from rust threw an exception.");
+ }
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
+ }
+}
+void probe_successful_LDKScore_jcall(void* this_arg, LDKCVec_RouteHopZ path) {
+ LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
+ JNIEnv *env;
+ jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
+ } else {
+ DO_ASSERT(get_jenv_res == JNI_OK);
+ }
+ LDKCVec_RouteHopZ path_var = path;
+ int64_tArray path_arr = NULL;
+ path_arr = (*env)->NewLongArray(env, path_var.datalen);
+ int64_t *path_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, path_arr, NULL);
+ for (size_t k = 0; k < path_var.datalen; k++) {
+ LDKRouteHop path_conv_10_var = path_var.data[k];
+ int64_t path_conv_10_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
+ path_conv_10_ref = tag_ptr(path_conv_10_var.inner, path_conv_10_var.is_owned);
+ path_arr_ptr[k] = path_conv_10_ref;
+ }
+ (*env)->ReleasePrimitiveArrayCritical(env, path_arr, path_arr_ptr, 0);
+ FREE(path_var.data);
+ jobject obj = (*env)->NewLocalRef(env, j_calls->o);
+ CHECK(obj != NULL);
+ (*env)->CallVoidMethod(env, obj, j_calls->probe_successful_meth, path_arr);
+ if (UNLIKELY((*env)->ExceptionCheck(env))) {
+ (*env)->ExceptionDescribe(env);
+ (*env)->FatalError(env, "A call to probe_successful in LDKScore from rust threw an exception.");
+ }
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
+ }
+}
+LDKCVec_u8Z write_LDKScore_jcall(const void* this_arg) {
+ LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
+ JNIEnv *env;
+ jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
+ } else {
+ DO_ASSERT(get_jenv_res == JNI_OK);
+ }
+ jobject obj = (*env)->NewLocalRef(env, j_calls->o);
+ CHECK(obj != NULL);
+ int8_tArray ret = (*env)->CallObjectMethod(env, obj, j_calls->write_meth);
+ if (UNLIKELY((*env)->ExceptionCheck(env))) {
+ (*env)->ExceptionDescribe(env);
+ (*env)->FatalError(env, "A call to write in LDKScore from rust threw an exception.");
+ }
+ LDKCVec_u8Z ret_ref;
+ ret_ref.datalen = (*env)->GetArrayLength(env, ret);
+ ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
+ (*env)->GetByteArrayRegion(env, ret, 0, ret_ref.datalen, ret_ref.data);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
+ }
+ return ret_ref;
+}
+static void LDKScore_JCalls_cloned(LDKScore* new_obj) {
+ LDKScore_JCalls *j_calls = (LDKScore_JCalls*) new_obj->this_arg;
+ atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
+}
+static inline LDKScore LDKScore_init (JNIEnv *env, jclass clz, jobject o) {
+ jclass c = (*env)->GetObjectClass(env, o);
+ CHECK(c != NULL);
+ LDKScore_JCalls *calls = MALLOC(sizeof(LDKScore_JCalls), "LDKScore_JCalls");
+ atomic_init(&calls->refcnt, 1);
+ DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
+ calls->o = (*env)->NewWeakGlobalRef(env, o);
+ calls->channel_penalty_msat_meth = (*env)->GetMethodID(env, c, "channel_penalty_msat", "(JJJJ)J");
+ CHECK(calls->channel_penalty_msat_meth != NULL);
+ calls->payment_path_failed_meth = (*env)->GetMethodID(env, c, "payment_path_failed", "([JJ)V");
+ CHECK(calls->payment_path_failed_meth != NULL);
+ calls->payment_path_successful_meth = (*env)->GetMethodID(env, c, "payment_path_successful", "([J)V");
+ CHECK(calls->payment_path_successful_meth != NULL);
+ calls->probe_failed_meth = (*env)->GetMethodID(env, c, "probe_failed", "([JJ)V");
+ CHECK(calls->probe_failed_meth != NULL);
+ calls->probe_successful_meth = (*env)->GetMethodID(env, c, "probe_successful", "([J)V");
+ CHECK(calls->probe_successful_meth != NULL);
+ calls->write_meth = (*env)->GetMethodID(env, c, "write", "()[B");
+ CHECK(calls->write_meth != NULL);
+
+ LDKScore ret = {
+ .this_arg = (void*) calls,
+ .channel_penalty_msat = channel_penalty_msat_LDKScore_jcall,
+ .payment_path_failed = payment_path_failed_LDKScore_jcall,
+ .payment_path_successful = payment_path_successful_LDKScore_jcall,
+ .probe_failed = probe_failed_LDKScore_jcall,
+ .probe_successful = probe_successful_LDKScore_jcall,
+ .write = write_LDKScore_jcall,
+ .free = LDKScore_JCalls_free,
+ };
+ return ret;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKScore_1new(JNIEnv *env, jclass clz, jobject o) {
+ LDKScore *res_ptr = MALLOC(sizeof(LDKScore), "LDKScore");
+ *res_ptr = LDKScore_init(env, clz, o);
+ return tag_ptr(res_ptr, true);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Score_1channel_1penalty_1msat(JNIEnv *env, jclass clz, int64_t this_arg, int64_t short_channel_id, int64_t source, int64_t target, int64_t usage) {
+ void* this_arg_ptr = untag_ptr(this_arg);
+ if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
+ LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
+ LDKNodeId source_conv;
+ source_conv.inner = untag_ptr(source);
+ source_conv.is_owned = ptr_is_owned(source);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(source_conv);
+ source_conv.is_owned = false;
+ LDKNodeId target_conv;
+ target_conv.inner = untag_ptr(target);
+ target_conv.is_owned = ptr_is_owned(target);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(target_conv);
+ target_conv.is_owned = false;
+ LDKChannelUsage usage_conv;
+ usage_conv.inner = untag_ptr(usage);
+ usage_conv.is_owned = ptr_is_owned(usage);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(usage_conv);
+ usage_conv = ChannelUsage_clone(&usage_conv);
+ int64_t ret_conv = (this_arg_conv->channel_penalty_msat)(this_arg_conv->this_arg, short_channel_id, &source_conv, &target_conv, usage_conv);
+ return ret_conv;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Score_1payment_1path_1failed(JNIEnv *env, jclass clz, int64_t this_arg, int64_tArray path, int64_t short_channel_id) {
+ void* this_arg_ptr = untag_ptr(this_arg);
+ if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
+ LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
+ LDKCVec_RouteHopZ path_constr;
+ path_constr.datalen = (*env)->GetArrayLength(env, path);
+ if (path_constr.datalen > 0)
+ path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
+ else
+ path_constr.data = NULL;
+ int64_t* path_vals = (*env)->GetLongArrayElements (env, path, NULL);
+ for (size_t k = 0; k < path_constr.datalen; k++) {
+ int64_t path_conv_10 = path_vals[k];
+ LDKRouteHop path_conv_10_conv;
+ path_conv_10_conv.inner = untag_ptr(path_conv_10);
+ path_conv_10_conv.is_owned = ptr_is_owned(path_conv_10);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
+ path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
+ path_constr.data[k] = path_conv_10_conv;
+ }
+ (*env)->ReleaseLongArrayElements(env, path, path_vals, 0);
+ (this_arg_conv->payment_path_failed)(this_arg_conv->this_arg, path_constr, short_channel_id);
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Score_1payment_1path_1successful(JNIEnv *env, jclass clz, int64_t this_arg, int64_tArray path) {
+ void* this_arg_ptr = untag_ptr(this_arg);
+ if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
+ LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
+ LDKCVec_RouteHopZ path_constr;
+ path_constr.datalen = (*env)->GetArrayLength(env, path);
+ if (path_constr.datalen > 0)
+ path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
+ else
+ path_constr.data = NULL;
+ int64_t* path_vals = (*env)->GetLongArrayElements (env, path, NULL);
+ for (size_t k = 0; k < path_constr.datalen; k++) {
+ int64_t path_conv_10 = path_vals[k];
+ LDKRouteHop path_conv_10_conv;
+ path_conv_10_conv.inner = untag_ptr(path_conv_10);
+ path_conv_10_conv.is_owned = ptr_is_owned(path_conv_10);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
+ path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
+ path_constr.data[k] = path_conv_10_conv;
+ }
+ (*env)->ReleaseLongArrayElements(env, path, path_vals, 0);
+ (this_arg_conv->payment_path_successful)(this_arg_conv->this_arg, path_constr);
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Score_1probe_1failed(JNIEnv *env, jclass clz, int64_t this_arg, int64_tArray path, int64_t short_channel_id) {
+ void* this_arg_ptr = untag_ptr(this_arg);
+ if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
+ LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
+ LDKCVec_RouteHopZ path_constr;
+ path_constr.datalen = (*env)->GetArrayLength(env, path);
+ if (path_constr.datalen > 0)
+ path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
+ else
+ path_constr.data = NULL;
+ int64_t* path_vals = (*env)->GetLongArrayElements (env, path, NULL);
+ for (size_t k = 0; k < path_constr.datalen; k++) {
+ int64_t path_conv_10 = path_vals[k];
+ LDKRouteHop path_conv_10_conv;
+ path_conv_10_conv.inner = untag_ptr(path_conv_10);
+ path_conv_10_conv.is_owned = ptr_is_owned(path_conv_10);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
+ path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
+ path_constr.data[k] = path_conv_10_conv;
+ }
+ (*env)->ReleaseLongArrayElements(env, path, path_vals, 0);
+ (this_arg_conv->probe_failed)(this_arg_conv->this_arg, path_constr, short_channel_id);
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Score_1probe_1successful(JNIEnv *env, jclass clz, int64_t this_arg, int64_tArray path) {
+ void* this_arg_ptr = untag_ptr(this_arg);
+ if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
+ LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
+ LDKCVec_RouteHopZ path_constr;
+ path_constr.datalen = (*env)->GetArrayLength(env, path);
+ if (path_constr.datalen > 0)
+ path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
+ else
+ path_constr.data = NULL;
+ int64_t* path_vals = (*env)->GetLongArrayElements (env, path, NULL);
+ for (size_t k = 0; k < path_constr.datalen; k++) {
+ int64_t path_conv_10 = path_vals[k];
+ LDKRouteHop path_conv_10_conv;
+ path_conv_10_conv.inner = untag_ptr(path_conv_10);
+ path_conv_10_conv.is_owned = ptr_is_owned(path_conv_10);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
+ path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
+ path_constr.data[k] = path_conv_10_conv;
+ }
+ (*env)->ReleaseLongArrayElements(env, path, path_vals, 0);
+ (this_arg_conv->probe_successful)(this_arg_conv->this_arg, path_constr);
+}
+
+JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_Score_1write(JNIEnv *env, jclass clz, int64_t this_arg) {
+ void* this_arg_ptr = untag_ptr(this_arg);
+ if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
+ LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
+ LDKCVec_u8Z ret_var = (this_arg_conv->write)(this_arg_conv->this_arg);
+ int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
+ (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
+ CVec_u8Z_free(ret_var);
+ return ret_arr;
+}
+
+typedef struct LDKLockableScore_JCalls {
+ atomic_size_t refcnt;
+ JavaVM *vm;
+ jweak o;
+ jmethodID lock_meth;
+} LDKLockableScore_JCalls;
+static void LDKLockableScore_JCalls_free(void* this_arg) {
+ LDKLockableScore_JCalls *j_calls = (LDKLockableScore_JCalls*) this_arg;
+ if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
+ JNIEnv *env;
+ jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
+ } else {
+ DO_ASSERT(get_jenv_res == JNI_OK);
+ }
+ (*env)->DeleteWeakGlobalRef(env, j_calls->o);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
+ }
+ FREE(j_calls);
+ }
+}
+LDKScore lock_LDKLockableScore_jcall(const void* this_arg) {
+ LDKLockableScore_JCalls *j_calls = (LDKLockableScore_JCalls*) this_arg;
+ JNIEnv *env;
+ jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
+ } else {
+ DO_ASSERT(get_jenv_res == JNI_OK);
+ }
+ jobject obj = (*env)->NewLocalRef(env, j_calls->o);
+ CHECK(obj != NULL);
+ uint64_t ret = (*env)->CallLongMethod(env, obj, j_calls->lock_meth);
+ if (UNLIKELY((*env)->ExceptionCheck(env))) {
+ (*env)->ExceptionDescribe(env);
+ (*env)->FatalError(env, "A call to lock in LDKLockableScore from rust threw an exception.");
+ }
+ void* ret_ptr = untag_ptr(ret);
+ CHECK_ACCESS(ret_ptr);
+ LDKScore ret_conv = *(LDKScore*)(ret_ptr);
+ if (ret_conv.free == LDKScore_JCalls_free) {
+ // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
+ LDKScore_JCalls_cloned(&ret_conv);
+ }// WARNING: we may need a move here but no clone is available for LDKScore
+
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
+ }
+ return ret_conv;
+}
+static void LDKLockableScore_JCalls_cloned(LDKLockableScore* new_obj) {
+ LDKLockableScore_JCalls *j_calls = (LDKLockableScore_JCalls*) new_obj->this_arg;
+ atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
+}
+static inline LDKLockableScore LDKLockableScore_init (JNIEnv *env, jclass clz, jobject o) {
+ jclass c = (*env)->GetObjectClass(env, o);
+ CHECK(c != NULL);
+ LDKLockableScore_JCalls *calls = MALLOC(sizeof(LDKLockableScore_JCalls), "LDKLockableScore_JCalls");
+ atomic_init(&calls->refcnt, 1);
+ DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
+ calls->o = (*env)->NewWeakGlobalRef(env, o);
+ calls->lock_meth = (*env)->GetMethodID(env, c, "lock", "()J");
+ CHECK(calls->lock_meth != NULL);
+
+ LDKLockableScore ret = {
+ .this_arg = (void*) calls,
+ .lock = lock_LDKLockableScore_jcall,
+ .free = LDKLockableScore_JCalls_free,
+ };
+ return ret;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKLockableScore_1new(JNIEnv *env, jclass clz, jobject o) {
+ LDKLockableScore *res_ptr = MALLOC(sizeof(LDKLockableScore), "LDKLockableScore");
+ *res_ptr = LDKLockableScore_init(env, clz, o);
+ return tag_ptr(res_ptr, true);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LockableScore_1lock(JNIEnv *env, jclass clz, int64_t this_arg) {
+ void* this_arg_ptr = untag_ptr(this_arg);
+ if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
+ LDKLockableScore* this_arg_conv = (LDKLockableScore*)this_arg_ptr;
+ LDKScore* ret_ret = MALLOC(sizeof(LDKScore), "LDKScore");
+ *ret_ret = (this_arg_conv->lock)(this_arg_conv->this_arg);
+ return tag_ptr(ret_ret, true);
+}
+
+typedef struct LDKWriteableScore_JCalls {
+ atomic_size_t refcnt;
+ JavaVM *vm;
+ jweak o;
+ LDKLockableScore_JCalls* LockableScore;
+ jmethodID write_meth;
+} LDKWriteableScore_JCalls;
+static void LDKWriteableScore_JCalls_free(void* this_arg) {
+ LDKWriteableScore_JCalls *j_calls = (LDKWriteableScore_JCalls*) this_arg;
+ if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
+ JNIEnv *env;
+ jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
+ } else {
+ DO_ASSERT(get_jenv_res == JNI_OK);
+ }
+ (*env)->DeleteWeakGlobalRef(env, j_calls->o);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
+ }
+ FREE(j_calls);
+ }
+}
+LDKCVec_u8Z write_LDKWriteableScore_jcall(const void* this_arg) {
+ LDKWriteableScore_JCalls *j_calls = (LDKWriteableScore_JCalls*) this_arg;
+ JNIEnv *env;
+ jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
+ } else {
+ DO_ASSERT(get_jenv_res == JNI_OK);
+ }
+ jobject obj = (*env)->NewLocalRef(env, j_calls->o);
+ CHECK(obj != NULL);
+ int8_tArray ret = (*env)->CallObjectMethod(env, obj, j_calls->write_meth);
+ if (UNLIKELY((*env)->ExceptionCheck(env))) {
+ (*env)->ExceptionDescribe(env);
+ (*env)->FatalError(env, "A call to write in LDKWriteableScore from rust threw an exception.");
+ }
+ LDKCVec_u8Z ret_ref;
+ ret_ref.datalen = (*env)->GetArrayLength(env, ret);
+ ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
+ (*env)->GetByteArrayRegion(env, ret, 0, ret_ref.datalen, ret_ref.data);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
+ }
+ return ret_ref;
+}
+static void LDKWriteableScore_JCalls_cloned(LDKWriteableScore* new_obj) {
+ LDKWriteableScore_JCalls *j_calls = (LDKWriteableScore_JCalls*) new_obj->this_arg;
+ atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
+ atomic_fetch_add_explicit(&j_calls->LockableScore->refcnt, 1, memory_order_release);
+}
+static inline LDKWriteableScore LDKWriteableScore_init (JNIEnv *env, jclass clz, jobject o, jobject LockableScore) {
+ jclass c = (*env)->GetObjectClass(env, o);
+ CHECK(c != NULL);
+ LDKWriteableScore_JCalls *calls = MALLOC(sizeof(LDKWriteableScore_JCalls), "LDKWriteableScore_JCalls");
+ atomic_init(&calls->refcnt, 1);
+ DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
+ calls->o = (*env)->NewWeakGlobalRef(env, o);
+ calls->write_meth = (*env)->GetMethodID(env, c, "write", "()[B");
+ CHECK(calls->write_meth != NULL);
+
+ LDKWriteableScore ret = {
+ .this_arg = (void*) calls,
+ .write = write_LDKWriteableScore_jcall,
+ .free = LDKWriteableScore_JCalls_free,
+ .LockableScore = LDKLockableScore_init(env, clz, LockableScore),
+ };
+ calls->LockableScore = ret.LockableScore.this_arg;
+ return ret;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKWriteableScore_1new(JNIEnv *env, jclass clz, jobject o, jobject LockableScore) {
+ LDKWriteableScore *res_ptr = MALLOC(sizeof(LDKWriteableScore), "LDKWriteableScore");
+ *res_ptr = LDKWriteableScore_init(env, clz, o, LockableScore);
+ return tag_ptr(res_ptr, true);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKWriteableScore_1get_1LockableScore(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKWriteableScore *inp = (LDKWriteableScore *)untag_ptr(arg);
+ return tag_ptr(&inp->LockableScore, false);
+}
+JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_WriteableScore_1write(JNIEnv *env, jclass clz, int64_t this_arg) {
+ void* this_arg_ptr = untag_ptr(this_arg);
+ if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
+ LDKWriteableScore* this_arg_conv = (LDKWriteableScore*)this_arg_ptr;
+ LDKCVec_u8Z ret_var = (this_arg_conv->write)(this_arg_conv->this_arg);
+ int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
+ (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
+ CVec_u8Z_free(ret_var);
+ return ret_arr;
+}
+
+static jclass LDKCOption_WriteableScoreZ_Some_class = NULL;
+static jmethodID LDKCOption_WriteableScoreZ_Some_meth = NULL;
+static jclass LDKCOption_WriteableScoreZ_None_class = NULL;
+static jmethodID LDKCOption_WriteableScoreZ_None_meth = NULL;
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKCOption_1WriteableScoreZ_init (JNIEnv *env, jclass clz) {
+ LDKCOption_WriteableScoreZ_Some_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "org/ldk/impl/bindings$LDKCOption_WriteableScoreZ$Some"));
+ CHECK(LDKCOption_WriteableScoreZ_Some_class != NULL);
+ LDKCOption_WriteableScoreZ_Some_meth = (*env)->GetMethodID(env, LDKCOption_WriteableScoreZ_Some_class, "<init>", "(J)V");
+ CHECK(LDKCOption_WriteableScoreZ_Some_meth != NULL);
+ LDKCOption_WriteableScoreZ_None_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "org/ldk/impl/bindings$LDKCOption_WriteableScoreZ$None"));
+ CHECK(LDKCOption_WriteableScoreZ_None_class != NULL);
+ LDKCOption_WriteableScoreZ_None_meth = (*env)->GetMethodID(env, LDKCOption_WriteableScoreZ_None_class, "<init>", "()V");
+ CHECK(LDKCOption_WriteableScoreZ_None_meth != NULL);
+}
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCOption_1WriteableScoreZ_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
+ LDKCOption_WriteableScoreZ *obj = (LDKCOption_WriteableScoreZ*)untag_ptr(ptr);
+ switch(obj->tag) {
+ case LDKCOption_WriteableScoreZ_Some: {
+ LDKWriteableScore* some_ret = MALLOC(sizeof(LDKWriteableScore), "LDKWriteableScore");
+ *some_ret = obj->some;
+ // WARNING: We likely need to clone here, but no clone is available, so we just do it for Java instances
+ if ((*some_ret).free == LDKWriteableScore_JCalls_free) {
+ // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
+ LDKWriteableScore_JCalls_cloned(&(*some_ret));
+ }
+ return (*env)->NewObject(env, LDKCOption_WriteableScoreZ_Some_class, LDKCOption_WriteableScoreZ_Some_meth, tag_ptr(some_ret, true));
+ }
+ case LDKCOption_WriteableScoreZ_None: {
+ return (*env)->NewObject(env, LDKCOption_WriteableScoreZ_None_class, LDKCOption_WriteableScoreZ_None_meth);
+ }
+ default: abort();
+ }
+}
static inline void CResult_NoneErrorZ_get_ok(LDKCResult_NoneErrorZ *NONNULL_PTR owner){
CHECK(owner->result_ok);
return *owner->contents.result;
return ret_ref;
}
-static inline LDKCVec_RouteHopZ CVec_RouteHopZ_clone(const LDKCVec_RouteHopZ *orig) {
- LDKCVec_RouteHopZ ret = { .data = MALLOC(sizeof(LDKRouteHop) * orig->datalen, "LDKCVec_RouteHopZ clone bytes"), .datalen = orig->datalen };
- for (size_t i = 0; i < ret.datalen; i++) {
- ret.data[i] = RouteHop_clone(&orig->data[i]);
- }
- return ret;
-}
static inline LDKCVec_CVec_RouteHopZZ CVec_CVec_RouteHopZZ_clone(const LDKCVec_CVec_RouteHopZZ *orig) {
LDKCVec_CVec_RouteHopZZ ret = { .data = MALLOC(sizeof(LDKCVec_RouteHopZ) * orig->datalen, "LDKCVec_CVec_RouteHopZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
(*env)->SetByteArrayRegion(env, payment_id_arr, 0, 32, obj->payment_path_failed.payment_id.data);
int8_tArray payment_hash_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, payment_hash_arr, 0, 32, obj->payment_path_failed.payment_hash.data);
- jboolean rejected_by_dest_conv = obj->payment_path_failed.rejected_by_dest;
+ jboolean payment_failed_permanently_conv = obj->payment_path_failed.payment_failed_permanently;
int64_t network_update_ref = tag_ptr(&obj->payment_path_failed.network_update, false);
jboolean all_paths_failed_conv = obj->payment_path_failed.all_paths_failed;
LDKCVec_RouteHopZ path_var = obj->payment_path_failed.path;
int64_t retry_ref = 0;
CHECK_INNER_FIELD_ACCESS_OR_NULL(retry_var);
retry_ref = tag_ptr(retry_var.inner, false);
- return (*env)->NewObject(env, LDKEvent_PaymentPathFailed_class, LDKEvent_PaymentPathFailed_meth, payment_id_arr, payment_hash_arr, rejected_by_dest_conv, network_update_ref, all_paths_failed_conv, path_arr, short_channel_id_ref, retry_ref);
+ return (*env)->NewObject(env, LDKEvent_PaymentPathFailed_class, LDKEvent_PaymentPathFailed_meth, payment_id_arr, payment_hash_arr, payment_failed_permanently_conv, network_update_ref, all_paths_failed_conv, path_arr, short_channel_id_ref, retry_ref);
}
case LDKEvent_ProbeSuccessful: {
int8_tArray payment_id_arr = (*env)->NewByteArray(env, 32);
static jmethodID LDKMessageSendEvent_SendShutdown_meth = NULL;
static jclass LDKMessageSendEvent_SendChannelReestablish_class = NULL;
static jmethodID LDKMessageSendEvent_SendChannelReestablish_meth = NULL;
+static jclass LDKMessageSendEvent_SendChannelAnnouncement_class = NULL;
+static jmethodID LDKMessageSendEvent_SendChannelAnnouncement_meth = NULL;
static jclass LDKMessageSendEvent_BroadcastChannelAnnouncement_class = NULL;
static jmethodID LDKMessageSendEvent_BroadcastChannelAnnouncement_meth = NULL;
-static jclass LDKMessageSendEvent_BroadcastNodeAnnouncement_class = NULL;
-static jmethodID LDKMessageSendEvent_BroadcastNodeAnnouncement_meth = NULL;
static jclass LDKMessageSendEvent_BroadcastChannelUpdate_class = NULL;
static jmethodID LDKMessageSendEvent_BroadcastChannelUpdate_meth = NULL;
static jclass LDKMessageSendEvent_SendChannelUpdate_class = NULL;
CHECK(LDKMessageSendEvent_SendChannelReestablish_class != NULL);
LDKMessageSendEvent_SendChannelReestablish_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendChannelReestablish_class, "<init>", "([BJ)V");
CHECK(LDKMessageSendEvent_SendChannelReestablish_meth != NULL);
+ LDKMessageSendEvent_SendChannelAnnouncement_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "org/ldk/impl/bindings$LDKMessageSendEvent$SendChannelAnnouncement"));
+ CHECK(LDKMessageSendEvent_SendChannelAnnouncement_class != NULL);
+ LDKMessageSendEvent_SendChannelAnnouncement_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendChannelAnnouncement_class, "<init>", "([BJJ)V");
+ CHECK(LDKMessageSendEvent_SendChannelAnnouncement_meth != NULL);
LDKMessageSendEvent_BroadcastChannelAnnouncement_class =
(*env)->NewGlobalRef(env, (*env)->FindClass(env, "org/ldk/impl/bindings$LDKMessageSendEvent$BroadcastChannelAnnouncement"));
CHECK(LDKMessageSendEvent_BroadcastChannelAnnouncement_class != NULL);
LDKMessageSendEvent_BroadcastChannelAnnouncement_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_BroadcastChannelAnnouncement_class, "<init>", "(JJ)V");
CHECK(LDKMessageSendEvent_BroadcastChannelAnnouncement_meth != NULL);
- LDKMessageSendEvent_BroadcastNodeAnnouncement_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "org/ldk/impl/bindings$LDKMessageSendEvent$BroadcastNodeAnnouncement"));
- CHECK(LDKMessageSendEvent_BroadcastNodeAnnouncement_class != NULL);
- LDKMessageSendEvent_BroadcastNodeAnnouncement_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_BroadcastNodeAnnouncement_class, "<init>", "(J)V");
- CHECK(LDKMessageSendEvent_BroadcastNodeAnnouncement_meth != NULL);
LDKMessageSendEvent_BroadcastChannelUpdate_class =
(*env)->NewGlobalRef(env, (*env)->FindClass(env, "org/ldk/impl/bindings$LDKMessageSendEvent$BroadcastChannelUpdate"));
CHECK(LDKMessageSendEvent_BroadcastChannelUpdate_class != NULL);
msg_ref = tag_ptr(msg_var.inner, false);
return (*env)->NewObject(env, LDKMessageSendEvent_SendChannelReestablish_class, LDKMessageSendEvent_SendChannelReestablish_meth, node_id_arr, msg_ref);
}
- case LDKMessageSendEvent_BroadcastChannelAnnouncement: {
- LDKChannelAnnouncement msg_var = obj->broadcast_channel_announcement.msg;
+ case LDKMessageSendEvent_SendChannelAnnouncement: {
+ int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
+ (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->send_channel_announcement.node_id.compressed_form);
+ LDKChannelAnnouncement msg_var = obj->send_channel_announcement.msg;
int64_t msg_ref = 0;
CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = tag_ptr(msg_var.inner, false);
- LDKChannelUpdate update_msg_var = obj->broadcast_channel_announcement.update_msg;
+ LDKChannelUpdate update_msg_var = obj->send_channel_announcement.update_msg;
int64_t update_msg_ref = 0;
CHECK_INNER_FIELD_ACCESS_OR_NULL(update_msg_var);
update_msg_ref = tag_ptr(update_msg_var.inner, false);
- return (*env)->NewObject(env, LDKMessageSendEvent_BroadcastChannelAnnouncement_class, LDKMessageSendEvent_BroadcastChannelAnnouncement_meth, msg_ref, update_msg_ref);
+ return (*env)->NewObject(env, LDKMessageSendEvent_SendChannelAnnouncement_class, LDKMessageSendEvent_SendChannelAnnouncement_meth, node_id_arr, msg_ref, update_msg_ref);
}
- case LDKMessageSendEvent_BroadcastNodeAnnouncement: {
- LDKNodeAnnouncement msg_var = obj->broadcast_node_announcement.msg;
+ case LDKMessageSendEvent_BroadcastChannelAnnouncement: {
+ LDKChannelAnnouncement msg_var = obj->broadcast_channel_announcement.msg;
int64_t msg_ref = 0;
CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = tag_ptr(msg_var.inner, false);
- return (*env)->NewObject(env, LDKMessageSendEvent_BroadcastNodeAnnouncement_class, LDKMessageSendEvent_BroadcastNodeAnnouncement_meth, msg_ref);
+ LDKChannelUpdate update_msg_var = obj->broadcast_channel_announcement.update_msg;
+ int64_t update_msg_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_msg_var);
+ update_msg_ref = tag_ptr(update_msg_var.inner, false);
+ return (*env)->NewObject(env, LDKMessageSendEvent_BroadcastChannelAnnouncement_class, LDKMessageSendEvent_BroadcastChannelAnnouncement_meth, msg_ref, update_msg_ref);
}
case LDKMessageSendEvent_BroadcastChannelUpdate: {
LDKChannelUpdate msg_var = obj->broadcast_channel_update.msg;
}
return ret;
}
-static jclass LDKCOption_C2Tuple_usizeTransactionZZ_Some_class = NULL;
-static jmethodID LDKCOption_C2Tuple_usizeTransactionZZ_Some_meth = NULL;
-static jclass LDKCOption_C2Tuple_usizeTransactionZZ_None_class = NULL;
-static jmethodID LDKCOption_C2Tuple_usizeTransactionZZ_None_meth = NULL;
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKCOption_1C2Tuple_1usizeTransactionZZ_init (JNIEnv *env, jclass clz) {
- LDKCOption_C2Tuple_usizeTransactionZZ_Some_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "org/ldk/impl/bindings$LDKCOption_C2Tuple_usizeTransactionZZ$Some"));
- CHECK(LDKCOption_C2Tuple_usizeTransactionZZ_Some_class != NULL);
- LDKCOption_C2Tuple_usizeTransactionZZ_Some_meth = (*env)->GetMethodID(env, LDKCOption_C2Tuple_usizeTransactionZZ_Some_class, "<init>", "(J)V");
- CHECK(LDKCOption_C2Tuple_usizeTransactionZZ_Some_meth != NULL);
- LDKCOption_C2Tuple_usizeTransactionZZ_None_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "org/ldk/impl/bindings$LDKCOption_C2Tuple_usizeTransactionZZ$None"));
- CHECK(LDKCOption_C2Tuple_usizeTransactionZZ_None_class != NULL);
- LDKCOption_C2Tuple_usizeTransactionZZ_None_meth = (*env)->GetMethodID(env, LDKCOption_C2Tuple_usizeTransactionZZ_None_class, "<init>", "()V");
- CHECK(LDKCOption_C2Tuple_usizeTransactionZZ_None_meth != NULL);
-}
-JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCOption_1C2Tuple_1usizeTransactionZZ_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
- LDKCOption_C2Tuple_usizeTransactionZZ *obj = (LDKCOption_C2Tuple_usizeTransactionZZ*)untag_ptr(ptr);
- switch(obj->tag) {
- case LDKCOption_C2Tuple_usizeTransactionZZ_Some: {
- LDKC2Tuple_usizeTransactionZ* some_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
- *some_conv = obj->some;
- *some_conv = C2Tuple_usizeTransactionZ_clone(some_conv);
- return (*env)->NewObject(env, LDKCOption_C2Tuple_usizeTransactionZZ_Some_class, LDKCOption_C2Tuple_usizeTransactionZZ_Some_meth, tag_ptr(some_conv, true));
- }
- case LDKCOption_C2Tuple_usizeTransactionZZ_None: {
- return (*env)->NewObject(env, LDKCOption_C2Tuple_usizeTransactionZZ_None_class, LDKCOption_C2Tuple_usizeTransactionZZ_None_meth);
- }
- default: abort();
- }
-}
static inline struct LDKFixedPenaltyScorer CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner){
LDKFixedPenaltyScorer ret = *owner->contents.result;
ret.is_owned = false;
return ret_ref;
}
-static inline LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(const LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *orig) {
- LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret = { .data = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ) * orig->datalen, "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ clone bytes"), .datalen = orig->datalen };
- for (size_t i = 0; i < ret.datalen; i++) {
- ret.data[i] = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(&orig->data[i]);
- }
- return ret;
+static jclass LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_class = NULL;
+static jmethodID LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_meth = NULL;
+static jclass LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_None_class = NULL;
+static jmethodID LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_None_meth = NULL;
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKCOption_1C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZZ_init (JNIEnv *env, jclass clz) {
+ LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "org/ldk/impl/bindings$LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ$Some"));
+ CHECK(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_class != NULL);
+ LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_meth = (*env)->GetMethodID(env, LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_class, "<init>", "(J)V");
+ CHECK(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_meth != NULL);
+ LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_None_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "org/ldk/impl/bindings$LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ$None"));
+ CHECK(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_None_class != NULL);
+ LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_None_meth = (*env)->GetMethodID(env, LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_None_class, "<init>", "()V");
+ CHECK(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_None_meth != NULL);
}
-static inline LDKCVec_NodeAnnouncementZ CVec_NodeAnnouncementZ_clone(const LDKCVec_NodeAnnouncementZ *orig) {
- LDKCVec_NodeAnnouncementZ ret = { .data = MALLOC(sizeof(LDKNodeAnnouncement) * orig->datalen, "LDKCVec_NodeAnnouncementZ clone bytes"), .datalen = orig->datalen };
- for (size_t i = 0; i < ret.datalen; i++) {
- ret.data[i] = NodeAnnouncement_clone(&orig->data[i]);
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCOption_1C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZZ_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
+ LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *obj = (LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ*)untag_ptr(ptr);
+ switch(obj->tag) {
+ case LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some: {
+ LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* some_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
+ *some_conv = obj->some;
+ *some_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(some_conv);
+ return (*env)->NewObject(env, LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_class, LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_meth, tag_ptr(some_conv, true));
+ }
+ case LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_None: {
+ return (*env)->NewObject(env, LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_None_class, LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_None_meth);
+ }
+ default: abort();
}
- return ret;
}
static inline void CResult_NoneLightningErrorZ_get_ok(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner){
CHECK(owner->result_ok);
CResult_SecretKeyNoneZ_get_err(owner_conv);
}
+static jclass LDKCOption_ScalarZ_Some_class = NULL;
+static jmethodID LDKCOption_ScalarZ_Some_meth = NULL;
+static jclass LDKCOption_ScalarZ_None_class = NULL;
+static jmethodID LDKCOption_ScalarZ_None_meth = NULL;
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKCOption_1ScalarZ_init (JNIEnv *env, jclass clz) {
+ LDKCOption_ScalarZ_Some_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "org/ldk/impl/bindings$LDKCOption_ScalarZ$Some"));
+ CHECK(LDKCOption_ScalarZ_Some_class != NULL);
+ LDKCOption_ScalarZ_Some_meth = (*env)->GetMethodID(env, LDKCOption_ScalarZ_Some_class, "<init>", "(J)V");
+ CHECK(LDKCOption_ScalarZ_Some_meth != NULL);
+ LDKCOption_ScalarZ_None_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "org/ldk/impl/bindings$LDKCOption_ScalarZ$None"));
+ CHECK(LDKCOption_ScalarZ_None_class != NULL);
+ LDKCOption_ScalarZ_None_meth = (*env)->GetMethodID(env, LDKCOption_ScalarZ_None_class, "<init>", "()V");
+ CHECK(LDKCOption_ScalarZ_None_meth != NULL);
+}
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCOption_1ScalarZ_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
+ LDKCOption_ScalarZ *obj = (LDKCOption_ScalarZ*)untag_ptr(ptr);
+ switch(obj->tag) {
+ case LDKCOption_ScalarZ_Some: {
+ LDKBigEndianScalar* some_ref = &obj->some;
+ return (*env)->NewObject(env, LDKCOption_ScalarZ_Some_class, LDKCOption_ScalarZ_Some_meth, tag_ptr(some_ref, false));
+ }
+ case LDKCOption_ScalarZ_None: {
+ return (*env)->NewObject(env, LDKCOption_ScalarZ_None_class, LDKCOption_ScalarZ_None_meth);
+ }
+ default: abort();
+ }
+}
+static inline struct LDKThirtyTwoBytes CResult_SharedSecretNoneZ_get_ok(LDKCResult_SharedSecretNoneZ *NONNULL_PTR owner){
+CHECK(owner->result_ok);
+ return ThirtyTwoBytes_clone(&*owner->contents.result);
+}
+JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_CResult_1SharedSecretNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t owner) {
+ LDKCResult_SharedSecretNoneZ* owner_conv = (LDKCResult_SharedSecretNoneZ*)untag_ptr(owner);
+ int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
+ (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, CResult_SharedSecretNoneZ_get_ok(owner_conv).data);
+ return ret_arr;
+}
+
+static inline void CResult_SharedSecretNoneZ_get_err(LDKCResult_SharedSecretNoneZ *NONNULL_PTR owner){
+CHECK(!owner->result_ok);
+ return *owner->contents.err;
+}
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1SharedSecretNoneZ_1get_1err(JNIEnv *env, jclass clz, int64_t owner) {
+ LDKCResult_SharedSecretNoneZ* owner_conv = (LDKCResult_SharedSecretNoneZ*)untag_ptr(owner);
+ CResult_SharedSecretNoneZ_get_err(owner_conv);
+}
+
typedef struct LDKBaseSign_JCalls {
atomic_size_t refcnt;
JavaVM *vm;
JavaVM *vm;
jweak o;
jmethodID get_node_secret_meth;
+ jmethodID ecdh_meth;
jmethodID get_destination_script_meth;
jmethodID get_shutdown_scriptpubkey_meth;
jmethodID get_channel_signer_meth;
}
return ret_conv;
}
+LDKCResult_SharedSecretNoneZ ecdh_LDKKeysInterface_jcall(const void* this_arg, LDKRecipient recipient, LDKPublicKey other_key, LDKCOption_ScalarZ tweak) {
+ LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
+ JNIEnv *env;
+ jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
+ } else {
+ DO_ASSERT(get_jenv_res == JNI_OK);
+ }
+ jclass recipient_conv = LDKRecipient_to_java(env, recipient);
+ int8_tArray other_key_arr = (*env)->NewByteArray(env, 33);
+ (*env)->SetByteArrayRegion(env, other_key_arr, 0, 33, other_key.compressed_form);
+ LDKCOption_ScalarZ *tweak_copy = MALLOC(sizeof(LDKCOption_ScalarZ), "LDKCOption_ScalarZ");
+ *tweak_copy = tweak;
+ int64_t tweak_ref = tag_ptr(tweak_copy, true);
+ jobject obj = (*env)->NewLocalRef(env, j_calls->o);
+ CHECK(obj != NULL);
+ uint64_t ret = (*env)->CallLongMethod(env, obj, j_calls->ecdh_meth, recipient_conv, other_key_arr, tweak_ref);
+ if (UNLIKELY((*env)->ExceptionCheck(env))) {
+ (*env)->ExceptionDescribe(env);
+ (*env)->FatalError(env, "A call to ecdh in LDKKeysInterface from rust threw an exception.");
+ }
+ void* ret_ptr = untag_ptr(ret);
+ CHECK_ACCESS(ret_ptr);
+ LDKCResult_SharedSecretNoneZ ret_conv = *(LDKCResult_SharedSecretNoneZ*)(ret_ptr);
+ FREE(untag_ptr(ret));
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
+ }
+ return ret_conv;
+}
LDKCVec_u8Z get_destination_script_LDKKeysInterface_jcall(const void* this_arg) {
LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
JNIEnv *env;
calls->o = (*env)->NewWeakGlobalRef(env, o);
calls->get_node_secret_meth = (*env)->GetMethodID(env, c, "get_node_secret", "(Lorg/ldk/enums/Recipient;)J");
CHECK(calls->get_node_secret_meth != NULL);
+ calls->ecdh_meth = (*env)->GetMethodID(env, c, "ecdh", "(Lorg/ldk/enums/Recipient;[BJ)J");
+ CHECK(calls->ecdh_meth != NULL);
calls->get_destination_script_meth = (*env)->GetMethodID(env, c, "get_destination_script", "()[B");
CHECK(calls->get_destination_script_meth != NULL);
calls->get_shutdown_scriptpubkey_meth = (*env)->GetMethodID(env, c, "get_shutdown_scriptpubkey", "()J");
LDKKeysInterface ret = {
.this_arg = (void*) calls,
.get_node_secret = get_node_secret_LDKKeysInterface_jcall,
+ .ecdh = ecdh_LDKKeysInterface_jcall,
.get_destination_script = get_destination_script_LDKKeysInterface_jcall,
.get_shutdown_scriptpubkey = get_shutdown_scriptpubkey_LDKKeysInterface_jcall,
.get_channel_signer = get_channel_signer_LDKKeysInterface_jcall,
return tag_ptr(ret_conv, true);
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_KeysInterface_1ecdh(JNIEnv *env, jclass clz, int64_t this_arg, jclass recipient, int8_tArray other_key, int64_t tweak) {
+ void* this_arg_ptr = untag_ptr(this_arg);
+ if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
+ LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)this_arg_ptr;
+ LDKRecipient recipient_conv = LDKRecipient_from_java(env, recipient);
+ LDKPublicKey other_key_ref;
+ CHECK((*env)->GetArrayLength(env, other_key) == 33);
+ (*env)->GetByteArrayRegion(env, other_key, 0, 33, other_key_ref.compressed_form);
+ void* tweak_ptr = untag_ptr(tweak);
+ CHECK_ACCESS(tweak_ptr);
+ LDKCOption_ScalarZ tweak_conv = *(LDKCOption_ScalarZ*)(tweak_ptr);
+ // WARNING: we may need a move here but no clone is available for LDKCOption_ScalarZ
+ LDKCResult_SharedSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SharedSecretNoneZ), "LDKCResult_SharedSecretNoneZ");
+ *ret_conv = (this_arg_conv->ecdh)(this_arg_conv->this_arg, recipient_conv, other_key_ref, tweak_conv);
+ return tag_ptr(ret_conv, true);
+}
+
JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_KeysInterface_1get_1destination_1script(JNIEnv *env, jclass clz, int64_t this_arg) {
void* this_arg_ptr = untag_ptr(this_arg);
if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
return ret_ref;
}
+static inline struct LDKInFlightHtlcs CResult_InFlightHtlcsDecodeErrorZ_get_ok(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR owner){
+ LDKInFlightHtlcs ret = *owner->contents.result;
+ ret.is_owned = false;
+ return ret;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InFlightHtlcsDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t owner) {
+ LDKCResult_InFlightHtlcsDecodeErrorZ* owner_conv = (LDKCResult_InFlightHtlcsDecodeErrorZ*)untag_ptr(owner);
+ LDKInFlightHtlcs ret_var = CResult_InFlightHtlcsDecodeErrorZ_get_ok(owner_conv);
+ int64_t ret_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
+ return ret_ref;
+}
+
+static inline struct LDKDecodeError CResult_InFlightHtlcsDecodeErrorZ_get_err(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR owner){
+ LDKDecodeError ret = *owner->contents.err;
+ ret.is_owned = false;
+ return ret;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InFlightHtlcsDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t owner) {
+ LDKCResult_InFlightHtlcsDecodeErrorZ* owner_conv = (LDKCResult_InFlightHtlcsDecodeErrorZ*)untag_ptr(owner);
+ LDKDecodeError ret_var = CResult_InFlightHtlcsDecodeErrorZ_get_err(owner_conv);
+ int64_t ret_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
+ return ret_ref;
+}
+
static jclass LDKParseError_Bech32Error_class = NULL;
static jmethodID LDKParseError_Bech32Error_meth = NULL;
static jclass LDKParseError_ParseAmountError_class = NULL;
static jmethodID LDKBalance_ClaimableAwaitingConfirmations_meth = NULL;
static jclass LDKBalance_ContentiousClaimable_class = NULL;
static jmethodID LDKBalance_ContentiousClaimable_meth = NULL;
-static jclass LDKBalance_MaybeClaimableHTLCAwaitingTimeout_class = NULL;
-static jmethodID LDKBalance_MaybeClaimableHTLCAwaitingTimeout_meth = NULL;
+static jclass LDKBalance_MaybeTimeoutClaimableHTLC_class = NULL;
+static jmethodID LDKBalance_MaybeTimeoutClaimableHTLC_meth = NULL;
+static jclass LDKBalance_MaybePreimageClaimableHTLC_class = NULL;
+static jmethodID LDKBalance_MaybePreimageClaimableHTLC_meth = NULL;
+static jclass LDKBalance_CounterpartyRevokedOutputClaimable_class = NULL;
+static jmethodID LDKBalance_CounterpartyRevokedOutputClaimable_meth = NULL;
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKBalance_init (JNIEnv *env, jclass clz) {
LDKBalance_ClaimableOnChannelClose_class =
(*env)->NewGlobalRef(env, (*env)->FindClass(env, "org/ldk/impl/bindings$LDKBalance$ClaimableOnChannelClose"));
CHECK(LDKBalance_ContentiousClaimable_class != NULL);
LDKBalance_ContentiousClaimable_meth = (*env)->GetMethodID(env, LDKBalance_ContentiousClaimable_class, "<init>", "(JI)V");
CHECK(LDKBalance_ContentiousClaimable_meth != NULL);
- LDKBalance_MaybeClaimableHTLCAwaitingTimeout_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "org/ldk/impl/bindings$LDKBalance$MaybeClaimableHTLCAwaitingTimeout"));
- CHECK(LDKBalance_MaybeClaimableHTLCAwaitingTimeout_class != NULL);
- LDKBalance_MaybeClaimableHTLCAwaitingTimeout_meth = (*env)->GetMethodID(env, LDKBalance_MaybeClaimableHTLCAwaitingTimeout_class, "<init>", "(JI)V");
- CHECK(LDKBalance_MaybeClaimableHTLCAwaitingTimeout_meth != NULL);
+ LDKBalance_MaybeTimeoutClaimableHTLC_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "org/ldk/impl/bindings$LDKBalance$MaybeTimeoutClaimableHTLC"));
+ CHECK(LDKBalance_MaybeTimeoutClaimableHTLC_class != NULL);
+ LDKBalance_MaybeTimeoutClaimableHTLC_meth = (*env)->GetMethodID(env, LDKBalance_MaybeTimeoutClaimableHTLC_class, "<init>", "(JI)V");
+ CHECK(LDKBalance_MaybeTimeoutClaimableHTLC_meth != NULL);
+ LDKBalance_MaybePreimageClaimableHTLC_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "org/ldk/impl/bindings$LDKBalance$MaybePreimageClaimableHTLC"));
+ CHECK(LDKBalance_MaybePreimageClaimableHTLC_class != NULL);
+ LDKBalance_MaybePreimageClaimableHTLC_meth = (*env)->GetMethodID(env, LDKBalance_MaybePreimageClaimableHTLC_class, "<init>", "(JI)V");
+ CHECK(LDKBalance_MaybePreimageClaimableHTLC_meth != NULL);
+ LDKBalance_CounterpartyRevokedOutputClaimable_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "org/ldk/impl/bindings$LDKBalance$CounterpartyRevokedOutputClaimable"));
+ CHECK(LDKBalance_CounterpartyRevokedOutputClaimable_class != NULL);
+ LDKBalance_CounterpartyRevokedOutputClaimable_meth = (*env)->GetMethodID(env, LDKBalance_CounterpartyRevokedOutputClaimable_class, "<init>", "(J)V");
+ CHECK(LDKBalance_CounterpartyRevokedOutputClaimable_meth != NULL);
}
JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKBalance_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
int32_t timeout_height_conv = obj->contentious_claimable.timeout_height;
return (*env)->NewObject(env, LDKBalance_ContentiousClaimable_class, LDKBalance_ContentiousClaimable_meth, claimable_amount_satoshis_conv, timeout_height_conv);
}
- case LDKBalance_MaybeClaimableHTLCAwaitingTimeout: {
- int64_t claimable_amount_satoshis_conv = obj->maybe_claimable_htlc_awaiting_timeout.claimable_amount_satoshis;
- int32_t claimable_height_conv = obj->maybe_claimable_htlc_awaiting_timeout.claimable_height;
- return (*env)->NewObject(env, LDKBalance_MaybeClaimableHTLCAwaitingTimeout_class, LDKBalance_MaybeClaimableHTLCAwaitingTimeout_meth, claimable_amount_satoshis_conv, claimable_height_conv);
+ case LDKBalance_MaybeTimeoutClaimableHTLC: {
+ int64_t claimable_amount_satoshis_conv = obj->maybe_timeout_claimable_htlc.claimable_amount_satoshis;
+ int32_t claimable_height_conv = obj->maybe_timeout_claimable_htlc.claimable_height;
+ return (*env)->NewObject(env, LDKBalance_MaybeTimeoutClaimableHTLC_class, LDKBalance_MaybeTimeoutClaimableHTLC_meth, claimable_amount_satoshis_conv, claimable_height_conv);
+ }
+ case LDKBalance_MaybePreimageClaimableHTLC: {
+ int64_t claimable_amount_satoshis_conv = obj->maybe_preimage_claimable_htlc.claimable_amount_satoshis;
+ int32_t expiry_height_conv = obj->maybe_preimage_claimable_htlc.expiry_height;
+ return (*env)->NewObject(env, LDKBalance_MaybePreimageClaimableHTLC_class, LDKBalance_MaybePreimageClaimableHTLC_meth, claimable_amount_satoshis_conv, expiry_height_conv);
+ }
+ case LDKBalance_CounterpartyRevokedOutputClaimable: {
+ int64_t claimable_amount_satoshis_conv = obj->counterparty_revoked_output_claimable.claimable_amount_satoshis;
+ return (*env)->NewObject(env, LDKBalance_CounterpartyRevokedOutputClaimable_class, LDKBalance_CounterpartyRevokedOutputClaimable_meth, claimable_amount_satoshis_conv);
}
default: abort();
}
return ret_ref;
}
+static jclass LDKSendError_Secp256k1_class = NULL;
+static jmethodID LDKSendError_Secp256k1_meth = NULL;
+static jclass LDKSendError_TooBigPacket_class = NULL;
+static jmethodID LDKSendError_TooBigPacket_meth = NULL;
+static jclass LDKSendError_TooFewBlindedHops_class = NULL;
+static jmethodID LDKSendError_TooFewBlindedHops_meth = NULL;
+static jclass LDKSendError_InvalidFirstHop_class = NULL;
+static jmethodID LDKSendError_InvalidFirstHop_meth = NULL;
+static jclass LDKSendError_BufferFull_class = NULL;
+static jmethodID LDKSendError_BufferFull_meth = NULL;
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKSendError_init (JNIEnv *env, jclass clz) {
+ LDKSendError_Secp256k1_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "org/ldk/impl/bindings$LDKSendError$Secp256k1"));
+ CHECK(LDKSendError_Secp256k1_class != NULL);
+ LDKSendError_Secp256k1_meth = (*env)->GetMethodID(env, LDKSendError_Secp256k1_class, "<init>", "(Lorg/ldk/enums/Secp256k1Error;)V");
+ CHECK(LDKSendError_Secp256k1_meth != NULL);
+ LDKSendError_TooBigPacket_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "org/ldk/impl/bindings$LDKSendError$TooBigPacket"));
+ CHECK(LDKSendError_TooBigPacket_class != NULL);
+ LDKSendError_TooBigPacket_meth = (*env)->GetMethodID(env, LDKSendError_TooBigPacket_class, "<init>", "()V");
+ CHECK(LDKSendError_TooBigPacket_meth != NULL);
+ LDKSendError_TooFewBlindedHops_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "org/ldk/impl/bindings$LDKSendError$TooFewBlindedHops"));
+ CHECK(LDKSendError_TooFewBlindedHops_class != NULL);
+ LDKSendError_TooFewBlindedHops_meth = (*env)->GetMethodID(env, LDKSendError_TooFewBlindedHops_class, "<init>", "()V");
+ CHECK(LDKSendError_TooFewBlindedHops_meth != NULL);
+ LDKSendError_InvalidFirstHop_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "org/ldk/impl/bindings$LDKSendError$InvalidFirstHop"));
+ CHECK(LDKSendError_InvalidFirstHop_class != NULL);
+ LDKSendError_InvalidFirstHop_meth = (*env)->GetMethodID(env, LDKSendError_InvalidFirstHop_class, "<init>", "()V");
+ CHECK(LDKSendError_InvalidFirstHop_meth != NULL);
+ LDKSendError_BufferFull_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "org/ldk/impl/bindings$LDKSendError$BufferFull"));
+ CHECK(LDKSendError_BufferFull_class != NULL);
+ LDKSendError_BufferFull_meth = (*env)->GetMethodID(env, LDKSendError_BufferFull_class, "<init>", "()V");
+ CHECK(LDKSendError_BufferFull_meth != NULL);
+}
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKSendError_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
+ LDKSendError *obj = (LDKSendError*)untag_ptr(ptr);
+ switch(obj->tag) {
+ case LDKSendError_Secp256k1: {
+ jclass secp256k1_conv = LDKSecp256k1Error_to_java(env, obj->secp256k1);
+ return (*env)->NewObject(env, LDKSendError_Secp256k1_class, LDKSendError_Secp256k1_meth, secp256k1_conv);
+ }
+ case LDKSendError_TooBigPacket: {
+ return (*env)->NewObject(env, LDKSendError_TooBigPacket_class, LDKSendError_TooBigPacket_meth);
+ }
+ case LDKSendError_TooFewBlindedHops: {
+ return (*env)->NewObject(env, LDKSendError_TooFewBlindedHops_class, LDKSendError_TooFewBlindedHops_meth);
+ }
+ case LDKSendError_InvalidFirstHop: {
+ return (*env)->NewObject(env, LDKSendError_InvalidFirstHop_class, LDKSendError_InvalidFirstHop_meth);
+ }
+ case LDKSendError_BufferFull: {
+ return (*env)->NewObject(env, LDKSendError_BufferFull_class, LDKSendError_BufferFull_meth);
+ }
+ default: abort();
+ }
+}
+static inline void CResult_NoneSendErrorZ_get_ok(LDKCResult_NoneSendErrorZ *NONNULL_PTR owner){
+CHECK(owner->result_ok);
+ return *owner->contents.result;
+}
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneSendErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t owner) {
+ LDKCResult_NoneSendErrorZ* owner_conv = (LDKCResult_NoneSendErrorZ*)untag_ptr(owner);
+ CResult_NoneSendErrorZ_get_ok(owner_conv);
+}
+
+static inline struct LDKSendError CResult_NoneSendErrorZ_get_err(LDKCResult_NoneSendErrorZ *NONNULL_PTR owner){
+CHECK(!owner->result_ok);
+ return SendError_clone(&*owner->contents.err);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneSendErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t owner) {
+ LDKCResult_NoneSendErrorZ* owner_conv = (LDKCResult_NoneSendErrorZ*)untag_ptr(owner);
+ LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
+ *ret_copy = CResult_NoneSendErrorZ_get_err(owner_conv);
+ int64_t ret_ref = tag_ptr(ret_copy, true);
+ return ret_ref;
+}
+
static jclass LDKGraphSyncError_DecodeError_class = NULL;
static jmethodID LDKGraphSyncError_DecodeError_meth = NULL;
static jclass LDKGraphSyncError_LightningError_class = NULL;
return ret_ref;
}
+static inline struct LDKOnionMessage CResult_OnionMessageDecodeErrorZ_get_ok(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR owner){
+ LDKOnionMessage ret = *owner->contents.result;
+ ret.is_owned = false;
+ return ret;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1OnionMessageDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t owner) {
+ LDKCResult_OnionMessageDecodeErrorZ* owner_conv = (LDKCResult_OnionMessageDecodeErrorZ*)untag_ptr(owner);
+ LDKOnionMessage ret_var = CResult_OnionMessageDecodeErrorZ_get_ok(owner_conv);
+ int64_t ret_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
+ return ret_ref;
+}
+
+static inline struct LDKDecodeError CResult_OnionMessageDecodeErrorZ_get_err(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR owner){
+ LDKDecodeError ret = *owner->contents.err;
+ ret.is_owned = false;
+ return ret;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1OnionMessageDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t owner) {
+ LDKCResult_OnionMessageDecodeErrorZ* owner_conv = (LDKCResult_OnionMessageDecodeErrorZ*)untag_ptr(owner);
+ LDKDecodeError ret_var = CResult_OnionMessageDecodeErrorZ_get_err(owner_conv);
+ int64_t ret_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
+ return ret_ref;
+}
+
static inline struct LDKPing CResult_PingDecodeErrorZ_get_ok(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner){
LDKPing ret = *owner->contents.result;
ret.is_owned = false;
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
}
-LDKCOption_C2Tuple_usizeTransactionZZ register_output_LDKFilter_jcall(const void* this_arg, LDKWatchedOutput output) {
+void register_output_LDKFilter_jcall(const void* this_arg, LDKWatchedOutput output) {
LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg;
JNIEnv *env;
jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
output_ref = tag_ptr(output_var.inner, output_var.is_owned);
jobject obj = (*env)->NewLocalRef(env, j_calls->o);
CHECK(obj != NULL);
- uint64_t ret = (*env)->CallLongMethod(env, obj, j_calls->register_output_meth, output_ref);
+ (*env)->CallVoidMethod(env, obj, j_calls->register_output_meth, output_ref);
if (UNLIKELY((*env)->ExceptionCheck(env))) {
(*env)->ExceptionDescribe(env);
(*env)->FatalError(env, "A call to register_output in LDKFilter from rust threw an exception.");
}
- void* ret_ptr = untag_ptr(ret);
- CHECK_ACCESS(ret_ptr);
- LDKCOption_C2Tuple_usizeTransactionZZ ret_conv = *(LDKCOption_C2Tuple_usizeTransactionZZ*)(ret_ptr);
- FREE(untag_ptr(ret));
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
- return ret_conv;
}
static void LDKFilter_JCalls_cloned(LDKFilter* new_obj) {
LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) new_obj->this_arg;
calls->o = (*env)->NewWeakGlobalRef(env, o);
calls->register_tx_meth = (*env)->GetMethodID(env, c, "register_tx", "([B[B)V");
CHECK(calls->register_tx_meth != NULL);
- calls->register_output_meth = (*env)->GetMethodID(env, c, "register_output", "(J)J");
+ calls->register_output_meth = (*env)->GetMethodID(env, c, "register_output", "(J)V");
CHECK(calls->register_output_meth != NULL);
LDKFilter ret = {
(*env)->ReleaseByteArrayElements(env, script_pubkey, (int8_t*)script_pubkey_ref.data, 0);
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Filter_1register_1output(JNIEnv *env, jclass clz, int64_t this_arg, int64_t output) {
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Filter_1register_1output(JNIEnv *env, jclass clz, int64_t this_arg, int64_t output) {
void* this_arg_ptr = untag_ptr(this_arg);
if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
LDKFilter* this_arg_conv = (LDKFilter*)this_arg_ptr;
output_conv.is_owned = ptr_is_owned(output);
CHECK_INNER_FIELD_ACCESS_OR_NULL(output_conv);
output_conv = WatchedOutput_clone(&output_conv);
- LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ");
- *ret_copy = (this_arg_conv->register_output)(this_arg_conv->this_arg, output_conv);
- int64_t ret_ref = tag_ptr(ret_copy, true);
- return ret_ref;
+ (this_arg_conv->register_output)(this_arg_conv->this_arg, output_conv);
}
static jclass LDKCOption_FilterZ_Some_class = NULL;
return ret_arr;
}
+typedef struct LDKOnionMessageProvider_JCalls {
+ atomic_size_t refcnt;
+ JavaVM *vm;
+ jweak o;
+ jmethodID next_onion_message_for_peer_meth;
+} LDKOnionMessageProvider_JCalls;
+static void LDKOnionMessageProvider_JCalls_free(void* this_arg) {
+ LDKOnionMessageProvider_JCalls *j_calls = (LDKOnionMessageProvider_JCalls*) this_arg;
+ if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
+ JNIEnv *env;
+ jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
+ } else {
+ DO_ASSERT(get_jenv_res == JNI_OK);
+ }
+ (*env)->DeleteWeakGlobalRef(env, j_calls->o);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
+ }
+ FREE(j_calls);
+ }
+}
+LDKOnionMessage next_onion_message_for_peer_LDKOnionMessageProvider_jcall(const void* this_arg, LDKPublicKey peer_node_id) {
+ LDKOnionMessageProvider_JCalls *j_calls = (LDKOnionMessageProvider_JCalls*) this_arg;
+ JNIEnv *env;
+ jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
+ } else {
+ DO_ASSERT(get_jenv_res == JNI_OK);
+ }
+ int8_tArray peer_node_id_arr = (*env)->NewByteArray(env, 33);
+ (*env)->SetByteArrayRegion(env, peer_node_id_arr, 0, 33, peer_node_id.compressed_form);
+ jobject obj = (*env)->NewLocalRef(env, j_calls->o);
+ CHECK(obj != NULL);
+ uint64_t ret = (*env)->CallLongMethod(env, obj, j_calls->next_onion_message_for_peer_meth, peer_node_id_arr);
+ if (UNLIKELY((*env)->ExceptionCheck(env))) {
+ (*env)->ExceptionDescribe(env);
+ (*env)->FatalError(env, "A call to next_onion_message_for_peer in LDKOnionMessageProvider from rust threw an exception.");
+ }
+ LDKOnionMessage ret_conv;
+ ret_conv.inner = untag_ptr(ret);
+ ret_conv.is_owned = ptr_is_owned(ret);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
+ }
+ return ret_conv;
+}
+static void LDKOnionMessageProvider_JCalls_cloned(LDKOnionMessageProvider* new_obj) {
+ LDKOnionMessageProvider_JCalls *j_calls = (LDKOnionMessageProvider_JCalls*) new_obj->this_arg;
+ atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
+}
+static inline LDKOnionMessageProvider LDKOnionMessageProvider_init (JNIEnv *env, jclass clz, jobject o) {
+ jclass c = (*env)->GetObjectClass(env, o);
+ CHECK(c != NULL);
+ LDKOnionMessageProvider_JCalls *calls = MALLOC(sizeof(LDKOnionMessageProvider_JCalls), "LDKOnionMessageProvider_JCalls");
+ atomic_init(&calls->refcnt, 1);
+ DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
+ calls->o = (*env)->NewWeakGlobalRef(env, o);
+ calls->next_onion_message_for_peer_meth = (*env)->GetMethodID(env, c, "next_onion_message_for_peer", "([B)J");
+ CHECK(calls->next_onion_message_for_peer_meth != NULL);
+
+ LDKOnionMessageProvider ret = {
+ .this_arg = (void*) calls,
+ .next_onion_message_for_peer = next_onion_message_for_peer_LDKOnionMessageProvider_jcall,
+ .free = LDKOnionMessageProvider_JCalls_free,
+ };
+ return ret;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKOnionMessageProvider_1new(JNIEnv *env, jclass clz, jobject o) {
+ LDKOnionMessageProvider *res_ptr = MALLOC(sizeof(LDKOnionMessageProvider), "LDKOnionMessageProvider");
+ *res_ptr = LDKOnionMessageProvider_init(env, clz, o);
+ return tag_ptr(res_ptr, true);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OnionMessageProvider_1next_1onion_1message_1for_1peer(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray peer_node_id) {
+ void* this_arg_ptr = untag_ptr(this_arg);
+ if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
+ LDKOnionMessageProvider* this_arg_conv = (LDKOnionMessageProvider*)this_arg_ptr;
+ LDKPublicKey peer_node_id_ref;
+ CHECK((*env)->GetArrayLength(env, peer_node_id) == 33);
+ (*env)->GetByteArrayRegion(env, peer_node_id, 0, 33, peer_node_id_ref.compressed_form);
+ LDKOnionMessage ret_var = (this_arg_conv->next_onion_message_for_peer)(this_arg_conv->this_arg, peer_node_id_ref);
+ int64_t ret_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
+ return ret_ref;
+}
+
typedef struct LDKEventHandler_JCalls {
atomic_size_t refcnt;
JavaVM *vm;
(this_arg_conv->process_pending_events)(this_arg_conv->this_arg, handler_conv);
}
-typedef struct LDKScore_JCalls {
- atomic_size_t refcnt;
- JavaVM *vm;
- jweak o;
- jmethodID channel_penalty_msat_meth;
- jmethodID payment_path_failed_meth;
- jmethodID payment_path_successful_meth;
- jmethodID probe_failed_meth;
- jmethodID probe_successful_meth;
- jmethodID write_meth;
-} LDKScore_JCalls;
-static void LDKScore_JCalls_free(void* this_arg) {
- LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
- if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
- JNIEnv *env;
- jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
- if (get_jenv_res == JNI_EDETACHED) {
- DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
- } else {
- DO_ASSERT(get_jenv_res == JNI_OK);
- }
- (*env)->DeleteWeakGlobalRef(env, j_calls->o);
- if (get_jenv_res == JNI_EDETACHED) {
- DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
- }
- FREE(j_calls);
- }
-}
-uint64_t channel_penalty_msat_LDKScore_jcall(const void* this_arg, uint64_t short_channel_id, const LDKNodeId * source, const LDKNodeId * target, LDKChannelUsage usage) {
- LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
- JNIEnv *env;
- jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
- if (get_jenv_res == JNI_EDETACHED) {
- DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
- } else {
- DO_ASSERT(get_jenv_res == JNI_OK);
- }
- int64_t short_channel_id_conv = short_channel_id;
- LDKNodeId source_var = *source;
- int64_t source_ref = 0;
- source_var = NodeId_clone(&source_var);
- CHECK_INNER_FIELD_ACCESS_OR_NULL(source_var);
- source_ref = tag_ptr(source_var.inner, source_var.is_owned);
- LDKNodeId target_var = *target;
- int64_t target_ref = 0;
- target_var = NodeId_clone(&target_var);
- CHECK_INNER_FIELD_ACCESS_OR_NULL(target_var);
- target_ref = tag_ptr(target_var.inner, target_var.is_owned);
- LDKChannelUsage usage_var = usage;
- int64_t usage_ref = 0;
- CHECK_INNER_FIELD_ACCESS_OR_NULL(usage_var);
- usage_ref = tag_ptr(usage_var.inner, usage_var.is_owned);
- jobject obj = (*env)->NewLocalRef(env, j_calls->o);
- CHECK(obj != NULL);
- int64_t ret = (*env)->CallLongMethod(env, obj, j_calls->channel_penalty_msat_meth, short_channel_id_conv, source_ref, target_ref, usage_ref);
- if (UNLIKELY((*env)->ExceptionCheck(env))) {
- (*env)->ExceptionDescribe(env);
- (*env)->FatalError(env, "A call to channel_penalty_msat in LDKScore from rust threw an exception.");
- }
- if (get_jenv_res == JNI_EDETACHED) {
- DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
- }
- return ret;
-}
-void payment_path_failed_LDKScore_jcall(void* this_arg, LDKCVec_RouteHopZ path, uint64_t short_channel_id) {
- LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
- JNIEnv *env;
- jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
- if (get_jenv_res == JNI_EDETACHED) {
- DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
- } else {
- DO_ASSERT(get_jenv_res == JNI_OK);
- }
- LDKCVec_RouteHopZ path_var = path;
- int64_tArray path_arr = NULL;
- path_arr = (*env)->NewLongArray(env, path_var.datalen);
- int64_t *path_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, path_arr, NULL);
- for (size_t k = 0; k < path_var.datalen; k++) {
- LDKRouteHop path_conv_10_var = path_var.data[k];
- int64_t path_conv_10_ref = 0;
- CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
- path_conv_10_ref = tag_ptr(path_conv_10_var.inner, path_conv_10_var.is_owned);
- path_arr_ptr[k] = path_conv_10_ref;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, path_arr, path_arr_ptr, 0);
- FREE(path_var.data);
- int64_t short_channel_id_conv = short_channel_id;
- jobject obj = (*env)->NewLocalRef(env, j_calls->o);
- CHECK(obj != NULL);
- (*env)->CallVoidMethod(env, obj, j_calls->payment_path_failed_meth, path_arr, short_channel_id_conv);
- if (UNLIKELY((*env)->ExceptionCheck(env))) {
- (*env)->ExceptionDescribe(env);
- (*env)->FatalError(env, "A call to payment_path_failed in LDKScore from rust threw an exception.");
- }
- if (get_jenv_res == JNI_EDETACHED) {
- DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
- }
-}
-void payment_path_successful_LDKScore_jcall(void* this_arg, LDKCVec_RouteHopZ path) {
- LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
- JNIEnv *env;
- jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
- if (get_jenv_res == JNI_EDETACHED) {
- DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
- } else {
- DO_ASSERT(get_jenv_res == JNI_OK);
- }
- LDKCVec_RouteHopZ path_var = path;
- int64_tArray path_arr = NULL;
- path_arr = (*env)->NewLongArray(env, path_var.datalen);
- int64_t *path_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, path_arr, NULL);
- for (size_t k = 0; k < path_var.datalen; k++) {
- LDKRouteHop path_conv_10_var = path_var.data[k];
- int64_t path_conv_10_ref = 0;
- CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
- path_conv_10_ref = tag_ptr(path_conv_10_var.inner, path_conv_10_var.is_owned);
- path_arr_ptr[k] = path_conv_10_ref;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, path_arr, path_arr_ptr, 0);
- FREE(path_var.data);
- jobject obj = (*env)->NewLocalRef(env, j_calls->o);
- CHECK(obj != NULL);
- (*env)->CallVoidMethod(env, obj, j_calls->payment_path_successful_meth, path_arr);
- if (UNLIKELY((*env)->ExceptionCheck(env))) {
- (*env)->ExceptionDescribe(env);
- (*env)->FatalError(env, "A call to payment_path_successful in LDKScore from rust threw an exception.");
- }
- if (get_jenv_res == JNI_EDETACHED) {
- DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
- }
-}
-void probe_failed_LDKScore_jcall(void* this_arg, LDKCVec_RouteHopZ path, uint64_t short_channel_id) {
- LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
- JNIEnv *env;
- jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
- if (get_jenv_res == JNI_EDETACHED) {
- DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
- } else {
- DO_ASSERT(get_jenv_res == JNI_OK);
- }
- LDKCVec_RouteHopZ path_var = path;
- int64_tArray path_arr = NULL;
- path_arr = (*env)->NewLongArray(env, path_var.datalen);
- int64_t *path_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, path_arr, NULL);
- for (size_t k = 0; k < path_var.datalen; k++) {
- LDKRouteHop path_conv_10_var = path_var.data[k];
- int64_t path_conv_10_ref = 0;
- CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
- path_conv_10_ref = tag_ptr(path_conv_10_var.inner, path_conv_10_var.is_owned);
- path_arr_ptr[k] = path_conv_10_ref;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, path_arr, path_arr_ptr, 0);
- FREE(path_var.data);
- int64_t short_channel_id_conv = short_channel_id;
- jobject obj = (*env)->NewLocalRef(env, j_calls->o);
- CHECK(obj != NULL);
- (*env)->CallVoidMethod(env, obj, j_calls->probe_failed_meth, path_arr, short_channel_id_conv);
- if (UNLIKELY((*env)->ExceptionCheck(env))) {
- (*env)->ExceptionDescribe(env);
- (*env)->FatalError(env, "A call to probe_failed in LDKScore from rust threw an exception.");
- }
- if (get_jenv_res == JNI_EDETACHED) {
- DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
- }
-}
-void probe_successful_LDKScore_jcall(void* this_arg, LDKCVec_RouteHopZ path) {
- LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
- JNIEnv *env;
- jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
- if (get_jenv_res == JNI_EDETACHED) {
- DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
- } else {
- DO_ASSERT(get_jenv_res == JNI_OK);
- }
- LDKCVec_RouteHopZ path_var = path;
- int64_tArray path_arr = NULL;
- path_arr = (*env)->NewLongArray(env, path_var.datalen);
- int64_t *path_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, path_arr, NULL);
- for (size_t k = 0; k < path_var.datalen; k++) {
- LDKRouteHop path_conv_10_var = path_var.data[k];
- int64_t path_conv_10_ref = 0;
- CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
- path_conv_10_ref = tag_ptr(path_conv_10_var.inner, path_conv_10_var.is_owned);
- path_arr_ptr[k] = path_conv_10_ref;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, path_arr, path_arr_ptr, 0);
- FREE(path_var.data);
- jobject obj = (*env)->NewLocalRef(env, j_calls->o);
- CHECK(obj != NULL);
- (*env)->CallVoidMethod(env, obj, j_calls->probe_successful_meth, path_arr);
- if (UNLIKELY((*env)->ExceptionCheck(env))) {
- (*env)->ExceptionDescribe(env);
- (*env)->FatalError(env, "A call to probe_successful in LDKScore from rust threw an exception.");
- }
- if (get_jenv_res == JNI_EDETACHED) {
- DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
- }
-}
-LDKCVec_u8Z write_LDKScore_jcall(const void* this_arg) {
- LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
- JNIEnv *env;
- jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
- if (get_jenv_res == JNI_EDETACHED) {
- DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
- } else {
- DO_ASSERT(get_jenv_res == JNI_OK);
- }
- jobject obj = (*env)->NewLocalRef(env, j_calls->o);
- CHECK(obj != NULL);
- int8_tArray ret = (*env)->CallObjectMethod(env, obj, j_calls->write_meth);
- if (UNLIKELY((*env)->ExceptionCheck(env))) {
- (*env)->ExceptionDescribe(env);
- (*env)->FatalError(env, "A call to write in LDKScore from rust threw an exception.");
- }
- LDKCVec_u8Z ret_ref;
- ret_ref.datalen = (*env)->GetArrayLength(env, ret);
- ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
- (*env)->GetByteArrayRegion(env, ret, 0, ret_ref.datalen, ret_ref.data);
- if (get_jenv_res == JNI_EDETACHED) {
- DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
- }
- return ret_ref;
-}
-static void LDKScore_JCalls_cloned(LDKScore* new_obj) {
- LDKScore_JCalls *j_calls = (LDKScore_JCalls*) new_obj->this_arg;
- atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
-}
-static inline LDKScore LDKScore_init (JNIEnv *env, jclass clz, jobject o) {
- jclass c = (*env)->GetObjectClass(env, o);
- CHECK(c != NULL);
- LDKScore_JCalls *calls = MALLOC(sizeof(LDKScore_JCalls), "LDKScore_JCalls");
- atomic_init(&calls->refcnt, 1);
- DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
- calls->o = (*env)->NewWeakGlobalRef(env, o);
- calls->channel_penalty_msat_meth = (*env)->GetMethodID(env, c, "channel_penalty_msat", "(JJJJ)J");
- CHECK(calls->channel_penalty_msat_meth != NULL);
- calls->payment_path_failed_meth = (*env)->GetMethodID(env, c, "payment_path_failed", "([JJ)V");
- CHECK(calls->payment_path_failed_meth != NULL);
- calls->payment_path_successful_meth = (*env)->GetMethodID(env, c, "payment_path_successful", "([J)V");
- CHECK(calls->payment_path_successful_meth != NULL);
- calls->probe_failed_meth = (*env)->GetMethodID(env, c, "probe_failed", "([JJ)V");
- CHECK(calls->probe_failed_meth != NULL);
- calls->probe_successful_meth = (*env)->GetMethodID(env, c, "probe_successful", "([J)V");
- CHECK(calls->probe_successful_meth != NULL);
- calls->write_meth = (*env)->GetMethodID(env, c, "write", "()[B");
- CHECK(calls->write_meth != NULL);
-
- LDKScore ret = {
- .this_arg = (void*) calls,
- .channel_penalty_msat = channel_penalty_msat_LDKScore_jcall,
- .payment_path_failed = payment_path_failed_LDKScore_jcall,
- .payment_path_successful = payment_path_successful_LDKScore_jcall,
- .probe_failed = probe_failed_LDKScore_jcall,
- .probe_successful = probe_successful_LDKScore_jcall,
- .write = write_LDKScore_jcall,
- .free = LDKScore_JCalls_free,
- };
- return ret;
-}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKScore_1new(JNIEnv *env, jclass clz, jobject o) {
- LDKScore *res_ptr = MALLOC(sizeof(LDKScore), "LDKScore");
- *res_ptr = LDKScore_init(env, clz, o);
- return tag_ptr(res_ptr, true);
-}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Score_1channel_1penalty_1msat(JNIEnv *env, jclass clz, int64_t this_arg, int64_t short_channel_id, int64_t source, int64_t target, int64_t usage) {
- void* this_arg_ptr = untag_ptr(this_arg);
- if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
- LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
- LDKNodeId source_conv;
- source_conv.inner = untag_ptr(source);
- source_conv.is_owned = ptr_is_owned(source);
- CHECK_INNER_FIELD_ACCESS_OR_NULL(source_conv);
- source_conv.is_owned = false;
- LDKNodeId target_conv;
- target_conv.inner = untag_ptr(target);
- target_conv.is_owned = ptr_is_owned(target);
- CHECK_INNER_FIELD_ACCESS_OR_NULL(target_conv);
- target_conv.is_owned = false;
- LDKChannelUsage usage_conv;
- usage_conv.inner = untag_ptr(usage);
- usage_conv.is_owned = ptr_is_owned(usage);
- CHECK_INNER_FIELD_ACCESS_OR_NULL(usage_conv);
- usage_conv = ChannelUsage_clone(&usage_conv);
- int64_t ret_conv = (this_arg_conv->channel_penalty_msat)(this_arg_conv->this_arg, short_channel_id, &source_conv, &target_conv, usage_conv);
- return ret_conv;
-}
-
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Score_1payment_1path_1failed(JNIEnv *env, jclass clz, int64_t this_arg, int64_tArray path, int64_t short_channel_id) {
- void* this_arg_ptr = untag_ptr(this_arg);
- if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
- LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
- LDKCVec_RouteHopZ path_constr;
- path_constr.datalen = (*env)->GetArrayLength(env, path);
- if (path_constr.datalen > 0)
- path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
- else
- path_constr.data = NULL;
- int64_t* path_vals = (*env)->GetLongArrayElements (env, path, NULL);
- for (size_t k = 0; k < path_constr.datalen; k++) {
- int64_t path_conv_10 = path_vals[k];
- LDKRouteHop path_conv_10_conv;
- path_conv_10_conv.inner = untag_ptr(path_conv_10);
- path_conv_10_conv.is_owned = ptr_is_owned(path_conv_10);
- CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
- path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
- path_constr.data[k] = path_conv_10_conv;
- }
- (*env)->ReleaseLongArrayElements(env, path, path_vals, 0);
- (this_arg_conv->payment_path_failed)(this_arg_conv->this_arg, path_constr, short_channel_id);
-}
-
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Score_1payment_1path_1successful(JNIEnv *env, jclass clz, int64_t this_arg, int64_tArray path) {
- void* this_arg_ptr = untag_ptr(this_arg);
- if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
- LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
- LDKCVec_RouteHopZ path_constr;
- path_constr.datalen = (*env)->GetArrayLength(env, path);
- if (path_constr.datalen > 0)
- path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
- else
- path_constr.data = NULL;
- int64_t* path_vals = (*env)->GetLongArrayElements (env, path, NULL);
- for (size_t k = 0; k < path_constr.datalen; k++) {
- int64_t path_conv_10 = path_vals[k];
- LDKRouteHop path_conv_10_conv;
- path_conv_10_conv.inner = untag_ptr(path_conv_10);
- path_conv_10_conv.is_owned = ptr_is_owned(path_conv_10);
- CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
- path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
- path_constr.data[k] = path_conv_10_conv;
- }
- (*env)->ReleaseLongArrayElements(env, path, path_vals, 0);
- (this_arg_conv->payment_path_successful)(this_arg_conv->this_arg, path_constr);
-}
-
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Score_1probe_1failed(JNIEnv *env, jclass clz, int64_t this_arg, int64_tArray path, int64_t short_channel_id) {
- void* this_arg_ptr = untag_ptr(this_arg);
- if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
- LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
- LDKCVec_RouteHopZ path_constr;
- path_constr.datalen = (*env)->GetArrayLength(env, path);
- if (path_constr.datalen > 0)
- path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
- else
- path_constr.data = NULL;
- int64_t* path_vals = (*env)->GetLongArrayElements (env, path, NULL);
- for (size_t k = 0; k < path_constr.datalen; k++) {
- int64_t path_conv_10 = path_vals[k];
- LDKRouteHop path_conv_10_conv;
- path_conv_10_conv.inner = untag_ptr(path_conv_10);
- path_conv_10_conv.is_owned = ptr_is_owned(path_conv_10);
- CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
- path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
- path_constr.data[k] = path_conv_10_conv;
- }
- (*env)->ReleaseLongArrayElements(env, path, path_vals, 0);
- (this_arg_conv->probe_failed)(this_arg_conv->this_arg, path_constr, short_channel_id);
-}
-
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Score_1probe_1successful(JNIEnv *env, jclass clz, int64_t this_arg, int64_tArray path) {
- void* this_arg_ptr = untag_ptr(this_arg);
- if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
- LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
- LDKCVec_RouteHopZ path_constr;
- path_constr.datalen = (*env)->GetArrayLength(env, path);
- if (path_constr.datalen > 0)
- path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
- else
- path_constr.data = NULL;
- int64_t* path_vals = (*env)->GetLongArrayElements (env, path, NULL);
- for (size_t k = 0; k < path_constr.datalen; k++) {
- int64_t path_conv_10 = path_vals[k];
- LDKRouteHop path_conv_10_conv;
- path_conv_10_conv.inner = untag_ptr(path_conv_10);
- path_conv_10_conv.is_owned = ptr_is_owned(path_conv_10);
- CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
- path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
- path_constr.data[k] = path_conv_10_conv;
- }
- (*env)->ReleaseLongArrayElements(env, path, path_vals, 0);
- (this_arg_conv->probe_successful)(this_arg_conv->this_arg, path_constr);
-}
-
-JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_Score_1write(JNIEnv *env, jclass clz, int64_t this_arg) {
- void* this_arg_ptr = untag_ptr(this_arg);
- if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
- LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
- LDKCVec_u8Z ret_var = (this_arg_conv->write)(this_arg_conv->this_arg);
- int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
- (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
- CVec_u8Z_free(ret_var);
- return ret_arr;
-}
-
typedef struct LDKPersister_JCalls {
atomic_size_t refcnt;
JavaVM *vm;
}
return ret_conv;
}
-LDKCResult_NoneErrorZ persist_scorer_LDKPersister_jcall(const void* this_arg, const LDKMultiThreadedLockableScore * scorer) {
+LDKCResult_NoneErrorZ persist_scorer_LDKPersister_jcall(const void* this_arg, const LDKWriteableScore * scorer) {
LDKPersister_JCalls *j_calls = (LDKPersister_JCalls*) this_arg;
JNIEnv *env;
jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
} else {
DO_ASSERT(get_jenv_res == JNI_OK);
}
- LDKMultiThreadedLockableScore scorer_var = *scorer;
- int64_t scorer_ref = 0;
- // WARNING: we may need a move here but no clone is available for LDKMultiThreadedLockableScore
- CHECK_INNER_FIELD_ACCESS_OR_NULL(scorer_var);
- scorer_ref = tag_ptr(scorer_var.inner, scorer_var.is_owned);
+ // WARNING: This object doesn't live past this scope, needs clone!
+ int64_t ret_scorer = tag_ptr(scorer, false);
jobject obj = (*env)->NewLocalRef(env, j_calls->o);
CHECK(obj != NULL);
- uint64_t ret = (*env)->CallLongMethod(env, obj, j_calls->persist_scorer_meth, scorer_ref);
+ uint64_t ret = (*env)->CallLongMethod(env, obj, j_calls->persist_scorer_meth, ret_scorer);
if (UNLIKELY((*env)->ExceptionCheck(env))) {
(*env)->ExceptionDescribe(env);
(*env)->FatalError(env, "A call to persist_scorer in LDKPersister from rust threw an exception.");
void* this_arg_ptr = untag_ptr(this_arg);
if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
LDKPersister* this_arg_conv = (LDKPersister*)this_arg_ptr;
- LDKMultiThreadedLockableScore scorer_conv;
- scorer_conv.inner = untag_ptr(scorer);
- scorer_conv.is_owned = ptr_is_owned(scorer);
- CHECK_INNER_FIELD_ACCESS_OR_NULL(scorer_conv);
- scorer_conv.is_owned = false;
+ void* scorer_ptr = untag_ptr(scorer);
+ if (ptr_is_owned(scorer)) { CHECK_ACCESS(scorer_ptr); }
+ LDKWriteableScore* scorer_conv = (LDKWriteableScore*)scorer_ptr;
LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
- *ret_conv = (this_arg_conv->persist_scorer)(this_arg_conv->this_arg, &scorer_conv);
+ *ret_conv = (this_arg_conv->persist_scorer)(this_arg_conv->this_arg, scorer_conv);
return tag_ptr(ret_conv, true);
}
+typedef struct LDKFutureCallback_JCalls {
+ atomic_size_t refcnt;
+ JavaVM *vm;
+ jweak o;
+ jmethodID call_meth;
+} LDKFutureCallback_JCalls;
+static void LDKFutureCallback_JCalls_free(void* this_arg) {
+ LDKFutureCallback_JCalls *j_calls = (LDKFutureCallback_JCalls*) this_arg;
+ if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
+ JNIEnv *env;
+ jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
+ } else {
+ DO_ASSERT(get_jenv_res == JNI_OK);
+ }
+ (*env)->DeleteWeakGlobalRef(env, j_calls->o);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
+ }
+ FREE(j_calls);
+ }
+}
+void call_LDKFutureCallback_jcall(const void* this_arg) {
+ LDKFutureCallback_JCalls *j_calls = (LDKFutureCallback_JCalls*) this_arg;
+ JNIEnv *env;
+ jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
+ } else {
+ DO_ASSERT(get_jenv_res == JNI_OK);
+ }
+ jobject obj = (*env)->NewLocalRef(env, j_calls->o);
+ CHECK(obj != NULL);
+ (*env)->CallVoidMethod(env, obj, j_calls->call_meth);
+ if (UNLIKELY((*env)->ExceptionCheck(env))) {
+ (*env)->ExceptionDescribe(env);
+ (*env)->FatalError(env, "A call to call in LDKFutureCallback from rust threw an exception.");
+ }
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
+ }
+}
+static void LDKFutureCallback_JCalls_cloned(LDKFutureCallback* new_obj) {
+ LDKFutureCallback_JCalls *j_calls = (LDKFutureCallback_JCalls*) new_obj->this_arg;
+ atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
+}
+static inline LDKFutureCallback LDKFutureCallback_init (JNIEnv *env, jclass clz, jobject o) {
+ jclass c = (*env)->GetObjectClass(env, o);
+ CHECK(c != NULL);
+ LDKFutureCallback_JCalls *calls = MALLOC(sizeof(LDKFutureCallback_JCalls), "LDKFutureCallback_JCalls");
+ atomic_init(&calls->refcnt, 1);
+ DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
+ calls->o = (*env)->NewWeakGlobalRef(env, o);
+ calls->call_meth = (*env)->GetMethodID(env, c, "call", "()V");
+ CHECK(calls->call_meth != NULL);
+
+ LDKFutureCallback ret = {
+ .this_arg = (void*) calls,
+ .call = call_LDKFutureCallback_jcall,
+ .free = LDKFutureCallback_JCalls_free,
+ };
+ return ret;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKFutureCallback_1new(JNIEnv *env, jclass clz, jobject o) {
+ LDKFutureCallback *res_ptr = MALLOC(sizeof(LDKFutureCallback), "LDKFutureCallback");
+ *res_ptr = LDKFutureCallback_init(env, clz, o);
+ return tag_ptr(res_ptr, true);
+}
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_FutureCallback_1call(JNIEnv *env, jclass clz, int64_t this_arg) {
+ void* this_arg_ptr = untag_ptr(this_arg);
+ if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
+ LDKFutureCallback* this_arg_conv = (LDKFutureCallback*)this_arg_ptr;
+ (this_arg_conv->call)(this_arg_conv->this_arg);
+}
+
typedef struct LDKListen_JCalls {
atomic_size_t refcnt;
JavaVM *vm;
jmethodID handle_channel_reestablish_meth;
jmethodID handle_channel_update_meth;
jmethodID handle_error_meth;
+ jmethodID provided_node_features_meth;
+ jmethodID provided_init_features_meth;
} LDKChannelMessageHandler_JCalls;
static void LDKChannelMessageHandler_JCalls_free(void* this_arg) {
LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
}
+LDKNodeFeatures provided_node_features_LDKChannelMessageHandler_jcall(const void* this_arg) {
+ LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
+ JNIEnv *env;
+ jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
+ } else {
+ DO_ASSERT(get_jenv_res == JNI_OK);
+ }
+ jobject obj = (*env)->NewLocalRef(env, j_calls->o);
+ CHECK(obj != NULL);
+ uint64_t ret = (*env)->CallLongMethod(env, obj, j_calls->provided_node_features_meth);
+ if (UNLIKELY((*env)->ExceptionCheck(env))) {
+ (*env)->ExceptionDescribe(env);
+ (*env)->FatalError(env, "A call to provided_node_features in LDKChannelMessageHandler from rust threw an exception.");
+ }
+ LDKNodeFeatures ret_conv;
+ ret_conv.inner = untag_ptr(ret);
+ ret_conv.is_owned = ptr_is_owned(ret);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
+ }
+ return ret_conv;
+}
+LDKInitFeatures provided_init_features_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id) {
+ LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
+ JNIEnv *env;
+ jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
+ } else {
+ DO_ASSERT(get_jenv_res == JNI_OK);
+ }
+ int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
+ (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
+ jobject obj = (*env)->NewLocalRef(env, j_calls->o);
+ CHECK(obj != NULL);
+ uint64_t ret = (*env)->CallLongMethod(env, obj, j_calls->provided_init_features_meth, their_node_id_arr);
+ if (UNLIKELY((*env)->ExceptionCheck(env))) {
+ (*env)->ExceptionDescribe(env);
+ (*env)->FatalError(env, "A call to provided_init_features in LDKChannelMessageHandler from rust threw an exception.");
+ }
+ LDKInitFeatures ret_conv;
+ ret_conv.inner = untag_ptr(ret);
+ ret_conv.is_owned = ptr_is_owned(ret);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
+ }
+ return ret_conv;
+}
static void LDKChannelMessageHandler_JCalls_cloned(LDKChannelMessageHandler* new_obj) {
LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) new_obj->this_arg;
atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
CHECK(calls->handle_channel_update_meth != NULL);
calls->handle_error_meth = (*env)->GetMethodID(env, c, "handle_error", "([BJ)V");
CHECK(calls->handle_error_meth != NULL);
+ calls->provided_node_features_meth = (*env)->GetMethodID(env, c, "provided_node_features", "()J");
+ CHECK(calls->provided_node_features_meth != NULL);
+ calls->provided_init_features_meth = (*env)->GetMethodID(env, c, "provided_init_features", "([B)J");
+ CHECK(calls->provided_init_features_meth != NULL);
LDKChannelMessageHandler ret = {
.this_arg = (void*) calls,
.handle_channel_reestablish = handle_channel_reestablish_LDKChannelMessageHandler_jcall,
.handle_channel_update = handle_channel_update_LDKChannelMessageHandler_jcall,
.handle_error = handle_error_LDKChannelMessageHandler_jcall,
+ .provided_node_features = provided_node_features_LDKChannelMessageHandler_jcall,
+ .provided_init_features = provided_init_features_LDKChannelMessageHandler_jcall,
.free = LDKChannelMessageHandler_JCalls_free,
.MessageSendEventsProvider = LDKMessageSendEventsProvider_init(env, clz, MessageSendEventsProvider),
};
(this_arg_conv->handle_error)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelMessageHandler_1provided_1node_1features(JNIEnv *env, jclass clz, int64_t this_arg) {
+ void* this_arg_ptr = untag_ptr(this_arg);
+ if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
+ LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
+ LDKNodeFeatures ret_var = (this_arg_conv->provided_node_features)(this_arg_conv->this_arg);
+ int64_t ret_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
+ return ret_ref;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelMessageHandler_1provided_1init_1features(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id) {
+ void* this_arg_ptr = untag_ptr(this_arg);
+ if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
+ LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
+ LDKPublicKey their_node_id_ref;
+ CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
+ (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
+ LDKInitFeatures ret_var = (this_arg_conv->provided_init_features)(this_arg_conv->this_arg, their_node_id_ref);
+ int64_t ret_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
+ return ret_ref;
+}
+
typedef struct LDKRoutingMessageHandler_JCalls {
atomic_size_t refcnt;
JavaVM *vm;
jmethodID handle_node_announcement_meth;
jmethodID handle_channel_announcement_meth;
jmethodID handle_channel_update_meth;
- jmethodID get_next_channel_announcements_meth;
- jmethodID get_next_node_announcements_meth;
+ jmethodID get_next_channel_announcement_meth;
+ jmethodID get_next_node_announcement_meth;
jmethodID peer_connected_meth;
jmethodID handle_reply_channel_range_meth;
jmethodID handle_reply_short_channel_ids_end_meth;
jmethodID handle_query_channel_range_meth;
jmethodID handle_query_short_channel_ids_meth;
+ jmethodID provided_node_features_meth;
+ jmethodID provided_init_features_meth;
} LDKRoutingMessageHandler_JCalls;
static void LDKRoutingMessageHandler_JCalls_free(void* this_arg) {
LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
}
return ret_conv;
}
-LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ get_next_channel_announcements_LDKRoutingMessageHandler_jcall(const void* this_arg, uint64_t starting_point, uint8_t batch_amount) {
+LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ get_next_channel_announcement_LDKRoutingMessageHandler_jcall(const void* this_arg, uint64_t starting_point) {
LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
JNIEnv *env;
jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
DO_ASSERT(get_jenv_res == JNI_OK);
}
int64_t starting_point_conv = starting_point;
- int8_t batch_amount_conv = batch_amount;
jobject obj = (*env)->NewLocalRef(env, j_calls->o);
CHECK(obj != NULL);
- int64_tArray ret = (*env)->CallObjectMethod(env, obj, j_calls->get_next_channel_announcements_meth, starting_point_conv, batch_amount_conv);
+ uint64_t ret = (*env)->CallLongMethod(env, obj, j_calls->get_next_channel_announcement_meth, starting_point_conv);
if (UNLIKELY((*env)->ExceptionCheck(env))) {
(*env)->ExceptionDescribe(env);
- (*env)->FatalError(env, "A call to get_next_channel_announcements in LDKRoutingMessageHandler from rust threw an exception.");
+ (*env)->FatalError(env, "A call to get_next_channel_announcement in LDKRoutingMessageHandler from rust threw an exception.");
}
- LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret_constr;
- ret_constr.datalen = (*env)->GetArrayLength(env, ret);
- if (ret_constr.datalen > 0)
- ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ Elements");
- else
- ret_constr.data = NULL;
- int64_t* ret_vals = (*env)->GetLongArrayElements (env, ret, NULL);
- for (size_t h = 0; h < ret_constr.datalen; h++) {
- int64_t ret_conv_59 = ret_vals[h];
- void* ret_conv_59_ptr = untag_ptr(ret_conv_59);
- CHECK_ACCESS(ret_conv_59_ptr);
- LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ ret_conv_59_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(ret_conv_59_ptr);
- FREE(untag_ptr(ret_conv_59));
- ret_constr.data[h] = ret_conv_59_conv;
- }
- (*env)->ReleaseLongArrayElements(env, ret, ret_vals, 0);
+ void* ret_ptr = untag_ptr(ret);
+ CHECK_ACCESS(ret_ptr);
+ LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret_conv = *(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ*)(ret_ptr);
+ FREE(untag_ptr(ret));
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
- return ret_constr;
+ return ret_conv;
}
-LDKCVec_NodeAnnouncementZ get_next_node_announcements_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey starting_point, uint8_t batch_amount) {
+LDKNodeAnnouncement get_next_node_announcement_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey starting_point) {
LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
JNIEnv *env;
jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
}
int8_tArray starting_point_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, starting_point_arr, 0, 33, starting_point.compressed_form);
- int8_t batch_amount_conv = batch_amount;
jobject obj = (*env)->NewLocalRef(env, j_calls->o);
CHECK(obj != NULL);
- int64_tArray ret = (*env)->CallObjectMethod(env, obj, j_calls->get_next_node_announcements_meth, starting_point_arr, batch_amount_conv);
+ uint64_t ret = (*env)->CallLongMethod(env, obj, j_calls->get_next_node_announcement_meth, starting_point_arr);
if (UNLIKELY((*env)->ExceptionCheck(env))) {
(*env)->ExceptionDescribe(env);
- (*env)->FatalError(env, "A call to get_next_node_announcements in LDKRoutingMessageHandler from rust threw an exception.");
- }
- LDKCVec_NodeAnnouncementZ ret_constr;
- ret_constr.datalen = (*env)->GetArrayLength(env, ret);
- if (ret_constr.datalen > 0)
- ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKNodeAnnouncement), "LDKCVec_NodeAnnouncementZ Elements");
- else
- ret_constr.data = NULL;
- int64_t* ret_vals = (*env)->GetLongArrayElements (env, ret, NULL);
- for (size_t s = 0; s < ret_constr.datalen; s++) {
- int64_t ret_conv_18 = ret_vals[s];
- LDKNodeAnnouncement ret_conv_18_conv;
- ret_conv_18_conv.inner = untag_ptr(ret_conv_18);
- ret_conv_18_conv.is_owned = ptr_is_owned(ret_conv_18);
- CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_18_conv);
- ret_constr.data[s] = ret_conv_18_conv;
+ (*env)->FatalError(env, "A call to get_next_node_announcement in LDKRoutingMessageHandler from rust threw an exception.");
}
- (*env)->ReleaseLongArrayElements(env, ret, ret_vals, 0);
+ LDKNodeAnnouncement ret_conv;
+ ret_conv.inner = untag_ptr(ret);
+ ret_conv.is_owned = ptr_is_owned(ret);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
- return ret_constr;
+ return ret_conv;
}
void peer_connected_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInit * init) {
LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
}
return ret_conv;
}
+LDKNodeFeatures provided_node_features_LDKRoutingMessageHandler_jcall(const void* this_arg) {
+ LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
+ JNIEnv *env;
+ jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
+ } else {
+ DO_ASSERT(get_jenv_res == JNI_OK);
+ }
+ jobject obj = (*env)->NewLocalRef(env, j_calls->o);
+ CHECK(obj != NULL);
+ uint64_t ret = (*env)->CallLongMethod(env, obj, j_calls->provided_node_features_meth);
+ if (UNLIKELY((*env)->ExceptionCheck(env))) {
+ (*env)->ExceptionDescribe(env);
+ (*env)->FatalError(env, "A call to provided_node_features in LDKRoutingMessageHandler from rust threw an exception.");
+ }
+ LDKNodeFeatures ret_conv;
+ ret_conv.inner = untag_ptr(ret);
+ ret_conv.is_owned = ptr_is_owned(ret);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
+ }
+ return ret_conv;
+}
+LDKInitFeatures provided_init_features_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id) {
+ LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
+ JNIEnv *env;
+ jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
+ } else {
+ DO_ASSERT(get_jenv_res == JNI_OK);
+ }
+ int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
+ (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
+ jobject obj = (*env)->NewLocalRef(env, j_calls->o);
+ CHECK(obj != NULL);
+ uint64_t ret = (*env)->CallLongMethod(env, obj, j_calls->provided_init_features_meth, their_node_id_arr);
+ if (UNLIKELY((*env)->ExceptionCheck(env))) {
+ (*env)->ExceptionDescribe(env);
+ (*env)->FatalError(env, "A call to provided_init_features in LDKRoutingMessageHandler from rust threw an exception.");
+ }
+ LDKInitFeatures ret_conv;
+ ret_conv.inner = untag_ptr(ret);
+ ret_conv.is_owned = ptr_is_owned(ret);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
+ }
+ return ret_conv;
+}
static void LDKRoutingMessageHandler_JCalls_cloned(LDKRoutingMessageHandler* new_obj) {
LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) new_obj->this_arg;
atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
CHECK(calls->handle_channel_announcement_meth != NULL);
calls->handle_channel_update_meth = (*env)->GetMethodID(env, c, "handle_channel_update", "(J)J");
CHECK(calls->handle_channel_update_meth != NULL);
- calls->get_next_channel_announcements_meth = (*env)->GetMethodID(env, c, "get_next_channel_announcements", "(JB)[J");
- CHECK(calls->get_next_channel_announcements_meth != NULL);
- calls->get_next_node_announcements_meth = (*env)->GetMethodID(env, c, "get_next_node_announcements", "([BB)[J");
- CHECK(calls->get_next_node_announcements_meth != NULL);
+ calls->get_next_channel_announcement_meth = (*env)->GetMethodID(env, c, "get_next_channel_announcement", "(J)J");
+ CHECK(calls->get_next_channel_announcement_meth != NULL);
+ calls->get_next_node_announcement_meth = (*env)->GetMethodID(env, c, "get_next_node_announcement", "([B)J");
+ CHECK(calls->get_next_node_announcement_meth != NULL);
calls->peer_connected_meth = (*env)->GetMethodID(env, c, "peer_connected", "([BJ)V");
CHECK(calls->peer_connected_meth != NULL);
calls->handle_reply_channel_range_meth = (*env)->GetMethodID(env, c, "handle_reply_channel_range", "([BJ)J");
CHECK(calls->handle_query_channel_range_meth != NULL);
calls->handle_query_short_channel_ids_meth = (*env)->GetMethodID(env, c, "handle_query_short_channel_ids", "([BJ)J");
CHECK(calls->handle_query_short_channel_ids_meth != NULL);
+ calls->provided_node_features_meth = (*env)->GetMethodID(env, c, "provided_node_features", "()J");
+ CHECK(calls->provided_node_features_meth != NULL);
+ calls->provided_init_features_meth = (*env)->GetMethodID(env, c, "provided_init_features", "([B)J");
+ CHECK(calls->provided_init_features_meth != NULL);
LDKRoutingMessageHandler ret = {
.this_arg = (void*) calls,
.handle_node_announcement = handle_node_announcement_LDKRoutingMessageHandler_jcall,
.handle_channel_announcement = handle_channel_announcement_LDKRoutingMessageHandler_jcall,
.handle_channel_update = handle_channel_update_LDKRoutingMessageHandler_jcall,
- .get_next_channel_announcements = get_next_channel_announcements_LDKRoutingMessageHandler_jcall,
- .get_next_node_announcements = get_next_node_announcements_LDKRoutingMessageHandler_jcall,
+ .get_next_channel_announcement = get_next_channel_announcement_LDKRoutingMessageHandler_jcall,
+ .get_next_node_announcement = get_next_node_announcement_LDKRoutingMessageHandler_jcall,
.peer_connected = peer_connected_LDKRoutingMessageHandler_jcall,
.handle_reply_channel_range = handle_reply_channel_range_LDKRoutingMessageHandler_jcall,
.handle_reply_short_channel_ids_end = handle_reply_short_channel_ids_end_LDKRoutingMessageHandler_jcall,
.handle_query_channel_range = handle_query_channel_range_LDKRoutingMessageHandler_jcall,
.handle_query_short_channel_ids = handle_query_short_channel_ids_LDKRoutingMessageHandler_jcall,
+ .provided_node_features = provided_node_features_LDKRoutingMessageHandler_jcall,
+ .provided_init_features = provided_init_features_LDKRoutingMessageHandler_jcall,
.free = LDKRoutingMessageHandler_JCalls_free,
.MessageSendEventsProvider = LDKMessageSendEventsProvider_init(env, clz, MessageSendEventsProvider),
};
return tag_ptr(ret_conv, true);
}
-JNIEXPORT int64_tArray JNICALL Java_org_ldk_impl_bindings_RoutingMessageHandler_1get_1next_1channel_1announcements(JNIEnv *env, jclass clz, int64_t this_arg, int64_t starting_point, int8_t batch_amount) {
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RoutingMessageHandler_1get_1next_1channel_1announcement(JNIEnv *env, jclass clz, int64_t this_arg, int64_t starting_point) {
void* this_arg_ptr = untag_ptr(this_arg);
if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
- LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret_var = (this_arg_conv->get_next_channel_announcements)(this_arg_conv->this_arg, starting_point, batch_amount);
- int64_tArray ret_arr = NULL;
- ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
- int64_t *ret_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, ret_arr, NULL);
- for (size_t h = 0; h < ret_var.datalen; h++) {
- LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv_59_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
- *ret_conv_59_conv = ret_var.data[h];
- ret_arr_ptr[h] = tag_ptr(ret_conv_59_conv, true);
- }
- (*env)->ReleasePrimitiveArrayCritical(env, ret_arr, ret_arr_ptr, 0);
- FREE(ret_var.data);
- return ret_arr;
+ LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret_copy = MALLOC(sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
+ *ret_copy = (this_arg_conv->get_next_channel_announcement)(this_arg_conv->this_arg, starting_point);
+ int64_t ret_ref = tag_ptr(ret_copy, true);
+ return ret_ref;
}
-JNIEXPORT int64_tArray JNICALL Java_org_ldk_impl_bindings_RoutingMessageHandler_1get_1next_1node_1announcements(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray starting_point, int8_t batch_amount) {
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RoutingMessageHandler_1get_1next_1node_1announcement(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray starting_point) {
void* this_arg_ptr = untag_ptr(this_arg);
if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
LDKPublicKey starting_point_ref;
CHECK((*env)->GetArrayLength(env, starting_point) == 33);
(*env)->GetByteArrayRegion(env, starting_point, 0, 33, starting_point_ref.compressed_form);
- LDKCVec_NodeAnnouncementZ ret_var = (this_arg_conv->get_next_node_announcements)(this_arg_conv->this_arg, starting_point_ref, batch_amount);
- int64_tArray ret_arr = NULL;
- ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
- int64_t *ret_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, ret_arr, NULL);
- for (size_t s = 0; s < ret_var.datalen; s++) {
- LDKNodeAnnouncement ret_conv_18_var = ret_var.data[s];
- int64_t ret_conv_18_ref = 0;
- CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_18_var);
- ret_conv_18_ref = tag_ptr(ret_conv_18_var.inner, ret_conv_18_var.is_owned);
- ret_arr_ptr[s] = ret_conv_18_ref;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, ret_arr, ret_arr_ptr, 0);
- FREE(ret_var.data);
- return ret_arr;
+ LDKNodeAnnouncement ret_var = (this_arg_conv->get_next_node_announcement)(this_arg_conv->this_arg, starting_point_ref);
+ int64_t ret_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
+ return ret_ref;
}
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RoutingMessageHandler_1peer_1connected(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id, int64_t init) {
return tag_ptr(ret_conv, true);
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RoutingMessageHandler_1provided_1node_1features(JNIEnv *env, jclass clz, int64_t this_arg) {
+ void* this_arg_ptr = untag_ptr(this_arg);
+ if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
+ LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
+ LDKNodeFeatures ret_var = (this_arg_conv->provided_node_features)(this_arg_conv->this_arg);
+ int64_t ret_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
+ return ret_ref;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RoutingMessageHandler_1provided_1init_1features(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id) {
+ void* this_arg_ptr = untag_ptr(this_arg);
+ if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
+ LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
+ LDKPublicKey their_node_id_ref;
+ CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
+ (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
+ LDKInitFeatures ret_var = (this_arg_conv->provided_init_features)(this_arg_conv->this_arg, their_node_id_ref);
+ int64_t ret_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
+ return ret_ref;
+}
+
+typedef struct LDKOnionMessageHandler_JCalls {
+ atomic_size_t refcnt;
+ JavaVM *vm;
+ jweak o;
+ LDKOnionMessageProvider_JCalls* OnionMessageProvider;
+ jmethodID handle_onion_message_meth;
+ jmethodID peer_connected_meth;
+ jmethodID peer_disconnected_meth;
+ jmethodID provided_node_features_meth;
+ jmethodID provided_init_features_meth;
+} LDKOnionMessageHandler_JCalls;
+static void LDKOnionMessageHandler_JCalls_free(void* this_arg) {
+ LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) this_arg;
+ if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
+ JNIEnv *env;
+ jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
+ } else {
+ DO_ASSERT(get_jenv_res == JNI_OK);
+ }
+ (*env)->DeleteWeakGlobalRef(env, j_calls->o);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
+ }
+ FREE(j_calls);
+ }
+}
+void handle_onion_message_LDKOnionMessageHandler_jcall(const void* this_arg, LDKPublicKey peer_node_id, const LDKOnionMessage * msg) {
+ LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) this_arg;
+ JNIEnv *env;
+ jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
+ } else {
+ DO_ASSERT(get_jenv_res == JNI_OK);
+ }
+ int8_tArray peer_node_id_arr = (*env)->NewByteArray(env, 33);
+ (*env)->SetByteArrayRegion(env, peer_node_id_arr, 0, 33, peer_node_id.compressed_form);
+ LDKOnionMessage msg_var = *msg;
+ int64_t msg_ref = 0;
+ msg_var = OnionMessage_clone(&msg_var);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
+ msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
+ jobject obj = (*env)->NewLocalRef(env, j_calls->o);
+ CHECK(obj != NULL);
+ (*env)->CallVoidMethod(env, obj, j_calls->handle_onion_message_meth, peer_node_id_arr, msg_ref);
+ if (UNLIKELY((*env)->ExceptionCheck(env))) {
+ (*env)->ExceptionDescribe(env);
+ (*env)->FatalError(env, "A call to handle_onion_message in LDKOnionMessageHandler from rust threw an exception.");
+ }
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
+ }
+}
+void peer_connected_LDKOnionMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInit * init) {
+ LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) this_arg;
+ JNIEnv *env;
+ jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
+ } else {
+ DO_ASSERT(get_jenv_res == JNI_OK);
+ }
+ int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
+ (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
+ LDKInit init_var = *init;
+ int64_t init_ref = 0;
+ init_var = Init_clone(&init_var);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(init_var);
+ init_ref = tag_ptr(init_var.inner, init_var.is_owned);
+ jobject obj = (*env)->NewLocalRef(env, j_calls->o);
+ CHECK(obj != NULL);
+ (*env)->CallVoidMethod(env, obj, j_calls->peer_connected_meth, their_node_id_arr, init_ref);
+ if (UNLIKELY((*env)->ExceptionCheck(env))) {
+ (*env)->ExceptionDescribe(env);
+ (*env)->FatalError(env, "A call to peer_connected in LDKOnionMessageHandler from rust threw an exception.");
+ }
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
+ }
+}
+void peer_disconnected_LDKOnionMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, bool no_connection_possible) {
+ LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) this_arg;
+ JNIEnv *env;
+ jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
+ } else {
+ DO_ASSERT(get_jenv_res == JNI_OK);
+ }
+ int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
+ (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
+ jboolean no_connection_possible_conv = no_connection_possible;
+ jobject obj = (*env)->NewLocalRef(env, j_calls->o);
+ CHECK(obj != NULL);
+ (*env)->CallVoidMethod(env, obj, j_calls->peer_disconnected_meth, their_node_id_arr, no_connection_possible_conv);
+ if (UNLIKELY((*env)->ExceptionCheck(env))) {
+ (*env)->ExceptionDescribe(env);
+ (*env)->FatalError(env, "A call to peer_disconnected in LDKOnionMessageHandler from rust threw an exception.");
+ }
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
+ }
+}
+LDKNodeFeatures provided_node_features_LDKOnionMessageHandler_jcall(const void* this_arg) {
+ LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) this_arg;
+ JNIEnv *env;
+ jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
+ } else {
+ DO_ASSERT(get_jenv_res == JNI_OK);
+ }
+ jobject obj = (*env)->NewLocalRef(env, j_calls->o);
+ CHECK(obj != NULL);
+ uint64_t ret = (*env)->CallLongMethod(env, obj, j_calls->provided_node_features_meth);
+ if (UNLIKELY((*env)->ExceptionCheck(env))) {
+ (*env)->ExceptionDescribe(env);
+ (*env)->FatalError(env, "A call to provided_node_features in LDKOnionMessageHandler from rust threw an exception.");
+ }
+ LDKNodeFeatures ret_conv;
+ ret_conv.inner = untag_ptr(ret);
+ ret_conv.is_owned = ptr_is_owned(ret);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
+ }
+ return ret_conv;
+}
+LDKInitFeatures provided_init_features_LDKOnionMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id) {
+ LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) this_arg;
+ JNIEnv *env;
+ jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
+ } else {
+ DO_ASSERT(get_jenv_res == JNI_OK);
+ }
+ int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
+ (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
+ jobject obj = (*env)->NewLocalRef(env, j_calls->o);
+ CHECK(obj != NULL);
+ uint64_t ret = (*env)->CallLongMethod(env, obj, j_calls->provided_init_features_meth, their_node_id_arr);
+ if (UNLIKELY((*env)->ExceptionCheck(env))) {
+ (*env)->ExceptionDescribe(env);
+ (*env)->FatalError(env, "A call to provided_init_features in LDKOnionMessageHandler from rust threw an exception.");
+ }
+ LDKInitFeatures ret_conv;
+ ret_conv.inner = untag_ptr(ret);
+ ret_conv.is_owned = ptr_is_owned(ret);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
+ }
+ return ret_conv;
+}
+static void LDKOnionMessageHandler_JCalls_cloned(LDKOnionMessageHandler* new_obj) {
+ LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) new_obj->this_arg;
+ atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
+ atomic_fetch_add_explicit(&j_calls->OnionMessageProvider->refcnt, 1, memory_order_release);
+}
+static inline LDKOnionMessageHandler LDKOnionMessageHandler_init (JNIEnv *env, jclass clz, jobject o, jobject OnionMessageProvider) {
+ jclass c = (*env)->GetObjectClass(env, o);
+ CHECK(c != NULL);
+ LDKOnionMessageHandler_JCalls *calls = MALLOC(sizeof(LDKOnionMessageHandler_JCalls), "LDKOnionMessageHandler_JCalls");
+ atomic_init(&calls->refcnt, 1);
+ DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
+ calls->o = (*env)->NewWeakGlobalRef(env, o);
+ calls->handle_onion_message_meth = (*env)->GetMethodID(env, c, "handle_onion_message", "([BJ)V");
+ CHECK(calls->handle_onion_message_meth != NULL);
+ calls->peer_connected_meth = (*env)->GetMethodID(env, c, "peer_connected", "([BJ)V");
+ CHECK(calls->peer_connected_meth != NULL);
+ calls->peer_disconnected_meth = (*env)->GetMethodID(env, c, "peer_disconnected", "([BZ)V");
+ CHECK(calls->peer_disconnected_meth != NULL);
+ calls->provided_node_features_meth = (*env)->GetMethodID(env, c, "provided_node_features", "()J");
+ CHECK(calls->provided_node_features_meth != NULL);
+ calls->provided_init_features_meth = (*env)->GetMethodID(env, c, "provided_init_features", "([B)J");
+ CHECK(calls->provided_init_features_meth != NULL);
+
+ LDKOnionMessageHandler ret = {
+ .this_arg = (void*) calls,
+ .handle_onion_message = handle_onion_message_LDKOnionMessageHandler_jcall,
+ .peer_connected = peer_connected_LDKOnionMessageHandler_jcall,
+ .peer_disconnected = peer_disconnected_LDKOnionMessageHandler_jcall,
+ .provided_node_features = provided_node_features_LDKOnionMessageHandler_jcall,
+ .provided_init_features = provided_init_features_LDKOnionMessageHandler_jcall,
+ .free = LDKOnionMessageHandler_JCalls_free,
+ .OnionMessageProvider = LDKOnionMessageProvider_init(env, clz, OnionMessageProvider),
+ };
+ calls->OnionMessageProvider = ret.OnionMessageProvider.this_arg;
+ return ret;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKOnionMessageHandler_1new(JNIEnv *env, jclass clz, jobject o, jobject OnionMessageProvider) {
+ LDKOnionMessageHandler *res_ptr = MALLOC(sizeof(LDKOnionMessageHandler), "LDKOnionMessageHandler");
+ *res_ptr = LDKOnionMessageHandler_init(env, clz, o, OnionMessageProvider);
+ return tag_ptr(res_ptr, true);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKOnionMessageHandler_1get_1OnionMessageProvider(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKOnionMessageHandler *inp = (LDKOnionMessageHandler *)untag_ptr(arg);
+ return tag_ptr(&inp->OnionMessageProvider, false);
+}
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OnionMessageHandler_1handle_1onion_1message(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray peer_node_id, int64_t msg) {
+ void* this_arg_ptr = untag_ptr(this_arg);
+ if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
+ LDKOnionMessageHandler* this_arg_conv = (LDKOnionMessageHandler*)this_arg_ptr;
+ LDKPublicKey peer_node_id_ref;
+ CHECK((*env)->GetArrayLength(env, peer_node_id) == 33);
+ (*env)->GetByteArrayRegion(env, peer_node_id, 0, 33, peer_node_id_ref.compressed_form);
+ LDKOnionMessage msg_conv;
+ msg_conv.inner = untag_ptr(msg);
+ msg_conv.is_owned = ptr_is_owned(msg);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
+ msg_conv.is_owned = false;
+ (this_arg_conv->handle_onion_message)(this_arg_conv->this_arg, peer_node_id_ref, &msg_conv);
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OnionMessageHandler_1peer_1connected(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id, int64_t init) {
+ void* this_arg_ptr = untag_ptr(this_arg);
+ if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
+ LDKOnionMessageHandler* this_arg_conv = (LDKOnionMessageHandler*)this_arg_ptr;
+ LDKPublicKey their_node_id_ref;
+ CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
+ (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
+ LDKInit init_conv;
+ init_conv.inner = untag_ptr(init);
+ init_conv.is_owned = ptr_is_owned(init);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(init_conv);
+ init_conv.is_owned = false;
+ (this_arg_conv->peer_connected)(this_arg_conv->this_arg, their_node_id_ref, &init_conv);
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OnionMessageHandler_1peer_1disconnected(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id, jboolean no_connection_possible) {
+ void* this_arg_ptr = untag_ptr(this_arg);
+ if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
+ LDKOnionMessageHandler* this_arg_conv = (LDKOnionMessageHandler*)this_arg_ptr;
+ LDKPublicKey their_node_id_ref;
+ CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
+ (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
+ (this_arg_conv->peer_disconnected)(this_arg_conv->this_arg, their_node_id_ref, no_connection_possible);
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OnionMessageHandler_1provided_1node_1features(JNIEnv *env, jclass clz, int64_t this_arg) {
+ void* this_arg_ptr = untag_ptr(this_arg);
+ if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
+ LDKOnionMessageHandler* this_arg_conv = (LDKOnionMessageHandler*)this_arg_ptr;
+ LDKNodeFeatures ret_var = (this_arg_conv->provided_node_features)(this_arg_conv->this_arg);
+ int64_t ret_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
+ return ret_ref;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OnionMessageHandler_1provided_1init_1features(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id) {
+ void* this_arg_ptr = untag_ptr(this_arg);
+ if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
+ LDKOnionMessageHandler* this_arg_conv = (LDKOnionMessageHandler*)this_arg_ptr;
+ LDKPublicKey their_node_id_ref;
+ CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
+ (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
+ LDKInitFeatures ret_var = (this_arg_conv->provided_init_features)(this_arg_conv->this_arg, their_node_id_ref);
+ int64_t ret_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
+ return ret_ref;
+}
+
typedef struct LDKCustomMessageReader_JCalls {
atomic_size_t refcnt;
JavaVM *vm;
default: abort();
}
}
-typedef struct LDKLockableScore_JCalls {
- atomic_size_t refcnt;
- JavaVM *vm;
- jweak o;
- jmethodID lock_meth;
-} LDKLockableScore_JCalls;
-static void LDKLockableScore_JCalls_free(void* this_arg) {
- LDKLockableScore_JCalls *j_calls = (LDKLockableScore_JCalls*) this_arg;
- if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
- JNIEnv *env;
- jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
- if (get_jenv_res == JNI_EDETACHED) {
- DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
- } else {
- DO_ASSERT(get_jenv_res == JNI_OK);
+static jclass LDKDestination_Node_class = NULL;
+static jmethodID LDKDestination_Node_meth = NULL;
+static jclass LDKDestination_BlindedRoute_class = NULL;
+static jmethodID LDKDestination_BlindedRoute_meth = NULL;
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKDestination_init (JNIEnv *env, jclass clz) {
+ LDKDestination_Node_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "org/ldk/impl/bindings$LDKDestination$Node"));
+ CHECK(LDKDestination_Node_class != NULL);
+ LDKDestination_Node_meth = (*env)->GetMethodID(env, LDKDestination_Node_class, "<init>", "([B)V");
+ CHECK(LDKDestination_Node_meth != NULL);
+ LDKDestination_BlindedRoute_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "org/ldk/impl/bindings$LDKDestination$BlindedRoute"));
+ CHECK(LDKDestination_BlindedRoute_class != NULL);
+ LDKDestination_BlindedRoute_meth = (*env)->GetMethodID(env, LDKDestination_BlindedRoute_class, "<init>", "(J)V");
+ CHECK(LDKDestination_BlindedRoute_meth != NULL);
+}
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKDestination_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
+ LDKDestination *obj = (LDKDestination*)untag_ptr(ptr);
+ switch(obj->tag) {
+ case LDKDestination_Node: {
+ int8_tArray node_arr = (*env)->NewByteArray(env, 33);
+ (*env)->SetByteArrayRegion(env, node_arr, 0, 33, obj->node.compressed_form);
+ return (*env)->NewObject(env, LDKDestination_Node_class, LDKDestination_Node_meth, node_arr);
}
- (*env)->DeleteWeakGlobalRef(env, j_calls->o);
- if (get_jenv_res == JNI_EDETACHED) {
- DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
+ case LDKDestination_BlindedRoute: {
+ LDKBlindedRoute blinded_route_var = obj->blinded_route;
+ int64_t blinded_route_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(blinded_route_var);
+ blinded_route_ref = tag_ptr(blinded_route_var.inner, false);
+ return (*env)->NewObject(env, LDKDestination_BlindedRoute_class, LDKDestination_BlindedRoute_meth, blinded_route_ref);
}
- FREE(j_calls);
- }
-}
-LDKScore lock_LDKLockableScore_jcall(const void* this_arg) {
- LDKLockableScore_JCalls *j_calls = (LDKLockableScore_JCalls*) this_arg;
- JNIEnv *env;
- jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
- if (get_jenv_res == JNI_EDETACHED) {
- DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
- } else {
- DO_ASSERT(get_jenv_res == JNI_OK);
- }
- jobject obj = (*env)->NewLocalRef(env, j_calls->o);
- CHECK(obj != NULL);
- uint64_t ret = (*env)->CallLongMethod(env, obj, j_calls->lock_meth);
- if (UNLIKELY((*env)->ExceptionCheck(env))) {
- (*env)->ExceptionDescribe(env);
- (*env)->FatalError(env, "A call to lock in LDKLockableScore from rust threw an exception.");
- }
- void* ret_ptr = untag_ptr(ret);
- CHECK_ACCESS(ret_ptr);
- LDKScore ret_conv = *(LDKScore*)(ret_ptr);
- if (ret_conv.free == LDKScore_JCalls_free) {
- // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
- LDKScore_JCalls_cloned(&ret_conv);
- }// WARNING: we may need a move here but no clone is available for LDKScore
-
- if (get_jenv_res == JNI_EDETACHED) {
- DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
+ default: abort();
}
- return ret_conv;
-}
-static void LDKLockableScore_JCalls_cloned(LDKLockableScore* new_obj) {
- LDKLockableScore_JCalls *j_calls = (LDKLockableScore_JCalls*) new_obj->this_arg;
- atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
-}
-static inline LDKLockableScore LDKLockableScore_init (JNIEnv *env, jclass clz, jobject o) {
- jclass c = (*env)->GetObjectClass(env, o);
- CHECK(c != NULL);
- LDKLockableScore_JCalls *calls = MALLOC(sizeof(LDKLockableScore_JCalls), "LDKLockableScore_JCalls");
- atomic_init(&calls->refcnt, 1);
- DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
- calls->o = (*env)->NewWeakGlobalRef(env, o);
- calls->lock_meth = (*env)->GetMethodID(env, c, "lock", "()J");
- CHECK(calls->lock_meth != NULL);
-
- LDKLockableScore ret = {
- .this_arg = (void*) calls,
- .lock = lock_LDKLockableScore_jcall,
- .free = LDKLockableScore_JCalls_free,
- };
- return ret;
-}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKLockableScore_1new(JNIEnv *env, jclass clz, jobject o) {
- LDKLockableScore *res_ptr = MALLOC(sizeof(LDKLockableScore), "LDKLockableScore");
- *res_ptr = LDKLockableScore_init(env, clz, o);
- return tag_ptr(res_ptr, true);
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LockableScore_1lock(JNIEnv *env, jclass clz, int64_t this_arg) {
- void* this_arg_ptr = untag_ptr(this_arg);
- if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
- LDKLockableScore* this_arg_conv = (LDKLockableScore*)this_arg_ptr;
- LDKScore* ret_ret = MALLOC(sizeof(LDKScore), "LDKScore");
- *ret_ret = (this_arg_conv->lock)(this_arg_conv->this_arg);
- return tag_ptr(ret_ret, true);
-}
-
static jclass LDKGossipSync_P2P_class = NULL;
static jmethodID LDKGossipSync_P2P_meth = NULL;
static jclass LDKGossipSync_Rapid_class = NULL;
JavaVM *vm;
jweak o;
jmethodID find_route_meth;
+ jmethodID notify_payment_path_failed_meth;
+ jmethodID notify_payment_path_successful_meth;
+ jmethodID notify_payment_probe_successful_meth;
+ jmethodID notify_payment_probe_failed_meth;
} LDKRouter_JCalls;
static void LDKRouter_JCalls_free(void* this_arg) {
LDKRouter_JCalls *j_calls = (LDKRouter_JCalls*) this_arg;
FREE(j_calls);
}
}
-LDKCResult_RouteLightningErrorZ find_route_LDKRouter_jcall(const void* this_arg, LDKPublicKey payer, const LDKRouteParameters * route_params, const uint8_t (* payment_hash)[32], LDKCVec_ChannelDetailsZ * first_hops, const LDKScore * scorer) {
+LDKCResult_RouteLightningErrorZ find_route_LDKRouter_jcall(const void* this_arg, LDKPublicKey payer, const LDKRouteParameters * route_params, const uint8_t (* payment_hash)[32], LDKCVec_ChannelDetailsZ * first_hops, LDKInFlightHtlcs inflight_htlcs) {
LDKRouter_JCalls *j_calls = (LDKRouter_JCalls*) this_arg;
JNIEnv *env;
jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
}
(*env)->ReleasePrimitiveArrayCritical(env, first_hops_arr, first_hops_arr_ptr, 0);
}
- // WARNING: This object doesn't live past this scope, needs clone!
- int64_t ret_scorer = tag_ptr(scorer, false);
+ LDKInFlightHtlcs inflight_htlcs_var = inflight_htlcs;
+ int64_t inflight_htlcs_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(inflight_htlcs_var);
+ inflight_htlcs_ref = tag_ptr(inflight_htlcs_var.inner, inflight_htlcs_var.is_owned);
jobject obj = (*env)->NewLocalRef(env, j_calls->o);
CHECK(obj != NULL);
- uint64_t ret = (*env)->CallLongMethod(env, obj, j_calls->find_route_meth, payer_arr, route_params_ref, payment_hash_arr, first_hops_arr, ret_scorer);
+ uint64_t ret = (*env)->CallLongMethod(env, obj, j_calls->find_route_meth, payer_arr, route_params_ref, payment_hash_arr, first_hops_arr, inflight_htlcs_ref);
if (UNLIKELY((*env)->ExceptionCheck(env))) {
(*env)->ExceptionDescribe(env);
(*env)->FatalError(env, "A call to find_route in LDKRouter from rust threw an exception.");
}
return ret_conv;
}
+void notify_payment_path_failed_LDKRouter_jcall(const void* this_arg, LDKCVec_RouteHopZ path, uint64_t short_channel_id) {
+ LDKRouter_JCalls *j_calls = (LDKRouter_JCalls*) this_arg;
+ JNIEnv *env;
+ jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
+ } else {
+ DO_ASSERT(get_jenv_res == JNI_OK);
+ }
+ LDKCVec_RouteHopZ path_var = path;
+ int64_tArray path_arr = NULL;
+ path_arr = (*env)->NewLongArray(env, path_var.datalen);
+ int64_t *path_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, path_arr, NULL);
+ for (size_t k = 0; k < path_var.datalen; k++) {
+ LDKRouteHop path_conv_10_var = path_var.data[k];
+ int64_t path_conv_10_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
+ path_conv_10_ref = tag_ptr(path_conv_10_var.inner, path_conv_10_var.is_owned);
+ path_arr_ptr[k] = path_conv_10_ref;
+ }
+ (*env)->ReleasePrimitiveArrayCritical(env, path_arr, path_arr_ptr, 0);
+ FREE(path_var.data);
+ int64_t short_channel_id_conv = short_channel_id;
+ jobject obj = (*env)->NewLocalRef(env, j_calls->o);
+ CHECK(obj != NULL);
+ (*env)->CallVoidMethod(env, obj, j_calls->notify_payment_path_failed_meth, path_arr, short_channel_id_conv);
+ if (UNLIKELY((*env)->ExceptionCheck(env))) {
+ (*env)->ExceptionDescribe(env);
+ (*env)->FatalError(env, "A call to notify_payment_path_failed in LDKRouter from rust threw an exception.");
+ }
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
+ }
+}
+void notify_payment_path_successful_LDKRouter_jcall(const void* this_arg, LDKCVec_RouteHopZ path) {
+ LDKRouter_JCalls *j_calls = (LDKRouter_JCalls*) this_arg;
+ JNIEnv *env;
+ jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
+ } else {
+ DO_ASSERT(get_jenv_res == JNI_OK);
+ }
+ LDKCVec_RouteHopZ path_var = path;
+ int64_tArray path_arr = NULL;
+ path_arr = (*env)->NewLongArray(env, path_var.datalen);
+ int64_t *path_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, path_arr, NULL);
+ for (size_t k = 0; k < path_var.datalen; k++) {
+ LDKRouteHop path_conv_10_var = path_var.data[k];
+ int64_t path_conv_10_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
+ path_conv_10_ref = tag_ptr(path_conv_10_var.inner, path_conv_10_var.is_owned);
+ path_arr_ptr[k] = path_conv_10_ref;
+ }
+ (*env)->ReleasePrimitiveArrayCritical(env, path_arr, path_arr_ptr, 0);
+ FREE(path_var.data);
+ jobject obj = (*env)->NewLocalRef(env, j_calls->o);
+ CHECK(obj != NULL);
+ (*env)->CallVoidMethod(env, obj, j_calls->notify_payment_path_successful_meth, path_arr);
+ if (UNLIKELY((*env)->ExceptionCheck(env))) {
+ (*env)->ExceptionDescribe(env);
+ (*env)->FatalError(env, "A call to notify_payment_path_successful in LDKRouter from rust threw an exception.");
+ }
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
+ }
+}
+void notify_payment_probe_successful_LDKRouter_jcall(const void* this_arg, LDKCVec_RouteHopZ path) {
+ LDKRouter_JCalls *j_calls = (LDKRouter_JCalls*) this_arg;
+ JNIEnv *env;
+ jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
+ } else {
+ DO_ASSERT(get_jenv_res == JNI_OK);
+ }
+ LDKCVec_RouteHopZ path_var = path;
+ int64_tArray path_arr = NULL;
+ path_arr = (*env)->NewLongArray(env, path_var.datalen);
+ int64_t *path_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, path_arr, NULL);
+ for (size_t k = 0; k < path_var.datalen; k++) {
+ LDKRouteHop path_conv_10_var = path_var.data[k];
+ int64_t path_conv_10_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
+ path_conv_10_ref = tag_ptr(path_conv_10_var.inner, path_conv_10_var.is_owned);
+ path_arr_ptr[k] = path_conv_10_ref;
+ }
+ (*env)->ReleasePrimitiveArrayCritical(env, path_arr, path_arr_ptr, 0);
+ FREE(path_var.data);
+ jobject obj = (*env)->NewLocalRef(env, j_calls->o);
+ CHECK(obj != NULL);
+ (*env)->CallVoidMethod(env, obj, j_calls->notify_payment_probe_successful_meth, path_arr);
+ if (UNLIKELY((*env)->ExceptionCheck(env))) {
+ (*env)->ExceptionDescribe(env);
+ (*env)->FatalError(env, "A call to notify_payment_probe_successful in LDKRouter from rust threw an exception.");
+ }
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
+ }
+}
+void notify_payment_probe_failed_LDKRouter_jcall(const void* this_arg, LDKCVec_RouteHopZ path, uint64_t short_channel_id) {
+ LDKRouter_JCalls *j_calls = (LDKRouter_JCalls*) this_arg;
+ JNIEnv *env;
+ jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
+ } else {
+ DO_ASSERT(get_jenv_res == JNI_OK);
+ }
+ LDKCVec_RouteHopZ path_var = path;
+ int64_tArray path_arr = NULL;
+ path_arr = (*env)->NewLongArray(env, path_var.datalen);
+ int64_t *path_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, path_arr, NULL);
+ for (size_t k = 0; k < path_var.datalen; k++) {
+ LDKRouteHop path_conv_10_var = path_var.data[k];
+ int64_t path_conv_10_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
+ path_conv_10_ref = tag_ptr(path_conv_10_var.inner, path_conv_10_var.is_owned);
+ path_arr_ptr[k] = path_conv_10_ref;
+ }
+ (*env)->ReleasePrimitiveArrayCritical(env, path_arr, path_arr_ptr, 0);
+ FREE(path_var.data);
+ int64_t short_channel_id_conv = short_channel_id;
+ jobject obj = (*env)->NewLocalRef(env, j_calls->o);
+ CHECK(obj != NULL);
+ (*env)->CallVoidMethod(env, obj, j_calls->notify_payment_probe_failed_meth, path_arr, short_channel_id_conv);
+ if (UNLIKELY((*env)->ExceptionCheck(env))) {
+ (*env)->ExceptionDescribe(env);
+ (*env)->FatalError(env, "A call to notify_payment_probe_failed in LDKRouter from rust threw an exception.");
+ }
+ if (get_jenv_res == JNI_EDETACHED) {
+ DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
+ }
+}
static void LDKRouter_JCalls_cloned(LDKRouter* new_obj) {
LDKRouter_JCalls *j_calls = (LDKRouter_JCalls*) new_obj->this_arg;
atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
calls->o = (*env)->NewWeakGlobalRef(env, o);
calls->find_route_meth = (*env)->GetMethodID(env, c, "find_route", "([BJ[B[JJ)J");
CHECK(calls->find_route_meth != NULL);
+ calls->notify_payment_path_failed_meth = (*env)->GetMethodID(env, c, "notify_payment_path_failed", "([JJ)V");
+ CHECK(calls->notify_payment_path_failed_meth != NULL);
+ calls->notify_payment_path_successful_meth = (*env)->GetMethodID(env, c, "notify_payment_path_successful", "([J)V");
+ CHECK(calls->notify_payment_path_successful_meth != NULL);
+ calls->notify_payment_probe_successful_meth = (*env)->GetMethodID(env, c, "notify_payment_probe_successful", "([J)V");
+ CHECK(calls->notify_payment_probe_successful_meth != NULL);
+ calls->notify_payment_probe_failed_meth = (*env)->GetMethodID(env, c, "notify_payment_probe_failed", "([JJ)V");
+ CHECK(calls->notify_payment_probe_failed_meth != NULL);
LDKRouter ret = {
.this_arg = (void*) calls,
.find_route = find_route_LDKRouter_jcall,
+ .notify_payment_path_failed = notify_payment_path_failed_LDKRouter_jcall,
+ .notify_payment_path_successful = notify_payment_path_successful_LDKRouter_jcall,
+ .notify_payment_probe_successful = notify_payment_probe_successful_LDKRouter_jcall,
+ .notify_payment_probe_failed = notify_payment_probe_failed_LDKRouter_jcall,
.free = LDKRouter_JCalls_free,
};
return ret;
*res_ptr = LDKRouter_init(env, clz, o);
return tag_ptr(res_ptr, true);
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Router_1find_1route(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray payer, int64_t route_params, int8_tArray payment_hash, int64_tArray first_hops, int64_t scorer) {
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Router_1find_1route(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray payer, int64_t route_params, int8_tArray payment_hash, int64_tArray first_hops, int64_t inflight_htlcs) {
void* this_arg_ptr = untag_ptr(this_arg);
if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
LDKRouter* this_arg_conv = (LDKRouter*)this_arg_ptr;
(*env)->ReleaseLongArrayElements(env, first_hops, first_hops_vals, 0);
first_hops_ptr = &first_hops_constr;
}
- void* scorer_ptr = untag_ptr(scorer);
- if (ptr_is_owned(scorer)) { CHECK_ACCESS(scorer_ptr); }
- LDKScore* scorer_conv = (LDKScore*)scorer_ptr;
+ LDKInFlightHtlcs inflight_htlcs_conv;
+ inflight_htlcs_conv.inner = untag_ptr(inflight_htlcs);
+ inflight_htlcs_conv.is_owned = ptr_is_owned(inflight_htlcs);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(inflight_htlcs_conv);
+ // WARNING: we need a move here but no clone is available for LDKInFlightHtlcs
+
LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
- *ret_conv = (this_arg_conv->find_route)(this_arg_conv->this_arg, payer_ref, &route_params_conv, payment_hash_ref, first_hops_ptr, scorer_conv);
+ *ret_conv = (this_arg_conv->find_route)(this_arg_conv->this_arg, payer_ref, &route_params_conv, payment_hash_ref, first_hops_ptr, inflight_htlcs_conv);
if (first_hops_ptr != NULL) { FREE(first_hops_constr.data); }
return tag_ptr(ret_conv, true);
}
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Router_1notify_1payment_1path_1failed(JNIEnv *env, jclass clz, int64_t this_arg, int64_tArray path, int64_t short_channel_id) {
+ void* this_arg_ptr = untag_ptr(this_arg);
+ if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
+ LDKRouter* this_arg_conv = (LDKRouter*)this_arg_ptr;
+ LDKCVec_RouteHopZ path_constr;
+ path_constr.datalen = (*env)->GetArrayLength(env, path);
+ if (path_constr.datalen > 0)
+ path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
+ else
+ path_constr.data = NULL;
+ int64_t* path_vals = (*env)->GetLongArrayElements (env, path, NULL);
+ for (size_t k = 0; k < path_constr.datalen; k++) {
+ int64_t path_conv_10 = path_vals[k];
+ LDKRouteHop path_conv_10_conv;
+ path_conv_10_conv.inner = untag_ptr(path_conv_10);
+ path_conv_10_conv.is_owned = ptr_is_owned(path_conv_10);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
+ path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
+ path_constr.data[k] = path_conv_10_conv;
+ }
+ (*env)->ReleaseLongArrayElements(env, path, path_vals, 0);
+ (this_arg_conv->notify_payment_path_failed)(this_arg_conv->this_arg, path_constr, short_channel_id);
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Router_1notify_1payment_1path_1successful(JNIEnv *env, jclass clz, int64_t this_arg, int64_tArray path) {
+ void* this_arg_ptr = untag_ptr(this_arg);
+ if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
+ LDKRouter* this_arg_conv = (LDKRouter*)this_arg_ptr;
+ LDKCVec_RouteHopZ path_constr;
+ path_constr.datalen = (*env)->GetArrayLength(env, path);
+ if (path_constr.datalen > 0)
+ path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
+ else
+ path_constr.data = NULL;
+ int64_t* path_vals = (*env)->GetLongArrayElements (env, path, NULL);
+ for (size_t k = 0; k < path_constr.datalen; k++) {
+ int64_t path_conv_10 = path_vals[k];
+ LDKRouteHop path_conv_10_conv;
+ path_conv_10_conv.inner = untag_ptr(path_conv_10);
+ path_conv_10_conv.is_owned = ptr_is_owned(path_conv_10);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
+ path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
+ path_constr.data[k] = path_conv_10_conv;
+ }
+ (*env)->ReleaseLongArrayElements(env, path, path_vals, 0);
+ (this_arg_conv->notify_payment_path_successful)(this_arg_conv->this_arg, path_constr);
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Router_1notify_1payment_1probe_1successful(JNIEnv *env, jclass clz, int64_t this_arg, int64_tArray path) {
+ void* this_arg_ptr = untag_ptr(this_arg);
+ if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
+ LDKRouter* this_arg_conv = (LDKRouter*)this_arg_ptr;
+ LDKCVec_RouteHopZ path_constr;
+ path_constr.datalen = (*env)->GetArrayLength(env, path);
+ if (path_constr.datalen > 0)
+ path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
+ else
+ path_constr.data = NULL;
+ int64_t* path_vals = (*env)->GetLongArrayElements (env, path, NULL);
+ for (size_t k = 0; k < path_constr.datalen; k++) {
+ int64_t path_conv_10 = path_vals[k];
+ LDKRouteHop path_conv_10_conv;
+ path_conv_10_conv.inner = untag_ptr(path_conv_10);
+ path_conv_10_conv.is_owned = ptr_is_owned(path_conv_10);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
+ path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
+ path_constr.data[k] = path_conv_10_conv;
+ }
+ (*env)->ReleaseLongArrayElements(env, path, path_vals, 0);
+ (this_arg_conv->notify_payment_probe_successful)(this_arg_conv->this_arg, path_constr);
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Router_1notify_1payment_1probe_1failed(JNIEnv *env, jclass clz, int64_t this_arg, int64_tArray path, int64_t short_channel_id) {
+ void* this_arg_ptr = untag_ptr(this_arg);
+ if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
+ LDKRouter* this_arg_conv = (LDKRouter*)this_arg_ptr;
+ LDKCVec_RouteHopZ path_constr;
+ path_constr.datalen = (*env)->GetArrayLength(env, path);
+ if (path_constr.datalen > 0)
+ path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
+ else
+ path_constr.data = NULL;
+ int64_t* path_vals = (*env)->GetLongArrayElements (env, path, NULL);
+ for (size_t k = 0; k < path_constr.datalen; k++) {
+ int64_t path_conv_10 = path_vals[k];
+ LDKRouteHop path_conv_10_conv;
+ path_conv_10_conv.inner = untag_ptr(path_conv_10);
+ path_conv_10_conv.is_owned = ptr_is_owned(path_conv_10);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
+ path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
+ path_constr.data[k] = path_conv_10_conv;
+ }
+ (*env)->ReleaseLongArrayElements(env, path, path_vals, 0);
+ (this_arg_conv->notify_payment_probe_failed)(this_arg_conv->this_arg, path_constr, short_channel_id);
+}
+
static jclass LDKRetry_Attempts_class = NULL;
static jmethodID LDKRetry_Attempts_meth = NULL;
static jclass LDKRetry_Timeout_class = NULL;
return ret_conv;
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_BigEndianScalar_1new(JNIEnv *env, jclass clz, int8_tArray big_endian_bytes) {
+ LDKThirtyTwoBytes big_endian_bytes_ref;
+ CHECK((*env)->GetArrayLength(env, big_endian_bytes) == 32);
+ (*env)->GetByteArrayRegion(env, big_endian_bytes, 0, 32, big_endian_bytes_ref.data);
+ LDKBigEndianScalar* ret_ref = MALLOC(sizeof(LDKBigEndianScalar), "LDKBigEndianScalar");
+ *ret_ref = BigEndianScalar_new(big_endian_bytes_ref);
+ return tag_ptr(ret_ref, true);
+}
+
static inline uint64_t Bech32Error_clone_ptr(LDKBech32Error *NONNULL_PTR arg) {
LDKBech32Error *ret_copy = MALLOC(sizeof(LDKBech32Error), "LDKBech32Error");
*ret_copy = Bech32Error_clone(arg);
Str_free(dummy);
}
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1PublicKeyZ_1free(JNIEnv *env, jclass clz, jobjectArray _res) {
+ LDKCVec_PublicKeyZ _res_constr;
+ _res_constr.datalen = (*env)->GetArrayLength(env, _res);
+ if (_res_constr.datalen > 0)
+ _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKPublicKey), "LDKCVec_PublicKeyZ Elements");
+ else
+ _res_constr.data = NULL;
+ for (size_t i = 0; i < _res_constr.datalen; i++) {
+ int8_tArray _res_conv_8 = (*env)->GetObjectArrayElement(env, _res, i);
+ LDKPublicKey _res_conv_8_ref;
+ CHECK((*env)->GetArrayLength(env, _res_conv_8) == 33);
+ (*env)->GetByteArrayRegion(env, _res_conv_8, 0, 33, _res_conv_8_ref.compressed_form);
+ _res_constr.data[i] = _res_conv_8_ref;
+ }
+ CVec_PublicKeyZ_free(_res_constr);
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1BlindedRouteNoneZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKBlindedRoute o_conv;
+ o_conv.inner = untag_ptr(o);
+ o_conv.is_owned = ptr_is_owned(o);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ // WARNING: we need a move here but no clone is available for LDKBlindedRoute
+
+ LDKCResult_BlindedRouteNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedRouteNoneZ), "LDKCResult_BlindedRouteNoneZ");
+ *ret_conv = CResult_BlindedRouteNoneZ_ok(o_conv);
+ return tag_ptr(ret_conv, true);
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1BlindedRouteNoneZ_1err(JNIEnv *env, jclass clz) {
+ LDKCResult_BlindedRouteNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedRouteNoneZ), "LDKCResult_BlindedRouteNoneZ");
+ *ret_conv = CResult_BlindedRouteNoneZ_err();
+ return tag_ptr(ret_conv, true);
+}
+
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1BlindedRouteNoneZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_BlindedRouteNoneZ* o_conv = (LDKCResult_BlindedRouteNoneZ*)untag_ptr(o);
+ jboolean ret_conv = CResult_BlindedRouteNoneZ_is_ok(o_conv);
+ return ret_conv;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1BlindedRouteNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
+ if (!ptr_is_owned(_res)) return;
+ void* _res_ptr = untag_ptr(_res);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_BlindedRouteNoneZ _res_conv = *(LDKCResult_BlindedRouteNoneZ*)(_res_ptr);
+ FREE(untag_ptr(_res));
+ CResult_BlindedRouteNoneZ_free(_res_conv);
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1BlindedRouteDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKBlindedRoute o_conv;
+ o_conv.inner = untag_ptr(o);
+ o_conv.is_owned = ptr_is_owned(o);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ // WARNING: we need a move here but no clone is available for LDKBlindedRoute
+
+ LDKCResult_BlindedRouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedRouteDecodeErrorZ), "LDKCResult_BlindedRouteDecodeErrorZ");
+ *ret_conv = CResult_BlindedRouteDecodeErrorZ_ok(o_conv);
+ return tag_ptr(ret_conv, true);
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1BlindedRouteDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = untag_ptr(e);
+ e_conv.is_owned = ptr_is_owned(e);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_BlindedRouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedRouteDecodeErrorZ), "LDKCResult_BlindedRouteDecodeErrorZ");
+ *ret_conv = CResult_BlindedRouteDecodeErrorZ_err(e_conv);
+ return tag_ptr(ret_conv, true);
+}
+
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1BlindedRouteDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_BlindedRouteDecodeErrorZ* o_conv = (LDKCResult_BlindedRouteDecodeErrorZ*)untag_ptr(o);
+ jboolean ret_conv = CResult_BlindedRouteDecodeErrorZ_is_ok(o_conv);
+ return ret_conv;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1BlindedRouteDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
+ if (!ptr_is_owned(_res)) return;
+ void* _res_ptr = untag_ptr(_res);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_BlindedRouteDecodeErrorZ _res_conv = *(LDKCResult_BlindedRouteDecodeErrorZ*)(_res_ptr);
+ FREE(untag_ptr(_res));
+ CResult_BlindedRouteDecodeErrorZ_free(_res_conv);
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1BlindedHopDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKBlindedHop o_conv;
+ o_conv.inner = untag_ptr(o);
+ o_conv.is_owned = ptr_is_owned(o);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ // WARNING: we need a move here but no clone is available for LDKBlindedHop
+
+ LDKCResult_BlindedHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopDecodeErrorZ), "LDKCResult_BlindedHopDecodeErrorZ");
+ *ret_conv = CResult_BlindedHopDecodeErrorZ_ok(o_conv);
+ return tag_ptr(ret_conv, true);
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1BlindedHopDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = untag_ptr(e);
+ e_conv.is_owned = ptr_is_owned(e);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_BlindedHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopDecodeErrorZ), "LDKCResult_BlindedHopDecodeErrorZ");
+ *ret_conv = CResult_BlindedHopDecodeErrorZ_err(e_conv);
+ return tag_ptr(ret_conv, true);
+}
+
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1BlindedHopDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_BlindedHopDecodeErrorZ* o_conv = (LDKCResult_BlindedHopDecodeErrorZ*)untag_ptr(o);
+ jboolean ret_conv = CResult_BlindedHopDecodeErrorZ_is_ok(o_conv);
+ return ret_conv;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1BlindedHopDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
+ if (!ptr_is_owned(_res)) return;
+ void* _res_ptr = untag_ptr(_res);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_BlindedHopDecodeErrorZ _res_conv = *(LDKCResult_BlindedHopDecodeErrorZ*)(_res_ptr);
+ FREE(untag_ptr(_res));
+ CResult_BlindedHopDecodeErrorZ_free(_res_conv);
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneNoneZ_1ok(JNIEnv *env, jclass clz) {
LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
*ret_conv = CResult_NoneNoneZ_ok();
return tag_ptr(ret_conv, true);
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1WriteableScoreZ_1some(JNIEnv *env, jclass clz, int64_t o) {
+ void* o_ptr = untag_ptr(o);
+ CHECK_ACCESS(o_ptr);
+ LDKWriteableScore o_conv = *(LDKWriteableScore*)(o_ptr);
+ if (o_conv.free == LDKWriteableScore_JCalls_free) {
+ // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
+ LDKWriteableScore_JCalls_cloned(&o_conv);
+ }
+ LDKCOption_WriteableScoreZ *ret_copy = MALLOC(sizeof(LDKCOption_WriteableScoreZ), "LDKCOption_WriteableScoreZ");
+ *ret_copy = COption_WriteableScoreZ_some(o_conv);
+ int64_t ret_ref = tag_ptr(ret_copy, true);
+ return ret_ref;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1WriteableScoreZ_1none(JNIEnv *env, jclass clz) {
+ LDKCOption_WriteableScoreZ *ret_copy = MALLOC(sizeof(LDKCOption_WriteableScoreZ), "LDKCOption_WriteableScoreZ");
+ *ret_copy = COption_WriteableScoreZ_none();
+ int64_t ret_ref = tag_ptr(ret_copy, true);
+ return ret_ref;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_COption_1WriteableScoreZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
+ if (!ptr_is_owned(_res)) return;
+ void* _res_ptr = untag_ptr(_res);
+ CHECK_ACCESS(_res_ptr);
+ LDKCOption_WriteableScoreZ _res_conv = *(LDKCOption_WriteableScoreZ*)(_res_ptr);
+ FREE(untag_ptr(_res));
+ COption_WriteableScoreZ_free(_res_conv);
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneErrorZ_1ok(JNIEnv *env, jclass clz) {
LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
*ret_conv = CResult_NoneErrorZ_ok();
return tag_ptr(ret_conv, true);
}
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1PublicKeyZ_1free(JNIEnv *env, jclass clz, jobjectArray _res) {
- LDKCVec_PublicKeyZ _res_constr;
- _res_constr.datalen = (*env)->GetArrayLength(env, _res);
- if (_res_constr.datalen > 0)
- _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKPublicKey), "LDKCVec_PublicKeyZ Elements");
- else
- _res_constr.data = NULL;
- for (size_t i = 0; i < _res_constr.datalen; i++) {
- int8_tArray _res_conv_8 = (*env)->GetObjectArrayElement(env, _res, i);
- LDKPublicKey _res_conv_8_ref;
- CHECK((*env)->GetArrayLength(env, _res_conv_8) == 33);
- (*env)->GetByteArrayRegion(env, _res_conv_8, 0, 33, _res_conv_8_ref.compressed_form);
- _res_constr.data[i] = _res_conv_8_ref;
- }
- CVec_PublicKeyZ_free(_res_constr);
-}
-
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentPurposeDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
void* o_ptr = untag_ptr(o);
CHECK_ACCESS(o_ptr);
CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res_constr);
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1C2Tuple_1usizeTransactionZZ_1some(JNIEnv *env, jclass clz, int64_t o) {
- void* o_ptr = untag_ptr(o);
- CHECK_ACCESS(o_ptr);
- LDKC2Tuple_usizeTransactionZ o_conv = *(LDKC2Tuple_usizeTransactionZ*)(o_ptr);
- o_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)untag_ptr(o));
- LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ");
- *ret_copy = COption_C2Tuple_usizeTransactionZZ_some(o_conv);
- int64_t ret_ref = tag_ptr(ret_copy, true);
- return ret_ref;
-}
-
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1C2Tuple_1usizeTransactionZZ_1none(JNIEnv *env, jclass clz) {
- LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ");
- *ret_copy = COption_C2Tuple_usizeTransactionZZ_none();
- int64_t ret_ref = tag_ptr(ret_copy, true);
- return ret_ref;
-}
-
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_COption_1C2Tuple_1usizeTransactionZZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
- if (!ptr_is_owned(_res)) return;
- void* _res_ptr = untag_ptr(_res);
- CHECK_ACCESS(_res_ptr);
- LDKCOption_C2Tuple_usizeTransactionZZ _res_conv = *(LDKCOption_C2Tuple_usizeTransactionZZ*)(_res_ptr);
- FREE(untag_ptr(_res));
- COption_C2Tuple_usizeTransactionZZ_free(_res_conv);
-}
-
-static inline uint64_t COption_C2Tuple_usizeTransactionZZ_clone_ptr(LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR arg) {
- LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ");
- *ret_copy = COption_C2Tuple_usizeTransactionZZ_clone(arg);
- int64_t ret_ref = tag_ptr(ret_copy, true);
- return ret_ref;
-}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1C2Tuple_1usizeTransactionZZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
- LDKCOption_C2Tuple_usizeTransactionZZ* arg_conv = (LDKCOption_C2Tuple_usizeTransactionZZ*)untag_ptr(arg);
- int64_t ret_conv = COption_C2Tuple_usizeTransactionZZ_clone_ptr(arg_conv);
- return ret_conv;
-}
-
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1C2Tuple_1usizeTransactionZZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
- LDKCOption_C2Tuple_usizeTransactionZZ* orig_conv = (LDKCOption_C2Tuple_usizeTransactionZZ*)untag_ptr(orig);
- LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ");
- *ret_copy = COption_C2Tuple_usizeTransactionZZ_clone(orig_conv);
- int64_t ret_ref = tag_ptr(ret_copy, true);
- return ret_ref;
-}
-
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1FixedPenaltyScorerDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
LDKFixedPenaltyScorer o_conv;
o_conv.inner = untag_ptr(o);
C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res_conv);
}
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
- LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res_constr;
- _res_constr.datalen = (*env)->GetArrayLength(env, _res);
- if (_res_constr.datalen > 0)
- _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ Elements");
- else
- _res_constr.data = NULL;
- int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
- for (size_t h = 0; h < _res_constr.datalen; h++) {
- int64_t _res_conv_59 = _res_vals[h];
- void* _res_conv_59_ptr = untag_ptr(_res_conv_59);
- CHECK_ACCESS(_res_conv_59_ptr);
- LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res_conv_59_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(_res_conv_59_ptr);
- FREE(untag_ptr(_res_conv_59));
- _res_constr.data[h] = _res_conv_59_conv;
- }
- (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
- CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res_constr);
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZZ_1some(JNIEnv *env, jclass clz, int64_t o) {
+ void* o_ptr = untag_ptr(o);
+ CHECK_ACCESS(o_ptr);
+ LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ o_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(o_ptr);
+ o_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone((LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)untag_ptr(o));
+ LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret_copy = MALLOC(sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
+ *ret_copy = COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(o_conv);
+ int64_t ret_ref = tag_ptr(ret_copy, true);
+ return ret_ref;
}
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1NodeAnnouncementZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
- LDKCVec_NodeAnnouncementZ _res_constr;
- _res_constr.datalen = (*env)->GetArrayLength(env, _res);
- if (_res_constr.datalen > 0)
- _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKNodeAnnouncement), "LDKCVec_NodeAnnouncementZ Elements");
- else
- _res_constr.data = NULL;
- int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
- for (size_t s = 0; s < _res_constr.datalen; s++) {
- int64_t _res_conv_18 = _res_vals[s];
- LDKNodeAnnouncement _res_conv_18_conv;
- _res_conv_18_conv.inner = untag_ptr(_res_conv_18);
- _res_conv_18_conv.is_owned = ptr_is_owned(_res_conv_18);
- CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_18_conv);
- _res_constr.data[s] = _res_conv_18_conv;
- }
- (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
- CVec_NodeAnnouncementZ_free(_res_constr);
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZZ_1none(JNIEnv *env, jclass clz) {
+ LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret_copy = MALLOC(sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
+ *ret_copy = COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none();
+ int64_t ret_ref = tag_ptr(ret_copy, true);
+ return ret_ref;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_COption_1C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
+ if (!ptr_is_owned(_res)) return;
+ void* _res_ptr = untag_ptr(_res);
+ CHECK_ACCESS(_res_ptr);
+ LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res_conv = *(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ*)(_res_ptr);
+ FREE(untag_ptr(_res));
+ COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res_conv);
+}
+
+static inline uint64_t COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *NONNULL_PTR arg) {
+ LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret_copy = MALLOC(sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
+ *ret_copy = COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(arg);
+ int64_t ret_ref = tag_ptr(ret_copy, true);
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* arg_conv = (LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ*)untag_ptr(arg);
+ int64_t ret_conv = COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(arg_conv);
+ return ret_conv;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
+ LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* orig_conv = (LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ*)untag_ptr(orig);
+ LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret_copy = MALLOC(sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
+ *ret_copy = COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(orig_conv);
+ int64_t ret_ref = tag_ptr(ret_copy, true);
+ return ret_ref;
}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1ok(JNIEnv *env, jclass clz) {
return tag_ptr(ret_conv, true);
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1ScalarZ_1some(JNIEnv *env, jclass clz, int64_t o) {
+ void* o_ptr = untag_ptr(o);
+ CHECK_ACCESS(o_ptr);
+ LDKBigEndianScalar o_conv = *(LDKBigEndianScalar*)(o_ptr);
+ // WARNING: we may need a move here but no clone is available for LDKBigEndianScalar
+ LDKCOption_ScalarZ *ret_copy = MALLOC(sizeof(LDKCOption_ScalarZ), "LDKCOption_ScalarZ");
+ *ret_copy = COption_ScalarZ_some(o_conv);
+ int64_t ret_ref = tag_ptr(ret_copy, true);
+ return ret_ref;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1ScalarZ_1none(JNIEnv *env, jclass clz) {
+ LDKCOption_ScalarZ *ret_copy = MALLOC(sizeof(LDKCOption_ScalarZ), "LDKCOption_ScalarZ");
+ *ret_copy = COption_ScalarZ_none();
+ int64_t ret_ref = tag_ptr(ret_copy, true);
+ return ret_ref;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_COption_1ScalarZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
+ if (!ptr_is_owned(_res)) return;
+ void* _res_ptr = untag_ptr(_res);
+ CHECK_ACCESS(_res_ptr);
+ LDKCOption_ScalarZ _res_conv = *(LDKCOption_ScalarZ*)(_res_ptr);
+ FREE(untag_ptr(_res));
+ COption_ScalarZ_free(_res_conv);
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SharedSecretNoneZ_1ok(JNIEnv *env, jclass clz, int8_tArray o) {
+ LDKThirtyTwoBytes o_ref;
+ CHECK((*env)->GetArrayLength(env, o) == 32);
+ (*env)->GetByteArrayRegion(env, o, 0, 32, o_ref.data);
+ LDKCResult_SharedSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SharedSecretNoneZ), "LDKCResult_SharedSecretNoneZ");
+ *ret_conv = CResult_SharedSecretNoneZ_ok(o_ref);
+ return tag_ptr(ret_conv, true);
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SharedSecretNoneZ_1err(JNIEnv *env, jclass clz) {
+ LDKCResult_SharedSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SharedSecretNoneZ), "LDKCResult_SharedSecretNoneZ");
+ *ret_conv = CResult_SharedSecretNoneZ_err();
+ return tag_ptr(ret_conv, true);
+}
+
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1SharedSecretNoneZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_SharedSecretNoneZ* o_conv = (LDKCResult_SharedSecretNoneZ*)untag_ptr(o);
+ jboolean ret_conv = CResult_SharedSecretNoneZ_is_ok(o_conv);
+ return ret_conv;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1SharedSecretNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
+ if (!ptr_is_owned(_res)) return;
+ void* _res_ptr = untag_ptr(_res);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_SharedSecretNoneZ _res_conv = *(LDKCResult_SharedSecretNoneZ*)(_res_ptr);
+ FREE(untag_ptr(_res));
+ CResult_SharedSecretNoneZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_SharedSecretNoneZ_clone_ptr(LDKCResult_SharedSecretNoneZ *NONNULL_PTR arg) {
+ LDKCResult_SharedSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SharedSecretNoneZ), "LDKCResult_SharedSecretNoneZ");
+ *ret_conv = CResult_SharedSecretNoneZ_clone(arg);
+ return tag_ptr(ret_conv, true);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SharedSecretNoneZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_SharedSecretNoneZ* arg_conv = (LDKCResult_SharedSecretNoneZ*)untag_ptr(arg);
+ int64_t ret_conv = CResult_SharedSecretNoneZ_clone_ptr(arg_conv);
+ return ret_conv;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SharedSecretNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
+ LDKCResult_SharedSecretNoneZ* orig_conv = (LDKCResult_SharedSecretNoneZ*)untag_ptr(orig);
+ LDKCResult_SharedSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SharedSecretNoneZ), "LDKCResult_SharedSecretNoneZ");
+ *ret_conv = CResult_SharedSecretNoneZ_clone(orig_conv);
+ return tag_ptr(ret_conv, true);
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SignDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
void* o_ptr = untag_ptr(o);
CHECK_ACCESS(o_ptr);
return tag_ptr(ret_conv, true);
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InFlightHtlcsDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKInFlightHtlcs o_conv;
+ o_conv.inner = untag_ptr(o);
+ o_conv.is_owned = ptr_is_owned(o);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ // WARNING: we need a move here but no clone is available for LDKInFlightHtlcs
+
+ LDKCResult_InFlightHtlcsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ), "LDKCResult_InFlightHtlcsDecodeErrorZ");
+ *ret_conv = CResult_InFlightHtlcsDecodeErrorZ_ok(o_conv);
+ return tag_ptr(ret_conv, true);
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InFlightHtlcsDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = untag_ptr(e);
+ e_conv.is_owned = ptr_is_owned(e);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_InFlightHtlcsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ), "LDKCResult_InFlightHtlcsDecodeErrorZ");
+ *ret_conv = CResult_InFlightHtlcsDecodeErrorZ_err(e_conv);
+ return tag_ptr(ret_conv, true);
+}
+
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1InFlightHtlcsDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_InFlightHtlcsDecodeErrorZ* o_conv = (LDKCResult_InFlightHtlcsDecodeErrorZ*)untag_ptr(o);
+ jboolean ret_conv = CResult_InFlightHtlcsDecodeErrorZ_is_ok(o_conv);
+ return ret_conv;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1InFlightHtlcsDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
+ if (!ptr_is_owned(_res)) return;
+ void* _res_ptr = untag_ptr(_res);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_InFlightHtlcsDecodeErrorZ _res_conv = *(LDKCResult_InFlightHtlcsDecodeErrorZ*)(_res_ptr);
+ FREE(untag_ptr(_res));
+ CResult_InFlightHtlcsDecodeErrorZ_free(_res_conv);
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SiPrefixParseErrorZ_1ok(JNIEnv *env, jclass clz, jclass o) {
LDKSiPrefix o_conv = LDKSiPrefix_from_java(env, o);
LDKCResult_SiPrefixParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixParseErrorZ), "LDKCResult_SiPrefixParseErrorZ");
return tag_ptr(ret_conv, true);
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneSendErrorZ_1ok(JNIEnv *env, jclass clz) {
+ LDKCResult_NoneSendErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSendErrorZ), "LDKCResult_NoneSendErrorZ");
+ *ret_conv = CResult_NoneSendErrorZ_ok();
+ return tag_ptr(ret_conv, true);
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneSendErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
+ void* e_ptr = untag_ptr(e);
+ CHECK_ACCESS(e_ptr);
+ LDKSendError e_conv = *(LDKSendError*)(e_ptr);
+ e_conv = SendError_clone((LDKSendError*)untag_ptr(e));
+ LDKCResult_NoneSendErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSendErrorZ), "LDKCResult_NoneSendErrorZ");
+ *ret_conv = CResult_NoneSendErrorZ_err(e_conv);
+ return tag_ptr(ret_conv, true);
+}
+
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NoneSendErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_NoneSendErrorZ* o_conv = (LDKCResult_NoneSendErrorZ*)untag_ptr(o);
+ jboolean ret_conv = CResult_NoneSendErrorZ_is_ok(o_conv);
+ return ret_conv;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneSendErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
+ if (!ptr_is_owned(_res)) return;
+ void* _res_ptr = untag_ptr(_res);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_NoneSendErrorZ _res_conv = *(LDKCResult_NoneSendErrorZ*)(_res_ptr);
+ FREE(untag_ptr(_res));
+ CResult_NoneSendErrorZ_free(_res_conv);
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1u32GraphSyncErrorZ_1ok(JNIEnv *env, jclass clz, int32_t o) {
LDKCResult_u32GraphSyncErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_u32GraphSyncErrorZ), "LDKCResult_u32GraphSyncErrorZ");
*ret_conv = CResult_u32GraphSyncErrorZ_ok(o);
return tag_ptr(ret_conv, true);
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1OnionMessageDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKOnionMessage o_conv;
+ o_conv.inner = untag_ptr(o);
+ o_conv.is_owned = ptr_is_owned(o);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = OnionMessage_clone(&o_conv);
+ LDKCResult_OnionMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OnionMessageDecodeErrorZ), "LDKCResult_OnionMessageDecodeErrorZ");
+ *ret_conv = CResult_OnionMessageDecodeErrorZ_ok(o_conv);
+ return tag_ptr(ret_conv, true);
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1OnionMessageDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = untag_ptr(e);
+ e_conv.is_owned = ptr_is_owned(e);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_OnionMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OnionMessageDecodeErrorZ), "LDKCResult_OnionMessageDecodeErrorZ");
+ *ret_conv = CResult_OnionMessageDecodeErrorZ_err(e_conv);
+ return tag_ptr(ret_conv, true);
+}
+
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1OnionMessageDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_OnionMessageDecodeErrorZ* o_conv = (LDKCResult_OnionMessageDecodeErrorZ*)untag_ptr(o);
+ jboolean ret_conv = CResult_OnionMessageDecodeErrorZ_is_ok(o_conv);
+ return ret_conv;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1OnionMessageDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
+ if (!ptr_is_owned(_res)) return;
+ void* _res_ptr = untag_ptr(_res);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_OnionMessageDecodeErrorZ _res_conv = *(LDKCResult_OnionMessageDecodeErrorZ*)(_res_ptr);
+ FREE(untag_ptr(_res));
+ CResult_OnionMessageDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_OnionMessageDecodeErrorZ_clone_ptr(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_OnionMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OnionMessageDecodeErrorZ), "LDKCResult_OnionMessageDecodeErrorZ");
+ *ret_conv = CResult_OnionMessageDecodeErrorZ_clone(arg);
+ return tag_ptr(ret_conv, true);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1OnionMessageDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_OnionMessageDecodeErrorZ* arg_conv = (LDKCResult_OnionMessageDecodeErrorZ*)untag_ptr(arg);
+ int64_t ret_conv = CResult_OnionMessageDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_conv;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1OnionMessageDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
+ LDKCResult_OnionMessageDecodeErrorZ* orig_conv = (LDKCResult_OnionMessageDecodeErrorZ*)untag_ptr(orig);
+ LDKCResult_OnionMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OnionMessageDecodeErrorZ), "LDKCResult_OnionMessageDecodeErrorZ");
+ *ret_conv = CResult_OnionMessageDecodeErrorZ_clone(orig_conv);
+ return tag_ptr(ret_conv, true);
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PingDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
LDKPing o_conv;
o_conv.inner = untag_ptr(o);
return ret_ref;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Event_1payment_1path_1failed(JNIEnv *env, jclass clz, int8_tArray payment_id, int8_tArray payment_hash, jboolean rejected_by_dest, int64_t network_update, jboolean all_paths_failed, int64_tArray path, int64_t short_channel_id, int64_t retry) {
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Event_1payment_1path_1failed(JNIEnv *env, jclass clz, int8_tArray payment_id, int8_tArray payment_hash, jboolean payment_failed_permanently, int64_t network_update, jboolean all_paths_failed, int64_tArray path, int64_t short_channel_id, int64_t retry) {
LDKThirtyTwoBytes payment_id_ref;
CHECK((*env)->GetArrayLength(env, payment_id) == 32);
(*env)->GetByteArrayRegion(env, payment_id, 0, 32, payment_id_ref.data);
CHECK_INNER_FIELD_ACCESS_OR_NULL(retry_conv);
retry_conv = RouteParameters_clone(&retry_conv);
LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
- *ret_copy = Event_payment_path_failed(payment_id_ref, payment_hash_ref, rejected_by_dest, network_update_conv, all_paths_failed, path_constr, short_channel_id_conv, retry_conv);
+ *ret_copy = Event_payment_path_failed(payment_id_ref, payment_hash_ref, payment_failed_permanently, network_update_conv, all_paths_failed, path_constr, short_channel_id_conv, retry_conv);
int64_t ret_ref = tag_ptr(ret_copy, true);
return ret_ref;
}
return ret_ref;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MessageSendEvent_1broadcast_1channel_1announcement(JNIEnv *env, jclass clz, int64_t msg, int64_t update_msg) {
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MessageSendEvent_1send_1channel_1announcement(JNIEnv *env, jclass clz, int8_tArray node_id, int64_t msg, int64_t update_msg) {
+ LDKPublicKey node_id_ref;
+ CHECK((*env)->GetArrayLength(env, node_id) == 33);
+ (*env)->GetByteArrayRegion(env, node_id, 0, 33, node_id_ref.compressed_form);
LDKChannelAnnouncement msg_conv;
msg_conv.inner = untag_ptr(msg);
msg_conv.is_owned = ptr_is_owned(msg);
CHECK_INNER_FIELD_ACCESS_OR_NULL(update_msg_conv);
update_msg_conv = ChannelUpdate_clone(&update_msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
- *ret_copy = MessageSendEvent_broadcast_channel_announcement(msg_conv, update_msg_conv);
+ *ret_copy = MessageSendEvent_send_channel_announcement(node_id_ref, msg_conv, update_msg_conv);
int64_t ret_ref = tag_ptr(ret_copy, true);
return ret_ref;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MessageSendEvent_1broadcast_1node_1announcement(JNIEnv *env, jclass clz, int64_t msg) {
- LDKNodeAnnouncement msg_conv;
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MessageSendEvent_1broadcast_1channel_1announcement(JNIEnv *env, jclass clz, int64_t msg, int64_t update_msg) {
+ LDKChannelAnnouncement msg_conv;
msg_conv.inner = untag_ptr(msg);
msg_conv.is_owned = ptr_is_owned(msg);
CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
- msg_conv = NodeAnnouncement_clone(&msg_conv);
+ msg_conv = ChannelAnnouncement_clone(&msg_conv);
+ LDKChannelUpdate update_msg_conv;
+ update_msg_conv.inner = untag_ptr(update_msg);
+ update_msg_conv.is_owned = ptr_is_owned(update_msg);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_msg_conv);
+ update_msg_conv = ChannelUpdate_clone(&update_msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
- *ret_copy = MessageSendEvent_broadcast_node_announcement(msg_conv);
+ *ret_copy = MessageSendEvent_broadcast_channel_announcement(msg_conv, update_msg_conv);
int64_t ret_ref = tag_ptr(ret_copy, true);
return ret_ref;
}
MessageSendEventsProvider_free(this_ptr_conv);
}
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OnionMessageProvider_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
+ if (!ptr_is_owned(this_ptr)) return;
+ void* this_ptr_ptr = untag_ptr(this_ptr);
+ CHECK_ACCESS(this_ptr_ptr);
+ LDKOnionMessageProvider this_ptr_conv = *(LDKOnionMessageProvider*)(this_ptr_ptr);
+ FREE(untag_ptr(this_ptr));
+ OnionMessageProvider_free(this_ptr_conv);
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_EventsProvider_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
if (!ptr_is_owned(this_ptr)) return;
void* this_ptr_ptr = untag_ptr(this_ptr);
Persister_free(this_ptr_conv);
}
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_FutureCallback_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
+ if (!ptr_is_owned(this_ptr)) return;
+ void* this_ptr_ptr = untag_ptr(this_ptr);
+ CHECK_ACCESS(this_ptr_ptr);
+ LDKFutureCallback this_ptr_conv = *(LDKFutureCallback*)(this_ptr_ptr);
+ FREE(untag_ptr(this_ptr));
+ FutureCallback_free(this_ptr_conv);
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Future_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
+ LDKFuture this_obj_conv;
+ this_obj_conv.inner = untag_ptr(this_obj);
+ this_obj_conv.is_owned = ptr_is_owned(this_obj);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
+ Future_free(this_obj_conv);
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Future_1register_1callback_1fn(JNIEnv *env, jclass clz, int64_t this_arg, int64_t callback) {
+ LDKFuture this_arg_conv;
+ this_arg_conv.inner = untag_ptr(this_arg);
+ this_arg_conv.is_owned = ptr_is_owned(this_arg);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
+ this_arg_conv.is_owned = false;
+ void* callback_ptr = untag_ptr(callback);
+ CHECK_ACCESS(callback_ptr);
+ LDKFutureCallback callback_conv = *(LDKFutureCallback*)(callback_ptr);
+ if (callback_conv.free == LDKFutureCallback_JCalls_free) {
+ // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
+ LDKFutureCallback_JCalls_cloned(&callback_conv);
+ }
+ Future_register_callback_fn(&this_arg_conv, callback_conv);
+}
+
JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_Level_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKLevel* orig_conv = (LDKLevel*)untag_ptr(orig);
jclass ret_conv = LDKLevel_to_java(env, Level_clone(orig_conv));
ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(&this_ptr_conv, val);
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeConfig_1new(JNIEnv *env, jclass clz, int32_t minimum_depth_arg, int16_t our_to_self_delay_arg, int64_t our_htlc_minimum_msat_arg, int8_t max_inbound_htlc_value_in_flight_percent_of_channel_arg, jboolean negotiate_scid_privacy_arg, jboolean announced_channel_arg, jboolean commit_upfront_shutdown_pubkey_arg) {
- LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_new(minimum_depth_arg, our_to_self_delay_arg, our_htlc_minimum_msat_arg, max_inbound_htlc_value_in_flight_percent_of_channel_arg, negotiate_scid_privacy_arg, announced_channel_arg, commit_upfront_shutdown_pubkey_arg);
+JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeConfig_1get_1their_1channel_1reserve_1proportional_1millionths(JNIEnv *env, jclass clz, int64_t this_ptr) {
+ LDKChannelHandshakeConfig this_ptr_conv;
+ this_ptr_conv.inner = untag_ptr(this_ptr);
+ this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ this_ptr_conv.is_owned = false;
+ int32_t ret_conv = ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(&this_ptr_conv);
+ return ret_conv;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeConfig_1set_1their_1channel_1reserve_1proportional_1millionths(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
+ LDKChannelHandshakeConfig this_ptr_conv;
+ this_ptr_conv.inner = untag_ptr(this_ptr);
+ this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ this_ptr_conv.is_owned = false;
+ ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(&this_ptr_conv, val);
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeConfig_1new(JNIEnv *env, jclass clz, int32_t minimum_depth_arg, int16_t our_to_self_delay_arg, int64_t our_htlc_minimum_msat_arg, int8_t max_inbound_htlc_value_in_flight_percent_of_channel_arg, jboolean negotiate_scid_privacy_arg, jboolean announced_channel_arg, jboolean commit_upfront_shutdown_pubkey_arg, int32_t their_channel_reserve_proportional_millionths_arg) {
+ LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_new(minimum_depth_arg, our_to_self_delay_arg, our_htlc_minimum_msat_arg, max_inbound_htlc_value_in_flight_percent_of_channel_arg, negotiate_scid_privacy_arg, announced_channel_arg, commit_upfront_shutdown_pubkey_arg, their_channel_reserve_proportional_millionths_arg);
int64_t ret_ref = 0;
CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
return ret_ref;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Balance_1maybe_1claimable_1htlcawaiting_1timeout(JNIEnv *env, jclass clz, int64_t claimable_amount_satoshis, int32_t claimable_height) {
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Balance_1maybe_1timeout_1claimable_1htlc(JNIEnv *env, jclass clz, int64_t claimable_amount_satoshis, int32_t claimable_height) {
+ LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
+ *ret_copy = Balance_maybe_timeout_claimable_htlc(claimable_amount_satoshis, claimable_height);
+ int64_t ret_ref = tag_ptr(ret_copy, true);
+ return ret_ref;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Balance_1maybe_1preimage_1claimable_1htlc(JNIEnv *env, jclass clz, int64_t claimable_amount_satoshis, int32_t expiry_height) {
LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
- *ret_copy = Balance_maybe_claimable_htlcawaiting_timeout(claimable_amount_satoshis, claimable_height);
+ *ret_copy = Balance_maybe_preimage_claimable_htlc(claimable_amount_satoshis, expiry_height);
+ int64_t ret_ref = tag_ptr(ret_copy, true);
+ return ret_ref;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Balance_1counterparty_1revoked_1output_1claimable(JNIEnv *env, jclass clz, int64_t claimable_amount_satoshis) {
+ LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
+ *ret_copy = Balance_counterparty_revoked_output_claimable(claimable_amount_satoshis);
int64_t ret_ref = tag_ptr(ret_copy, true);
return ret_ref;
}
return tag_ptr(ret_conv, true);
}
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelManager_1broadcast_1node_1announcement(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray rgb, int8_tArray alias, int64_tArray addresses) {
- LDKChannelManager this_arg_conv;
- this_arg_conv.inner = untag_ptr(this_arg);
- this_arg_conv.is_owned = ptr_is_owned(this_arg);
- CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
- this_arg_conv.is_owned = false;
- LDKThreeBytes rgb_ref;
- CHECK((*env)->GetArrayLength(env, rgb) == 3);
- (*env)->GetByteArrayRegion(env, rgb, 0, 3, rgb_ref.data);
- LDKThirtyTwoBytes alias_ref;
- CHECK((*env)->GetArrayLength(env, alias) == 32);
- (*env)->GetByteArrayRegion(env, alias, 0, 32, alias_ref.data);
- LDKCVec_NetAddressZ addresses_constr;
- addresses_constr.datalen = (*env)->GetArrayLength(env, addresses);
- if (addresses_constr.datalen > 0)
- addresses_constr.data = MALLOC(addresses_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
- else
- addresses_constr.data = NULL;
- int64_t* addresses_vals = (*env)->GetLongArrayElements (env, addresses, NULL);
- for (size_t m = 0; m < addresses_constr.datalen; m++) {
- int64_t addresses_conv_12 = addresses_vals[m];
- void* addresses_conv_12_ptr = untag_ptr(addresses_conv_12);
- CHECK_ACCESS(addresses_conv_12_ptr);
- LDKNetAddress addresses_conv_12_conv = *(LDKNetAddress*)(addresses_conv_12_ptr);
- addresses_constr.data[m] = addresses_conv_12_conv;
- }
- (*env)->ReleaseLongArrayElements(env, addresses, addresses_vals, 0);
- ChannelManager_broadcast_node_announcement(&this_arg_conv, rgb_ref, alias_ref, addresses_constr);
-}
-
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManager_1update_1channel_1config(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray counterparty_node_id, jobjectArray channel_ids, int64_t config) {
LDKChannelManager this_arg_conv;
this_arg_conv.inner = untag_ptr(this_arg);
ChannelManager_await_persistable_update(&this_arg_conv);
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManager_1get_1persistable_1update_1future(JNIEnv *env, jclass clz, int64_t this_arg) {
+ LDKChannelManager this_arg_conv;
+ this_arg_conv.inner = untag_ptr(this_arg);
+ this_arg_conv.is_owned = ptr_is_owned(this_arg);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
+ this_arg_conv.is_owned = false;
+ LDKFuture ret_var = ChannelManager_get_persistable_update_future(&this_arg_conv);
+ int64_t ret_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
+ return ret_ref;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManager_1current_1best_1block(JNIEnv *env, jclass clz, int64_t this_arg) {
LDKChannelManager this_arg_conv;
this_arg_conv.inner = untag_ptr(this_arg);
return ret_ref;
}
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OnionMessage_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
+ LDKOnionMessage this_obj_conv;
+ this_obj_conv.inner = untag_ptr(this_obj);
+ this_obj_conv.is_owned = ptr_is_owned(this_obj);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
+ OnionMessage_free(this_obj_conv);
+}
+
+JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_OnionMessage_1get_1blinding_1point(JNIEnv *env, jclass clz, int64_t this_ptr) {
+ LDKOnionMessage this_ptr_conv;
+ this_ptr_conv.inner = untag_ptr(this_ptr);
+ this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ this_ptr_conv.is_owned = false;
+ int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
+ (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, OnionMessage_get_blinding_point(&this_ptr_conv).compressed_form);
+ return ret_arr;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OnionMessage_1set_1blinding_1point(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
+ LDKOnionMessage this_ptr_conv;
+ this_ptr_conv.inner = untag_ptr(this_ptr);
+ this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ this_ptr_conv.is_owned = false;
+ LDKPublicKey val_ref;
+ CHECK((*env)->GetArrayLength(env, val) == 33);
+ (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
+ OnionMessage_set_blinding_point(&this_ptr_conv, val_ref);
+}
+
+static inline uint64_t OnionMessage_clone_ptr(LDKOnionMessage *NONNULL_PTR arg) {
+ LDKOnionMessage ret_var = OnionMessage_clone(arg);
+ int64_t ret_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OnionMessage_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKOnionMessage arg_conv;
+ arg_conv.inner = untag_ptr(arg);
+ arg_conv.is_owned = ptr_is_owned(arg);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ arg_conv.is_owned = false;
+ int64_t ret_conv = OnionMessage_clone_ptr(&arg_conv);
+ return ret_conv;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OnionMessage_1clone(JNIEnv *env, jclass clz, int64_t orig) {
+ LDKOnionMessage orig_conv;
+ orig_conv.inner = untag_ptr(orig);
+ orig_conv.is_owned = ptr_is_owned(orig);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
+ orig_conv.is_owned = false;
+ LDKOnionMessage ret_var = OnionMessage_clone(&orig_conv);
+ int64_t ret_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
+ return ret_ref;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateFulfillHTLC_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
LDKUpdateFulfillHTLC this_obj_conv;
this_obj_conv.inner = untag_ptr(this_obj);
RoutingMessageHandler_free(this_ptr_conv);
}
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OnionMessageHandler_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
+ if (!ptr_is_owned(this_ptr)) return;
+ void* this_ptr_ptr = untag_ptr(this_ptr);
+ CHECK_ACCESS(this_ptr_ptr);
+ LDKOnionMessageHandler this_ptr_conv = *(LDKOnionMessageHandler*)(this_ptr_ptr);
+ FREE(untag_ptr(this_ptr));
+ OnionMessageHandler_free(this_ptr_conv);
+}
+
JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1write(JNIEnv *env, jclass clz, int64_t obj) {
LDKAcceptChannel obj_conv;
obj_conv.inner = untag_ptr(obj);
return tag_ptr(ret_conv, true);
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OnionMessage_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
+ LDKu8slice ser_ref;
+ ser_ref.datalen = (*env)->GetArrayLength(env, ser);
+ ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
+ LDKCResult_OnionMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OnionMessageDecodeErrorZ), "LDKCResult_OnionMessageDecodeErrorZ");
+ *ret_conv = OnionMessage_read(ser_ref);
+ (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
+ return tag_ptr(ret_conv, true);
+}
+
+JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_OnionMessage_1write(JNIEnv *env, jclass clz, int64_t obj) {
+ LDKOnionMessage obj_conv;
+ obj_conv.inner = untag_ptr(obj);
+ obj_conv.is_owned = ptr_is_owned(obj);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
+ obj_conv.is_owned = false;
+ LDKCVec_u8Z ret_var = OnionMessage_write(&obj_conv);
+ int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
+ (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
+ CVec_u8Z_free(ret_var);
+ return ret_arr;
+}
+
JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_Ping_1write(JNIEnv *env, jclass clz, int64_t obj) {
LDKPing obj_conv;
obj_conv.inner = untag_ptr(obj);
return tag_ptr(ret_ret, true);
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_IgnoringMessageHandler_1as_1OnionMessageProvider(JNIEnv *env, jclass clz, int64_t this_arg) {
+ LDKIgnoringMessageHandler this_arg_conv;
+ this_arg_conv.inner = untag_ptr(this_arg);
+ this_arg_conv.is_owned = ptr_is_owned(this_arg);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
+ this_arg_conv.is_owned = false;
+ LDKOnionMessageProvider* ret_ret = MALLOC(sizeof(LDKOnionMessageProvider), "LDKOnionMessageProvider");
+ *ret_ret = IgnoringMessageHandler_as_OnionMessageProvider(&this_arg_conv);
+ return tag_ptr(ret_ret, true);
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_IgnoringMessageHandler_1as_1OnionMessageHandler(JNIEnv *env, jclass clz, int64_t this_arg) {
+ LDKIgnoringMessageHandler this_arg_conv;
+ this_arg_conv.inner = untag_ptr(this_arg);
+ this_arg_conv.is_owned = ptr_is_owned(this_arg);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
+ this_arg_conv.is_owned = false;
+ LDKOnionMessageHandler* ret_ret = MALLOC(sizeof(LDKOnionMessageHandler), "LDKOnionMessageHandler");
+ *ret_ret = IgnoringMessageHandler_as_OnionMessageHandler(&this_arg_conv);
+ return tag_ptr(ret_ret, true);
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_IgnoringMessageHandler_1as_1CustomMessageReader(JNIEnv *env, jclass clz, int64_t this_arg) {
LDKIgnoringMessageHandler this_arg_conv;
this_arg_conv.inner = untag_ptr(this_arg);
MessageHandler_set_route_handler(&this_ptr_conv, val_conv);
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MessageHandler_1new(JNIEnv *env, jclass clz, int64_t chan_handler_arg, int64_t route_handler_arg) {
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MessageHandler_1get_1onion_1message_1handler(JNIEnv *env, jclass clz, int64_t this_ptr) {
+ LDKMessageHandler this_ptr_conv;
+ this_ptr_conv.inner = untag_ptr(this_ptr);
+ this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ this_ptr_conv.is_owned = false;
+ // WARNING: This object doesn't live past this scope, needs clone!
+ int64_t ret_ret = tag_ptr(MessageHandler_get_onion_message_handler(&this_ptr_conv), false);
+ return ret_ret;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_MessageHandler_1set_1onion_1message_1handler(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
+ LDKMessageHandler this_ptr_conv;
+ this_ptr_conv.inner = untag_ptr(this_ptr);
+ this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ this_ptr_conv.is_owned = false;
+ void* val_ptr = untag_ptr(val);
+ CHECK_ACCESS(val_ptr);
+ LDKOnionMessageHandler val_conv = *(LDKOnionMessageHandler*)(val_ptr);
+ if (val_conv.free == LDKOnionMessageHandler_JCalls_free) {
+ // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
+ LDKOnionMessageHandler_JCalls_cloned(&val_conv);
+ }
+ MessageHandler_set_onion_message_handler(&this_ptr_conv, val_conv);
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MessageHandler_1new(JNIEnv *env, jclass clz, int64_t chan_handler_arg, int64_t route_handler_arg, int64_t onion_message_handler_arg) {
void* chan_handler_arg_ptr = untag_ptr(chan_handler_arg);
CHECK_ACCESS(chan_handler_arg_ptr);
LDKChannelMessageHandler chan_handler_arg_conv = *(LDKChannelMessageHandler*)(chan_handler_arg_ptr);
// If this_arg is a JCalls struct, then we need to increment the refcnt in it.
LDKRoutingMessageHandler_JCalls_cloned(&route_handler_arg_conv);
}
- LDKMessageHandler ret_var = MessageHandler_new(chan_handler_arg_conv, route_handler_arg_conv);
+ void* onion_message_handler_arg_ptr = untag_ptr(onion_message_handler_arg);
+ CHECK_ACCESS(onion_message_handler_arg_ptr);
+ LDKOnionMessageHandler onion_message_handler_arg_conv = *(LDKOnionMessageHandler*)(onion_message_handler_arg_ptr);
+ if (onion_message_handler_arg_conv.free == LDKOnionMessageHandler_JCalls_free) {
+ // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
+ LDKOnionMessageHandler_JCalls_cloned(&onion_message_handler_arg_conv);
+ }
+ LDKMessageHandler ret_var = MessageHandler_new(chan_handler_arg_conv, route_handler_arg_conv, onion_message_handler_arg_conv);
int64_t ret_ref = 0;
CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
PeerManager_free(this_obj_conv);
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PeerManager_1new(JNIEnv *env, jclass clz, int64_t message_handler, int8_tArray our_node_secret, int8_tArray ephemeral_random_data, int64_t logger, int64_t custom_message_handler) {
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PeerManager_1new(JNIEnv *env, jclass clz, int64_t message_handler, int8_tArray our_node_secret, int64_t current_time, int8_tArray ephemeral_random_data, int64_t logger, int64_t custom_message_handler) {
LDKMessageHandler message_handler_conv;
message_handler_conv.inner = untag_ptr(message_handler);
message_handler_conv.is_owned = ptr_is_owned(message_handler);
// If this_arg is a JCalls struct, then we need to increment the refcnt in it.
LDKCustomMessageHandler_JCalls_cloned(&custom_message_handler_conv);
}
- LDKPeerManager ret_var = PeerManager_new(message_handler_conv, our_node_secret_ref, ephemeral_random_data_ref, logger_conv, custom_message_handler_conv);
+ LDKPeerManager ret_var = PeerManager_new(message_handler_conv, our_node_secret_ref, current_time, ephemeral_random_data_ref, logger_conv, custom_message_handler_conv);
int64_t ret_ref = 0;
CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
PeerManager_timer_tick_occurred(&this_arg_conv);
}
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_PeerManager_1broadcast_1node_1announcement(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray rgb, int8_tArray alias, int64_tArray addresses) {
+ LDKPeerManager this_arg_conv;
+ this_arg_conv.inner = untag_ptr(this_arg);
+ this_arg_conv.is_owned = ptr_is_owned(this_arg);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
+ this_arg_conv.is_owned = false;
+ LDKThreeBytes rgb_ref;
+ CHECK((*env)->GetArrayLength(env, rgb) == 3);
+ (*env)->GetByteArrayRegion(env, rgb, 0, 3, rgb_ref.data);
+ LDKThirtyTwoBytes alias_ref;
+ CHECK((*env)->GetArrayLength(env, alias) == 32);
+ (*env)->GetByteArrayRegion(env, alias, 0, 32, alias_ref.data);
+ LDKCVec_NetAddressZ addresses_constr;
+ addresses_constr.datalen = (*env)->GetArrayLength(env, addresses);
+ if (addresses_constr.datalen > 0)
+ addresses_constr.data = MALLOC(addresses_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
+ else
+ addresses_constr.data = NULL;
+ int64_t* addresses_vals = (*env)->GetLongArrayElements (env, addresses, NULL);
+ for (size_t m = 0; m < addresses_constr.datalen; m++) {
+ int64_t addresses_conv_12 = addresses_vals[m];
+ void* addresses_conv_12_ptr = untag_ptr(addresses_conv_12);
+ CHECK_ACCESS(addresses_conv_12_ptr);
+ LDKNetAddress addresses_conv_12_conv = *(LDKNetAddress*)(addresses_conv_12_ptr);
+ addresses_constr.data[m] = addresses_conv_12_conv;
+ }
+ (*env)->ReleaseLongArrayElements(env, addresses, addresses_vals, 0);
+ PeerManager_broadcast_node_announcement(&this_arg_conv, rgb_ref, alias_ref, addresses_constr);
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_htlc_1success_1tx_1weight(JNIEnv *env, jclass clz, jboolean opt_anchors) {
int64_t ret_conv = htlc_success_tx_weight(opt_anchors);
return ret_conv;
ChannelTypeFeatures_free(this_obj_conv);
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InitFeatures_1known_1channel_1features(JNIEnv *env, jclass clz) {
+ LDKInitFeatures ret_var = InitFeatures_known_channel_features();
+ int64_t ret_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
+ return ret_ref;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeFeatures_1known_1channel_1features(JNIEnv *env, jclass clz) {
+ LDKNodeFeatures ret_var = NodeFeatures_known_channel_features();
+ int64_t ret_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
+ return ret_ref;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InitFeatures_1empty(JNIEnv *env, jclass clz) {
LDKInitFeatures ret_var = InitFeatures_empty();
int64_t ret_ref = 0;
return ret_conv;
}
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_InitFeatures_1set_1onion_1messages_1optional(JNIEnv *env, jclass clz, int64_t this_arg) {
+ LDKInitFeatures this_arg_conv;
+ this_arg_conv.inner = untag_ptr(this_arg);
+ this_arg_conv.is_owned = ptr_is_owned(this_arg);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
+ this_arg_conv.is_owned = false;
+ InitFeatures_set_onion_messages_optional(&this_arg_conv);
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_InitFeatures_1set_1onion_1messages_1required(JNIEnv *env, jclass clz, int64_t this_arg) {
+ LDKInitFeatures this_arg_conv;
+ this_arg_conv.inner = untag_ptr(this_arg);
+ this_arg_conv.is_owned = ptr_is_owned(this_arg);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
+ this_arg_conv.is_owned = false;
+ InitFeatures_set_onion_messages_required(&this_arg_conv);
+}
+
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_InitFeatures_1supports_1onion_1messages(JNIEnv *env, jclass clz, int64_t this_arg) {
+ LDKInitFeatures this_arg_conv;
+ this_arg_conv.inner = untag_ptr(this_arg);
+ this_arg_conv.is_owned = ptr_is_owned(this_arg);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
+ this_arg_conv.is_owned = false;
+ jboolean ret_conv = InitFeatures_supports_onion_messages(&this_arg_conv);
+ return ret_conv;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NodeFeatures_1set_1onion_1messages_1optional(JNIEnv *env, jclass clz, int64_t this_arg) {
+ LDKNodeFeatures this_arg_conv;
+ this_arg_conv.inner = untag_ptr(this_arg);
+ this_arg_conv.is_owned = ptr_is_owned(this_arg);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
+ this_arg_conv.is_owned = false;
+ NodeFeatures_set_onion_messages_optional(&this_arg_conv);
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NodeFeatures_1set_1onion_1messages_1required(JNIEnv *env, jclass clz, int64_t this_arg) {
+ LDKNodeFeatures this_arg_conv;
+ this_arg_conv.inner = untag_ptr(this_arg);
+ this_arg_conv.is_owned = ptr_is_owned(this_arg);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
+ this_arg_conv.is_owned = false;
+ NodeFeatures_set_onion_messages_required(&this_arg_conv);
+}
+
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_NodeFeatures_1supports_1onion_1messages(JNIEnv *env, jclass clz, int64_t this_arg) {
+ LDKNodeFeatures this_arg_conv;
+ this_arg_conv.inner = untag_ptr(this_arg);
+ this_arg_conv.is_owned = ptr_is_owned(this_arg);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
+ this_arg_conv.is_owned = false;
+ jboolean ret_conv = NodeFeatures_supports_onion_messages(&this_arg_conv);
+ return ret_conv;
+}
+
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_InitFeatures_1requires_1onion_1messages(JNIEnv *env, jclass clz, int64_t this_arg) {
+ LDKInitFeatures this_arg_conv;
+ this_arg_conv.inner = untag_ptr(this_arg);
+ this_arg_conv.is_owned = ptr_is_owned(this_arg);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
+ this_arg_conv.is_owned = false;
+ jboolean ret_conv = InitFeatures_requires_onion_messages(&this_arg_conv);
+ return ret_conv;
+}
+
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_NodeFeatures_1requires_1onion_1messages(JNIEnv *env, jclass clz, int64_t this_arg) {
+ LDKNodeFeatures this_arg_conv;
+ this_arg_conv.inner = untag_ptr(this_arg);
+ this_arg_conv.is_owned = ptr_is_owned(this_arg);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
+ this_arg_conv.is_owned = false;
+ jboolean ret_conv = NodeFeatures_requires_onion_messages(&this_arg_conv);
+ return ret_conv;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_InitFeatures_1set_1channel_1type_1optional(JNIEnv *env, jclass clz, int64_t this_arg) {
LDKInitFeatures this_arg_conv;
this_arg_conv.inner = untag_ptr(this_arg);
LockableScore_free(this_ptr_conv);
}
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_WriteableScore_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
+ if (!ptr_is_owned(this_ptr)) return;
+ void* this_ptr_ptr = untag_ptr(this_ptr);
+ CHECK_ACCESS(this_ptr_ptr);
+ LDKWriteableScore this_ptr_conv = *(LDKWriteableScore*)(this_ptr_ptr);
+ FREE(untag_ptr(this_ptr));
+ WriteableScore_free(this_ptr_conv);
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_MultiThreadedLockableScore_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
LDKMultiThreadedLockableScore this_obj_conv;
this_obj_conv.inner = untag_ptr(this_obj);
MultiThreadedLockableScore_free(this_obj_conv);
}
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_MultiThreadedScoreLock_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
+ LDKMultiThreadedScoreLock this_obj_conv;
+ this_obj_conv.inner = untag_ptr(this_obj);
+ this_obj_conv.is_owned = ptr_is_owned(this_obj);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
+ MultiThreadedScoreLock_free(this_obj_conv);
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MultiThreadedScoreLock_1as_1Score(JNIEnv *env, jclass clz, int64_t this_arg) {
+ LDKMultiThreadedScoreLock this_arg_conv;
+ this_arg_conv.inner = untag_ptr(this_arg);
+ this_arg_conv.is_owned = ptr_is_owned(this_arg);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
+ this_arg_conv.is_owned = false;
+ LDKScore* ret_ret = MALLOC(sizeof(LDKScore), "LDKScore");
+ *ret_ret = MultiThreadedScoreLock_as_Score(&this_arg_conv);
+ return tag_ptr(ret_ret, true);
+}
+
+JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_MultiThreadedScoreLock_1write(JNIEnv *env, jclass clz, int64_t obj) {
+ LDKMultiThreadedScoreLock obj_conv;
+ obj_conv.inner = untag_ptr(obj);
+ obj_conv.is_owned = ptr_is_owned(obj);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
+ obj_conv.is_owned = false;
+ LDKCVec_u8Z ret_var = MultiThreadedScoreLock_write(&obj_conv);
+ int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
+ (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
+ CVec_u8Z_free(ret_var);
+ return ret_arr;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MultiThreadedLockableScore_1as_1LockableScore(JNIEnv *env, jclass clz, int64_t this_arg) {
+ LDKMultiThreadedLockableScore this_arg_conv;
+ this_arg_conv.inner = untag_ptr(this_arg);
+ this_arg_conv.is_owned = ptr_is_owned(this_arg);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
+ this_arg_conv.is_owned = false;
+ LDKLockableScore* ret_ret = MALLOC(sizeof(LDKLockableScore), "LDKLockableScore");
+ *ret_ret = MultiThreadedLockableScore_as_LockableScore(&this_arg_conv);
+ return tag_ptr(ret_ret, true);
+}
+
JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_MultiThreadedLockableScore_1write(JNIEnv *env, jclass clz, int64_t obj) {
LDKMultiThreadedLockableScore obj_conv;
obj_conv.inner = untag_ptr(obj);
return ret_arr;
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MultiThreadedLockableScore_1as_1WriteableScore(JNIEnv *env, jclass clz, int64_t this_arg) {
+ LDKMultiThreadedLockableScore this_arg_conv;
+ this_arg_conv.inner = untag_ptr(this_arg);
+ this_arg_conv.is_owned = ptr_is_owned(this_arg);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
+ this_arg_conv.is_owned = false;
+ LDKWriteableScore* ret_ret = MALLOC(sizeof(LDKWriteableScore), "LDKWriteableScore");
+ *ret_ret = MultiThreadedLockableScore_as_WriteableScore(&this_arg_conv);
+ return tag_ptr(ret_ret, true);
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MultiThreadedLockableScore_1new(JNIEnv *env, jclass clz, int64_t score) {
void* score_ptr = untag_ptr(score);
CHECK_ACCESS(score_ptr);
return tag_ptr(ret_conv, true);
}
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_BlindedRoute_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
+ LDKBlindedRoute this_obj_conv;
+ this_obj_conv.inner = untag_ptr(this_obj);
+ this_obj_conv.is_owned = ptr_is_owned(this_obj);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
+ BlindedRoute_free(this_obj_conv);
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_BlindedHop_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
+ LDKBlindedHop this_obj_conv;
+ this_obj_conv.inner = untag_ptr(this_obj);
+ this_obj_conv.is_owned = ptr_is_owned(this_obj);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
+ BlindedHop_free(this_obj_conv);
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_BlindedRoute_1new(JNIEnv *env, jclass clz, jobjectArray node_pks, int64_t keys_manager) {
+ LDKCVec_PublicKeyZ node_pks_constr;
+ node_pks_constr.datalen = (*env)->GetArrayLength(env, node_pks);
+ if (node_pks_constr.datalen > 0)
+ node_pks_constr.data = MALLOC(node_pks_constr.datalen * sizeof(LDKPublicKey), "LDKCVec_PublicKeyZ Elements");
+ else
+ node_pks_constr.data = NULL;
+ for (size_t i = 0; i < node_pks_constr.datalen; i++) {
+ int8_tArray node_pks_conv_8 = (*env)->GetObjectArrayElement(env, node_pks, i);
+ LDKPublicKey node_pks_conv_8_ref;
+ CHECK((*env)->GetArrayLength(env, node_pks_conv_8) == 33);
+ (*env)->GetByteArrayRegion(env, node_pks_conv_8, 0, 33, node_pks_conv_8_ref.compressed_form);
+ node_pks_constr.data[i] = node_pks_conv_8_ref;
+ }
+ void* keys_manager_ptr = untag_ptr(keys_manager);
+ if (ptr_is_owned(keys_manager)) { CHECK_ACCESS(keys_manager_ptr); }
+ LDKKeysInterface* keys_manager_conv = (LDKKeysInterface*)keys_manager_ptr;
+ LDKCResult_BlindedRouteNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedRouteNoneZ), "LDKCResult_BlindedRouteNoneZ");
+ *ret_conv = BlindedRoute_new(node_pks_constr, keys_manager_conv);
+ return tag_ptr(ret_conv, true);
+}
+
+JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_BlindedRoute_1write(JNIEnv *env, jclass clz, int64_t obj) {
+ LDKBlindedRoute obj_conv;
+ obj_conv.inner = untag_ptr(obj);
+ obj_conv.is_owned = ptr_is_owned(obj);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
+ obj_conv.is_owned = false;
+ LDKCVec_u8Z ret_var = BlindedRoute_write(&obj_conv);
+ int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
+ (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
+ CVec_u8Z_free(ret_var);
+ return ret_arr;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_BlindedRoute_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
+ LDKu8slice ser_ref;
+ ser_ref.datalen = (*env)->GetArrayLength(env, ser);
+ ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
+ LDKCResult_BlindedRouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedRouteDecodeErrorZ), "LDKCResult_BlindedRouteDecodeErrorZ");
+ *ret_conv = BlindedRoute_read(ser_ref);
+ (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
+ return tag_ptr(ret_conv, true);
+}
+
+JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_BlindedHop_1write(JNIEnv *env, jclass clz, int64_t obj) {
+ LDKBlindedHop obj_conv;
+ obj_conv.inner = untag_ptr(obj);
+ obj_conv.is_owned = ptr_is_owned(obj);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
+ obj_conv.is_owned = false;
+ LDKCVec_u8Z ret_var = BlindedHop_write(&obj_conv);
+ int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
+ (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
+ CVec_u8Z_free(ret_var);
+ return ret_arr;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_BlindedHop_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
+ LDKu8slice ser_ref;
+ ser_ref.datalen = (*env)->GetArrayLength(env, ser);
+ ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
+ LDKCResult_BlindedHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopDecodeErrorZ), "LDKCResult_BlindedHopDecodeErrorZ");
+ *ret_conv = BlindedHop_read(ser_ref);
+ (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
+ return tag_ptr(ret_conv, true);
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OnionMessenger_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
+ LDKOnionMessenger this_obj_conv;
+ this_obj_conv.inner = untag_ptr(this_obj);
+ this_obj_conv.is_owned = ptr_is_owned(this_obj);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
+ OnionMessenger_free(this_obj_conv);
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Destination_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
+ if (!ptr_is_owned(this_ptr)) return;
+ void* this_ptr_ptr = untag_ptr(this_ptr);
+ CHECK_ACCESS(this_ptr_ptr);
+ LDKDestination this_ptr_conv = *(LDKDestination*)(this_ptr_ptr);
+ FREE(untag_ptr(this_ptr));
+ Destination_free(this_ptr_conv);
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Destination_1node(JNIEnv *env, jclass clz, int8_tArray a) {
+ LDKPublicKey a_ref;
+ CHECK((*env)->GetArrayLength(env, a) == 33);
+ (*env)->GetByteArrayRegion(env, a, 0, 33, a_ref.compressed_form);
+ LDKDestination *ret_copy = MALLOC(sizeof(LDKDestination), "LDKDestination");
+ *ret_copy = Destination_node(a_ref);
+ int64_t ret_ref = tag_ptr(ret_copy, true);
+ return ret_ref;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Destination_1blinded_1route(JNIEnv *env, jclass clz, int64_t a) {
+ LDKBlindedRoute a_conv;
+ a_conv.inner = untag_ptr(a);
+ a_conv.is_owned = ptr_is_owned(a);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
+ // WARNING: we need a move here but no clone is available for LDKBlindedRoute
+
+ LDKDestination *ret_copy = MALLOC(sizeof(LDKDestination), "LDKDestination");
+ *ret_copy = Destination_blinded_route(a_conv);
+ int64_t ret_ref = tag_ptr(ret_copy, true);
+ return ret_ref;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_SendError_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
+ if (!ptr_is_owned(this_ptr)) return;
+ void* this_ptr_ptr = untag_ptr(this_ptr);
+ CHECK_ACCESS(this_ptr_ptr);
+ LDKSendError this_ptr_conv = *(LDKSendError*)(this_ptr_ptr);
+ FREE(untag_ptr(this_ptr));
+ SendError_free(this_ptr_conv);
+}
+
+static inline uint64_t SendError_clone_ptr(LDKSendError *NONNULL_PTR arg) {
+ LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
+ *ret_copy = SendError_clone(arg);
+ int64_t ret_ref = tag_ptr(ret_copy, true);
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SendError_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKSendError* arg_conv = (LDKSendError*)untag_ptr(arg);
+ int64_t ret_conv = SendError_clone_ptr(arg_conv);
+ return ret_conv;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SendError_1clone(JNIEnv *env, jclass clz, int64_t orig) {
+ LDKSendError* orig_conv = (LDKSendError*)untag_ptr(orig);
+ LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
+ *ret_copy = SendError_clone(orig_conv);
+ int64_t ret_ref = tag_ptr(ret_copy, true);
+ return ret_ref;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SendError_1secp256k1(JNIEnv *env, jclass clz, jclass a) {
+ LDKSecp256k1Error a_conv = LDKSecp256k1Error_from_java(env, a);
+ LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
+ *ret_copy = SendError_secp256k1(a_conv);
+ int64_t ret_ref = tag_ptr(ret_copy, true);
+ return ret_ref;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SendError_1too_1big_1packet(JNIEnv *env, jclass clz) {
+ LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
+ *ret_copy = SendError_too_big_packet();
+ int64_t ret_ref = tag_ptr(ret_copy, true);
+ return ret_ref;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SendError_1too_1few_1blinded_1hops(JNIEnv *env, jclass clz) {
+ LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
+ *ret_copy = SendError_too_few_blinded_hops();
+ int64_t ret_ref = tag_ptr(ret_copy, true);
+ return ret_ref;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SendError_1invalid_1first_1hop(JNIEnv *env, jclass clz) {
+ LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
+ *ret_copy = SendError_invalid_first_hop();
+ int64_t ret_ref = tag_ptr(ret_copy, true);
+ return ret_ref;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SendError_1buffer_1full(JNIEnv *env, jclass clz) {
+ LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
+ *ret_copy = SendError_buffer_full();
+ int64_t ret_ref = tag_ptr(ret_copy, true);
+ return ret_ref;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OnionMessenger_1new(JNIEnv *env, jclass clz, int64_t keys_manager, int64_t logger) {
+ void* keys_manager_ptr = untag_ptr(keys_manager);
+ CHECK_ACCESS(keys_manager_ptr);
+ LDKKeysInterface keys_manager_conv = *(LDKKeysInterface*)(keys_manager_ptr);
+ if (keys_manager_conv.free == LDKKeysInterface_JCalls_free) {
+ // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
+ LDKKeysInterface_JCalls_cloned(&keys_manager_conv);
+ }
+ void* logger_ptr = untag_ptr(logger);
+ CHECK_ACCESS(logger_ptr);
+ LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
+ if (logger_conv.free == LDKLogger_JCalls_free) {
+ // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
+ LDKLogger_JCalls_cloned(&logger_conv);
+ }
+ LDKOnionMessenger ret_var = OnionMessenger_new(keys_manager_conv, logger_conv);
+ int64_t ret_ref = 0;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
+ return ret_ref;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OnionMessenger_1send_1onion_1message(JNIEnv *env, jclass clz, int64_t this_arg, jobjectArray intermediate_nodes, int64_t destination, int64_t reply_path) {
+ LDKOnionMessenger this_arg_conv;
+ this_arg_conv.inner = untag_ptr(this_arg);
+ this_arg_conv.is_owned = ptr_is_owned(this_arg);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
+ this_arg_conv.is_owned = false;
+ LDKCVec_PublicKeyZ intermediate_nodes_constr;
+ intermediate_nodes_constr.datalen = (*env)->GetArrayLength(env, intermediate_nodes);
+ if (intermediate_nodes_constr.datalen > 0)
+ intermediate_nodes_constr.data = MALLOC(intermediate_nodes_constr.datalen * sizeof(LDKPublicKey), "LDKCVec_PublicKeyZ Elements");
+ else
+ intermediate_nodes_constr.data = NULL;
+ for (size_t i = 0; i < intermediate_nodes_constr.datalen; i++) {
+ int8_tArray intermediate_nodes_conv_8 = (*env)->GetObjectArrayElement(env, intermediate_nodes, i);
+ LDKPublicKey intermediate_nodes_conv_8_ref;
+ CHECK((*env)->GetArrayLength(env, intermediate_nodes_conv_8) == 33);
+ (*env)->GetByteArrayRegion(env, intermediate_nodes_conv_8, 0, 33, intermediate_nodes_conv_8_ref.compressed_form);
+ intermediate_nodes_constr.data[i] = intermediate_nodes_conv_8_ref;
+ }
+ void* destination_ptr = untag_ptr(destination);
+ CHECK_ACCESS(destination_ptr);
+ LDKDestination destination_conv = *(LDKDestination*)(destination_ptr);
+ // WARNING: we may need a move here but no clone is available for LDKDestination
+ LDKBlindedRoute reply_path_conv;
+ reply_path_conv.inner = untag_ptr(reply_path);
+ reply_path_conv.is_owned = ptr_is_owned(reply_path);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(reply_path_conv);
+ reply_path_conv.is_owned = false;
+ LDKCResult_NoneSendErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSendErrorZ), "LDKCResult_NoneSendErrorZ");
+ *ret_conv = OnionMessenger_send_onion_message(&this_arg_conv, intermediate_nodes_constr, destination_conv, reply_path_conv);
+ return tag_ptr(ret_conv, true);
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OnionMessenger_1as_1OnionMessageHandler(JNIEnv *env, jclass clz, int64_t this_arg) {
+ LDKOnionMessenger this_arg_conv;
+ this_arg_conv.inner = untag_ptr(this_arg);
+ this_arg_conv.is_owned = ptr_is_owned(this_arg);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
+ this_arg_conv.is_owned = false;
+ LDKOnionMessageHandler* ret_ret = MALLOC(sizeof(LDKOnionMessageHandler), "LDKOnionMessageHandler");
+ *ret_ret = OnionMessenger_as_OnionMessageHandler(&this_arg_conv);
+ return tag_ptr(ret_ret, true);
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OnionMessenger_1as_1OnionMessageProvider(JNIEnv *env, jclass clz, int64_t this_arg) {
+ LDKOnionMessenger this_arg_conv;
+ this_arg_conv.inner = untag_ptr(this_arg);
+ this_arg_conv.is_owned = ptr_is_owned(this_arg);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
+ this_arg_conv.is_owned = false;
+ LDKOnionMessageProvider* ret_ret = MALLOC(sizeof(LDKOnionMessageProvider), "LDKOnionMessageProvider");
+ *ret_ret = OnionMessenger_as_OnionMessageProvider(&this_arg_conv);
+ return tag_ptr(ret_ret, true);
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_FilesystemPersister_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
LDKFilesystemPersister this_obj_conv;
this_obj_conv.inner = untag_ptr(this_obj);
// If this_arg is a JCalls struct, then we need to increment the refcnt in it.
LDKLogger_JCalls_cloned(&logger_conv);
}
- LDKMultiThreadedLockableScore scorer_conv;
- scorer_conv.inner = untag_ptr(scorer);
- scorer_conv.is_owned = ptr_is_owned(scorer);
- CHECK_INNER_FIELD_ACCESS_OR_NULL(scorer_conv);
- scorer_conv.is_owned = false;
+ void* scorer_ptr = untag_ptr(scorer);
+ CHECK_ACCESS(scorer_ptr);
+ LDKCOption_WriteableScoreZ scorer_conv = *(LDKCOption_WriteableScoreZ*)(scorer_ptr);
+ // WARNING: we may need a move here but no clone is available for LDKCOption_WriteableScoreZ
+ if (scorer_conv.tag == LDKCOption_WriteableScoreZ_Some) {
+ // Manually implement clone for Java trait instances
+ if (scorer_conv.some.free == LDKWriteableScore_JCalls_free) {
+ // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
+ LDKWriteableScore_JCalls_cloned(&scorer_conv.some);
+ }
+ }
LDKBackgroundProcessor ret_var = BackgroundProcessor_start(persister_conv, event_handler_conv, &chain_monitor_conv, &channel_manager_conv, gossip_sync_conv, &peer_manager_conv, logger_conv, scorer_conv);
int64_t ret_ref = 0;
CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
return ret_ref;
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Invoice_1hash(JNIEnv *env, jclass clz, int64_t o) {
+ LDKInvoice o_conv;
+ o_conv.inner = untag_ptr(o);
+ o_conv.is_owned = ptr_is_owned(o);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv.is_owned = false;
+ int64_t ret_conv = Invoice_hash(&o_conv);
+ return ret_conv;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_SignedRawInvoice_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
LDKSignedRawInvoice this_obj_conv;
this_obj_conv.inner = untag_ptr(this_obj);
return ret_ref;
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SignedRawInvoice_1hash(JNIEnv *env, jclass clz, int64_t o) {
+ LDKSignedRawInvoice o_conv;
+ o_conv.inner = untag_ptr(o);
+ o_conv.is_owned = ptr_is_owned(o);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv.is_owned = false;
+ int64_t ret_conv = SignedRawInvoice_hash(&o_conv);
+ return ret_conv;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RawInvoice_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
LDKRawInvoice this_obj_conv;
this_obj_conv.inner = untag_ptr(this_obj);
return ret_ref;
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RawInvoice_1hash(JNIEnv *env, jclass clz, int64_t o) {
+ LDKRawInvoice o_conv;
+ o_conv.inner = untag_ptr(o);
+ o_conv.is_owned = ptr_is_owned(o);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv.is_owned = false;
+ int64_t ret_conv = RawInvoice_hash(&o_conv);
+ return ret_conv;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RawDataPart_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
LDKRawDataPart this_obj_conv;
this_obj_conv.inner = untag_ptr(this_obj);
return ret_ref;
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RawDataPart_1hash(JNIEnv *env, jclass clz, int64_t o) {
+ LDKRawDataPart o_conv;
+ o_conv.inner = untag_ptr(o);
+ o_conv.is_owned = ptr_is_owned(o);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv.is_owned = false;
+ int64_t ret_conv = RawDataPart_hash(&o_conv);
+ return ret_conv;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_PositiveTimestamp_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
LDKPositiveTimestamp this_obj_conv;
this_obj_conv.inner = untag_ptr(this_obj);
return ret_ref;
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PositiveTimestamp_1hash(JNIEnv *env, jclass clz, int64_t o) {
+ LDKPositiveTimestamp o_conv;
+ o_conv.inner = untag_ptr(o);
+ o_conv.is_owned = ptr_is_owned(o);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv.is_owned = false;
+ int64_t ret_conv = PositiveTimestamp_hash(&o_conv);
+ return ret_conv;
+}
+
JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_SiPrefix_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKSiPrefix* orig_conv = (LDKSiPrefix*)untag_ptr(orig);
jclass ret_conv = LDKSiPrefix_to_java(env, SiPrefix_clone(orig_conv));
return ret_conv;
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SiPrefix_1hash(JNIEnv *env, jclass clz, int64_t o) {
+ LDKSiPrefix* o_conv = (LDKSiPrefix*)untag_ptr(o);
+ int64_t ret_conv = SiPrefix_hash(o_conv);
+ return ret_conv;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SiPrefix_1multiplier(JNIEnv *env, jclass clz, int64_t this_arg) {
LDKSiPrefix* this_arg_conv = (LDKSiPrefix*)untag_ptr(this_arg);
int64_t ret_conv = SiPrefix_multiplier(this_arg_conv);
return ret_ref;
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InvoiceSignature_1hash(JNIEnv *env, jclass clz, int64_t o) {
+ LDKInvoiceSignature o_conv;
+ o_conv.inner = untag_ptr(o);
+ o_conv.is_owned = ptr_is_owned(o);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv.is_owned = false;
+ int64_t ret_conv = InvoiceSignature_hash(&o_conv);
+ return ret_conv;
+}
+
JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_InvoiceSignature_1eq(JNIEnv *env, jclass clz, int64_t a, int64_t b) {
LDKInvoiceSignature a_conv;
a_conv.inner = untag_ptr(a);
return ret_ref;
}
-JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_SignedRawInvoice_1hash(JNIEnv *env, jclass clz, int64_t this_arg) {
+JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_SignedRawInvoice_1signable_1hash(JNIEnv *env, jclass clz, int64_t this_arg) {
LDKSignedRawInvoice this_arg_conv;
this_arg_conv.inner = untag_ptr(this_arg);
this_arg_conv.is_owned = ptr_is_owned(this_arg);
CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
this_arg_conv.is_owned = false;
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
- (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *SignedRawInvoice_hash(&this_arg_conv));
+ (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *SignedRawInvoice_signable_hash(&this_arg_conv));
return ret_arr;
}
return ret_conv;
}
-JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_RawInvoice_1hash(JNIEnv *env, jclass clz, int64_t this_arg) {
+JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_RawInvoice_1signable_1hash(JNIEnv *env, jclass clz, int64_t this_arg) {
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = untag_ptr(this_arg);
this_arg_conv.is_owned = ptr_is_owned(this_arg);
CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
this_arg_conv.is_owned = false;
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
- (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, RawInvoice_hash(&this_arg_conv).data);
+ (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, RawInvoice_signable_hash(&this_arg_conv).data);
return ret_arr;
}
return ret_ref;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InvoicePayer_1new(JNIEnv *env, jclass clz, int64_t payer, int64_t router, int64_t scorer, int64_t logger, int64_t event_handler, int64_t retry) {
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InvoicePayer_1new(JNIEnv *env, jclass clz, int64_t payer, int64_t router, int64_t logger, int64_t event_handler, int64_t retry) {
void* payer_ptr = untag_ptr(payer);
CHECK_ACCESS(payer_ptr);
LDKPayer payer_conv = *(LDKPayer*)(payer_ptr);
// If this_arg is a JCalls struct, then we need to increment the refcnt in it.
LDKRouter_JCalls_cloned(&router_conv);
}
- LDKMultiThreadedLockableScore scorer_conv;
- scorer_conv.inner = untag_ptr(scorer);
- scorer_conv.is_owned = ptr_is_owned(scorer);
- CHECK_INNER_FIELD_ACCESS_OR_NULL(scorer_conv);
- scorer_conv.is_owned = false;
void* logger_ptr = untag_ptr(logger);
CHECK_ACCESS(logger_ptr);
LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
CHECK_ACCESS(retry_ptr);
LDKRetry retry_conv = *(LDKRetry*)(retry_ptr);
retry_conv = Retry_clone((LDKRetry*)untag_ptr(retry));
- LDKInvoicePayer ret_var = InvoicePayer_new(payer_conv, router_conv, &scorer_conv, logger_conv, event_handler_conv, retry_conv);
+ LDKInvoicePayer ret_var = InvoicePayer_new(payer_conv, router_conv, logger_conv, event_handler_conv, retry_conv);
int64_t ret_ref = 0;
CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
return tag_ptr(ret_ret, true);
}
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_InFlightHtlcs_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
+ LDKInFlightHtlcs this_obj_conv;
+ this_obj_conv.inner = untag_ptr(this_obj);
+ this_obj_conv.is_owned = ptr_is_owned(this_obj);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
+ InFlightHtlcs_free(this_obj_conv);
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InFlightHtlcs_1used_1liquidity_1msat(JNIEnv *env, jclass clz, int64_t this_arg, int64_t source, int64_t target, int64_t channel_scid) {
+ LDKInFlightHtlcs this_arg_conv;
+ this_arg_conv.inner = untag_ptr(this_arg);
+ this_arg_conv.is_owned = ptr_is_owned(this_arg);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
+ this_arg_conv.is_owned = false;
+ LDKNodeId source_conv;
+ source_conv.inner = untag_ptr(source);
+ source_conv.is_owned = ptr_is_owned(source);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(source_conv);
+ source_conv.is_owned = false;
+ LDKNodeId target_conv;
+ target_conv.inner = untag_ptr(target);
+ target_conv.is_owned = ptr_is_owned(target);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(target_conv);
+ target_conv.is_owned = false;
+ LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
+ *ret_copy = InFlightHtlcs_used_liquidity_msat(&this_arg_conv, &source_conv, &target_conv, channel_scid);
+ int64_t ret_ref = tag_ptr(ret_copy, true);
+ return ret_ref;
+}
+
+JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_InFlightHtlcs_1write(JNIEnv *env, jclass clz, int64_t obj) {
+ LDKInFlightHtlcs obj_conv;
+ obj_conv.inner = untag_ptr(obj);
+ obj_conv.is_owned = ptr_is_owned(obj);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
+ obj_conv.is_owned = false;
+ LDKCVec_u8Z ret_var = InFlightHtlcs_write(&obj_conv);
+ int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
+ (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
+ CVec_u8Z_free(ret_var);
+ return ret_arr;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InFlightHtlcs_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
+ LDKu8slice ser_ref;
+ ser_ref.datalen = (*env)->GetArrayLength(env, ser);
+ ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
+ LDKCResult_InFlightHtlcsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ), "LDKCResult_InFlightHtlcsDecodeErrorZ");
+ *ret_conv = InFlightHtlcs_read(ser_ref);
+ (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
+ return tag_ptr(ret_conv, true);
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_create_1phantom_1invoice(JNIEnv *env, jclass clz, int64_t amt_msat, int8_tArray payment_hash, jstring description, int32_t invoice_expiry_delta_secs, int64_tArray phantom_route_hints, int64_t keys_manager, jclass network) {
void* amt_msat_ptr = untag_ptr(amt_msat);
CHECK_ACCESS(amt_msat_ptr);
DefaultRouter_free(this_obj_conv);
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DefaultRouter_1new(JNIEnv *env, jclass clz, int64_t network_graph, int64_t logger, int8_tArray random_seed_bytes) {
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DefaultRouter_1new(JNIEnv *env, jclass clz, int64_t network_graph, int64_t logger, int8_tArray random_seed_bytes, int64_t scorer) {
LDKNetworkGraph network_graph_conv;
network_graph_conv.inner = untag_ptr(network_graph);
network_graph_conv.is_owned = ptr_is_owned(network_graph);
LDKThirtyTwoBytes random_seed_bytes_ref;
CHECK((*env)->GetArrayLength(env, random_seed_bytes) == 32);
(*env)->GetByteArrayRegion(env, random_seed_bytes, 0, 32, random_seed_bytes_ref.data);
- LDKDefaultRouter ret_var = DefaultRouter_new(&network_graph_conv, logger_conv, random_seed_bytes_ref);
+ void* scorer_ptr = untag_ptr(scorer);
+ CHECK_ACCESS(scorer_ptr);
+ LDKLockableScore scorer_conv = *(LDKLockableScore*)(scorer_ptr);
+ if (scorer_conv.free == LDKLockableScore_JCalls_free) {
+ // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
+ LDKLockableScore_JCalls_cloned(&scorer_conv);
+ }
+ LDKDefaultRouter ret_var = DefaultRouter_new(&network_graph_conv, logger_conv, random_seed_bytes_ref, scorer_conv);
int64_t ret_ref = 0;
CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
projects / ldk-java / blobdiff