+static inline LDKCVec_CResult_NoneAPIErrorZZ CVec_CResult_NoneAPIErrorZZ_clone(const LDKCVec_CResult_NoneAPIErrorZZ *orig) {
+ LDKCVec_CResult_NoneAPIErrorZZ ret = { .data = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ) * orig->datalen, "LDKCVec_CResult_NoneAPIErrorZZ clone bytes"), .datalen = orig->datalen };
+ for (size_t i = 0; i < ret.datalen; i++) {
+ ret.data[i] = CResult_NoneAPIErrorZ_clone(&orig->data[i]);
+ }
+ return ret;
+}
+uint32_t __attribute__((visibility("default"))) TS_LDKCVec_APIErrorZ_new(uint32_tArray elems) {
+ LDKCVec_APIErrorZ *ret = MALLOC(sizeof(LDKCVec_APIErrorZ), "LDKCVec_APIErrorZ");
+ ret->datalen = *((uint32_t*)elems);
+ if (ret->datalen == 0) {
+ ret->data = NULL;
+ } else {
+ ret->data = MALLOC(sizeof(LDKAPIError) * ret->datalen, "LDKCVec_APIErrorZ Data");
+ uint32_t *java_elems = (uint32_t*)(elems + 4);
+ for (size_t i = 0; i < ret->datalen; i++) {
+ uint32_t arr_elem = java_elems[i];
+ LDKAPIError arr_elem_conv = *(LDKAPIError*)(((uint64_t)arr_elem) & ~1);
+ arr_elem_conv = APIError_clone((LDKAPIError*)(((uint64_t)arr_elem) & ~1));
+ ret->data[i] = arr_elem_conv;
+ }
+ }
+ return (long)ret;
+}
+static inline LDKCVec_APIErrorZ CVec_APIErrorZ_clone(const LDKCVec_APIErrorZ *orig) {
+ LDKCVec_APIErrorZ ret = { .data = MALLOC(sizeof(LDKAPIError) * orig->datalen, "LDKCVec_APIErrorZ clone bytes"), .datalen = orig->datalen };
+ for (size_t i = 0; i < ret.datalen; i++) {
+ ret.data[i] = APIError_clone(&orig->data[i]);
+ }
+ return ret;
+}
+uint32_t __attribute__((visibility("default"))) TS_LDKPaymentSendFailure_ref_from_ptr(uint32_t ptr) {
+ LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)(ptr & ~1);
+ switch(obj->tag) {
+ case LDKPaymentSendFailure_ParameterError: {
+ long parameter_error_ref = ((long)&obj->parameter_error) | 1;
+ return 0 /* LDKPaymentSendFailure - ParameterError */; (void) parameter_error_ref;
+ }
+ case LDKPaymentSendFailure_PathParameterError: {
+ LDKCVec_CResult_NoneAPIErrorZZ path_parameter_error_var = obj->path_parameter_error;
+ uint32_tArray path_parameter_error_arr = init_arr(path_parameter_error_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
+ uint32_t *path_parameter_error_arr_ptr = (uint32_t*)(path_parameter_error_arr + 4);
+ for (size_t w = 0; w < path_parameter_error_var.datalen; w++) {
+ LDKCResult_NoneAPIErrorZ* path_parameter_error_conv_22_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
+ *path_parameter_error_conv_22_conv = path_parameter_error_var.data[w];
+ *path_parameter_error_conv_22_conv = CResult_NoneAPIErrorZ_clone(path_parameter_error_conv_22_conv);
+ path_parameter_error_arr_ptr[w] = (long)path_parameter_error_conv_22_conv;
+ }
+ return 0 /* LDKPaymentSendFailure - PathParameterError */; (void) path_parameter_error_arr;
+ }
+ case LDKPaymentSendFailure_AllFailedRetrySafe: {
+ LDKCVec_APIErrorZ all_failed_retry_safe_var = obj->all_failed_retry_safe;
+ uint32_tArray all_failed_retry_safe_arr = init_arr(all_failed_retry_safe_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
+ uint32_t *all_failed_retry_safe_arr_ptr = (uint32_t*)(all_failed_retry_safe_arr + 4);
+ for (size_t k = 0; k < all_failed_retry_safe_var.datalen; k++) {
+ long all_failed_retry_safe_conv_10_ref = ((long)&all_failed_retry_safe_var.data[k]) | 1;
+ all_failed_retry_safe_arr_ptr[k] = all_failed_retry_safe_conv_10_ref;
+ }
+ return 0 /* LDKPaymentSendFailure - AllFailedRetrySafe */; (void) all_failed_retry_safe_arr;
+ }
+ case LDKPaymentSendFailure_PartialFailure: {
+ LDKCVec_CResult_NoneAPIErrorZZ partial_failure_var = obj->partial_failure;
+ uint32_tArray partial_failure_arr = init_arr(partial_failure_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
+ uint32_t *partial_failure_arr_ptr = (uint32_t*)(partial_failure_arr + 4);
+ for (size_t w = 0; w < partial_failure_var.datalen; w++) {
+ LDKCResult_NoneAPIErrorZ* partial_failure_conv_22_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
+ *partial_failure_conv_22_conv = partial_failure_var.data[w];
+ *partial_failure_conv_22_conv = CResult_NoneAPIErrorZ_clone(partial_failure_conv_22_conv);
+ partial_failure_arr_ptr[w] = (long)partial_failure_conv_22_conv;
+ }
+ return 0 /* LDKPaymentSendFailure - PartialFailure */; (void) partial_failure_arr;
+ }
+ default: abort();
+ }
+}
+jboolean __attribute__((visibility("default"))) TS_LDKCResult_NonePaymentSendFailureZ_result_ok(uint32_t arg) {
+ return ((LDKCResult_NonePaymentSendFailureZ*)arg)->result_ok;
+}
+void __attribute__((visibility("default"))) TS_LDKCResult_NonePaymentSendFailureZ_get_ok(uint32_t arg) {
+ LDKCResult_NonePaymentSendFailureZ *val = (LDKCResult_NonePaymentSendFailureZ*)(arg & ~1);
+ CHECK(val->result_ok);
+ return *val->contents.result;
+}
+uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NonePaymentSendFailureZ_get_err(uint32_t arg) {
+ LDKCResult_NonePaymentSendFailureZ *val = (LDKCResult_NonePaymentSendFailureZ*)(arg & ~1);
+ CHECK(!val->result_ok);
+ long err_ref = ((long)&(*val->contents.err)) | 1;
+ return err_ref;
+}
+uint32_t __attribute__((visibility("default"))) TS_LDKCVec_ChannelMonitorZ_new(uint32_tArray elems) {
+ LDKCVec_ChannelMonitorZ *ret = MALLOC(sizeof(LDKCVec_ChannelMonitorZ), "LDKCVec_ChannelMonitorZ");
+ ret->datalen = *((uint32_t*)elems);
+ if (ret->datalen == 0) {
+ ret->data = NULL;
+ } else {
+ ret->data = MALLOC(sizeof(LDKChannelMonitor) * ret->datalen, "LDKCVec_ChannelMonitorZ Data");
+ uint32_t *java_elems = (uint32_t*)(elems + 4);
+ for (size_t i = 0; i < ret->datalen; i++) {
+ uint32_t arr_elem = java_elems[i];
+ LDKChannelMonitor arr_elem_conv;
+ arr_elem_conv.inner = (void*)(arr_elem & (~1));
+ arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
+ arr_elem_conv = ChannelMonitor_clone(&arr_elem_conv);
+ ret->data[i] = arr_elem_conv;
+ }
+ }
+ return (long)ret;
+}
+static inline LDKCVec_ChannelMonitorZ CVec_ChannelMonitorZ_clone(const LDKCVec_ChannelMonitorZ *orig) {
+ LDKCVec_ChannelMonitorZ ret = { .data = MALLOC(sizeof(LDKChannelMonitor) * orig->datalen, "LDKCVec_ChannelMonitorZ clone bytes"), .datalen = orig->datalen };
+ for (size_t i = 0; i < ret.datalen; i++) {
+ ret.data[i] = ChannelMonitor_clone(&orig->data[i]);
+ }
+ return ret;
+}
+typedef struct LDKWatch_JCalls {
+ atomic_size_t refcnt;
+ uint32_t watch_channel_meth;
+ uint32_t update_channel_meth;
+ uint32_t release_pending_monitor_events_meth;
+} LDKWatch_JCalls;
+static void LDKWatch_JCalls_free(void* this_arg) {
+ LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
+ if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
+ js_free(j_calls->watch_channel_meth);
+ js_free(j_calls->update_channel_meth);
+ js_free(j_calls->release_pending_monitor_events_meth);
+ FREE(j_calls);
+ }
+}
+LDKCResult_NoneChannelMonitorUpdateErrZ watch_channel_LDKWatch_jcall(const void* this_arg, LDKOutPoint funding_txo, LDKChannelMonitor monitor) {
+ LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
+ LDKOutPoint funding_txo_var = funding_txo;
+ CHECK((((long)funding_txo_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((long)&funding_txo_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ long funding_txo_ref = (long)funding_txo_var.inner;
+ if (funding_txo_var.is_owned) {
+ funding_txo_ref |= 1;
+ }
+ LDKChannelMonitor monitor_var = monitor;
+ CHECK((((long)monitor_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((long)&monitor_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ long monitor_ref = (long)monitor_var.inner;
+ if (monitor_var.is_owned) {
+ monitor_ref |= 1;
+ }
+ LDKCResult_NoneChannelMonitorUpdateErrZ* ret = (LDKCResult_NoneChannelMonitorUpdateErrZ*)js_invoke_function_2(j_calls->watch_channel_meth, funding_txo_ref, monitor_ref);
+ LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1);
+ ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1));
+ return ret_conv;
+}
+LDKCResult_NoneChannelMonitorUpdateErrZ update_channel_LDKWatch_jcall(const void* this_arg, LDKOutPoint funding_txo, LDKChannelMonitorUpdate update) {
+ LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
+ LDKOutPoint funding_txo_var = funding_txo;
+ CHECK((((long)funding_txo_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((long)&funding_txo_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ long funding_txo_ref = (long)funding_txo_var.inner;
+ if (funding_txo_var.is_owned) {
+ funding_txo_ref |= 1;
+ }
+ LDKChannelMonitorUpdate update_var = update;
+ CHECK((((long)update_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((long)&update_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ long update_ref = (long)update_var.inner;
+ if (update_var.is_owned) {
+ update_ref |= 1;
+ }
+ LDKCResult_NoneChannelMonitorUpdateErrZ* ret = (LDKCResult_NoneChannelMonitorUpdateErrZ*)js_invoke_function_2(j_calls->update_channel_meth, funding_txo_ref, update_ref);
+ LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1);
+ ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1));
+ return ret_conv;
+}
+LDKCVec_MonitorEventZ release_pending_monitor_events_LDKWatch_jcall(const void* this_arg) {
+ LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
+ uint32_tArray ret = js_invoke_function_0(j_calls->release_pending_monitor_events_meth);
+ LDKCVec_MonitorEventZ ret_constr;
+ ret_constr.datalen = *((uint32_t*)ret);
+ if (ret_constr.datalen > 0)
+ ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKMonitorEvent), "LDKCVec_MonitorEventZ Elements");
+ else
+ ret_constr.data = NULL;
+ uint32_t* ret_vals = (uint32_t*)(ret + 4);
+ for (size_t o = 0; o < ret_constr.datalen; o++) {
+ uint32_t ret_conv_14 = ret_vals[o];
+ LDKMonitorEvent ret_conv_14_conv = *(LDKMonitorEvent*)(((uint64_t)ret_conv_14) & ~1);
+ ret_conv_14_conv = MonitorEvent_clone((LDKMonitorEvent*)(((uint64_t)ret_conv_14) & ~1));
+ ret_constr.data[o] = ret_conv_14_conv;
+ }
+ return ret_constr;
+}
+static void* LDKWatch_JCalls_clone(const void* this_arg) {
+ LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
+ atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
+ return (void*) this_arg;
+}
+static inline LDKWatch LDKWatch_init (/*TODO: JS Object Reference */void* o) {
+ LDKWatch_JCalls *calls = MALLOC(sizeof(LDKWatch_JCalls), "LDKWatch_JCalls");
+ atomic_init(&calls->refcnt, 1);
+ //TODO: Assign calls->o from o
+
+ LDKWatch ret = {
+ .this_arg = (void*) calls,
+ .watch_channel = watch_channel_LDKWatch_jcall,
+ .update_channel = update_channel_LDKWatch_jcall,
+ .release_pending_monitor_events = release_pending_monitor_events_LDKWatch_jcall,
+ .free = LDKWatch_JCalls_free,
+ };
+ return ret;
+}
+long __attribute__((visibility("default"))) TS_LDKWatch_new(/*TODO: JS Object Reference */void* o) {
+ LDKWatch *res_ptr = MALLOC(sizeof(LDKWatch), "LDKWatch");
+ *res_ptr = LDKWatch_init(o);
+ return (long)res_ptr;
+}
+uint32_t __attribute__((visibility("default"))) TS_Watch_watch_channel(uint32_t this_arg, uint32_t funding_txo, uint32_t monitor) {
+ LDKWatch* this_arg_conv = (LDKWatch*)(((uint64_t)this_arg) & ~1);
+ LDKOutPoint funding_txo_conv;
+ funding_txo_conv.inner = (void*)(funding_txo & (~1));
+ funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
+ funding_txo_conv = OutPoint_clone(&funding_txo_conv);
+ LDKChannelMonitor monitor_conv;
+ monitor_conv.inner = (void*)(monitor & (~1));
+ monitor_conv.is_owned = (monitor & 1) || (monitor == 0);
+ monitor_conv = ChannelMonitor_clone(&monitor_conv);
+ LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
+ *ret_conv = (this_arg_conv->watch_channel)(this_arg_conv->this_arg, funding_txo_conv, monitor_conv);
+ return (long)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_Watch_update_channel(uint32_t this_arg, uint32_t funding_txo, uint32_t update) {
+ LDKWatch* this_arg_conv = (LDKWatch*)(((uint64_t)this_arg) & ~1);
+ LDKOutPoint funding_txo_conv;
+ funding_txo_conv.inner = (void*)(funding_txo & (~1));
+ funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
+ funding_txo_conv = OutPoint_clone(&funding_txo_conv);
+ LDKChannelMonitorUpdate update_conv;
+ update_conv.inner = (void*)(update & (~1));
+ update_conv.is_owned = (update & 1) || (update == 0);
+ update_conv = ChannelMonitorUpdate_clone(&update_conv);
+ LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
+ *ret_conv = (this_arg_conv->update_channel)(this_arg_conv->this_arg, funding_txo_conv, update_conv);
+ return (long)ret_conv;
+}
+
+uint32_tArray __attribute__((visibility("default"))) TS_Watch_release_pending_monitor_events(uint32_t this_arg) {
+ LDKWatch* this_arg_conv = (LDKWatch*)(((uint64_t)this_arg) & ~1);
+ LDKCVec_MonitorEventZ ret_var = (this_arg_conv->release_pending_monitor_events)(this_arg_conv->this_arg);
+ uint32_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
+ uint32_t *ret_arr_ptr = (uint32_t*)(ret_arr + 4);
+ for (size_t o = 0; o < ret_var.datalen; o++) {
+ LDKMonitorEvent *ret_conv_14_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
+ *ret_conv_14_copy = MonitorEvent_clone(&ret_var.data[o]);
+ long ret_conv_14_ref = (long)ret_conv_14_copy;
+ ret_arr_ptr[o] = ret_conv_14_ref;
+ }
+ FREE(ret_var.data);
+ return ret_arr;
+}
+
+typedef struct LDKBroadcasterInterface_JCalls {
+ atomic_size_t refcnt;
+ uint32_t broadcast_transaction_meth;
+} LDKBroadcasterInterface_JCalls;
+static void LDKBroadcasterInterface_JCalls_free(void* this_arg) {
+ LDKBroadcasterInterface_JCalls *j_calls = (LDKBroadcasterInterface_JCalls*) this_arg;
+ if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
+ js_free(j_calls->broadcast_transaction_meth);
+ FREE(j_calls);
+ }
+}
+void broadcast_transaction_LDKBroadcasterInterface_jcall(const void* this_arg, LDKTransaction tx) {
+ LDKBroadcasterInterface_JCalls *j_calls = (LDKBroadcasterInterface_JCalls*) this_arg;
+ LDKTransaction tx_var = tx;
+ int8_tArray tx_arr = init_arr(tx_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
+ memcpy((uint8_t*)(tx_arr + 4), tx_var.data, tx_var.datalen);
+ Transaction_free(tx_var);
+ js_invoke_function_1(j_calls->broadcast_transaction_meth, tx_arr);
+}
+static void* LDKBroadcasterInterface_JCalls_clone(const void* this_arg) {
+ LDKBroadcasterInterface_JCalls *j_calls = (LDKBroadcasterInterface_JCalls*) this_arg;
+ atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
+ return (void*) this_arg;
+}
+static inline LDKBroadcasterInterface LDKBroadcasterInterface_init (/*TODO: JS Object Reference */void* o) {
+ LDKBroadcasterInterface_JCalls *calls = MALLOC(sizeof(LDKBroadcasterInterface_JCalls), "LDKBroadcasterInterface_JCalls");
+ atomic_init(&calls->refcnt, 1);
+ //TODO: Assign calls->o from o
+
+ LDKBroadcasterInterface ret = {
+ .this_arg = (void*) calls,
+ .broadcast_transaction = broadcast_transaction_LDKBroadcasterInterface_jcall,
+ .free = LDKBroadcasterInterface_JCalls_free,
+ };
+ return ret;
+}
+long __attribute__((visibility("default"))) TS_LDKBroadcasterInterface_new(/*TODO: JS Object Reference */void* o) {
+ LDKBroadcasterInterface *res_ptr = MALLOC(sizeof(LDKBroadcasterInterface), "LDKBroadcasterInterface");
+ *res_ptr = LDKBroadcasterInterface_init(o);
+ return (long)res_ptr;
+}
+void __attribute__((visibility("default"))) TS_BroadcasterInterface_broadcast_transaction(uint32_t this_arg, int8_tArray tx) {
+ LDKBroadcasterInterface* this_arg_conv = (LDKBroadcasterInterface*)(((uint64_t)this_arg) & ~1);
+ LDKTransaction tx_ref;
+ tx_ref.datalen = *((uint32_t*)tx);
+ tx_ref.data = MALLOC(tx_ref.datalen, "LDKTransaction Bytes");
+ memcpy(tx_ref.data, (uint8_t*)(tx + 4), tx_ref.datalen);
+ tx_ref.data_is_owned = true;
+ (this_arg_conv->broadcast_transaction)(this_arg_conv->this_arg, tx_ref);
+}
+
+typedef struct LDKKeysInterface_JCalls {
+ atomic_size_t refcnt;
+ uint32_t get_node_secret_meth;
+ uint32_t get_destination_script_meth;
+ uint32_t get_shutdown_pubkey_meth;
+ uint32_t get_channel_signer_meth;
+ uint32_t get_secure_random_bytes_meth;
+ uint32_t read_chan_signer_meth;
+} LDKKeysInterface_JCalls;
+static void LDKKeysInterface_JCalls_free(void* this_arg) {
+ LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
+ if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
+ js_free(j_calls->get_node_secret_meth);
+ js_free(j_calls->get_destination_script_meth);
+ js_free(j_calls->get_shutdown_pubkey_meth);
+ js_free(j_calls->get_channel_signer_meth);
+ js_free(j_calls->get_secure_random_bytes_meth);
+ js_free(j_calls->read_chan_signer_meth);
+ FREE(j_calls);
+ }
+}
+LDKSecretKey get_node_secret_LDKKeysInterface_jcall(const void* this_arg) {
+ LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
+ int8_tArray ret = js_invoke_function_0(j_calls->get_node_secret_meth);
+ LDKSecretKey ret_ref;
+ CHECK(*((uint32_t*)ret) == 32);
+ memcpy(ret_ref.bytes, (uint8_t*)(ret + 4), 32);
+ return ret_ref;