+ *ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+void __attribute__((visibility("default"))) TS_CVec_MonitorEventZ_free(uint32_tArray _res) {
+ LDKCVec_MonitorEventZ _res_constr;
+ _res_constr.datalen = *((uint32_t*)_res);
+ if (_res_constr.datalen > 0)
+ _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKMonitorEvent), "LDKCVec_MonitorEventZ Elements");
+ else
+ _res_constr.data = NULL;
+ uint32_t* _res_vals = (uint32_t*)(_res + 4);
+ for (size_t o = 0; o < _res_constr.datalen; o++) {
+ uint32_t _res_conv_14 = _res_vals[o];
+ void* _res_conv_14_ptr = (void*)(((uint64_t)_res_conv_14) & ~1);
+ CHECK_ACCESS(_res_conv_14_ptr);
+ LDKMonitorEvent _res_conv_14_conv = *(LDKMonitorEvent*)(_res_conv_14_ptr);
+ FREE((void*)_res_conv_14);
+ _res_constr.data[o] = _res_conv_14_conv;
+ }
+ CVec_MonitorEventZ_free(_res_constr);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_C2Tuple_usizeTransactionZZ_some(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKC2Tuple_usizeTransactionZ o_conv = *(LDKC2Tuple_usizeTransactionZ*)(o_ptr);
+ o_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)(((uint64_t)o) & ~1));
+ LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ");
+ *ret_copy = COption_C2Tuple_usizeTransactionZZ_some(o_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_C2Tuple_usizeTransactionZZ_none() {
+ LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ");
+ *ret_copy = COption_C2Tuple_usizeTransactionZZ_none();
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+void __attribute__((visibility("default"))) TS_COption_C2Tuple_usizeTransactionZZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCOption_C2Tuple_usizeTransactionZZ _res_conv = *(LDKCOption_C2Tuple_usizeTransactionZZ*)(_res_ptr);
+ FREE((void*)_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);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_COption_C2Tuple_usizeTransactionZZ_clone_ptr(uint32_t arg) {
+ LDKCOption_C2Tuple_usizeTransactionZZ* arg_conv = (LDKCOption_C2Tuple_usizeTransactionZZ*)arg;
+ int64_t ret_val = COption_C2Tuple_usizeTransactionZZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_C2Tuple_usizeTransactionZZ_clone(uint32_t orig) {
+ LDKCOption_C2Tuple_usizeTransactionZZ* orig_conv = (LDKCOption_C2Tuple_usizeTransactionZZ*)orig;
+ LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ");
+ *ret_copy = COption_C2Tuple_usizeTransactionZZ_clone(orig_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_ClosureReasonZ_some(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKClosureReason o_conv = *(LDKClosureReason*)(o_ptr);
+ o_conv = ClosureReason_clone((LDKClosureReason*)(((uint64_t)o) & ~1));
+ LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
+ *ret_copy = COption_ClosureReasonZ_some(o_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_ClosureReasonZ_none() {
+ LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
+ *ret_copy = COption_ClosureReasonZ_none();
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+void __attribute__((visibility("default"))) TS_COption_ClosureReasonZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCOption_ClosureReasonZ _res_conv = *(LDKCOption_ClosureReasonZ*)(_res_ptr);
+ FREE((void*)_res);
+ COption_ClosureReasonZ_free(_res_conv);
+}
+
+static inline uint64_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg) {
+ LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
+ *ret_copy = COption_ClosureReasonZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_COption_ClosureReasonZ_clone_ptr(uint32_t arg) {
+ LDKCOption_ClosureReasonZ* arg_conv = (LDKCOption_ClosureReasonZ*)arg;
+ int64_t ret_val = COption_ClosureReasonZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_ClosureReasonZ_clone(uint32_t orig) {
+ LDKCOption_ClosureReasonZ* orig_conv = (LDKCOption_ClosureReasonZ*)orig;
+ LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
+ *ret_copy = COption_ClosureReasonZ_clone(orig_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKCOption_ClosureReasonZ o_conv = *(LDKCOption_ClosureReasonZ*)(o_ptr);
+ o_conv = COption_ClosureReasonZ_clone((LDKCOption_ClosureReasonZ*)(((uint64_t)o) & ~1));
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
+ *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
+ *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* o_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ _res_conv = *(LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_COption_ClosureReasonZDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
+ *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* arg_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* orig_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(orig & ~1);
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
+ *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_NetworkUpdateZ_some(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKNetworkUpdate o_conv = *(LDKNetworkUpdate*)(o_ptr);
+ o_conv = NetworkUpdate_clone((LDKNetworkUpdate*)(((uint64_t)o) & ~1));
+ LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
+ *ret_copy = COption_NetworkUpdateZ_some(o_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_NetworkUpdateZ_none() {
+ LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
+ *ret_copy = COption_NetworkUpdateZ_none();
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+void __attribute__((visibility("default"))) TS_COption_NetworkUpdateZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCOption_NetworkUpdateZ _res_conv = *(LDKCOption_NetworkUpdateZ*)(_res_ptr);
+ FREE((void*)_res);
+ COption_NetworkUpdateZ_free(_res_conv);
+}
+
+static inline uint64_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg) {
+ LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
+ *ret_copy = COption_NetworkUpdateZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_COption_NetworkUpdateZ_clone_ptr(uint32_t arg) {
+ LDKCOption_NetworkUpdateZ* arg_conv = (LDKCOption_NetworkUpdateZ*)arg;
+ int64_t ret_val = COption_NetworkUpdateZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_NetworkUpdateZ_clone(uint32_t orig) {
+ LDKCOption_NetworkUpdateZ* orig_conv = (LDKCOption_NetworkUpdateZ*)orig;
+ LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
+ *ret_copy = COption_NetworkUpdateZ_clone(orig_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+void __attribute__((visibility("default"))) TS_CVec_SpendableOutputDescriptorZ_free(uint32_tArray _res) {
+ LDKCVec_SpendableOutputDescriptorZ _res_constr;
+ _res_constr.datalen = *((uint32_t*)_res);
+ if (_res_constr.datalen > 0)
+ _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKSpendableOutputDescriptor), "LDKCVec_SpendableOutputDescriptorZ Elements");
+ else
+ _res_constr.data = NULL;
+ uint32_t* _res_vals = (uint32_t*)(_res + 4);
+ for (size_t b = 0; b < _res_constr.datalen; b++) {
+ uint32_t _res_conv_27 = _res_vals[b];
+ void* _res_conv_27_ptr = (void*)(((uint64_t)_res_conv_27) & ~1);
+ CHECK_ACCESS(_res_conv_27_ptr);
+ LDKSpendableOutputDescriptor _res_conv_27_conv = *(LDKSpendableOutputDescriptor*)(_res_conv_27_ptr);
+ FREE((void*)_res_conv_27);
+ _res_constr.data[b] = _res_conv_27_conv;
+ }
+ CVec_SpendableOutputDescriptorZ_free(_res_constr);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_EventZ_some(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKEvent o_conv = *(LDKEvent*)(o_ptr);
+ o_conv = Event_clone((LDKEvent*)(((uint64_t)o) & ~1));
+ LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
+ *ret_copy = COption_EventZ_some(o_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_EventZ_none() {
+ LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
+ *ret_copy = COption_EventZ_none();
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+void __attribute__((visibility("default"))) TS_COption_EventZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCOption_EventZ _res_conv = *(LDKCOption_EventZ*)(_res_ptr);
+ FREE((void*)_res);
+ COption_EventZ_free(_res_conv);
+}
+
+static inline uint64_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg) {
+ LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
+ *ret_copy = COption_EventZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_COption_EventZ_clone_ptr(uint32_t arg) {
+ LDKCOption_EventZ* arg_conv = (LDKCOption_EventZ*)arg;
+ int64_t ret_val = COption_EventZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_EventZ_clone(uint32_t orig) {
+ LDKCOption_EventZ* orig_conv = (LDKCOption_EventZ*)orig;
+ LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
+ *ret_copy = COption_EventZ_clone(orig_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_EventZDecodeErrorZ_ok(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKCOption_EventZ o_conv = *(LDKCOption_EventZ*)(o_ptr);
+ o_conv = COption_EventZ_clone((LDKCOption_EventZ*)(((uint64_t)o) & ~1));
+ LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
+ *ret_conv = CResult_COption_EventZDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_EventZDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
+ *ret_conv = CResult_COption_EventZDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_COption_EventZDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_COption_EventZDecodeErrorZ* o_conv = (LDKCResult_COption_EventZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_COption_EventZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_COption_EventZDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_COption_EventZDecodeErrorZ _res_conv = *(LDKCResult_COption_EventZDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_COption_EventZDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
+ *ret_conv = CResult_COption_EventZDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_COption_EventZDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_COption_EventZDecodeErrorZ* arg_conv = (LDKCResult_COption_EventZDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_COption_EventZDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_EventZDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_COption_EventZDecodeErrorZ* orig_conv = (LDKCResult_COption_EventZDecodeErrorZ*)(orig & ~1);
+ LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
+ *ret_conv = CResult_COption_EventZDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+void __attribute__((visibility("default"))) TS_CVec_MessageSendEventZ_free(uint32_tArray _res) {
+ LDKCVec_MessageSendEventZ _res_constr;
+ _res_constr.datalen = *((uint32_t*)_res);
+ if (_res_constr.datalen > 0)
+ _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKMessageSendEvent), "LDKCVec_MessageSendEventZ Elements");
+ else
+ _res_constr.data = NULL;
+ uint32_t* _res_vals = (uint32_t*)(_res + 4);
+ for (size_t s = 0; s < _res_constr.datalen; s++) {
+ uint32_t _res_conv_18 = _res_vals[s];
+ void* _res_conv_18_ptr = (void*)(((uint64_t)_res_conv_18) & ~1);
+ CHECK_ACCESS(_res_conv_18_ptr);
+ LDKMessageSendEvent _res_conv_18_conv = *(LDKMessageSendEvent*)(_res_conv_18_ptr);
+ FREE((void*)_res_conv_18);
+ _res_constr.data[s] = _res_conv_18_conv;
+ }
+ CVec_MessageSendEventZ_free(_res_constr);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_InitFeaturesDecodeErrorZ_ok(uint32_t o) {
+ LDKInitFeatures o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = InitFeatures_clone(&o_conv);
+ LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
+ *ret_conv = CResult_InitFeaturesDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_InitFeaturesDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
+ *ret_conv = CResult_InitFeaturesDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_InitFeaturesDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_InitFeaturesDecodeErrorZ* o_conv = (LDKCResult_InitFeaturesDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_InitFeaturesDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_InitFeaturesDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_InitFeaturesDecodeErrorZ _res_conv = *(LDKCResult_InitFeaturesDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_InitFeaturesDecodeErrorZ_free(_res_conv);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NodeFeaturesDecodeErrorZ_ok(uint32_t o) {
+ LDKNodeFeatures o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = NodeFeatures_clone(&o_conv);
+ LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
+ *ret_conv = CResult_NodeFeaturesDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NodeFeaturesDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
+ *ret_conv = CResult_NodeFeaturesDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_NodeFeaturesDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NodeFeaturesDecodeErrorZ* o_conv = (LDKCResult_NodeFeaturesDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NodeFeaturesDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_NodeFeaturesDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_NodeFeaturesDecodeErrorZ _res_conv = *(LDKCResult_NodeFeaturesDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_NodeFeaturesDecodeErrorZ_free(_res_conv);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelFeaturesDecodeErrorZ_ok(uint32_t o) {
+ LDKChannelFeatures o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = ChannelFeatures_clone(&o_conv);
+ LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
+ *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelFeaturesDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
+ *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ChannelFeaturesDecodeErrorZ* o_conv = (LDKCResult_ChannelFeaturesDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelFeaturesDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_ChannelFeaturesDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_ChannelFeaturesDecodeErrorZ _res_conv = *(LDKCResult_ChannelFeaturesDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_ChannelFeaturesDecodeErrorZ_free(_res_conv);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_ok(uint32_t o) {
+ LDKInvoiceFeatures o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = InvoiceFeatures_clone(&o_conv);
+ LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
+ *ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
+ *ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_InvoiceFeaturesDecodeErrorZ* o_conv = (LDKCResult_InvoiceFeaturesDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_InvoiceFeaturesDecodeErrorZ _res_conv = *(LDKCResult_InvoiceFeaturesDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_InvoiceFeaturesDecodeErrorZ_free(_res_conv);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ScoringParametersDecodeErrorZ_ok(uint32_t o) {
+ LDKScoringParameters o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ // Warning: we need a move here but no clone is available for LDKScoringParameters
+ LDKCResult_ScoringParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ScoringParametersDecodeErrorZ), "LDKCResult_ScoringParametersDecodeErrorZ");
+ *ret_conv = CResult_ScoringParametersDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ScoringParametersDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_ScoringParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ScoringParametersDecodeErrorZ), "LDKCResult_ScoringParametersDecodeErrorZ");
+ *ret_conv = CResult_ScoringParametersDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_ScoringParametersDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ScoringParametersDecodeErrorZ* o_conv = (LDKCResult_ScoringParametersDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ScoringParametersDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_ScoringParametersDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_ScoringParametersDecodeErrorZ _res_conv = *(LDKCResult_ScoringParametersDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_ScoringParametersDecodeErrorZ_free(_res_conv);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ScorerDecodeErrorZ_ok(uint32_t o) {
+ LDKScorer o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ // Warning: we need a move here but no clone is available for LDKScorer
+ LDKCResult_ScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ScorerDecodeErrorZ), "LDKCResult_ScorerDecodeErrorZ");
+ *ret_conv = CResult_ScorerDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ScorerDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_ScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ScorerDecodeErrorZ), "LDKCResult_ScorerDecodeErrorZ");
+ *ret_conv = CResult_ScorerDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_ScorerDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ScorerDecodeErrorZ* o_conv = (LDKCResult_ScorerDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ScorerDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_ScorerDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_ScorerDecodeErrorZ _res_conv = *(LDKCResult_ScorerDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_ScorerDecodeErrorZ_free(_res_conv);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(uint32_t o) {
+ LDKDelayedPaymentOutputDescriptor o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = DelayedPaymentOutputDescriptor_clone(&o_conv);
+ LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
+ *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
+ *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* o_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res_conv = *(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
+ *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* arg_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(orig & ~1);
+ LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
+ *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(uint32_t o) {
+ LDKStaticPaymentOutputDescriptor o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = StaticPaymentOutputDescriptor_clone(&o_conv);
+ LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
+ *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
+ *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* o_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res_conv = *(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
+ *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* arg_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(orig & ~1);
+ LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
+ *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKSpendableOutputDescriptor o_conv = *(LDKSpendableOutputDescriptor*)(o_ptr);
+ o_conv = SpendableOutputDescriptor_clone((LDKSpendableOutputDescriptor*)(((uint64_t)o) & ~1));
+ LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
+ *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
+ *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_SpendableOutputDescriptorDecodeErrorZ* o_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res_conv = *(LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
+ *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_SpendableOutputDescriptorDecodeErrorZ* arg_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_SpendableOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(orig & ~1);
+ LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
+ *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NoneNoneZ_ok() {
+ LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
+ *ret_conv = CResult_NoneNoneZ_ok();
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NoneNoneZ_err() {
+ LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
+ *ret_conv = CResult_NoneNoneZ_err();
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_NoneNoneZ_is_ok(uint32_t o) {
+ LDKCResult_NoneNoneZ* o_conv = (LDKCResult_NoneNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_NoneNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_NoneNoneZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_NoneNoneZ _res_conv = *(LDKCResult_NoneNoneZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_NoneNoneZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg) {
+ LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
+ *ret_conv = CResult_NoneNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NoneNoneZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NoneNoneZ* arg_conv = (LDKCResult_NoneNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_NoneNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NoneNoneZ_clone(uint32_t orig) {
+ LDKCResult_NoneNoneZ* orig_conv = (LDKCResult_NoneNoneZ*)(orig & ~1);
+ LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
+ *ret_conv = CResult_NoneNoneZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+static inline uint64_t C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR arg) {
+ LDKC2Tuple_SignatureCVec_SignatureZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
+ *ret_conv = C2Tuple_SignatureCVec_SignatureZZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(uint32_t arg) {
+ LDKC2Tuple_SignatureCVec_SignatureZZ* arg_conv = (LDKC2Tuple_SignatureCVec_SignatureZZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_C2Tuple_SignatureCVec_SignatureZZ_clone(uint32_t orig) {
+ LDKC2Tuple_SignatureCVec_SignatureZZ* orig_conv = (LDKC2Tuple_SignatureCVec_SignatureZZ*)(orig & ~1);
+ LDKC2Tuple_SignatureCVec_SignatureZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
+ *ret_conv = C2Tuple_SignatureCVec_SignatureZZ_clone(orig_conv);
+ return ((uint64_t)ret_conv);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_C2Tuple_SignatureCVec_SignatureZZ_new(int8_tArray a, ptrArray b) {
+ LDKSignature a_ref;
+ CHECK(*((uint32_t*)a) == 64);
+ memcpy(a_ref.compact_form, (uint8_t*)(a + 4), 64);
+ LDKCVec_SignatureZ b_constr;
+ b_constr.datalen = *((uint32_t*)b);
+ if (b_constr.datalen > 0)
+ b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
+ else
+ b_constr.data = NULL;
+ int8_tArray* b_vals = (int8_tArray*)(b + 4);
+ for (size_t m = 0; m < b_constr.datalen; m++) {
+ int8_tArray b_conv_12 = b_vals[m];
+ LDKSignature b_conv_12_ref;
+ CHECK(*((uint32_t*)b_conv_12) == 64);
+ memcpy(b_conv_12_ref.compact_form, (uint8_t*)(b_conv_12 + 4), 64);
+ b_constr.data[m] = b_conv_12_ref;
+ }
+ LDKC2Tuple_SignatureCVec_SignatureZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
+ *ret_conv = C2Tuple_SignatureCVec_SignatureZZ_new(a_ref, b_constr);
+ return ((uint64_t)ret_conv);
+}
+
+void __attribute__((visibility("default"))) TS_C2Tuple_SignatureCVec_SignatureZZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKC2Tuple_SignatureCVec_SignatureZZ _res_conv = *(LDKC2Tuple_SignatureCVec_SignatureZZ*)(_res_ptr);
+ FREE((void*)_res);
+ C2Tuple_SignatureCVec_SignatureZZ_free(_res_conv);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKC2Tuple_SignatureCVec_SignatureZZ o_conv = *(LDKC2Tuple_SignatureCVec_SignatureZZ*)(o_ptr);
+ o_conv = C2Tuple_SignatureCVec_SignatureZZ_clone((LDKC2Tuple_SignatureCVec_SignatureZZ*)(((uint64_t)o) & ~1));
+ LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
+ *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err() {
+ LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
+ *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err();
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(uint32_t o) {
+ LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* o_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ _res_conv = *(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR arg) {
+ LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
+ *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(uint32_t arg) {
+ LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* arg_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(uint32_t orig) {
+ LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* orig_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(orig & ~1);
+ LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
+ *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_SignatureNoneZ_ok(int8_tArray o) {
+ LDKSignature o_ref;
+ CHECK(*((uint32_t*)o) == 64);
+ memcpy(o_ref.compact_form, (uint8_t*)(o + 4), 64);
+ LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
+ *ret_conv = CResult_SignatureNoneZ_ok(o_ref);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_SignatureNoneZ_err() {
+ LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
+ *ret_conv = CResult_SignatureNoneZ_err();
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_SignatureNoneZ_is_ok(uint32_t o) {
+ LDKCResult_SignatureNoneZ* o_conv = (LDKCResult_SignatureNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_SignatureNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_SignatureNoneZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_SignatureNoneZ _res_conv = *(LDKCResult_SignatureNoneZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_SignatureNoneZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_SignatureNoneZ_clone_ptr(LDKCResult_SignatureNoneZ *NONNULL_PTR arg) {
+ LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
+ *ret_conv = CResult_SignatureNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_SignatureNoneZ_clone_ptr(uint32_t arg) {
+ LDKCResult_SignatureNoneZ* arg_conv = (LDKCResult_SignatureNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_SignatureNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_SignatureNoneZ_clone(uint32_t orig) {
+ LDKCResult_SignatureNoneZ* orig_conv = (LDKCResult_SignatureNoneZ*)(orig & ~1);
+ LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
+ *ret_conv = CResult_SignatureNoneZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_SignDecodeErrorZ_ok(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKSign o_conv = *(LDKSign*)(o_ptr);
+ LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
+ *ret_conv = CResult_SignDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_SignDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
+ *ret_conv = CResult_SignDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_SignDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_SignDecodeErrorZ* o_conv = (LDKCResult_SignDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_SignDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_SignDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_SignDecodeErrorZ _res_conv = *(LDKCResult_SignDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_SignDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_SignDecodeErrorZ_clone_ptr(LDKCResult_SignDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
+ *ret_conv = CResult_SignDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_SignDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_SignDecodeErrorZ* arg_conv = (LDKCResult_SignDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_SignDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_SignDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_SignDecodeErrorZ* orig_conv = (LDKCResult_SignDecodeErrorZ*)(orig & ~1);
+ LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
+ *ret_conv = CResult_SignDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+void __attribute__((visibility("default"))) TS_CVec_u8Z_free(int8_tArray _res) {
+ LDKCVec_u8Z _res_ref;
+ _res_ref.datalen = *((uint32_t*)_res);
+ _res_ref.data = MALLOC(_res_ref.datalen, "LDKCVec_u8Z Bytes");
+ memcpy(_res_ref.data, (uint8_t*)(_res + 4), _res_ref.datalen);
+ CVec_u8Z_free(_res_ref);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_RecoverableSignatureNoneZ_ok(int8_tArray arg) {
+ LDKRecoverableSignature arg_ref;
+ CHECK(*((uint32_t*)arg) == 68);
+ memcpy(arg_ref.serialized_form, (uint8_t*)(arg + 4), 68);
+ LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
+ *ret_conv = CResult_RecoverableSignatureNoneZ_ok(arg_ref);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_RecoverableSignatureNoneZ_err() {
+ LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
+ *ret_conv = CResult_RecoverableSignatureNoneZ_err();
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_RecoverableSignatureNoneZ_is_ok(uint32_t o) {
+ LDKCResult_RecoverableSignatureNoneZ* o_conv = (LDKCResult_RecoverableSignatureNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_RecoverableSignatureNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_RecoverableSignatureNoneZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_RecoverableSignatureNoneZ _res_conv = *(LDKCResult_RecoverableSignatureNoneZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_RecoverableSignatureNoneZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg) {
+ LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
+ *ret_conv = CResult_RecoverableSignatureNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_RecoverableSignatureNoneZ_clone_ptr(uint32_t arg) {
+ LDKCResult_RecoverableSignatureNoneZ* arg_conv = (LDKCResult_RecoverableSignatureNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_RecoverableSignatureNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_RecoverableSignatureNoneZ_clone(uint32_t orig) {
+ LDKCResult_RecoverableSignatureNoneZ* orig_conv = (LDKCResult_RecoverableSignatureNoneZ*)(orig & ~1);
+ LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
+ *ret_conv = CResult_RecoverableSignatureNoneZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+void __attribute__((visibility("default"))) TS_CVec_CVec_u8ZZ_free(ptrArray _res) {
+ LDKCVec_CVec_u8ZZ _res_constr;
+ _res_constr.datalen = *((uint32_t*)_res);
+ if (_res_constr.datalen > 0)
+ _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKCVec_u8Z), "LDKCVec_CVec_u8ZZ Elements");
+ else
+ _res_constr.data = NULL;
+ int8_tArray* _res_vals = (int8_tArray*)(_res + 4);
+ for (size_t m = 0; m < _res_constr.datalen; m++) {
+ int8_tArray _res_conv_12 = _res_vals[m];
+ LDKCVec_u8Z _res_conv_12_ref;
+ _res_conv_12_ref.datalen = *((uint32_t*)_res_conv_12);
+ _res_conv_12_ref.data = MALLOC(_res_conv_12_ref.datalen, "LDKCVec_u8Z Bytes");
+ memcpy(_res_conv_12_ref.data, (uint8_t*)(_res_conv_12 + 4), _res_conv_12_ref.datalen);
+ _res_constr.data[m] = _res_conv_12_ref;
+ }
+ CVec_CVec_u8ZZ_free(_res_constr);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_CVec_CVec_u8ZZNoneZ_ok(ptrArray o) {
+ LDKCVec_CVec_u8ZZ o_constr;
+ o_constr.datalen = *((uint32_t*)o);
+ if (o_constr.datalen > 0)
+ o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKCVec_u8Z), "LDKCVec_CVec_u8ZZ Elements");
+ else
+ o_constr.data = NULL;
+ int8_tArray* o_vals = (int8_tArray*)(o + 4);
+ for (size_t m = 0; m < o_constr.datalen; m++) {
+ int8_tArray o_conv_12 = o_vals[m];
+ LDKCVec_u8Z o_conv_12_ref;
+ o_conv_12_ref.datalen = *((uint32_t*)o_conv_12);
+ o_conv_12_ref.data = MALLOC(o_conv_12_ref.datalen, "LDKCVec_u8Z Bytes");
+ memcpy(o_conv_12_ref.data, (uint8_t*)(o_conv_12 + 4), o_conv_12_ref.datalen);
+ o_constr.data[m] = o_conv_12_ref;
+ }
+ LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
+ *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_ok(o_constr);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_CVec_CVec_u8ZZNoneZ_err() {
+ LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
+ *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_err();
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_CVec_CVec_u8ZZNoneZ_is_ok(uint32_t o) {
+ LDKCResult_CVec_CVec_u8ZZNoneZ* o_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_CVec_CVec_u8ZZNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_CVec_CVec_u8ZZNoneZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_CVec_CVec_u8ZZNoneZ _res_conv = *(LDKCResult_CVec_CVec_u8ZZNoneZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_CVec_CVec_u8ZZNoneZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR arg) {
+ LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
+ *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(uint32_t arg) {
+ LDKCResult_CVec_CVec_u8ZZNoneZ* arg_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_CVec_CVec_u8ZZNoneZ_clone(uint32_t orig) {
+ LDKCResult_CVec_CVec_u8ZZNoneZ* orig_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)(orig & ~1);
+ LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
+ *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_InMemorySignerDecodeErrorZ_ok(uint32_t o) {
+ LDKInMemorySigner o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = InMemorySigner_clone(&o_conv);
+ LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
+ *ret_conv = CResult_InMemorySignerDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_InMemorySignerDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
+ *ret_conv = CResult_InMemorySignerDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_InMemorySignerDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_InMemorySignerDecodeErrorZ* o_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_InMemorySignerDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_InMemorySignerDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_InMemorySignerDecodeErrorZ _res_conv = *(LDKCResult_InMemorySignerDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_InMemorySignerDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
+ *ret_conv = CResult_InMemorySignerDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_InMemorySignerDecodeErrorZ* arg_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_InMemorySignerDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_InMemorySignerDecodeErrorZ* orig_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)(orig & ~1);
+ LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
+ *ret_conv = CResult_InMemorySignerDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+void __attribute__((visibility("default"))) TS_CVec_TxOutZ_free(uint32_tArray _res) {
+ LDKCVec_TxOutZ _res_constr;
+ _res_constr.datalen = *((uint32_t*)_res);
+ if (_res_constr.datalen > 0)
+ _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKTxOut), "LDKCVec_TxOutZ Elements");
+ else
+ _res_constr.data = NULL;
+ uint32_t* _res_vals = (uint32_t*)(_res + 4);
+ for (size_t h = 0; h < _res_constr.datalen; h++) {
+ uint32_t _res_conv_7 = _res_vals[h];
+ void* _res_conv_7_ptr = (void*)(((uint64_t)_res_conv_7) & ~1);
+ CHECK_ACCESS(_res_conv_7_ptr);
+ LDKTxOut _res_conv_7_conv = *(LDKTxOut*)(_res_conv_7_ptr);
+ FREE((void*)_res_conv_7);
+ _res_constr.data[h] = _res_conv_7_conv;
+ }
+ CVec_TxOutZ_free(_res_constr);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_TransactionNoneZ_ok(int8_tArray o) {
+ LDKTransaction o_ref;
+ o_ref.datalen = *((uint32_t*)o);
+ o_ref.data = MALLOC(o_ref.datalen, "LDKTransaction Bytes");
+ memcpy(o_ref.data, (uint8_t*)(o + 4), o_ref.datalen);
+ o_ref.data_is_owned = true;
+ LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
+ *ret_conv = CResult_TransactionNoneZ_ok(o_ref);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_TransactionNoneZ_err() {
+ LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
+ *ret_conv = CResult_TransactionNoneZ_err();
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_TransactionNoneZ_is_ok(uint32_t o) {
+ LDKCResult_TransactionNoneZ* o_conv = (LDKCResult_TransactionNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_TransactionNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_TransactionNoneZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_TransactionNoneZ _res_conv = *(LDKCResult_TransactionNoneZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_TransactionNoneZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg) {
+ LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
+ *ret_conv = CResult_TransactionNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_TransactionNoneZ_clone_ptr(uint32_t arg) {
+ LDKCResult_TransactionNoneZ* arg_conv = (LDKCResult_TransactionNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_TransactionNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_TransactionNoneZ_clone(uint32_t orig) {
+ LDKCResult_TransactionNoneZ* orig_conv = (LDKCResult_TransactionNoneZ*)(orig & ~1);
+ LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
+ *ret_conv = CResult_TransactionNoneZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+static inline uint64_t C2Tuple_BlockHashChannelMonitorZ_clone_ptr(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR arg) {
+ LDKC2Tuple_BlockHashChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
+ *ret_conv = C2Tuple_BlockHashChannelMonitorZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C2Tuple_BlockHashChannelMonitorZ_clone_ptr(uint32_t arg) {
+ LDKC2Tuple_BlockHashChannelMonitorZ* arg_conv = (LDKC2Tuple_BlockHashChannelMonitorZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_C2Tuple_BlockHashChannelMonitorZ_clone(uint32_t orig) {
+ LDKC2Tuple_BlockHashChannelMonitorZ* orig_conv = (LDKC2Tuple_BlockHashChannelMonitorZ*)(orig & ~1);
+ LDKC2Tuple_BlockHashChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
+ *ret_conv = C2Tuple_BlockHashChannelMonitorZ_clone(orig_conv);
+ return ((uint64_t)ret_conv);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_C2Tuple_BlockHashChannelMonitorZ_new(int8_tArray a, uint32_t b) {
+ LDKThirtyTwoBytes a_ref;
+ CHECK(*((uint32_t*)a) == 32);
+ memcpy(a_ref.data, (uint8_t*)(a + 4), 32);
+ LDKChannelMonitor b_conv;
+ b_conv.inner = (void*)(b & (~1));
+ b_conv.is_owned = (b & 1) || (b == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
+ b_conv = ChannelMonitor_clone(&b_conv);
+ LDKC2Tuple_BlockHashChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
+ *ret_conv = C2Tuple_BlockHashChannelMonitorZ_new(a_ref, b_conv);
+ return ((uint64_t)ret_conv);
+}
+
+void __attribute__((visibility("default"))) TS_C2Tuple_BlockHashChannelMonitorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKC2Tuple_BlockHashChannelMonitorZ _res_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(_res_ptr);
+ FREE((void*)_res);
+ C2Tuple_BlockHashChannelMonitorZ_free(_res_conv);
+}
+
+void __attribute__((visibility("default"))) TS_CVec_C2Tuple_BlockHashChannelMonitorZZ_free(uint32_tArray _res) {
+ LDKCVec_C2Tuple_BlockHashChannelMonitorZZ _res_constr;
+ _res_constr.datalen = *((uint32_t*)_res);
+ if (_res_constr.datalen > 0)
+ _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKCVec_C2Tuple_BlockHashChannelMonitorZZ Elements");
+ else
+ _res_constr.data = NULL;
+ uint32_t* _res_vals = (uint32_t*)(_res + 4);
+ for (size_t j = 0; j < _res_constr.datalen; j++) {
+ uint32_t _res_conv_35 = _res_vals[j];
+ void* _res_conv_35_ptr = (void*)(((uint64_t)_res_conv_35) & ~1);
+ CHECK_ACCESS(_res_conv_35_ptr);
+ LDKC2Tuple_BlockHashChannelMonitorZ _res_conv_35_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(_res_conv_35_ptr);
+ FREE((void*)_res_conv_35);
+ _res_constr.data[j] = _res_conv_35_conv;
+ }
+ CVec_C2Tuple_BlockHashChannelMonitorZZ_free(_res_constr);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_ok(uint32_tArray o) {
+ LDKCVec_C2Tuple_BlockHashChannelMonitorZZ o_constr;
+ o_constr.datalen = *((uint32_t*)o);
+ if (o_constr.datalen > 0)
+ o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKCVec_C2Tuple_BlockHashChannelMonitorZZ Elements");
+ else
+ o_constr.data = NULL;
+ uint32_t* o_vals = (uint32_t*)(o + 4);
+ for (size_t j = 0; j < o_constr.datalen; j++) {
+ uint32_t o_conv_35 = o_vals[j];
+ void* o_conv_35_ptr = (void*)(((uint64_t)o_conv_35) & ~1);
+ CHECK_ACCESS(o_conv_35_ptr);
+ LDKC2Tuple_BlockHashChannelMonitorZ o_conv_35_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(o_conv_35_ptr);
+ o_conv_35_conv = C2Tuple_BlockHashChannelMonitorZ_clone((LDKC2Tuple_BlockHashChannelMonitorZ*)(((uint64_t)o_conv_35) & ~1));
+ o_constr.data[j] = o_conv_35_conv;
+ }
+ LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ), "LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ");
+ *ret_conv = CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_ok(o_constr);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_err(uint32_t e) {
+ LDKIOError e_conv = LDKIOError_from_js(e);
+ LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ), "LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ");
+ *ret_conv = CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_is_ok(uint32_t o) {
+ LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* o_conv = (LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ _res_conv = *(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone_ptr(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ *NONNULL_PTR arg) {
+ LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ), "LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ");
+ *ret_conv = CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* arg_conv = (LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone(uint32_t orig) {
+ LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* orig_conv = (LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)(orig & ~1);
+ LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ), "LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ");
+ *ret_conv = CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_u16Z_some(int16_t o) {
+ LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
+ *ret_copy = COption_u16Z_some(o);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_u16Z_none() {
+ LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
+ *ret_copy = COption_u16Z_none();
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+void __attribute__((visibility("default"))) TS_COption_u16Z_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCOption_u16Z _res_conv = *(LDKCOption_u16Z*)(_res_ptr);
+ FREE((void*)_res);
+ COption_u16Z_free(_res_conv);
+}
+
+static inline uint64_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg) {
+ LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
+ *ret_copy = COption_u16Z_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_COption_u16Z_clone_ptr(uint32_t arg) {
+ LDKCOption_u16Z* arg_conv = (LDKCOption_u16Z*)arg;
+ int64_t ret_val = COption_u16Z_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_u16Z_clone(uint32_t orig) {
+ LDKCOption_u16Z* orig_conv = (LDKCOption_u16Z*)orig;
+ LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
+ *ret_copy = COption_u16Z_clone(orig_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NoneAPIErrorZ_ok() {
+ LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
+ *ret_conv = CResult_NoneAPIErrorZ_ok();
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NoneAPIErrorZ_err(uint32_t e) {
+ void* e_ptr = (void*)(((uint64_t)e) & ~1);
+ CHECK_ACCESS(e_ptr);
+ LDKAPIError e_conv = *(LDKAPIError*)(e_ptr);
+ e_conv = APIError_clone((LDKAPIError*)(((uint64_t)e) & ~1));
+ LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
+ *ret_conv = CResult_NoneAPIErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_NoneAPIErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NoneAPIErrorZ* o_conv = (LDKCResult_NoneAPIErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NoneAPIErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_NoneAPIErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_NoneAPIErrorZ _res_conv = *(LDKCResult_NoneAPIErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_NoneAPIErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
+ *ret_conv = CResult_NoneAPIErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NoneAPIErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NoneAPIErrorZ* arg_conv = (LDKCResult_NoneAPIErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NoneAPIErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NoneAPIErrorZ_clone(uint32_t orig) {
+ LDKCResult_NoneAPIErrorZ* orig_conv = (LDKCResult_NoneAPIErrorZ*)(orig & ~1);
+ LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
+ *ret_conv = CResult_NoneAPIErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+void __attribute__((visibility("default"))) TS_CVec_CResult_NoneAPIErrorZZ_free(uint32_tArray _res) {
+ LDKCVec_CResult_NoneAPIErrorZZ _res_constr;
+ _res_constr.datalen = *((uint32_t*)_res);
+ if (_res_constr.datalen > 0)
+ _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKCResult_NoneAPIErrorZ), "LDKCVec_CResult_NoneAPIErrorZZ Elements");
+ else
+ _res_constr.data = NULL;
+ uint32_t* _res_vals = (uint32_t*)(_res + 4);
+ for (size_t w = 0; w < _res_constr.datalen; w++) {
+ uint32_t _res_conv_22 = _res_vals[w];
+ void* _res_conv_22_ptr = (void*)(((uint64_t)_res_conv_22) & ~1);
+ CHECK_ACCESS(_res_conv_22_ptr);
+ LDKCResult_NoneAPIErrorZ _res_conv_22_conv = *(LDKCResult_NoneAPIErrorZ*)(_res_conv_22_ptr);
+ FREE((void*)_res_conv_22);
+ _res_constr.data[w] = _res_conv_22_conv;
+ }
+ CVec_CResult_NoneAPIErrorZZ_free(_res_constr);
+}
+
+void __attribute__((visibility("default"))) TS_CVec_APIErrorZ_free(uint32_tArray _res) {
+ LDKCVec_APIErrorZ _res_constr;
+ _res_constr.datalen = *((uint32_t*)_res);
+ if (_res_constr.datalen > 0)
+ _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKAPIError), "LDKCVec_APIErrorZ Elements");
+ else
+ _res_constr.data = NULL;
+ uint32_t* _res_vals = (uint32_t*)(_res + 4);
+ for (size_t k = 0; k < _res_constr.datalen; k++) {
+ uint32_t _res_conv_10 = _res_vals[k];
+ void* _res_conv_10_ptr = (void*)(((uint64_t)_res_conv_10) & ~1);
+ CHECK_ACCESS(_res_conv_10_ptr);
+ LDKAPIError _res_conv_10_conv = *(LDKAPIError*)(_res_conv_10_ptr);
+ FREE((void*)_res_conv_10);
+ _res_constr.data[k] = _res_conv_10_conv;
+ }
+ CVec_APIErrorZ_free(_res_constr);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult__u832APIErrorZ_ok(int8_tArray o) {
+ LDKThirtyTwoBytes o_ref;
+ CHECK(*((uint32_t*)o) == 32);
+ memcpy(o_ref.data, (uint8_t*)(o + 4), 32);
+ LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
+ *ret_conv = CResult__u832APIErrorZ_ok(o_ref);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult__u832APIErrorZ_err(uint32_t e) {
+ void* e_ptr = (void*)(((uint64_t)e) & ~1);
+ CHECK_ACCESS(e_ptr);
+ LDKAPIError e_conv = *(LDKAPIError*)(e_ptr);
+ e_conv = APIError_clone((LDKAPIError*)(((uint64_t)e) & ~1));
+ LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
+ *ret_conv = CResult__u832APIErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult__u832APIErrorZ_is_ok(uint32_t o) {
+ LDKCResult__u832APIErrorZ* o_conv = (LDKCResult__u832APIErrorZ*)(o & ~1);
+ jboolean ret_val = CResult__u832APIErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult__u832APIErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult__u832APIErrorZ _res_conv = *(LDKCResult__u832APIErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult__u832APIErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult__u832APIErrorZ_clone_ptr(LDKCResult__u832APIErrorZ *NONNULL_PTR arg) {
+ LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
+ *ret_conv = CResult__u832APIErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult__u832APIErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult__u832APIErrorZ* arg_conv = (LDKCResult__u832APIErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult__u832APIErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult__u832APIErrorZ_clone(uint32_t orig) {
+ LDKCResult__u832APIErrorZ* orig_conv = (LDKCResult__u832APIErrorZ*)(orig & ~1);
+ LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
+ *ret_conv = CResult__u832APIErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_PaymentIdPaymentSendFailureZ_ok(int8_tArray o) {
+ LDKThirtyTwoBytes o_ref;
+ CHECK(*((uint32_t*)o) == 32);
+ memcpy(o_ref.data, (uint8_t*)(o + 4), 32);
+ LDKCResult_PaymentIdPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentSendFailureZ), "LDKCResult_PaymentIdPaymentSendFailureZ");
+ *ret_conv = CResult_PaymentIdPaymentSendFailureZ_ok(o_ref);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_PaymentIdPaymentSendFailureZ_err(uint32_t e) {
+ void* e_ptr = (void*)(((uint64_t)e) & ~1);
+ CHECK_ACCESS(e_ptr);
+ LDKPaymentSendFailure e_conv = *(LDKPaymentSendFailure*)(e_ptr);
+ e_conv = PaymentSendFailure_clone((LDKPaymentSendFailure*)(((uint64_t)e) & ~1));
+ LDKCResult_PaymentIdPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentSendFailureZ), "LDKCResult_PaymentIdPaymentSendFailureZ");
+ *ret_conv = CResult_PaymentIdPaymentSendFailureZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_PaymentIdPaymentSendFailureZ_is_ok(uint32_t o) {
+ LDKCResult_PaymentIdPaymentSendFailureZ* o_conv = (LDKCResult_PaymentIdPaymentSendFailureZ*)(o & ~1);
+ jboolean ret_val = CResult_PaymentIdPaymentSendFailureZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_PaymentIdPaymentSendFailureZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_PaymentIdPaymentSendFailureZ _res_conv = *(LDKCResult_PaymentIdPaymentSendFailureZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_PaymentIdPaymentSendFailureZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_PaymentIdPaymentSendFailureZ_clone_ptr(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR arg) {
+ LDKCResult_PaymentIdPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentSendFailureZ), "LDKCResult_PaymentIdPaymentSendFailureZ");
+ *ret_conv = CResult_PaymentIdPaymentSendFailureZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_PaymentIdPaymentSendFailureZ_clone_ptr(uint32_t arg) {
+ LDKCResult_PaymentIdPaymentSendFailureZ* arg_conv = (LDKCResult_PaymentIdPaymentSendFailureZ*)(arg & ~1);
+ int64_t ret_val = CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_PaymentIdPaymentSendFailureZ_clone(uint32_t orig) {
+ LDKCResult_PaymentIdPaymentSendFailureZ* orig_conv = (LDKCResult_PaymentIdPaymentSendFailureZ*)(orig & ~1);
+ LDKCResult_PaymentIdPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentSendFailureZ), "LDKCResult_PaymentIdPaymentSendFailureZ");
+ *ret_conv = CResult_PaymentIdPaymentSendFailureZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NonePaymentSendFailureZ_ok() {
+ LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
+ *ret_conv = CResult_NonePaymentSendFailureZ_ok();
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NonePaymentSendFailureZ_err(uint32_t e) {
+ void* e_ptr = (void*)(((uint64_t)e) & ~1);
+ CHECK_ACCESS(e_ptr);
+ LDKPaymentSendFailure e_conv = *(LDKPaymentSendFailure*)(e_ptr);
+ e_conv = PaymentSendFailure_clone((LDKPaymentSendFailure*)(((uint64_t)e) & ~1));
+ LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
+ *ret_conv = CResult_NonePaymentSendFailureZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_NonePaymentSendFailureZ_is_ok(uint32_t o) {
+ LDKCResult_NonePaymentSendFailureZ* o_conv = (LDKCResult_NonePaymentSendFailureZ*)(o & ~1);
+ jboolean ret_val = CResult_NonePaymentSendFailureZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_NonePaymentSendFailureZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_NonePaymentSendFailureZ _res_conv = *(LDKCResult_NonePaymentSendFailureZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_NonePaymentSendFailureZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_NonePaymentSendFailureZ_clone_ptr(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR arg) {
+ LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
+ *ret_conv = CResult_NonePaymentSendFailureZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NonePaymentSendFailureZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NonePaymentSendFailureZ* arg_conv = (LDKCResult_NonePaymentSendFailureZ*)(arg & ~1);
+ int64_t ret_val = CResult_NonePaymentSendFailureZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NonePaymentSendFailureZ_clone(uint32_t orig) {
+ LDKCResult_NonePaymentSendFailureZ* orig_conv = (LDKCResult_NonePaymentSendFailureZ*)(orig & ~1);
+ LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
+ *ret_conv = CResult_NonePaymentSendFailureZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+static inline uint64_t C2Tuple_PaymentHashPaymentIdZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR arg) {
+ LDKC2Tuple_PaymentHashPaymentIdZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentIdZ), "LDKC2Tuple_PaymentHashPaymentIdZ");
+ *ret_conv = C2Tuple_PaymentHashPaymentIdZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C2Tuple_PaymentHashPaymentIdZ_clone_ptr(uint32_t arg) {
+ LDKC2Tuple_PaymentHashPaymentIdZ* arg_conv = (LDKC2Tuple_PaymentHashPaymentIdZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_C2Tuple_PaymentHashPaymentIdZ_clone(uint32_t orig) {
+ LDKC2Tuple_PaymentHashPaymentIdZ* orig_conv = (LDKC2Tuple_PaymentHashPaymentIdZ*)(orig & ~1);
+ LDKC2Tuple_PaymentHashPaymentIdZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentIdZ), "LDKC2Tuple_PaymentHashPaymentIdZ");
+ *ret_conv = C2Tuple_PaymentHashPaymentIdZ_clone(orig_conv);
+ return ((uint64_t)ret_conv);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_C2Tuple_PaymentHashPaymentIdZ_new(int8_tArray a, int8_tArray b) {
+ LDKThirtyTwoBytes a_ref;
+ CHECK(*((uint32_t*)a) == 32);
+ memcpy(a_ref.data, (uint8_t*)(a + 4), 32);
+ LDKThirtyTwoBytes b_ref;
+ CHECK(*((uint32_t*)b) == 32);
+ memcpy(b_ref.data, (uint8_t*)(b + 4), 32);
+ LDKC2Tuple_PaymentHashPaymentIdZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentIdZ), "LDKC2Tuple_PaymentHashPaymentIdZ");
+ *ret_conv = C2Tuple_PaymentHashPaymentIdZ_new(a_ref, b_ref);
+ return ((uint64_t)ret_conv);
+}
+
+void __attribute__((visibility("default"))) TS_C2Tuple_PaymentHashPaymentIdZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKC2Tuple_PaymentHashPaymentIdZ _res_conv = *(LDKC2Tuple_PaymentHashPaymentIdZ*)(_res_ptr);
+ FREE((void*)_res);
+ C2Tuple_PaymentHashPaymentIdZ_free(_res_conv);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKC2Tuple_PaymentHashPaymentIdZ o_conv = *(LDKC2Tuple_PaymentHashPaymentIdZ*)(o_ptr);
+ o_conv = C2Tuple_PaymentHashPaymentIdZ_clone((LDKC2Tuple_PaymentHashPaymentIdZ*)(((uint64_t)o) & ~1));
+ LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ");
+ *ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(uint32_t e) {
+ void* e_ptr = (void*)(((uint64_t)e) & ~1);
+ CHECK_ACCESS(e_ptr);
+ LDKPaymentSendFailure e_conv = *(LDKPaymentSendFailure*)(e_ptr);
+ e_conv = PaymentSendFailure_clone((LDKPaymentSendFailure*)(((uint64_t)e) & ~1));
+ LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ");
+ *ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(uint32_t o) {
+ LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* o_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)(o & ~1);
+ jboolean ret_val = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ _res_conv = *(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR arg) {
+ LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ");
+ *ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(uint32_t arg) {
+ LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* arg_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)(arg & ~1);
+ int64_t ret_val = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(uint32_t orig) {
+ LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* orig_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)(orig & ~1);
+ LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ");
+ *ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+void __attribute__((visibility("default"))) TS_CVec_NetAddressZ_free(uint32_tArray _res) {
+ LDKCVec_NetAddressZ _res_constr;
+ _res_constr.datalen = *((uint32_t*)_res);
+ if (_res_constr.datalen > 0)
+ _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
+ else
+ _res_constr.data = NULL;
+ uint32_t* _res_vals = (uint32_t*)(_res + 4);
+ for (size_t m = 0; m < _res_constr.datalen; m++) {
+ uint32_t _res_conv_12 = _res_vals[m];
+ void* _res_conv_12_ptr = (void*)(((uint64_t)_res_conv_12) & ~1);
+ CHECK_ACCESS(_res_conv_12_ptr);
+ LDKNetAddress _res_conv_12_conv = *(LDKNetAddress*)(_res_conv_12_ptr);
+ FREE((void*)_res_conv_12);
+ _res_constr.data[m] = _res_conv_12_conv;
+ }
+ CVec_NetAddressZ_free(_res_constr);
+}
+
+static inline uint64_t C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR arg) {
+ LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
+ *ret_conv = C2Tuple_PaymentHashPaymentSecretZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(uint32_t arg) {
+ LDKC2Tuple_PaymentHashPaymentSecretZ* arg_conv = (LDKC2Tuple_PaymentHashPaymentSecretZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_C2Tuple_PaymentHashPaymentSecretZ_clone(uint32_t orig) {
+ LDKC2Tuple_PaymentHashPaymentSecretZ* orig_conv = (LDKC2Tuple_PaymentHashPaymentSecretZ*)(orig & ~1);
+ LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
+ *ret_conv = C2Tuple_PaymentHashPaymentSecretZ_clone(orig_conv);
+ return ((uint64_t)ret_conv);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_C2Tuple_PaymentHashPaymentSecretZ_new(int8_tArray a, int8_tArray b) {
+ LDKThirtyTwoBytes a_ref;
+ CHECK(*((uint32_t*)a) == 32);
+ memcpy(a_ref.data, (uint8_t*)(a + 4), 32);
+ LDKThirtyTwoBytes b_ref;
+ CHECK(*((uint32_t*)b) == 32);
+ memcpy(b_ref.data, (uint8_t*)(b + 4), 32);
+ LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
+ *ret_conv = C2Tuple_PaymentHashPaymentSecretZ_new(a_ref, b_ref);
+ return ((uint64_t)ret_conv);
+}
+
+void __attribute__((visibility("default"))) TS_C2Tuple_PaymentHashPaymentSecretZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKC2Tuple_PaymentHashPaymentSecretZ _res_conv = *(LDKC2Tuple_PaymentHashPaymentSecretZ*)(_res_ptr);
+ FREE((void*)_res);
+ C2Tuple_PaymentHashPaymentSecretZ_free(_res_conv);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_PaymentSecretAPIErrorZ_ok(int8_tArray o) {
+ LDKThirtyTwoBytes o_ref;
+ CHECK(*((uint32_t*)o) == 32);
+ memcpy(o_ref.data, (uint8_t*)(o + 4), 32);
+ LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
+ *ret_conv = CResult_PaymentSecretAPIErrorZ_ok(o_ref);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_PaymentSecretAPIErrorZ_err(uint32_t e) {
+ void* e_ptr = (void*)(((uint64_t)e) & ~1);
+ CHECK_ACCESS(e_ptr);
+ LDKAPIError e_conv = *(LDKAPIError*)(e_ptr);
+ e_conv = APIError_clone((LDKAPIError*)(((uint64_t)e) & ~1));
+ LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
+ *ret_conv = CResult_PaymentSecretAPIErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_PaymentSecretAPIErrorZ_is_ok(uint32_t o) {
+ LDKCResult_PaymentSecretAPIErrorZ* o_conv = (LDKCResult_PaymentSecretAPIErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PaymentSecretAPIErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_PaymentSecretAPIErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_PaymentSecretAPIErrorZ _res_conv = *(LDKCResult_PaymentSecretAPIErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_PaymentSecretAPIErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_PaymentSecretAPIErrorZ_clone_ptr(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
+ *ret_conv = CResult_PaymentSecretAPIErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_PaymentSecretAPIErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_PaymentSecretAPIErrorZ* arg_conv = (LDKCResult_PaymentSecretAPIErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PaymentSecretAPIErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_PaymentSecretAPIErrorZ_clone(uint32_t orig) {
+ LDKCResult_PaymentSecretAPIErrorZ* orig_conv = (LDKCResult_PaymentSecretAPIErrorZ*)(orig & ~1);
+ LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
+ *ret_conv = CResult_PaymentSecretAPIErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+void __attribute__((visibility("default"))) TS_CVec_ChannelMonitorZ_free(uint32_tArray _res) {
+ LDKCVec_ChannelMonitorZ _res_constr;
+ _res_constr.datalen = *((uint32_t*)_res);
+ if (_res_constr.datalen > 0)
+ _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKChannelMonitor), "LDKCVec_ChannelMonitorZ Elements");
+ else
+ _res_constr.data = NULL;
+ uint32_t* _res_vals = (uint32_t*)(_res + 4);
+ for (size_t q = 0; q < _res_constr.datalen; q++) {
+ uint32_t _res_conv_16 = _res_vals[q];
+ LDKChannelMonitor _res_conv_16_conv;
+ _res_conv_16_conv.inner = (void*)(_res_conv_16 & (~1));
+ _res_conv_16_conv.is_owned = (_res_conv_16 & 1) || (_res_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_16_conv);
+ _res_constr.data[q] = _res_conv_16_conv;
+ }
+ CVec_ChannelMonitorZ_free(_res_constr);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_C2Tuple_BlockHashChannelManagerZ_new(int8_tArray a, uint32_t b) {
+ LDKThirtyTwoBytes a_ref;
+ CHECK(*((uint32_t*)a) == 32);
+ memcpy(a_ref.data, (uint8_t*)(a + 4), 32);
+ LDKChannelManager b_conv;
+ b_conv.inner = (void*)(b & (~1));
+ b_conv.is_owned = (b & 1) || (b == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
+ // Warning: we need a move here but no clone is available for LDKChannelManager
+ LDKC2Tuple_BlockHashChannelManagerZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelManagerZ), "LDKC2Tuple_BlockHashChannelManagerZ");
+ *ret_conv = C2Tuple_BlockHashChannelManagerZ_new(a_ref, b_conv);
+ return ((uint64_t)ret_conv);
+}
+
+void __attribute__((visibility("default"))) TS_C2Tuple_BlockHashChannelManagerZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKC2Tuple_BlockHashChannelManagerZ _res_conv = *(LDKC2Tuple_BlockHashChannelManagerZ*)(_res_ptr);
+ FREE((void*)_res);
+ C2Tuple_BlockHashChannelManagerZ_free(_res_conv);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKC2Tuple_BlockHashChannelManagerZ o_conv = *(LDKC2Tuple_BlockHashChannelManagerZ*)(o_ptr);
+ // Warning: we may need a move here but no clone is available for LDKC2Tuple_BlockHashChannelManagerZ
+ LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ");
+ *ret_conv = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ");
+ *ret_conv = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* o_conv = (LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res_conv = *(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res_conv);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelConfigDecodeErrorZ_ok(uint32_t o) {
+ LDKChannelConfig o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = ChannelConfig_clone(&o_conv);
+ LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
+ *ret_conv = CResult_ChannelConfigDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelConfigDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
+ *ret_conv = CResult_ChannelConfigDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_ChannelConfigDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ChannelConfigDecodeErrorZ* o_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelConfigDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_ChannelConfigDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_ChannelConfigDecodeErrorZ _res_conv = *(LDKCResult_ChannelConfigDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_ChannelConfigDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_ChannelConfigDecodeErrorZ_clone_ptr(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
+ *ret_conv = CResult_ChannelConfigDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ChannelConfigDecodeErrorZ* arg_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelConfigDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_ChannelConfigDecodeErrorZ* orig_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)(orig & ~1);
+ LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
+ *ret_conv = CResult_ChannelConfigDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_OutPointDecodeErrorZ_ok(uint32_t o) {
+ LDKOutPoint o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = OutPoint_clone(&o_conv);
+ LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
+ *ret_conv = CResult_OutPointDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_OutPointDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
+ *ret_conv = CResult_OutPointDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_OutPointDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_OutPointDecodeErrorZ* o_conv = (LDKCResult_OutPointDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_OutPointDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_OutPointDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_OutPointDecodeErrorZ _res_conv = *(LDKCResult_OutPointDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_OutPointDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_OutPointDecodeErrorZ_clone_ptr(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
+ *ret_conv = CResult_OutPointDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_OutPointDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_OutPointDecodeErrorZ* arg_conv = (LDKCResult_OutPointDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_OutPointDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_OutPointDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_OutPointDecodeErrorZ* orig_conv = (LDKCResult_OutPointDecodeErrorZ*)(orig & ~1);
+ LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
+ *ret_conv = CResult_OutPointDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_TypeZ_some(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKType o_conv = *(LDKType*)(o_ptr);
+ LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
+ *ret_copy = COption_TypeZ_some(o_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_TypeZ_none() {
+ LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
+ *ret_copy = COption_TypeZ_none();
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+void __attribute__((visibility("default"))) TS_COption_TypeZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCOption_TypeZ _res_conv = *(LDKCOption_TypeZ*)(_res_ptr);
+ FREE((void*)_res);
+ COption_TypeZ_free(_res_conv);
+}
+
+static inline uint64_t COption_TypeZ_clone_ptr(LDKCOption_TypeZ *NONNULL_PTR arg) {
+ LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
+ *ret_copy = COption_TypeZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_COption_TypeZ_clone_ptr(uint32_t arg) {
+ LDKCOption_TypeZ* arg_conv = (LDKCOption_TypeZ*)arg;
+ int64_t ret_val = COption_TypeZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_TypeZ_clone(uint32_t orig) {
+ LDKCOption_TypeZ* orig_conv = (LDKCOption_TypeZ*)orig;
+ LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
+ *ret_copy = COption_TypeZ_clone(orig_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_TypeZDecodeErrorZ_ok(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKCOption_TypeZ o_conv = *(LDKCOption_TypeZ*)(o_ptr);
+ o_conv = COption_TypeZ_clone((LDKCOption_TypeZ*)(((uint64_t)o) & ~1));
+ LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
+ *ret_conv = CResult_COption_TypeZDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_TypeZDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
+ *ret_conv = CResult_COption_TypeZDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_COption_TypeZDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_COption_TypeZDecodeErrorZ* o_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_COption_TypeZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_COption_TypeZDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_COption_TypeZDecodeErrorZ _res_conv = *(LDKCResult_COption_TypeZDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_COption_TypeZDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_COption_TypeZDecodeErrorZ_clone_ptr(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
+ *ret_conv = CResult_COption_TypeZDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_COption_TypeZDecodeErrorZ* arg_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_TypeZDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_COption_TypeZDecodeErrorZ* orig_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)(orig & ~1);
+ LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
+ *ret_conv = CResult_COption_TypeZDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_PaymentIdPaymentErrorZ_ok(int8_tArray o) {
+ LDKThirtyTwoBytes o_ref;
+ CHECK(*((uint32_t*)o) == 32);
+ memcpy(o_ref.data, (uint8_t*)(o + 4), 32);
+ LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
+ *ret_conv = CResult_PaymentIdPaymentErrorZ_ok(o_ref);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_PaymentIdPaymentErrorZ_err(uint32_t e) {
+ void* e_ptr = (void*)(((uint64_t)e) & ~1);
+ CHECK_ACCESS(e_ptr);
+ LDKPaymentError e_conv = *(LDKPaymentError*)(e_ptr);
+ e_conv = PaymentError_clone((LDKPaymentError*)(((uint64_t)e) & ~1));
+ LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
+ *ret_conv = CResult_PaymentIdPaymentErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_PaymentIdPaymentErrorZ_is_ok(uint32_t o) {
+ LDKCResult_PaymentIdPaymentErrorZ* o_conv = (LDKCResult_PaymentIdPaymentErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PaymentIdPaymentErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_PaymentIdPaymentErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_PaymentIdPaymentErrorZ _res_conv = *(LDKCResult_PaymentIdPaymentErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_PaymentIdPaymentErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_PaymentIdPaymentErrorZ_clone_ptr(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
+ *ret_conv = CResult_PaymentIdPaymentErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_PaymentIdPaymentErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_PaymentIdPaymentErrorZ* arg_conv = (LDKCResult_PaymentIdPaymentErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PaymentIdPaymentErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_PaymentIdPaymentErrorZ_clone(uint32_t orig) {
+ LDKCResult_PaymentIdPaymentErrorZ* orig_conv = (LDKCResult_PaymentIdPaymentErrorZ*)(orig & ~1);
+ LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
+ *ret_conv = CResult_PaymentIdPaymentErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_SiPrefixNoneZ_ok(uint32_t o) {
+ LDKSiPrefix o_conv = LDKSiPrefix_from_js(o);
+ LDKCResult_SiPrefixNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixNoneZ), "LDKCResult_SiPrefixNoneZ");
+ *ret_conv = CResult_SiPrefixNoneZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_SiPrefixNoneZ_err() {
+ LDKCResult_SiPrefixNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixNoneZ), "LDKCResult_SiPrefixNoneZ");
+ *ret_conv = CResult_SiPrefixNoneZ_err();
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_SiPrefixNoneZ_is_ok(uint32_t o) {
+ LDKCResult_SiPrefixNoneZ* o_conv = (LDKCResult_SiPrefixNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_SiPrefixNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_SiPrefixNoneZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_SiPrefixNoneZ _res_conv = *(LDKCResult_SiPrefixNoneZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_SiPrefixNoneZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_SiPrefixNoneZ_clone_ptr(LDKCResult_SiPrefixNoneZ *NONNULL_PTR arg) {
+ LDKCResult_SiPrefixNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixNoneZ), "LDKCResult_SiPrefixNoneZ");
+ *ret_conv = CResult_SiPrefixNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_SiPrefixNoneZ_clone_ptr(uint32_t arg) {
+ LDKCResult_SiPrefixNoneZ* arg_conv = (LDKCResult_SiPrefixNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_SiPrefixNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_SiPrefixNoneZ_clone(uint32_t orig) {
+ LDKCResult_SiPrefixNoneZ* orig_conv = (LDKCResult_SiPrefixNoneZ*)(orig & ~1);
+ LDKCResult_SiPrefixNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixNoneZ), "LDKCResult_SiPrefixNoneZ");
+ *ret_conv = CResult_SiPrefixNoneZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_InvoiceNoneZ_ok(uint32_t o) {
+ LDKInvoice o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = Invoice_clone(&o_conv);
+ LDKCResult_InvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceNoneZ), "LDKCResult_InvoiceNoneZ");
+ *ret_conv = CResult_InvoiceNoneZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_InvoiceNoneZ_err() {
+ LDKCResult_InvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceNoneZ), "LDKCResult_InvoiceNoneZ");
+ *ret_conv = CResult_InvoiceNoneZ_err();
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_InvoiceNoneZ_is_ok(uint32_t o) {
+ LDKCResult_InvoiceNoneZ* o_conv = (LDKCResult_InvoiceNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_InvoiceNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_InvoiceNoneZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_InvoiceNoneZ _res_conv = *(LDKCResult_InvoiceNoneZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_InvoiceNoneZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_InvoiceNoneZ_clone_ptr(LDKCResult_InvoiceNoneZ *NONNULL_PTR arg) {
+ LDKCResult_InvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceNoneZ), "LDKCResult_InvoiceNoneZ");
+ *ret_conv = CResult_InvoiceNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_InvoiceNoneZ_clone_ptr(uint32_t arg) {
+ LDKCResult_InvoiceNoneZ* arg_conv = (LDKCResult_InvoiceNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_InvoiceNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_InvoiceNoneZ_clone(uint32_t orig) {
+ LDKCResult_InvoiceNoneZ* orig_conv = (LDKCResult_InvoiceNoneZ*)(orig & ~1);
+ LDKCResult_InvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceNoneZ), "LDKCResult_InvoiceNoneZ");
+ *ret_conv = CResult_InvoiceNoneZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_SignedRawInvoiceNoneZ_ok(uint32_t o) {
+ LDKSignedRawInvoice o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = SignedRawInvoice_clone(&o_conv);
+ LDKCResult_SignedRawInvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceNoneZ), "LDKCResult_SignedRawInvoiceNoneZ");
+ *ret_conv = CResult_SignedRawInvoiceNoneZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_SignedRawInvoiceNoneZ_err() {
+ LDKCResult_SignedRawInvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceNoneZ), "LDKCResult_SignedRawInvoiceNoneZ");
+ *ret_conv = CResult_SignedRawInvoiceNoneZ_err();
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_SignedRawInvoiceNoneZ_is_ok(uint32_t o) {
+ LDKCResult_SignedRawInvoiceNoneZ* o_conv = (LDKCResult_SignedRawInvoiceNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_SignedRawInvoiceNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_SignedRawInvoiceNoneZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_SignedRawInvoiceNoneZ _res_conv = *(LDKCResult_SignedRawInvoiceNoneZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_SignedRawInvoiceNoneZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_SignedRawInvoiceNoneZ_clone_ptr(LDKCResult_SignedRawInvoiceNoneZ *NONNULL_PTR arg) {
+ LDKCResult_SignedRawInvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceNoneZ), "LDKCResult_SignedRawInvoiceNoneZ");
+ *ret_conv = CResult_SignedRawInvoiceNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_SignedRawInvoiceNoneZ_clone_ptr(uint32_t arg) {
+ LDKCResult_SignedRawInvoiceNoneZ* arg_conv = (LDKCResult_SignedRawInvoiceNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_SignedRawInvoiceNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_SignedRawInvoiceNoneZ_clone(uint32_t orig) {
+ LDKCResult_SignedRawInvoiceNoneZ* orig_conv = (LDKCResult_SignedRawInvoiceNoneZ*)(orig & ~1);
+ LDKCResult_SignedRawInvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceNoneZ), "LDKCResult_SignedRawInvoiceNoneZ");
+ *ret_conv = CResult_SignedRawInvoiceNoneZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+static inline uint64_t C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR arg) {
+ LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
+ *ret_conv = C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(uint32_t arg) {
+ LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* arg_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(arg & ~1);
+ int64_t ret_val = C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(uint32_t orig) {
+ LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* orig_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(orig & ~1);
+ LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
+ *ret_conv = C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig_conv);
+ return ((uint64_t)ret_conv);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(uint32_t a, int8_tArray b, uint32_t c) {
+ LDKRawInvoice a_conv;
+ a_conv.inner = (void*)(a & (~1));
+ a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
+ a_conv = RawInvoice_clone(&a_conv);
+ LDKThirtyTwoBytes b_ref;
+ CHECK(*((uint32_t*)b) == 32);
+ memcpy(b_ref.data, (uint8_t*)(b + 4), 32);
+ LDKInvoiceSignature c_conv;
+ c_conv.inner = (void*)(c & (~1));
+ c_conv.is_owned = (c & 1) || (c == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(c_conv);
+ c_conv = InvoiceSignature_clone(&c_conv);
+ LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
+ *ret_conv = C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a_conv, b_ref, c_conv);
+ return ((uint64_t)ret_conv);
+}
+
+void __attribute__((visibility("default"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ _res_conv = *(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(_res_ptr);
+ FREE((void*)_res);
+ C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res_conv);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_PayeePubKeyErrorZ_ok(uint32_t o) {
+ LDKPayeePubKey o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = PayeePubKey_clone(&o_conv);
+ LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
+ *ret_conv = CResult_PayeePubKeyErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_PayeePubKeyErrorZ_err(uint32_t e) {
+ LDKSecp256k1Error e_conv = LDKSecp256k1Error_from_js(e);
+ LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
+ *ret_conv = CResult_PayeePubKeyErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_PayeePubKeyErrorZ_is_ok(uint32_t o) {
+ LDKCResult_PayeePubKeyErrorZ* o_conv = (LDKCResult_PayeePubKeyErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PayeePubKeyErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_PayeePubKeyErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_PayeePubKeyErrorZ _res_conv = *(LDKCResult_PayeePubKeyErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_PayeePubKeyErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_PayeePubKeyErrorZ_clone_ptr(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
+ *ret_conv = CResult_PayeePubKeyErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_PayeePubKeyErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_PayeePubKeyErrorZ* arg_conv = (LDKCResult_PayeePubKeyErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PayeePubKeyErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_PayeePubKeyErrorZ_clone(uint32_t orig) {
+ LDKCResult_PayeePubKeyErrorZ* orig_conv = (LDKCResult_PayeePubKeyErrorZ*)(orig & ~1);
+ LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
+ *ret_conv = CResult_PayeePubKeyErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+void __attribute__((visibility("default"))) TS_CVec_PrivateRouteZ_free(uint32_tArray _res) {
+ LDKCVec_PrivateRouteZ _res_constr;
+ _res_constr.datalen = *((uint32_t*)_res);
+ if (_res_constr.datalen > 0)
+ _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKPrivateRoute), "LDKCVec_PrivateRouteZ Elements");
+ else
+ _res_constr.data = NULL;
+ uint32_t* _res_vals = (uint32_t*)(_res + 4);
+ for (size_t o = 0; o < _res_constr.datalen; o++) {
+ uint32_t _res_conv_14 = _res_vals[o];
+ LDKPrivateRoute _res_conv_14_conv;
+ _res_conv_14_conv.inner = (void*)(_res_conv_14 & (~1));
+ _res_conv_14_conv.is_owned = (_res_conv_14 & 1) || (_res_conv_14 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_14_conv);
+ _res_constr.data[o] = _res_conv_14_conv;
+ }
+ CVec_PrivateRouteZ_free(_res_constr);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_PositiveTimestampCreationErrorZ_ok(uint32_t o) {
+ LDKPositiveTimestamp o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = PositiveTimestamp_clone(&o_conv);
+ LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
+ *ret_conv = CResult_PositiveTimestampCreationErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_PositiveTimestampCreationErrorZ_err(uint32_t e) {
+ LDKCreationError e_conv = LDKCreationError_from_js(e);
+ LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
+ *ret_conv = CResult_PositiveTimestampCreationErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_PositiveTimestampCreationErrorZ_is_ok(uint32_t o) {
+ LDKCResult_PositiveTimestampCreationErrorZ* o_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PositiveTimestampCreationErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_PositiveTimestampCreationErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_PositiveTimestampCreationErrorZ _res_conv = *(LDKCResult_PositiveTimestampCreationErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_PositiveTimestampCreationErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_PositiveTimestampCreationErrorZ_clone_ptr(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
+ *ret_conv = CResult_PositiveTimestampCreationErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_PositiveTimestampCreationErrorZ* arg_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_PositiveTimestampCreationErrorZ_clone(uint32_t orig) {
+ LDKCResult_PositiveTimestampCreationErrorZ* orig_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)(orig & ~1);
+ LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
+ *ret_conv = CResult_PositiveTimestampCreationErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NoneSemanticErrorZ_ok() {
+ LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
+ *ret_conv = CResult_NoneSemanticErrorZ_ok();
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NoneSemanticErrorZ_err(uint32_t e) {
+ LDKSemanticError e_conv = LDKSemanticError_from_js(e);
+ LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
+ *ret_conv = CResult_NoneSemanticErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_NoneSemanticErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NoneSemanticErrorZ* o_conv = (LDKCResult_NoneSemanticErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NoneSemanticErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_NoneSemanticErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_NoneSemanticErrorZ _res_conv = *(LDKCResult_NoneSemanticErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_NoneSemanticErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_NoneSemanticErrorZ_clone_ptr(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
+ *ret_conv = CResult_NoneSemanticErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NoneSemanticErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NoneSemanticErrorZ* arg_conv = (LDKCResult_NoneSemanticErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NoneSemanticErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NoneSemanticErrorZ_clone(uint32_t orig) {
+ LDKCResult_NoneSemanticErrorZ* orig_conv = (LDKCResult_NoneSemanticErrorZ*)(orig & ~1);
+ LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
+ *ret_conv = CResult_NoneSemanticErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_InvoiceSemanticErrorZ_ok(uint32_t o) {
+ LDKInvoice o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = Invoice_clone(&o_conv);
+ LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
+ *ret_conv = CResult_InvoiceSemanticErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_InvoiceSemanticErrorZ_err(uint32_t e) {
+ LDKSemanticError e_conv = LDKSemanticError_from_js(e);
+ LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
+ *ret_conv = CResult_InvoiceSemanticErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_InvoiceSemanticErrorZ_is_ok(uint32_t o) {
+ LDKCResult_InvoiceSemanticErrorZ* o_conv = (LDKCResult_InvoiceSemanticErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_InvoiceSemanticErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_InvoiceSemanticErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_InvoiceSemanticErrorZ _res_conv = *(LDKCResult_InvoiceSemanticErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_InvoiceSemanticErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_InvoiceSemanticErrorZ_clone_ptr(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR arg) {
+ LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
+ *ret_conv = CResult_InvoiceSemanticErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_InvoiceSemanticErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_InvoiceSemanticErrorZ* arg_conv = (LDKCResult_InvoiceSemanticErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_InvoiceSemanticErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_InvoiceSemanticErrorZ_clone(uint32_t orig) {
+ LDKCResult_InvoiceSemanticErrorZ* orig_conv = (LDKCResult_InvoiceSemanticErrorZ*)(orig & ~1);
+ LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
+ *ret_conv = CResult_InvoiceSemanticErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_DescriptionCreationErrorZ_ok(uint32_t o) {
+ LDKDescription o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = Description_clone(&o_conv);
+ LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
+ *ret_conv = CResult_DescriptionCreationErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_DescriptionCreationErrorZ_err(uint32_t e) {
+ LDKCreationError e_conv = LDKCreationError_from_js(e);
+ LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
+ *ret_conv = CResult_DescriptionCreationErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_DescriptionCreationErrorZ_is_ok(uint32_t o) {
+ LDKCResult_DescriptionCreationErrorZ* o_conv = (LDKCResult_DescriptionCreationErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_DescriptionCreationErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_DescriptionCreationErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_DescriptionCreationErrorZ _res_conv = *(LDKCResult_DescriptionCreationErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_DescriptionCreationErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_DescriptionCreationErrorZ_clone_ptr(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR arg) {
+ LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
+ *ret_conv = CResult_DescriptionCreationErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_DescriptionCreationErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_DescriptionCreationErrorZ* arg_conv = (LDKCResult_DescriptionCreationErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_DescriptionCreationErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_DescriptionCreationErrorZ_clone(uint32_t orig) {
+ LDKCResult_DescriptionCreationErrorZ* orig_conv = (LDKCResult_DescriptionCreationErrorZ*)(orig & ~1);
+ LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
+ *ret_conv = CResult_DescriptionCreationErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ExpiryTimeCreationErrorZ_ok(uint32_t o) {
+ LDKExpiryTime o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = ExpiryTime_clone(&o_conv);
+ LDKCResult_ExpiryTimeCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ExpiryTimeCreationErrorZ), "LDKCResult_ExpiryTimeCreationErrorZ");
+ *ret_conv = CResult_ExpiryTimeCreationErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ExpiryTimeCreationErrorZ_err(uint32_t e) {
+ LDKCreationError e_conv = LDKCreationError_from_js(e);
+ LDKCResult_ExpiryTimeCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ExpiryTimeCreationErrorZ), "LDKCResult_ExpiryTimeCreationErrorZ");
+ *ret_conv = CResult_ExpiryTimeCreationErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_ExpiryTimeCreationErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ExpiryTimeCreationErrorZ* o_conv = (LDKCResult_ExpiryTimeCreationErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ExpiryTimeCreationErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_ExpiryTimeCreationErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_ExpiryTimeCreationErrorZ _res_conv = *(LDKCResult_ExpiryTimeCreationErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_ExpiryTimeCreationErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_ExpiryTimeCreationErrorZ_clone_ptr(LDKCResult_ExpiryTimeCreationErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ExpiryTimeCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ExpiryTimeCreationErrorZ), "LDKCResult_ExpiryTimeCreationErrorZ");
+ *ret_conv = CResult_ExpiryTimeCreationErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ExpiryTimeCreationErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ExpiryTimeCreationErrorZ* arg_conv = (LDKCResult_ExpiryTimeCreationErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ExpiryTimeCreationErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ExpiryTimeCreationErrorZ_clone(uint32_t orig) {
+ LDKCResult_ExpiryTimeCreationErrorZ* orig_conv = (LDKCResult_ExpiryTimeCreationErrorZ*)(orig & ~1);
+ LDKCResult_ExpiryTimeCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ExpiryTimeCreationErrorZ), "LDKCResult_ExpiryTimeCreationErrorZ");
+ *ret_conv = CResult_ExpiryTimeCreationErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_PrivateRouteCreationErrorZ_ok(uint32_t o) {
+ LDKPrivateRoute o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = PrivateRoute_clone(&o_conv);
+ LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
+ *ret_conv = CResult_PrivateRouteCreationErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_PrivateRouteCreationErrorZ_err(uint32_t e) {
+ LDKCreationError e_conv = LDKCreationError_from_js(e);
+ LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
+ *ret_conv = CResult_PrivateRouteCreationErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_PrivateRouteCreationErrorZ_is_ok(uint32_t o) {
+ LDKCResult_PrivateRouteCreationErrorZ* o_conv = (LDKCResult_PrivateRouteCreationErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PrivateRouteCreationErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_PrivateRouteCreationErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_PrivateRouteCreationErrorZ _res_conv = *(LDKCResult_PrivateRouteCreationErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_PrivateRouteCreationErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_PrivateRouteCreationErrorZ_clone_ptr(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
+ *ret_conv = CResult_PrivateRouteCreationErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_PrivateRouteCreationErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_PrivateRouteCreationErrorZ* arg_conv = (LDKCResult_PrivateRouteCreationErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PrivateRouteCreationErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_PrivateRouteCreationErrorZ_clone(uint32_t orig) {
+ LDKCResult_PrivateRouteCreationErrorZ* orig_conv = (LDKCResult_PrivateRouteCreationErrorZ*)(orig & ~1);
+ LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
+ *ret_conv = CResult_PrivateRouteCreationErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_StringErrorZ_ok(jstring o) {
+ LDKStr o_conv = str_ref_to_owned_c(o);
+ LDKCResult_StringErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StringErrorZ), "LDKCResult_StringErrorZ");
+ *ret_conv = CResult_StringErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_StringErrorZ_err(uint32_t e) {
+ LDKSecp256k1Error e_conv = LDKSecp256k1Error_from_js(e);
+ LDKCResult_StringErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StringErrorZ), "LDKCResult_StringErrorZ");
+ *ret_conv = CResult_StringErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_StringErrorZ_is_ok(uint32_t o) {
+ LDKCResult_StringErrorZ* o_conv = (LDKCResult_StringErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_StringErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_StringErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_StringErrorZ _res_conv = *(LDKCResult_StringErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_StringErrorZ_free(_res_conv);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_ok(uint32_t o) {
+ LDKChannelMonitorUpdate o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = ChannelMonitorUpdate_clone(&o_conv);
+ LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
+ *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
+ *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ChannelMonitorUpdateDecodeErrorZ* o_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res_conv = *(LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
+ *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ChannelMonitorUpdateDecodeErrorZ* arg_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_ChannelMonitorUpdateDecodeErrorZ* orig_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(orig & ~1);
+ LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
+ *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_MonitorEventZ_some(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKMonitorEvent o_conv = *(LDKMonitorEvent*)(o_ptr);
+ o_conv = MonitorEvent_clone((LDKMonitorEvent*)(((uint64_t)o) & ~1));
+ LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
+ *ret_copy = COption_MonitorEventZ_some(o_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_MonitorEventZ_none() {
+ LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
+ *ret_copy = COption_MonitorEventZ_none();
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+void __attribute__((visibility("default"))) TS_COption_MonitorEventZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCOption_MonitorEventZ _res_conv = *(LDKCOption_MonitorEventZ*)(_res_ptr);
+ FREE((void*)_res);
+ COption_MonitorEventZ_free(_res_conv);
+}
+
+static inline uint64_t COption_MonitorEventZ_clone_ptr(LDKCOption_MonitorEventZ *NONNULL_PTR arg) {
+ LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
+ *ret_copy = COption_MonitorEventZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_COption_MonitorEventZ_clone_ptr(uint32_t arg) {
+ LDKCOption_MonitorEventZ* arg_conv = (LDKCOption_MonitorEventZ*)arg;
+ int64_t ret_val = COption_MonitorEventZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_MonitorEventZ_clone(uint32_t orig) {
+ LDKCOption_MonitorEventZ* orig_conv = (LDKCOption_MonitorEventZ*)orig;
+ LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
+ *ret_copy = COption_MonitorEventZ_clone(orig_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_ok(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKCOption_MonitorEventZ o_conv = *(LDKCOption_MonitorEventZ*)(o_ptr);
+ o_conv = COption_MonitorEventZ_clone((LDKCOption_MonitorEventZ*)(((uint64_t)o) & ~1));
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
+ *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
+ *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* o_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_COption_MonitorEventZDecodeErrorZ _res_conv = *(LDKCResult_COption_MonitorEventZDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_COption_MonitorEventZDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
+ *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* arg_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* orig_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)(orig & ~1);
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
+ *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_HTLCUpdateDecodeErrorZ_ok(uint32_t o) {
+ LDKHTLCUpdate o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = HTLCUpdate_clone(&o_conv);
+ LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
+ *ret_conv = CResult_HTLCUpdateDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_HTLCUpdateDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
+ *ret_conv = CResult_HTLCUpdateDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_HTLCUpdateDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_HTLCUpdateDecodeErrorZ* o_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_HTLCUpdateDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_HTLCUpdateDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_HTLCUpdateDecodeErrorZ _res_conv = *(LDKCResult_HTLCUpdateDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_HTLCUpdateDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_HTLCUpdateDecodeErrorZ_clone_ptr(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
+ *ret_conv = CResult_HTLCUpdateDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_HTLCUpdateDecodeErrorZ* arg_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_HTLCUpdateDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_HTLCUpdateDecodeErrorZ* orig_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)(orig & ~1);
+ LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
+ *ret_conv = CResult_HTLCUpdateDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NoneMonitorUpdateErrorZ_ok() {
+ LDKCResult_NoneMonitorUpdateErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneMonitorUpdateErrorZ), "LDKCResult_NoneMonitorUpdateErrorZ");
+ *ret_conv = CResult_NoneMonitorUpdateErrorZ_ok();
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NoneMonitorUpdateErrorZ_err(uint32_t e) {
+ LDKMonitorUpdateError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = MonitorUpdateError_clone(&e_conv);
+ LDKCResult_NoneMonitorUpdateErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneMonitorUpdateErrorZ), "LDKCResult_NoneMonitorUpdateErrorZ");
+ *ret_conv = CResult_NoneMonitorUpdateErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_NoneMonitorUpdateErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NoneMonitorUpdateErrorZ* o_conv = (LDKCResult_NoneMonitorUpdateErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NoneMonitorUpdateErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_NoneMonitorUpdateErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_NoneMonitorUpdateErrorZ _res_conv = *(LDKCResult_NoneMonitorUpdateErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_NoneMonitorUpdateErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_NoneMonitorUpdateErrorZ_clone_ptr(LDKCResult_NoneMonitorUpdateErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NoneMonitorUpdateErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneMonitorUpdateErrorZ), "LDKCResult_NoneMonitorUpdateErrorZ");
+ *ret_conv = CResult_NoneMonitorUpdateErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NoneMonitorUpdateErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NoneMonitorUpdateErrorZ* arg_conv = (LDKCResult_NoneMonitorUpdateErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NoneMonitorUpdateErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NoneMonitorUpdateErrorZ_clone(uint32_t orig) {
+ LDKCResult_NoneMonitorUpdateErrorZ* orig_conv = (LDKCResult_NoneMonitorUpdateErrorZ*)(orig & ~1);
+ LDKCResult_NoneMonitorUpdateErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneMonitorUpdateErrorZ), "LDKCResult_NoneMonitorUpdateErrorZ");
+ *ret_conv = CResult_NoneMonitorUpdateErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+static inline uint64_t C2Tuple_OutPointScriptZ_clone_ptr(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR arg) {
+ LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
+ *ret_conv = C2Tuple_OutPointScriptZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C2Tuple_OutPointScriptZ_clone_ptr(uint32_t arg) {
+ LDKC2Tuple_OutPointScriptZ* arg_conv = (LDKC2Tuple_OutPointScriptZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_OutPointScriptZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_C2Tuple_OutPointScriptZ_clone(uint32_t orig) {
+ LDKC2Tuple_OutPointScriptZ* orig_conv = (LDKC2Tuple_OutPointScriptZ*)(orig & ~1);
+ LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
+ *ret_conv = C2Tuple_OutPointScriptZ_clone(orig_conv);
+ return ((uint64_t)ret_conv);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_C2Tuple_OutPointScriptZ_new(uint32_t a, int8_tArray b) {
+ LDKOutPoint a_conv;
+ a_conv.inner = (void*)(a & (~1));
+ a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
+ a_conv = OutPoint_clone(&a_conv);
+ LDKCVec_u8Z b_ref;
+ b_ref.datalen = *((uint32_t*)b);
+ b_ref.data = MALLOC(b_ref.datalen, "LDKCVec_u8Z Bytes");
+ memcpy(b_ref.data, (uint8_t*)(b + 4), b_ref.datalen);
+ LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
+ *ret_conv = C2Tuple_OutPointScriptZ_new(a_conv, b_ref);
+ return ((uint64_t)ret_conv);
+}
+
+void __attribute__((visibility("default"))) TS_C2Tuple_OutPointScriptZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKC2Tuple_OutPointScriptZ _res_conv = *(LDKC2Tuple_OutPointScriptZ*)(_res_ptr);
+ FREE((void*)_res);
+ C2Tuple_OutPointScriptZ_free(_res_conv);
+}
+
+static inline uint64_t C2Tuple_u32ScriptZ_clone_ptr(LDKC2Tuple_u32ScriptZ *NONNULL_PTR arg) {
+ LDKC2Tuple_u32ScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
+ *ret_conv = C2Tuple_u32ScriptZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C2Tuple_u32ScriptZ_clone_ptr(uint32_t arg) {
+ LDKC2Tuple_u32ScriptZ* arg_conv = (LDKC2Tuple_u32ScriptZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_u32ScriptZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_C2Tuple_u32ScriptZ_clone(uint32_t orig) {
+ LDKC2Tuple_u32ScriptZ* orig_conv = (LDKC2Tuple_u32ScriptZ*)(orig & ~1);
+ LDKC2Tuple_u32ScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
+ *ret_conv = C2Tuple_u32ScriptZ_clone(orig_conv);
+ return ((uint64_t)ret_conv);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_C2Tuple_u32ScriptZ_new(int32_t a, int8_tArray b) {
+ LDKCVec_u8Z b_ref;
+ b_ref.datalen = *((uint32_t*)b);
+ b_ref.data = MALLOC(b_ref.datalen, "LDKCVec_u8Z Bytes");
+ memcpy(b_ref.data, (uint8_t*)(b + 4), b_ref.datalen);
+ LDKC2Tuple_u32ScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
+ *ret_conv = C2Tuple_u32ScriptZ_new(a, b_ref);
+ return ((uint64_t)ret_conv);
+}
+
+void __attribute__((visibility("default"))) TS_C2Tuple_u32ScriptZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKC2Tuple_u32ScriptZ _res_conv = *(LDKC2Tuple_u32ScriptZ*)(_res_ptr);
+ FREE((void*)_res);
+ C2Tuple_u32ScriptZ_free(_res_conv);
+}
+
+void __attribute__((visibility("default"))) TS_CVec_C2Tuple_u32ScriptZZ_free(uint32_tArray _res) {
+ LDKCVec_C2Tuple_u32ScriptZZ _res_constr;
+ _res_constr.datalen = *((uint32_t*)_res);
+ if (_res_constr.datalen > 0)
+ _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_u32ScriptZ), "LDKCVec_C2Tuple_u32ScriptZZ Elements");
+ else
+ _res_constr.data = NULL;
+ uint32_t* _res_vals = (uint32_t*)(_res + 4);
+ for (size_t v = 0; v < _res_constr.datalen; v++) {
+ uint32_t _res_conv_21 = _res_vals[v];
+ void* _res_conv_21_ptr = (void*)(((uint64_t)_res_conv_21) & ~1);
+ CHECK_ACCESS(_res_conv_21_ptr);
+ LDKC2Tuple_u32ScriptZ _res_conv_21_conv = *(LDKC2Tuple_u32ScriptZ*)(_res_conv_21_ptr);
+ FREE((void*)_res_conv_21);
+ _res_constr.data[v] = _res_conv_21_conv;
+ }
+ CVec_C2Tuple_u32ScriptZZ_free(_res_constr);
+}
+
+static inline uint64_t C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR arg) {
+ LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
+ *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(uint32_t arg) {
+ LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* arg_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(uint32_t orig) {
+ LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* orig_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(orig & ~1);
+ LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
+ *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig_conv);
+ return ((uint64_t)ret_conv);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(int8_tArray a, uint32_tArray b) {
+ LDKThirtyTwoBytes a_ref;
+ CHECK(*((uint32_t*)a) == 32);
+ memcpy(a_ref.data, (uint8_t*)(a + 4), 32);
+ LDKCVec_C2Tuple_u32ScriptZZ b_constr;
+ b_constr.datalen = *((uint32_t*)b);
+ if (b_constr.datalen > 0)
+ b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKC2Tuple_u32ScriptZ), "LDKCVec_C2Tuple_u32ScriptZZ Elements");
+ else
+ b_constr.data = NULL;
+ uint32_t* b_vals = (uint32_t*)(b + 4);
+ for (size_t v = 0; v < b_constr.datalen; v++) {
+ uint32_t b_conv_21 = b_vals[v];
+ void* b_conv_21_ptr = (void*)(((uint64_t)b_conv_21) & ~1);
+ CHECK_ACCESS(b_conv_21_ptr);
+ LDKC2Tuple_u32ScriptZ b_conv_21_conv = *(LDKC2Tuple_u32ScriptZ*)(b_conv_21_ptr);
+ b_conv_21_conv = C2Tuple_u32ScriptZ_clone((LDKC2Tuple_u32ScriptZ*)(((uint64_t)b_conv_21) & ~1));
+ b_constr.data[v] = b_conv_21_conv;
+ }
+ LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
+ *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a_ref, b_constr);
+ return ((uint64_t)ret_conv);
+}
+
+void __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(_res_ptr);
+ FREE((void*)_res);
+ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res_conv);
+}
+
+void __attribute__((visibility("default"))) TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(uint32_tArray _res) {
+ LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ _res_constr;
+ _res_constr.datalen = *((uint32_t*)_res);
+ if (_res_constr.datalen > 0)
+ _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ Elements");
+ else
+ _res_constr.data = NULL;
+ uint32_t* _res_vals = (uint32_t*)(_res + 4);
+ for (size_t o = 0; o < _res_constr.datalen; o++) {
+ uint32_t _res_conv_40 = _res_vals[o];
+ void* _res_conv_40_ptr = (void*)(((uint64_t)_res_conv_40) & ~1);
+ CHECK_ACCESS(_res_conv_40_ptr);
+ LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res_conv_40_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(_res_conv_40_ptr);
+ FREE((void*)_res_conv_40);
+ _res_constr.data[o] = _res_conv_40_conv;
+ }
+ CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res_constr);
+}
+
+void __attribute__((visibility("default"))) TS_CVec_EventZ_free(uint32_tArray _res) {
+ LDKCVec_EventZ _res_constr;
+ _res_constr.datalen = *((uint32_t*)_res);
+ if (_res_constr.datalen > 0)
+ _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKEvent), "LDKCVec_EventZ Elements");
+ else
+ _res_constr.data = NULL;
+ uint32_t* _res_vals = (uint32_t*)(_res + 4);
+ for (size_t h = 0; h < _res_constr.datalen; h++) {
+ uint32_t _res_conv_7 = _res_vals[h];
+ void* _res_conv_7_ptr = (void*)(((uint64_t)_res_conv_7) & ~1);
+ CHECK_ACCESS(_res_conv_7_ptr);
+ LDKEvent _res_conv_7_conv = *(LDKEvent*)(_res_conv_7_ptr);
+ FREE((void*)_res_conv_7);
+ _res_constr.data[h] = _res_conv_7_conv;
+ }
+ CVec_EventZ_free(_res_constr);
+}
+
+void __attribute__((visibility("default"))) TS_CVec_TransactionZ_free(ptrArray _res) {
+ LDKCVec_TransactionZ _res_constr;
+ _res_constr.datalen = *((uint32_t*)_res);
+ if (_res_constr.datalen > 0)
+ _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKTransaction), "LDKCVec_TransactionZ Elements");
+ else
+ _res_constr.data = NULL;
+ int8_tArray* _res_vals = (int8_tArray*)(_res + 4);
+ for (size_t m = 0; m < _res_constr.datalen; m++) {
+ int8_tArray _res_conv_12 = _res_vals[m];
+ LDKTransaction _res_conv_12_ref;
+ _res_conv_12_ref.datalen = *((uint32_t*)_res_conv_12);
+ _res_conv_12_ref.data = MALLOC(_res_conv_12_ref.datalen, "LDKTransaction Bytes");
+ memcpy(_res_conv_12_ref.data, (uint8_t*)(_res_conv_12 + 4), _res_conv_12_ref.datalen);
+ _res_conv_12_ref.data_is_owned = true;
+ _res_constr.data[m] = _res_conv_12_ref;
+ }
+ CVec_TransactionZ_free(_res_constr);
+}
+
+static inline uint64_t C2Tuple_u32TxOutZ_clone_ptr(LDKC2Tuple_u32TxOutZ *NONNULL_PTR arg) {
+ LDKC2Tuple_u32TxOutZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
+ *ret_conv = C2Tuple_u32TxOutZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C2Tuple_u32TxOutZ_clone_ptr(uint32_t arg) {
+ LDKC2Tuple_u32TxOutZ* arg_conv = (LDKC2Tuple_u32TxOutZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_u32TxOutZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_C2Tuple_u32TxOutZ_clone(uint32_t orig) {
+ LDKC2Tuple_u32TxOutZ* orig_conv = (LDKC2Tuple_u32TxOutZ*)(orig & ~1);
+ LDKC2Tuple_u32TxOutZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
+ *ret_conv = C2Tuple_u32TxOutZ_clone(orig_conv);
+ return ((uint64_t)ret_conv);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_C2Tuple_u32TxOutZ_new(int32_t a, uint32_t b) {
+ void* b_ptr = (void*)(((uint64_t)b) & ~1);
+ CHECK_ACCESS(b_ptr);
+ LDKTxOut b_conv = *(LDKTxOut*)(b_ptr);
+ b_conv = TxOut_clone((LDKTxOut*)(((uint64_t)b) & ~1));
+ LDKC2Tuple_u32TxOutZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
+ *ret_conv = C2Tuple_u32TxOutZ_new(a, b_conv);
+ return ((uint64_t)ret_conv);
+}
+
+void __attribute__((visibility("default"))) TS_C2Tuple_u32TxOutZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKC2Tuple_u32TxOutZ _res_conv = *(LDKC2Tuple_u32TxOutZ*)(_res_ptr);
+ FREE((void*)_res);
+ C2Tuple_u32TxOutZ_free(_res_conv);
+}
+
+void __attribute__((visibility("default"))) TS_CVec_C2Tuple_u32TxOutZZ_free(uint32_tArray _res) {
+ LDKCVec_C2Tuple_u32TxOutZZ _res_constr;
+ _res_constr.datalen = *((uint32_t*)_res);
+ if (_res_constr.datalen > 0)
+ _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_u32TxOutZ), "LDKCVec_C2Tuple_u32TxOutZZ Elements");
+ else
+ _res_constr.data = NULL;
+ uint32_t* _res_vals = (uint32_t*)(_res + 4);
+ for (size_t u = 0; u < _res_constr.datalen; u++) {
+ uint32_t _res_conv_20 = _res_vals[u];
+ void* _res_conv_20_ptr = (void*)(((uint64_t)_res_conv_20) & ~1);
+ CHECK_ACCESS(_res_conv_20_ptr);
+ LDKC2Tuple_u32TxOutZ _res_conv_20_conv = *(LDKC2Tuple_u32TxOutZ*)(_res_conv_20_ptr);
+ FREE((void*)_res_conv_20);
+ _res_constr.data[u] = _res_conv_20_conv;
+ }
+ CVec_C2Tuple_u32TxOutZZ_free(_res_constr);
+}
+
+static inline uint64_t C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR arg) {
+ LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
+ *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(uint32_t arg) {
+ LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* arg_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(uint32_t orig) {
+ LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* orig_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(orig & ~1);
+ LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
+ *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig_conv);
+ return ((uint64_t)ret_conv);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(int8_tArray a, uint32_tArray b) {
+ LDKThirtyTwoBytes a_ref;
+ CHECK(*((uint32_t*)a) == 32);
+ memcpy(a_ref.data, (uint8_t*)(a + 4), 32);
+ LDKCVec_C2Tuple_u32TxOutZZ b_constr;
+ b_constr.datalen = *((uint32_t*)b);
+ if (b_constr.datalen > 0)
+ b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKC2Tuple_u32TxOutZ), "LDKCVec_C2Tuple_u32TxOutZZ Elements");
+ else
+ b_constr.data = NULL;
+ uint32_t* b_vals = (uint32_t*)(b + 4);
+ for (size_t u = 0; u < b_constr.datalen; u++) {
+ uint32_t b_conv_20 = b_vals[u];
+ void* b_conv_20_ptr = (void*)(((uint64_t)b_conv_20) & ~1);
+ CHECK_ACCESS(b_conv_20_ptr);
+ LDKC2Tuple_u32TxOutZ b_conv_20_conv = *(LDKC2Tuple_u32TxOutZ*)(b_conv_20_ptr);
+ b_conv_20_conv = C2Tuple_u32TxOutZ_clone((LDKC2Tuple_u32TxOutZ*)(((uint64_t)b_conv_20) & ~1));
+ b_constr.data[u] = b_conv_20_conv;
+ }
+ LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
+ *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a_ref, b_constr);
+ return ((uint64_t)ret_conv);
+}
+
+void __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(_res_ptr);
+ FREE((void*)_res);
+ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res_conv);
+}
+
+void __attribute__((visibility("default"))) TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(uint32_tArray _res) {
+ LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ _res_constr;
+ _res_constr.datalen = *((uint32_t*)_res);
+ if (_res_constr.datalen > 0)
+ _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ Elements");
+ else
+ _res_constr.data = NULL;
+ uint32_t* _res_vals = (uint32_t*)(_res + 4);
+ for (size_t n = 0; n < _res_constr.datalen; n++) {
+ uint32_t _res_conv_39 = _res_vals[n];
+ void* _res_conv_39_ptr = (void*)(((uint64_t)_res_conv_39) & ~1);
+ CHECK_ACCESS(_res_conv_39_ptr);
+ LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res_conv_39_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(_res_conv_39_ptr);
+ FREE((void*)_res_conv_39);
+ _res_constr.data[n] = _res_conv_39_conv;
+ }
+ CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res_constr);
+}
+
+void __attribute__((visibility("default"))) TS_CVec_BalanceZ_free(uint32_tArray _res) {
+ LDKCVec_BalanceZ _res_constr;
+ _res_constr.datalen = *((uint32_t*)_res);
+ if (_res_constr.datalen > 0)
+ _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKBalance), "LDKCVec_BalanceZ Elements");
+ else
+ _res_constr.data = NULL;
+ uint32_t* _res_vals = (uint32_t*)(_res + 4);
+ for (size_t j = 0; j < _res_constr.datalen; j++) {
+ uint32_t _res_conv_9 = _res_vals[j];
+ void* _res_conv_9_ptr = (void*)(((uint64_t)_res_conv_9) & ~1);
+ CHECK_ACCESS(_res_conv_9_ptr);
+ LDKBalance _res_conv_9_conv = *(LDKBalance*)(_res_conv_9_ptr);
+ FREE((void*)_res_conv_9);
+ _res_constr.data[j] = _res_conv_9_conv;
+ }
+ CVec_BalanceZ_free(_res_constr);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKC2Tuple_BlockHashChannelMonitorZ o_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(o_ptr);
+ o_conv = C2Tuple_BlockHashChannelMonitorZ_clone((LDKC2Tuple_BlockHashChannelMonitorZ*)(((uint64_t)o) & ~1));
+ LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
+ *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
+ *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* o_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ _res_conv = *(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
+ *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* arg_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* orig_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(orig & ~1);
+ LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
+ *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_ok() {
+ LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
+ *ret_conv = CResult_NoneLightningErrorZ_ok();
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_err(uint32_t e) {
+ LDKLightningError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = LightningError_clone(&e_conv);
+ LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
+ *ret_conv = CResult_NoneLightningErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NoneLightningErrorZ* o_conv = (LDKCResult_NoneLightningErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NoneLightningErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_NoneLightningErrorZ _res_conv = *(LDKCResult_NoneLightningErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_NoneLightningErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_NoneLightningErrorZ_clone_ptr(LDKCResult_NoneLightningErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
+ *ret_conv = CResult_NoneLightningErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NoneLightningErrorZ* arg_conv = (LDKCResult_NoneLightningErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NoneLightningErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_clone(uint32_t orig) {
+ LDKCResult_NoneLightningErrorZ* orig_conv = (LDKCResult_NoneLightningErrorZ*)(orig & ~1);
+ LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
+ *ret_conv = CResult_NoneLightningErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+static inline uint64_t C2Tuple_PublicKeyTypeZ_clone_ptr(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR arg) {
+ LDKC2Tuple_PublicKeyTypeZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ");
+ *ret_conv = C2Tuple_PublicKeyTypeZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C2Tuple_PublicKeyTypeZ_clone_ptr(uint32_t arg) {
+ LDKC2Tuple_PublicKeyTypeZ* arg_conv = (LDKC2Tuple_PublicKeyTypeZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_PublicKeyTypeZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_C2Tuple_PublicKeyTypeZ_clone(uint32_t orig) {
+ LDKC2Tuple_PublicKeyTypeZ* orig_conv = (LDKC2Tuple_PublicKeyTypeZ*)(orig & ~1);
+ LDKC2Tuple_PublicKeyTypeZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ");
+ *ret_conv = C2Tuple_PublicKeyTypeZ_clone(orig_conv);
+ return ((uint64_t)ret_conv);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_C2Tuple_PublicKeyTypeZ_new(int8_tArray a, uint32_t b) {
+ LDKPublicKey a_ref;
+ CHECK(*((uint32_t*)a) == 33);
+ memcpy(a_ref.compressed_form, (uint8_t*)(a + 4), 33);
+ void* b_ptr = (void*)(((uint64_t)b) & ~1);
+ CHECK_ACCESS(b_ptr);
+ LDKType b_conv = *(LDKType*)(b_ptr);
+ LDKC2Tuple_PublicKeyTypeZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ");
+ *ret_conv = C2Tuple_PublicKeyTypeZ_new(a_ref, b_conv);
+ return ((uint64_t)ret_conv);
+}
+
+void __attribute__((visibility("default"))) TS_C2Tuple_PublicKeyTypeZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKC2Tuple_PublicKeyTypeZ _res_conv = *(LDKC2Tuple_PublicKeyTypeZ*)(_res_ptr);
+ FREE((void*)_res);
+ C2Tuple_PublicKeyTypeZ_free(_res_conv);
+}
+
+void __attribute__((visibility("default"))) TS_CVec_C2Tuple_PublicKeyTypeZZ_free(uint32_tArray _res) {
+ LDKCVec_C2Tuple_PublicKeyTypeZZ _res_constr;
+ _res_constr.datalen = *((uint32_t*)_res);
+ if (_res_constr.datalen > 0)
+ _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKCVec_C2Tuple_PublicKeyTypeZZ Elements");
+ else
+ _res_constr.data = NULL;
+ uint32_t* _res_vals = (uint32_t*)(_res + 4);
+ for (size_t z = 0; z < _res_constr.datalen; z++) {
+ uint32_t _res_conv_25 = _res_vals[z];
+ void* _res_conv_25_ptr = (void*)(((uint64_t)_res_conv_25) & ~1);
+ CHECK_ACCESS(_res_conv_25_ptr);
+ LDKC2Tuple_PublicKeyTypeZ _res_conv_25_conv = *(LDKC2Tuple_PublicKeyTypeZ*)(_res_conv_25_ptr);
+ FREE((void*)_res_conv_25);
+ _res_constr.data[z] = _res_conv_25_conv;
+ }
+ CVec_C2Tuple_PublicKeyTypeZZ_free(_res_constr);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_boolLightningErrorZ_ok(jboolean o) {
+ LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
+ *ret_conv = CResult_boolLightningErrorZ_ok(o);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_boolLightningErrorZ_err(uint32_t e) {
+ LDKLightningError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = LightningError_clone(&e_conv);
+ LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
+ *ret_conv = CResult_boolLightningErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_boolLightningErrorZ_is_ok(uint32_t o) {
+ LDKCResult_boolLightningErrorZ* o_conv = (LDKCResult_boolLightningErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_boolLightningErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_boolLightningErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_boolLightningErrorZ _res_conv = *(LDKCResult_boolLightningErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_boolLightningErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_boolLightningErrorZ_clone_ptr(LDKCResult_boolLightningErrorZ *NONNULL_PTR arg) {
+ LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
+ *ret_conv = CResult_boolLightningErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_boolLightningErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_boolLightningErrorZ* arg_conv = (LDKCResult_boolLightningErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_boolLightningErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_boolLightningErrorZ_clone(uint32_t orig) {
+ LDKCResult_boolLightningErrorZ* orig_conv = (LDKCResult_boolLightningErrorZ*)(orig & ~1);
+ LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
+ *ret_conv = CResult_boolLightningErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+static inline uint64_t C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR arg) {
+ LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
+ *ret_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(uint32_t arg) {
+ LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* arg_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(arg & ~1);
+ int64_t ret_val = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(uint32_t orig) {
+ LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* orig_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(orig & ~1);
+ LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
+ *ret_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig_conv);
+ return ((uint64_t)ret_conv);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(uint32_t a, uint32_t b, uint32_t c) {
+ LDKChannelAnnouncement a_conv;
+ a_conv.inner = (void*)(a & (~1));
+ a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
+ a_conv = ChannelAnnouncement_clone(&a_conv);
+ LDKChannelUpdate b_conv;
+ b_conv.inner = (void*)(b & (~1));
+ b_conv.is_owned = (b & 1) || (b == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
+ b_conv = ChannelUpdate_clone(&b_conv);
+ LDKChannelUpdate c_conv;
+ c_conv.inner = (void*)(c & (~1));
+ c_conv.is_owned = (c & 1) || (c == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(c_conv);
+ c_conv = ChannelUpdate_clone(&c_conv);
+ LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
+ *ret_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a_conv, b_conv, c_conv);
+ return ((uint64_t)ret_conv);
+}
+
+void __attribute__((visibility("default"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(_res_ptr);
+ FREE((void*)_res);
+ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res_conv);
+}
+
+void __attribute__((visibility("default"))) TS_CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(uint32_tArray _res) {
+ LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res_constr;
+ _res_constr.datalen = *((uint32_t*)_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;
+ uint32_t* _res_vals = (uint32_t*)(_res + 4);
+ for (size_t h = 0; h < _res_constr.datalen; h++) {
+ uint32_t _res_conv_59 = _res_vals[h];
+ void* _res_conv_59_ptr = (void*)(((uint64_t)_res_conv_59) & ~1);
+ CHECK_ACCESS(_res_conv_59_ptr);
+ LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res_conv_59_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(_res_conv_59_ptr);
+ FREE((void*)_res_conv_59);
+ _res_constr.data[h] = _res_conv_59_conv;
+ }
+ CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res_constr);
+}
+
+void __attribute__((visibility("default"))) TS_CVec_NodeAnnouncementZ_free(uint32_tArray _res) {
+ LDKCVec_NodeAnnouncementZ _res_constr;
+ _res_constr.datalen = *((uint32_t*)_res);
+ if (_res_constr.datalen > 0)
+ _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKNodeAnnouncement), "LDKCVec_NodeAnnouncementZ Elements");
+ else
+ _res_constr.data = NULL;
+ uint32_t* _res_vals = (uint32_t*)(_res + 4);
+ for (size_t s = 0; s < _res_constr.datalen; s++) {
+ uint32_t _res_conv_18 = _res_vals[s];
+ LDKNodeAnnouncement _res_conv_18_conv;
+ _res_conv_18_conv.inner = (void*)(_res_conv_18 & (~1));
+ _res_conv_18_conv.is_owned = (_res_conv_18 & 1) || (_res_conv_18 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_18_conv);
+ _res_constr.data[s] = _res_conv_18_conv;
+ }
+ CVec_NodeAnnouncementZ_free(_res_constr);
+}
+
+void __attribute__((visibility("default"))) TS_CVec_PublicKeyZ_free(ptrArray _res) {
+ LDKCVec_PublicKeyZ _res_constr;
+ _res_constr.datalen = *((uint32_t*)_res);
+ if (_res_constr.datalen > 0)
+ _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKPublicKey), "LDKCVec_PublicKeyZ Elements");
+ else
+ _res_constr.data = NULL;
+ int8_tArray* _res_vals = (int8_tArray*)(_res + 4);
+ for (size_t m = 0; m < _res_constr.datalen; m++) {
+ int8_tArray _res_conv_12 = _res_vals[m];
+ LDKPublicKey _res_conv_12_ref;
+ CHECK(*((uint32_t*)_res_conv_12) == 33);
+ memcpy(_res_conv_12_ref.compressed_form, (uint8_t*)(_res_conv_12 + 4), 33);
+ _res_constr.data[m] = _res_conv_12_ref;
+ }
+ CVec_PublicKeyZ_free(_res_constr);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_ok(int8_tArray o) {
+ LDKCVec_u8Z o_ref;
+ o_ref.datalen = *((uint32_t*)o);
+ o_ref.data = MALLOC(o_ref.datalen, "LDKCVec_u8Z Bytes");
+ memcpy(o_ref.data, (uint8_t*)(o + 4), o_ref.datalen);
+ LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
+ *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_ok(o_ref);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_err(uint32_t e) {
+ LDKPeerHandleError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = PeerHandleError_clone(&e_conv);
+ LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
+ *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok(uint32_t o) {
+ LDKCResult_CVec_u8ZPeerHandleErrorZ* o_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_CVec_u8ZPeerHandleErrorZ _res_conv = *(LDKCResult_CVec_u8ZPeerHandleErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_CVec_u8ZPeerHandleErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR arg) {
+ LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
+ *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_CVec_u8ZPeerHandleErrorZ* arg_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_clone(uint32_t orig) {
+ LDKCResult_CVec_u8ZPeerHandleErrorZ* orig_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(orig & ~1);
+ LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
+ *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NonePeerHandleErrorZ_ok() {
+ LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
+ *ret_conv = CResult_NonePeerHandleErrorZ_ok();
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NonePeerHandleErrorZ_err(uint32_t e) {
+ LDKPeerHandleError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = PeerHandleError_clone(&e_conv);
+ LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
+ *ret_conv = CResult_NonePeerHandleErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_NonePeerHandleErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NonePeerHandleErrorZ* o_conv = (LDKCResult_NonePeerHandleErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NonePeerHandleErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_NonePeerHandleErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_NonePeerHandleErrorZ _res_conv = *(LDKCResult_NonePeerHandleErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_NonePeerHandleErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_NonePeerHandleErrorZ_clone_ptr(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
+ *ret_conv = CResult_NonePeerHandleErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NonePeerHandleErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NonePeerHandleErrorZ* arg_conv = (LDKCResult_NonePeerHandleErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NonePeerHandleErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NonePeerHandleErrorZ_clone(uint32_t orig) {
+ LDKCResult_NonePeerHandleErrorZ* orig_conv = (LDKCResult_NonePeerHandleErrorZ*)(orig & ~1);
+ LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
+ *ret_conv = CResult_NonePeerHandleErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_boolPeerHandleErrorZ_ok(jboolean o) {
+ LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
+ *ret_conv = CResult_boolPeerHandleErrorZ_ok(o);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_boolPeerHandleErrorZ_err(uint32_t e) {
+ LDKPeerHandleError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = PeerHandleError_clone(&e_conv);
+ LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
+ *ret_conv = CResult_boolPeerHandleErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_boolPeerHandleErrorZ_is_ok(uint32_t o) {
+ LDKCResult_boolPeerHandleErrorZ* o_conv = (LDKCResult_boolPeerHandleErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_boolPeerHandleErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_boolPeerHandleErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_boolPeerHandleErrorZ _res_conv = *(LDKCResult_boolPeerHandleErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_boolPeerHandleErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_boolPeerHandleErrorZ_clone_ptr(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR arg) {
+ LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
+ *ret_conv = CResult_boolPeerHandleErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_boolPeerHandleErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_boolPeerHandleErrorZ* arg_conv = (LDKCResult_boolPeerHandleErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_boolPeerHandleErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_boolPeerHandleErrorZ_clone(uint32_t orig) {
+ LDKCResult_boolPeerHandleErrorZ* orig_conv = (LDKCResult_boolPeerHandleErrorZ*)(orig & ~1);
+ LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
+ *ret_conv = CResult_boolPeerHandleErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NodeIdDecodeErrorZ_ok(uint32_t o) {
+ LDKNodeId o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = NodeId_clone(&o_conv);
+ LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
+ *ret_conv = CResult_NodeIdDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NodeIdDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
+ *ret_conv = CResult_NodeIdDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_NodeIdDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NodeIdDecodeErrorZ* o_conv = (LDKCResult_NodeIdDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NodeIdDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_NodeIdDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_NodeIdDecodeErrorZ _res_conv = *(LDKCResult_NodeIdDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_NodeIdDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_NodeIdDecodeErrorZ_clone_ptr(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
+ *ret_conv = CResult_NodeIdDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NodeIdDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NodeIdDecodeErrorZ* arg_conv = (LDKCResult_NodeIdDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NodeIdDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NodeIdDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_NodeIdDecodeErrorZ* orig_conv = (LDKCResult_NodeIdDecodeErrorZ*)(orig & ~1);
+ LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
+ *ret_conv = CResult_NodeIdDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKCOption_NetworkUpdateZ o_conv = *(LDKCOption_NetworkUpdateZ*)(o_ptr);
+ o_conv = COption_NetworkUpdateZ_clone((LDKCOption_NetworkUpdateZ*)(((uint64_t)o) & ~1));
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
+ *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
+ *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* o_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ _res_conv = *(LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
+ *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* arg_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* orig_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(orig & ~1);
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
+ *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_AccessZ_some(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKAccess o_conv = *(LDKAccess*)(o_ptr);
+ LDKCOption_AccessZ *ret_copy = MALLOC(sizeof(LDKCOption_AccessZ), "LDKCOption_AccessZ");
+ *ret_copy = COption_AccessZ_some(o_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_AccessZ_none() {
+ LDKCOption_AccessZ *ret_copy = MALLOC(sizeof(LDKCOption_AccessZ), "LDKCOption_AccessZ");
+ *ret_copy = COption_AccessZ_none();
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+void __attribute__((visibility("default"))) TS_COption_AccessZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCOption_AccessZ _res_conv = *(LDKCOption_AccessZ*)(_res_ptr);
+ FREE((void*)_res);
+ COption_AccessZ_free(_res_conv);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_DirectionalChannelInfoDecodeErrorZ_ok(uint32_t o) {
+ LDKDirectionalChannelInfo o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = DirectionalChannelInfo_clone(&o_conv);
+ LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ");
+ *ret_conv = CResult_DirectionalChannelInfoDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_DirectionalChannelInfoDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ");
+ *ret_conv = CResult_DirectionalChannelInfoDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_DirectionalChannelInfoDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_DirectionalChannelInfoDecodeErrorZ* o_conv = (LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_DirectionalChannelInfoDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_DirectionalChannelInfoDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_DirectionalChannelInfoDecodeErrorZ _res_conv = *(LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_DirectionalChannelInfoDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_DirectionalChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_DirectionalChannelInfoDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ");
+ *ret_conv = CResult_DirectionalChannelInfoDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_DirectionalChannelInfoDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_DirectionalChannelInfoDecodeErrorZ* arg_conv = (LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_DirectionalChannelInfoDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_DirectionalChannelInfoDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_DirectionalChannelInfoDecodeErrorZ* orig_conv = (LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(orig & ~1);
+ LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ");
+ *ret_conv = CResult_DirectionalChannelInfoDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelInfoDecodeErrorZ_ok(uint32_t o) {
+ LDKChannelInfo o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = ChannelInfo_clone(&o_conv);
+ LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
+ *ret_conv = CResult_ChannelInfoDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelInfoDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
+ *ret_conv = CResult_ChannelInfoDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_ChannelInfoDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ChannelInfoDecodeErrorZ* o_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelInfoDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_ChannelInfoDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_ChannelInfoDecodeErrorZ _res_conv = *(LDKCResult_ChannelInfoDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_ChannelInfoDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_ChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
+ *ret_conv = CResult_ChannelInfoDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ChannelInfoDecodeErrorZ* arg_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelInfoDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_ChannelInfoDecodeErrorZ* orig_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)(orig & ~1);
+ LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
+ *ret_conv = CResult_ChannelInfoDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_RoutingFeesDecodeErrorZ_ok(uint32_t o) {
+ LDKRoutingFees o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = RoutingFees_clone(&o_conv);
+ LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
+ *ret_conv = CResult_RoutingFeesDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_RoutingFeesDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
+ *ret_conv = CResult_RoutingFeesDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_RoutingFeesDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_RoutingFeesDecodeErrorZ* o_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RoutingFeesDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_RoutingFeesDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_RoutingFeesDecodeErrorZ _res_conv = *(LDKCResult_RoutingFeesDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_RoutingFeesDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_RoutingFeesDecodeErrorZ_clone_ptr(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
+ *ret_conv = CResult_RoutingFeesDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_RoutingFeesDecodeErrorZ* arg_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_RoutingFeesDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_RoutingFeesDecodeErrorZ* orig_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)(orig & ~1);
+ LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
+ *ret_conv = CResult_RoutingFeesDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_ok(uint32_t o) {
+ LDKNodeAnnouncementInfo o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = NodeAnnouncementInfo_clone(&o_conv);
+ LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
+ *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
+ *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NodeAnnouncementInfoDecodeErrorZ* o_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res_conv = *(LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
+ *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NodeAnnouncementInfoDecodeErrorZ* arg_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_NodeAnnouncementInfoDecodeErrorZ* orig_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(orig & ~1);
+ LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
+ *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+void __attribute__((visibility("default"))) TS_CVec_u64Z_free(int64_tArray _res) {
+ LDKCVec_u64Z _res_constr;
+ _res_constr.datalen = *((uint32_t*)_res);
+ if (_res_constr.datalen > 0)
+ _res_constr.data = MALLOC(_res_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
+ else
+ _res_constr.data = NULL;
+ int64_t* _res_vals = (int64_t*)(_res + 4);
+ for (size_t i = 0; i < _res_constr.datalen; i++) {
+ int64_t _res_conv_8 = _res_vals[i];
+ _res_constr.data[i] = _res_conv_8;
+ }
+ CVec_u64Z_free(_res_constr);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NodeInfoDecodeErrorZ_ok(uint32_t o) {
+ LDKNodeInfo o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = NodeInfo_clone(&o_conv);
+ LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
+ *ret_conv = CResult_NodeInfoDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NodeInfoDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
+ *ret_conv = CResult_NodeInfoDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_NodeInfoDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NodeInfoDecodeErrorZ* o_conv = (LDKCResult_NodeInfoDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NodeInfoDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_NodeInfoDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_NodeInfoDecodeErrorZ _res_conv = *(LDKCResult_NodeInfoDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_NodeInfoDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_NodeInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
+ *ret_conv = CResult_NodeInfoDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NodeInfoDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NodeInfoDecodeErrorZ* arg_conv = (LDKCResult_NodeInfoDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NodeInfoDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NodeInfoDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_NodeInfoDecodeErrorZ* orig_conv = (LDKCResult_NodeInfoDecodeErrorZ*)(orig & ~1);
+ LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
+ *ret_conv = CResult_NodeInfoDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NetworkGraphDecodeErrorZ_ok(uint32_t o) {
+ LDKNetworkGraph o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = NetworkGraph_clone(&o_conv);
+ LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
+ *ret_conv = CResult_NetworkGraphDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NetworkGraphDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
+ *ret_conv = CResult_NetworkGraphDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_NetworkGraphDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NetworkGraphDecodeErrorZ* o_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NetworkGraphDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_NetworkGraphDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_NetworkGraphDecodeErrorZ _res_conv = *(LDKCResult_NetworkGraphDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_NetworkGraphDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_NetworkGraphDecodeErrorZ_clone_ptr(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
+ *ret_conv = CResult_NetworkGraphDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NetworkGraphDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NetworkGraphDecodeErrorZ* arg_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NetworkGraphDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NetworkGraphDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_NetworkGraphDecodeErrorZ* orig_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)(orig & ~1);
+ LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
+ *ret_conv = CResult_NetworkGraphDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_CVec_NetAddressZZ_some(uint32_tArray o) {
+ LDKCVec_NetAddressZ o_constr;
+ o_constr.datalen = *((uint32_t*)o);
+ if (o_constr.datalen > 0)
+ o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
+ else
+ o_constr.data = NULL;
+ uint32_t* o_vals = (uint32_t*)(o + 4);
+ for (size_t m = 0; m < o_constr.datalen; m++) {
+ uint32_t o_conv_12 = o_vals[m];
+ void* o_conv_12_ptr = (void*)(((uint64_t)o_conv_12) & ~1);
+ CHECK_ACCESS(o_conv_12_ptr);
+ LDKNetAddress o_conv_12_conv = *(LDKNetAddress*)(o_conv_12_ptr);
+ o_conv_12_conv = NetAddress_clone((LDKNetAddress*)(((uint64_t)o_conv_12) & ~1));
+ o_constr.data[m] = o_conv_12_conv;
+ }
+ LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ");
+ *ret_copy = COption_CVec_NetAddressZZ_some(o_constr);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_CVec_NetAddressZZ_none() {
+ LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ");
+ *ret_copy = COption_CVec_NetAddressZZ_none();
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+void __attribute__((visibility("default"))) TS_COption_CVec_NetAddressZZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCOption_CVec_NetAddressZZ _res_conv = *(LDKCOption_CVec_NetAddressZZ*)(_res_ptr);
+ FREE((void*)_res);
+ COption_CVec_NetAddressZZ_free(_res_conv);
+}
+
+static inline uint64_t COption_CVec_NetAddressZZ_clone_ptr(LDKCOption_CVec_NetAddressZZ *NONNULL_PTR arg) {
+ LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ");
+ *ret_copy = COption_CVec_NetAddressZZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_COption_CVec_NetAddressZZ_clone_ptr(uint32_t arg) {
+ LDKCOption_CVec_NetAddressZZ* arg_conv = (LDKCOption_CVec_NetAddressZZ*)arg;
+ int64_t ret_val = COption_CVec_NetAddressZZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_CVec_NetAddressZZ_clone(uint32_t orig) {
+ LDKCOption_CVec_NetAddressZZ* orig_conv = (LDKCOption_CVec_NetAddressZZ*)orig;
+ LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ");
+ *ret_copy = COption_CVec_NetAddressZZ_clone(orig_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NetAddressDecodeErrorZ_ok(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKNetAddress o_conv = *(LDKNetAddress*)(o_ptr);
+ o_conv = NetAddress_clone((LDKNetAddress*)(((uint64_t)o) & ~1));
+ LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
+ *ret_conv = CResult_NetAddressDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NetAddressDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
+ *ret_conv = CResult_NetAddressDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_NetAddressDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NetAddressDecodeErrorZ* o_conv = (LDKCResult_NetAddressDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NetAddressDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_NetAddressDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_NetAddressDecodeErrorZ _res_conv = *(LDKCResult_NetAddressDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_NetAddressDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_NetAddressDecodeErrorZ_clone_ptr(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
+ *ret_conv = CResult_NetAddressDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NetAddressDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NetAddressDecodeErrorZ* arg_conv = (LDKCResult_NetAddressDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NetAddressDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NetAddressDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_NetAddressDecodeErrorZ* orig_conv = (LDKCResult_NetAddressDecodeErrorZ*)(orig & ~1);
+ LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
+ *ret_conv = CResult_NetAddressDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+void __attribute__((visibility("default"))) TS_CVec_UpdateAddHTLCZ_free(uint32_tArray _res) {
+ LDKCVec_UpdateAddHTLCZ _res_constr;
+ _res_constr.datalen = *((uint32_t*)_res);
+ if (_res_constr.datalen > 0)
+ _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateAddHTLC), "LDKCVec_UpdateAddHTLCZ Elements");
+ else
+ _res_constr.data = NULL;
+ uint32_t* _res_vals = (uint32_t*)(_res + 4);
+ for (size_t p = 0; p < _res_constr.datalen; p++) {
+ uint32_t _res_conv_15 = _res_vals[p];
+ LDKUpdateAddHTLC _res_conv_15_conv;
+ _res_conv_15_conv.inner = (void*)(_res_conv_15 & (~1));
+ _res_conv_15_conv.is_owned = (_res_conv_15 & 1) || (_res_conv_15 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_15_conv);
+ _res_constr.data[p] = _res_conv_15_conv;
+ }
+ CVec_UpdateAddHTLCZ_free(_res_constr);
+}
+
+void __attribute__((visibility("default"))) TS_CVec_UpdateFulfillHTLCZ_free(uint32_tArray _res) {
+ LDKCVec_UpdateFulfillHTLCZ _res_constr;
+ _res_constr.datalen = *((uint32_t*)_res);
+ if (_res_constr.datalen > 0)
+ _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateFulfillHTLC), "LDKCVec_UpdateFulfillHTLCZ Elements");
+ else
+ _res_constr.data = NULL;
+ uint32_t* _res_vals = (uint32_t*)(_res + 4);
+ for (size_t t = 0; t < _res_constr.datalen; t++) {
+ uint32_t _res_conv_19 = _res_vals[t];
+ LDKUpdateFulfillHTLC _res_conv_19_conv;
+ _res_conv_19_conv.inner = (void*)(_res_conv_19 & (~1));
+ _res_conv_19_conv.is_owned = (_res_conv_19 & 1) || (_res_conv_19 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_19_conv);
+ _res_constr.data[t] = _res_conv_19_conv;
+ }
+ CVec_UpdateFulfillHTLCZ_free(_res_constr);
+}
+
+void __attribute__((visibility("default"))) TS_CVec_UpdateFailHTLCZ_free(uint32_tArray _res) {
+ LDKCVec_UpdateFailHTLCZ _res_constr;
+ _res_constr.datalen = *((uint32_t*)_res);
+ if (_res_constr.datalen > 0)
+ _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateFailHTLC), "LDKCVec_UpdateFailHTLCZ Elements");
+ else
+ _res_constr.data = NULL;
+ uint32_t* _res_vals = (uint32_t*)(_res + 4);
+ for (size_t q = 0; q < _res_constr.datalen; q++) {
+ uint32_t _res_conv_16 = _res_vals[q];
+ LDKUpdateFailHTLC _res_conv_16_conv;
+ _res_conv_16_conv.inner = (void*)(_res_conv_16 & (~1));
+ _res_conv_16_conv.is_owned = (_res_conv_16 & 1) || (_res_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_16_conv);
+ _res_constr.data[q] = _res_conv_16_conv;
+ }
+ CVec_UpdateFailHTLCZ_free(_res_constr);
+}
+
+void __attribute__((visibility("default"))) TS_CVec_UpdateFailMalformedHTLCZ_free(uint32_tArray _res) {
+ LDKCVec_UpdateFailMalformedHTLCZ _res_constr;
+ _res_constr.datalen = *((uint32_t*)_res);
+ if (_res_constr.datalen > 0)
+ _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateFailMalformedHTLC), "LDKCVec_UpdateFailMalformedHTLCZ Elements");
+ else
+ _res_constr.data = NULL;
+ uint32_t* _res_vals = (uint32_t*)(_res + 4);
+ for (size_t z = 0; z < _res_constr.datalen; z++) {
+ uint32_t _res_conv_25 = _res_vals[z];
+ LDKUpdateFailMalformedHTLC _res_conv_25_conv;
+ _res_conv_25_conv.inner = (void*)(_res_conv_25 & (~1));
+ _res_conv_25_conv.is_owned = (_res_conv_25 & 1) || (_res_conv_25 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_25_conv);
+ _res_constr.data[z] = _res_conv_25_conv;
+ }
+ CVec_UpdateFailMalformedHTLCZ_free(_res_constr);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_AcceptChannelDecodeErrorZ_ok(uint32_t o) {
+ LDKAcceptChannel o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = AcceptChannel_clone(&o_conv);
+ LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
+ *ret_conv = CResult_AcceptChannelDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_AcceptChannelDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
+ *ret_conv = CResult_AcceptChannelDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_AcceptChannelDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_AcceptChannelDecodeErrorZ* o_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_AcceptChannelDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_AcceptChannelDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_AcceptChannelDecodeErrorZ _res_conv = *(LDKCResult_AcceptChannelDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_AcceptChannelDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
+ *ret_conv = CResult_AcceptChannelDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_AcceptChannelDecodeErrorZ* arg_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_AcceptChannelDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_AcceptChannelDecodeErrorZ* orig_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)(orig & ~1);
+ LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
+ *ret_conv = CResult_AcceptChannelDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok(uint32_t o) {
+ LDKAnnouncementSignatures o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = AnnouncementSignatures_clone(&o_conv);
+ LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
+ *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
+ *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_AnnouncementSignaturesDecodeErrorZ* o_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_AnnouncementSignaturesDecodeErrorZ _res_conv = *(LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_AnnouncementSignaturesDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
+ *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_AnnouncementSignaturesDecodeErrorZ* arg_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_AnnouncementSignaturesDecodeErrorZ* orig_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(orig & ~1);
+ LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
+ *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelReestablishDecodeErrorZ_ok(uint32_t o) {
+ LDKChannelReestablish o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = ChannelReestablish_clone(&o_conv);
+ LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
+ *ret_conv = CResult_ChannelReestablishDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelReestablishDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
+ *ret_conv = CResult_ChannelReestablishDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_ChannelReestablishDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ChannelReestablishDecodeErrorZ* o_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelReestablishDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_ChannelReestablishDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_ChannelReestablishDecodeErrorZ _res_conv = *(LDKCResult_ChannelReestablishDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_ChannelReestablishDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
+ *ret_conv = CResult_ChannelReestablishDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ChannelReestablishDecodeErrorZ* arg_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelReestablishDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_ChannelReestablishDecodeErrorZ* orig_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)(orig & ~1);
+ LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
+ *ret_conv = CResult_ChannelReestablishDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ClosingSignedDecodeErrorZ_ok(uint32_t o) {
+ LDKClosingSigned o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = ClosingSigned_clone(&o_conv);
+ LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
+ *ret_conv = CResult_ClosingSignedDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ClosingSignedDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
+ *ret_conv = CResult_ClosingSignedDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_ClosingSignedDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ClosingSignedDecodeErrorZ* o_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ClosingSignedDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_ClosingSignedDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_ClosingSignedDecodeErrorZ _res_conv = *(LDKCResult_ClosingSignedDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_ClosingSignedDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
+ *ret_conv = CResult_ClosingSignedDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ClosingSignedDecodeErrorZ* arg_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ClosingSignedDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_ClosingSignedDecodeErrorZ* orig_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)(orig & ~1);
+ LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
+ *ret_conv = CResult_ClosingSignedDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(uint32_t o) {
+ LDKClosingSignedFeeRange o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = ClosingSignedFeeRange_clone(&o_conv);
+ LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
+ *ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
+ *ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* o_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_ClosingSignedFeeRangeDecodeErrorZ _res_conv = *(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
+ *ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* arg_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* orig_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)(orig & ~1);
+ LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
+ *ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_CommitmentSignedDecodeErrorZ_ok(uint32_t o) {
+ LDKCommitmentSigned o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = CommitmentSigned_clone(&o_conv);
+ LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
+ *ret_conv = CResult_CommitmentSignedDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_CommitmentSignedDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
+ *ret_conv = CResult_CommitmentSignedDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_CommitmentSignedDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_CommitmentSignedDecodeErrorZ* o_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_CommitmentSignedDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_CommitmentSignedDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_CommitmentSignedDecodeErrorZ _res_conv = *(LDKCResult_CommitmentSignedDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_CommitmentSignedDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_CommitmentSignedDecodeErrorZ_clone_ptr(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
+ *ret_conv = CResult_CommitmentSignedDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_CommitmentSignedDecodeErrorZ* arg_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_CommitmentSignedDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_CommitmentSignedDecodeErrorZ* orig_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)(orig & ~1);
+ LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
+ *ret_conv = CResult_CommitmentSignedDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_FundingCreatedDecodeErrorZ_ok(uint32_t o) {
+ LDKFundingCreated o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = FundingCreated_clone(&o_conv);
+ LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
+ *ret_conv = CResult_FundingCreatedDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_FundingCreatedDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
+ *ret_conv = CResult_FundingCreatedDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_FundingCreatedDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_FundingCreatedDecodeErrorZ* o_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_FundingCreatedDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_FundingCreatedDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_FundingCreatedDecodeErrorZ _res_conv = *(LDKCResult_FundingCreatedDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_FundingCreatedDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_FundingCreatedDecodeErrorZ_clone_ptr(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
+ *ret_conv = CResult_FundingCreatedDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_FundingCreatedDecodeErrorZ* arg_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_FundingCreatedDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_FundingCreatedDecodeErrorZ* orig_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)(orig & ~1);
+ LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
+ *ret_conv = CResult_FundingCreatedDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_FundingSignedDecodeErrorZ_ok(uint32_t o) {
+ LDKFundingSigned o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = FundingSigned_clone(&o_conv);
+ LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
+ *ret_conv = CResult_FundingSignedDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_FundingSignedDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
+ *ret_conv = CResult_FundingSignedDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_FundingSignedDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_FundingSignedDecodeErrorZ* o_conv = (LDKCResult_FundingSignedDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_FundingSignedDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_FundingSignedDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_FundingSignedDecodeErrorZ _res_conv = *(LDKCResult_FundingSignedDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_FundingSignedDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_FundingSignedDecodeErrorZ_clone_ptr(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
+ *ret_conv = CResult_FundingSignedDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_FundingSignedDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_FundingSignedDecodeErrorZ* arg_conv = (LDKCResult_FundingSignedDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_FundingSignedDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_FundingSignedDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_FundingSignedDecodeErrorZ* orig_conv = (LDKCResult_FundingSignedDecodeErrorZ*)(orig & ~1);
+ LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
+ *ret_conv = CResult_FundingSignedDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_FundingLockedDecodeErrorZ_ok(uint32_t o) {
+ LDKFundingLocked o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = FundingLocked_clone(&o_conv);
+ LDKCResult_FundingLockedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingLockedDecodeErrorZ), "LDKCResult_FundingLockedDecodeErrorZ");
+ *ret_conv = CResult_FundingLockedDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_FundingLockedDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_FundingLockedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingLockedDecodeErrorZ), "LDKCResult_FundingLockedDecodeErrorZ");
+ *ret_conv = CResult_FundingLockedDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_FundingLockedDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_FundingLockedDecodeErrorZ* o_conv = (LDKCResult_FundingLockedDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_FundingLockedDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_FundingLockedDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_FundingLockedDecodeErrorZ _res_conv = *(LDKCResult_FundingLockedDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_FundingLockedDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_FundingLockedDecodeErrorZ_clone_ptr(LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_FundingLockedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingLockedDecodeErrorZ), "LDKCResult_FundingLockedDecodeErrorZ");
+ *ret_conv = CResult_FundingLockedDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_FundingLockedDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_FundingLockedDecodeErrorZ* arg_conv = (LDKCResult_FundingLockedDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_FundingLockedDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_FundingLockedDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_FundingLockedDecodeErrorZ* orig_conv = (LDKCResult_FundingLockedDecodeErrorZ*)(orig & ~1);
+ LDKCResult_FundingLockedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingLockedDecodeErrorZ), "LDKCResult_FundingLockedDecodeErrorZ");
+ *ret_conv = CResult_FundingLockedDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_InitDecodeErrorZ_ok(uint32_t o) {
+ LDKInit o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = Init_clone(&o_conv);
+ LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
+ *ret_conv = CResult_InitDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_InitDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
+ *ret_conv = CResult_InitDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_InitDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_InitDecodeErrorZ* o_conv = (LDKCResult_InitDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_InitDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_InitDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_InitDecodeErrorZ _res_conv = *(LDKCResult_InitDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_InitDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_InitDecodeErrorZ_clone_ptr(LDKCResult_InitDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
+ *ret_conv = CResult_InitDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_InitDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_InitDecodeErrorZ* arg_conv = (LDKCResult_InitDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_InitDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_InitDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_InitDecodeErrorZ* orig_conv = (LDKCResult_InitDecodeErrorZ*)(orig & ~1);
+ LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
+ *ret_conv = CResult_InitDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_OpenChannelDecodeErrorZ_ok(uint32_t o) {
+ LDKOpenChannel o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = OpenChannel_clone(&o_conv);
+ LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
+ *ret_conv = CResult_OpenChannelDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_OpenChannelDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
+ *ret_conv = CResult_OpenChannelDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_OpenChannelDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_OpenChannelDecodeErrorZ* o_conv = (LDKCResult_OpenChannelDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_OpenChannelDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_OpenChannelDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_OpenChannelDecodeErrorZ _res_conv = *(LDKCResult_OpenChannelDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_OpenChannelDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_OpenChannelDecodeErrorZ_clone_ptr(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
+ *ret_conv = CResult_OpenChannelDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_OpenChannelDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_OpenChannelDecodeErrorZ* arg_conv = (LDKCResult_OpenChannelDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_OpenChannelDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_OpenChannelDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_OpenChannelDecodeErrorZ* orig_conv = (LDKCResult_OpenChannelDecodeErrorZ*)(orig & ~1);
+ LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
+ *ret_conv = CResult_OpenChannelDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_RevokeAndACKDecodeErrorZ_ok(uint32_t o) {
+ LDKRevokeAndACK o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = RevokeAndACK_clone(&o_conv);
+ LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
+ *ret_conv = CResult_RevokeAndACKDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_RevokeAndACKDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
+ *ret_conv = CResult_RevokeAndACKDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_RevokeAndACKDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_RevokeAndACKDecodeErrorZ* o_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RevokeAndACKDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_RevokeAndACKDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_RevokeAndACKDecodeErrorZ _res_conv = *(LDKCResult_RevokeAndACKDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_RevokeAndACKDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_RevokeAndACKDecodeErrorZ_clone_ptr(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
+ *ret_conv = CResult_RevokeAndACKDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_RevokeAndACKDecodeErrorZ* arg_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_RevokeAndACKDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_RevokeAndACKDecodeErrorZ* orig_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)(orig & ~1);
+ LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
+ *ret_conv = CResult_RevokeAndACKDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ShutdownDecodeErrorZ_ok(uint32_t o) {
+ LDKShutdown o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = Shutdown_clone(&o_conv);
+ LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
+ *ret_conv = CResult_ShutdownDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ShutdownDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
+ *ret_conv = CResult_ShutdownDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_ShutdownDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ShutdownDecodeErrorZ* o_conv = (LDKCResult_ShutdownDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ShutdownDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_ShutdownDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_ShutdownDecodeErrorZ _res_conv = *(LDKCResult_ShutdownDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_ShutdownDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_ShutdownDecodeErrorZ_clone_ptr(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
+ *ret_conv = CResult_ShutdownDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ShutdownDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ShutdownDecodeErrorZ* arg_conv = (LDKCResult_ShutdownDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ShutdownDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ShutdownDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_ShutdownDecodeErrorZ* orig_conv = (LDKCResult_ShutdownDecodeErrorZ*)(orig & ~1);
+ LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
+ *ret_conv = CResult_ShutdownDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_ok(uint32_t o) {
+ LDKUpdateFailHTLC o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = UpdateFailHTLC_clone(&o_conv);
+ LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
+ *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
+ *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_UpdateFailHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_UpdateFailHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateFailHTLCDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_UpdateFailHTLCDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
+ *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_UpdateFailHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_UpdateFailHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)(orig & ~1);
+ LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
+ *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(uint32_t o) {
+ LDKUpdateFailMalformedHTLC o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = UpdateFailMalformedHTLC_clone(&o_conv);
+ LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
+ *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
+ *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
+ *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(orig & ~1);
+ LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
+ *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateFeeDecodeErrorZ_ok(uint32_t o) {
+ LDKUpdateFee o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = UpdateFee_clone(&o_conv);
+ LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
+ *ret_conv = CResult_UpdateFeeDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateFeeDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
+ *ret_conv = CResult_UpdateFeeDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_UpdateFeeDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_UpdateFeeDecodeErrorZ* o_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UpdateFeeDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_UpdateFeeDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_UpdateFeeDecodeErrorZ _res_conv = *(LDKCResult_UpdateFeeDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_UpdateFeeDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_UpdateFeeDecodeErrorZ_clone_ptr(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
+ *ret_conv = CResult_UpdateFeeDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_UpdateFeeDecodeErrorZ* arg_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateFeeDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_UpdateFeeDecodeErrorZ* orig_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)(orig & ~1);
+ LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
+ *ret_conv = CResult_UpdateFeeDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_ok(uint32_t o) {
+ LDKUpdateFulfillHTLC o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = UpdateFulfillHTLC_clone(&o_conv);
+ LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
+ *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
+ *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_UpdateFulfillHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
+ *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_UpdateFulfillHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_UpdateFulfillHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(orig & ~1);
+ LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
+ *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_ok(uint32_t o) {
+ LDKUpdateAddHTLC o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = UpdateAddHTLC_clone(&o_conv);
+ LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
+ *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
+ *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_UpdateAddHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_UpdateAddHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateAddHTLCDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_UpdateAddHTLCDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
+ *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_UpdateAddHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_UpdateAddHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)(orig & ~1);
+ LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
+ *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_PingDecodeErrorZ_ok(uint32_t o) {
+ LDKPing o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = Ping_clone(&o_conv);
+ LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
+ *ret_conv = CResult_PingDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_PingDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
+ *ret_conv = CResult_PingDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_PingDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_PingDecodeErrorZ* o_conv = (LDKCResult_PingDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PingDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_PingDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_PingDecodeErrorZ _res_conv = *(LDKCResult_PingDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_PingDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_PingDecodeErrorZ_clone_ptr(LDKCResult_PingDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
+ *ret_conv = CResult_PingDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_PingDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_PingDecodeErrorZ* arg_conv = (LDKCResult_PingDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PingDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_PingDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_PingDecodeErrorZ* orig_conv = (LDKCResult_PingDecodeErrorZ*)(orig & ~1);
+ LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
+ *ret_conv = CResult_PingDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_PongDecodeErrorZ_ok(uint32_t o) {
+ LDKPong o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = Pong_clone(&o_conv);
+ LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
+ *ret_conv = CResult_PongDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_PongDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
+ *ret_conv = CResult_PongDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_PongDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_PongDecodeErrorZ* o_conv = (LDKCResult_PongDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PongDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_PongDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_PongDecodeErrorZ _res_conv = *(LDKCResult_PongDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_PongDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_PongDecodeErrorZ_clone_ptr(LDKCResult_PongDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
+ *ret_conv = CResult_PongDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_PongDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_PongDecodeErrorZ* arg_conv = (LDKCResult_PongDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PongDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_PongDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_PongDecodeErrorZ* orig_conv = (LDKCResult_PongDecodeErrorZ*)(orig & ~1);
+ LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
+ *ret_conv = CResult_PongDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(uint32_t o) {
+ LDKUnsignedChannelAnnouncement o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = UnsignedChannelAnnouncement_clone(&o_conv);
+ LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
+ *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
+ *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* o_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
+ *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(orig & ~1);
+ LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
+ *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_ok(uint32_t o) {
+ LDKChannelAnnouncement o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = ChannelAnnouncement_clone(&o_conv);
+ LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
+ *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
+ *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ChannelAnnouncementDecodeErrorZ* o_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_ChannelAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_ChannelAnnouncementDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_ChannelAnnouncementDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
+ *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ChannelAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_ChannelAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)(orig & ~1);
+ LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
+ *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_ok(uint32_t o) {
+ LDKUnsignedChannelUpdate o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = UnsignedChannelUpdate_clone(&o_conv);
+ LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
+ *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
+ *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_UnsignedChannelUpdateDecodeErrorZ* o_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res_conv = *(LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
+ *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_UnsignedChannelUpdateDecodeErrorZ* arg_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_UnsignedChannelUpdateDecodeErrorZ* orig_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(orig & ~1);
+ LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
+ *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelUpdateDecodeErrorZ_ok(uint32_t o) {
+ LDKChannelUpdate o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = ChannelUpdate_clone(&o_conv);
+ LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
+ *ret_conv = CResult_ChannelUpdateDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelUpdateDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
+ *ret_conv = CResult_ChannelUpdateDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_ChannelUpdateDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ChannelUpdateDecodeErrorZ* o_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelUpdateDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_ChannelUpdateDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_ChannelUpdateDecodeErrorZ _res_conv = *(LDKCResult_ChannelUpdateDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_ChannelUpdateDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_ChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
+ *ret_conv = CResult_ChannelUpdateDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ChannelUpdateDecodeErrorZ* arg_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelUpdateDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_ChannelUpdateDecodeErrorZ* orig_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)(orig & ~1);
+ LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
+ *ret_conv = CResult_ChannelUpdateDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ErrorMessageDecodeErrorZ_ok(uint32_t o) {
+ LDKErrorMessage o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = ErrorMessage_clone(&o_conv);
+ LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
+ *ret_conv = CResult_ErrorMessageDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ErrorMessageDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
+ *ret_conv = CResult_ErrorMessageDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_ErrorMessageDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ErrorMessageDecodeErrorZ* o_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ErrorMessageDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_ErrorMessageDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_ErrorMessageDecodeErrorZ _res_conv = *(LDKCResult_ErrorMessageDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_ErrorMessageDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_ErrorMessageDecodeErrorZ_clone_ptr(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
+ *ret_conv = CResult_ErrorMessageDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ErrorMessageDecodeErrorZ* arg_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ErrorMessageDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_ErrorMessageDecodeErrorZ* orig_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)(orig & ~1);
+ LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
+ *ret_conv = CResult_ErrorMessageDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(uint32_t o) {
+ LDKUnsignedNodeAnnouncement o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = UnsignedNodeAnnouncement_clone(&o_conv);
+ LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
+ *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
+ *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* o_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
+ *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(orig & ~1);
+ LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
+ *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementDecodeErrorZ_ok(uint32_t o) {
+ LDKNodeAnnouncement o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = NodeAnnouncement_clone(&o_conv);
+ LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
+ *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
+ *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NodeAnnouncementDecodeErrorZ* o_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NodeAnnouncementDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_NodeAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_NodeAnnouncementDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_NodeAnnouncementDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
+ *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NodeAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_NodeAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)(orig & ~1);
+ LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
+ *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_ok(uint32_t o) {
+ LDKQueryShortChannelIds o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = QueryShortChannelIds_clone(&o_conv);
+ LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
+ *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
+ *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_QueryShortChannelIdsDecodeErrorZ* o_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_QueryShortChannelIdsDecodeErrorZ _res_conv = *(LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_QueryShortChannelIdsDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
+ *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_QueryShortChannelIdsDecodeErrorZ* arg_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_QueryShortChannelIdsDecodeErrorZ* orig_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(orig & ~1);
+ LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
+ *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(uint32_t o) {
+ LDKReplyShortChannelIdsEnd o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = ReplyShortChannelIdsEnd_clone(&o_conv);
+ LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
+ *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
+ *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* o_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res_conv = *(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
+ *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* arg_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* orig_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(orig & ~1);
+ LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
+ *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_QueryChannelRangeDecodeErrorZ_ok(uint32_t o) {
+ LDKQueryChannelRange o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = QueryChannelRange_clone(&o_conv);
+ LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
+ *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_QueryChannelRangeDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
+ *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_QueryChannelRangeDecodeErrorZ* o_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_QueryChannelRangeDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_QueryChannelRangeDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_QueryChannelRangeDecodeErrorZ _res_conv = *(LDKCResult_QueryChannelRangeDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_QueryChannelRangeDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
+ *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_QueryChannelRangeDecodeErrorZ* arg_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_QueryChannelRangeDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_QueryChannelRangeDecodeErrorZ* orig_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)(orig & ~1);
+ LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
+ *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_ok(uint32_t o) {
+ LDKReplyChannelRange o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = ReplyChannelRange_clone(&o_conv);
+ LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
+ *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
+ *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ReplyChannelRangeDecodeErrorZ* o_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_ReplyChannelRangeDecodeErrorZ _res_conv = *(LDKCResult_ReplyChannelRangeDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_ReplyChannelRangeDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
+ *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ReplyChannelRangeDecodeErrorZ* arg_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_ReplyChannelRangeDecodeErrorZ* orig_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)(orig & ~1);
+ LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
+ *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_ok(uint32_t o) {
+ LDKGossipTimestampFilter o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = GossipTimestampFilter_clone(&o_conv);
+ LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
+ *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
+ *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_GossipTimestampFilterDecodeErrorZ* o_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_GossipTimestampFilterDecodeErrorZ _res_conv = *(LDKCResult_GossipTimestampFilterDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_GossipTimestampFilterDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
+ *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_GossipTimestampFilterDecodeErrorZ* arg_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_GossipTimestampFilterDecodeErrorZ* orig_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)(orig & ~1);
+ LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
+ *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_InvoiceSignOrCreationErrorZ_ok(uint32_t o) {
+ LDKInvoice o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ o_conv = Invoice_clone(&o_conv);
+ LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
+ *ret_conv = CResult_InvoiceSignOrCreationErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_InvoiceSignOrCreationErrorZ_err(uint32_t e) {
+ void* e_ptr = (void*)(((uint64_t)e) & ~1);
+ CHECK_ACCESS(e_ptr);
+ LDKSignOrCreationError e_conv = *(LDKSignOrCreationError*)(e_ptr);
+ e_conv = SignOrCreationError_clone((LDKSignOrCreationError*)(((uint64_t)e) & ~1));
+ LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
+ *ret_conv = CResult_InvoiceSignOrCreationErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_InvoiceSignOrCreationErrorZ_is_ok(uint32_t o) {
+ LDKCResult_InvoiceSignOrCreationErrorZ* o_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_InvoiceSignOrCreationErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_InvoiceSignOrCreationErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_InvoiceSignOrCreationErrorZ _res_conv = *(LDKCResult_InvoiceSignOrCreationErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_InvoiceSignOrCreationErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_InvoiceSignOrCreationErrorZ_clone_ptr(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR arg) {
+ LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
+ *ret_conv = CResult_InvoiceSignOrCreationErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_InvoiceSignOrCreationErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_InvoiceSignOrCreationErrorZ* arg_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_InvoiceSignOrCreationErrorZ_clone(uint32_t orig) {
+ LDKCResult_InvoiceSignOrCreationErrorZ* orig_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)(orig & ~1);
+ LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
+ *ret_conv = CResult_InvoiceSignOrCreationErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_FilterZ_some(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKFilter o_conv = *(LDKFilter*)(o_ptr);
+ LDKCOption_FilterZ *ret_copy = MALLOC(sizeof(LDKCOption_FilterZ), "LDKCOption_FilterZ");
+ *ret_copy = COption_FilterZ_some(o_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_FilterZ_none() {
+ LDKCOption_FilterZ *ret_copy = MALLOC(sizeof(LDKCOption_FilterZ), "LDKCOption_FilterZ");
+ *ret_copy = COption_FilterZ_none();
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+void __attribute__((visibility("default"))) TS_COption_FilterZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCOption_FilterZ _res_conv = *(LDKCOption_FilterZ*)(_res_ptr);
+ FREE((void*)_res);
+ COption_FilterZ_free(_res_conv);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_LockedChannelMonitorNoneZ_ok(uint32_t o) {
+ LDKLockedChannelMonitor o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ // Warning: we need a move here but no clone is available for LDKLockedChannelMonitor
+ LDKCResult_LockedChannelMonitorNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_LockedChannelMonitorNoneZ), "LDKCResult_LockedChannelMonitorNoneZ");
+ *ret_conv = CResult_LockedChannelMonitorNoneZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_LockedChannelMonitorNoneZ_err() {
+ LDKCResult_LockedChannelMonitorNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_LockedChannelMonitorNoneZ), "LDKCResult_LockedChannelMonitorNoneZ");
+ *ret_conv = CResult_LockedChannelMonitorNoneZ_err();
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_LockedChannelMonitorNoneZ_is_ok(uint32_t o) {
+ LDKCResult_LockedChannelMonitorNoneZ* o_conv = (LDKCResult_LockedChannelMonitorNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_LockedChannelMonitorNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_LockedChannelMonitorNoneZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_LockedChannelMonitorNoneZ _res_conv = *(LDKCResult_LockedChannelMonitorNoneZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_LockedChannelMonitorNoneZ_free(_res_conv);
+}
+
+void __attribute__((visibility("default"))) TS_CVec_OutPointZ_free(uint32_tArray _res) {
+ LDKCVec_OutPointZ _res_constr;
+ _res_constr.datalen = *((uint32_t*)_res);
+ if (_res_constr.datalen > 0)
+ _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKOutPoint), "LDKCVec_OutPointZ Elements");
+ else
+ _res_constr.data = NULL;
+ uint32_t* _res_vals = (uint32_t*)(_res + 4);
+ for (size_t k = 0; k < _res_constr.datalen; k++) {
+ uint32_t _res_conv_10 = _res_vals[k];
+ LDKOutPoint _res_conv_10_conv;
+ _res_conv_10_conv.inner = (void*)(_res_conv_10 & (~1));
+ _res_conv_10_conv.is_owned = (_res_conv_10 & 1) || (_res_conv_10 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_10_conv);
+ _res_constr.data[k] = _res_conv_10_conv;
+ }
+ CVec_OutPointZ_free(_res_constr);
+}
+
+void __attribute__((visibility("default"))) TS_PaymentPurpose_free(uint32_t this_ptr) {
+ if ((this_ptr & 1) != 0) return;
+ void* this_ptr_ptr = (void*)(((uint64_t)this_ptr) & ~1);
+ CHECK_ACCESS(this_ptr_ptr);
+ LDKPaymentPurpose this_ptr_conv = *(LDKPaymentPurpose*)(this_ptr_ptr);
+ FREE((void*)this_ptr);
+ PaymentPurpose_free(this_ptr_conv);
+}
+
+static inline uint64_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg) {
+ LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
+ *ret_copy = PaymentPurpose_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_PaymentPurpose_clone_ptr(uint32_t arg) {
+ LDKPaymentPurpose* arg_conv = (LDKPaymentPurpose*)arg;
+ int64_t ret_val = PaymentPurpose_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_PaymentPurpose_clone(uint32_t orig) {
+ LDKPaymentPurpose* orig_conv = (LDKPaymentPurpose*)orig;
+ LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
+ *ret_copy = PaymentPurpose_clone(orig_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_PaymentPurpose_invoice_payment(int8_tArray payment_preimage, int8_tArray payment_secret, int64_t user_payment_id) {
+ LDKThirtyTwoBytes payment_preimage_ref;
+ CHECK(*((uint32_t*)payment_preimage) == 32);
+ memcpy(payment_preimage_ref.data, (uint8_t*)(payment_preimage + 4), 32);
+ LDKThirtyTwoBytes payment_secret_ref;
+ CHECK(*((uint32_t*)payment_secret) == 32);
+ memcpy(payment_secret_ref.data, (uint8_t*)(payment_secret + 4), 32);
+ LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
+ *ret_copy = PaymentPurpose_invoice_payment(payment_preimage_ref, payment_secret_ref, user_payment_id);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_PaymentPurpose_spontaneous_payment(int8_tArray a) {
+ LDKThirtyTwoBytes a_ref;
+ CHECK(*((uint32_t*)a) == 32);
+ memcpy(a_ref.data, (uint8_t*)(a + 4), 32);
+ LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
+ *ret_copy = PaymentPurpose_spontaneous_payment(a_ref);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+void __attribute__((visibility("default"))) TS_ClosureReason_free(uint32_t this_ptr) {
+ if ((this_ptr & 1) != 0) return;
+ void* this_ptr_ptr = (void*)(((uint64_t)this_ptr) & ~1);
+ CHECK_ACCESS(this_ptr_ptr);
+ LDKClosureReason this_ptr_conv = *(LDKClosureReason*)(this_ptr_ptr);
+ FREE((void*)this_ptr);
+ ClosureReason_free(this_ptr_conv);
+}
+
+static inline uint64_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg) {
+ LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
+ *ret_copy = ClosureReason_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ClosureReason_clone_ptr(uint32_t arg) {
+ LDKClosureReason* arg_conv = (LDKClosureReason*)arg;
+ int64_t ret_val = ClosureReason_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_ClosureReason_clone(uint32_t orig) {
+ LDKClosureReason* orig_conv = (LDKClosureReason*)orig;
+ LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
+ *ret_copy = ClosureReason_clone(orig_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_ClosureReason_counterparty_force_closed(jstring peer_msg) {
+ LDKStr peer_msg_conv = str_ref_to_owned_c(peer_msg);
+ LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
+ *ret_copy = ClosureReason_counterparty_force_closed(peer_msg_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_ClosureReason_holder_force_closed() {
+ LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
+ *ret_copy = ClosureReason_holder_force_closed();
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_ClosureReason_cooperative_closure() {
+ LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
+ *ret_copy = ClosureReason_cooperative_closure();
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_ClosureReason_commitment_tx_confirmed() {
+ LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
+ *ret_copy = ClosureReason_commitment_tx_confirmed();
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_ClosureReason_processing_error(jstring err) {
+ LDKStr err_conv = str_ref_to_owned_c(err);
+ LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
+ *ret_copy = ClosureReason_processing_error(err_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_ClosureReason_disconnected_peer() {
+ LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
+ *ret_copy = ClosureReason_disconnected_peer();
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_ClosureReason_outdated_channel_manager() {
+ LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
+ *ret_copy = ClosureReason_outdated_channel_manager();
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+int8_tArray __attribute__((visibility("default"))) TS_ClosureReason_write(uint32_t obj) {
+ LDKClosureReason* obj_conv = (LDKClosureReason*)obj;
+ LDKCVec_u8Z ret_var = ClosureReason_write(obj_conv);
+ int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
+ memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
+ CVec_u8Z_free(ret_var);
+ return ret_arr;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_ClosureReason_read(int8_tArray ser) {
+ LDKu8slice ser_ref;
+ ser_ref.datalen = *((uint32_t*)ser);
+ ser_ref.data = (int8_t*)(ser + 4);
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
+ *ret_conv = ClosureReason_read(ser_ref);
+ return (uint64_t)ret_conv;
+}
+
+void __attribute__((visibility("default"))) TS_Event_free(uint32_t this_ptr) {
+ if ((this_ptr & 1) != 0) return;
+ void* this_ptr_ptr = (void*)(((uint64_t)this_ptr) & ~1);
+ CHECK_ACCESS(this_ptr_ptr);
+ LDKEvent this_ptr_conv = *(LDKEvent*)(this_ptr_ptr);
+ FREE((void*)this_ptr);
+ Event_free(this_ptr_conv);
+}
+
+static inline uint64_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg) {
+ LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
+ *ret_copy = Event_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_Event_clone_ptr(uint32_t arg) {
+ LDKEvent* arg_conv = (LDKEvent*)arg;
+ int64_t ret_val = Event_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_Event_clone(uint32_t orig) {
+ LDKEvent* orig_conv = (LDKEvent*)orig;
+ LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
+ *ret_copy = Event_clone(orig_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_Event_funding_generation_ready(int8_tArray temporary_channel_id, int64_t channel_value_satoshis, int8_tArray output_script, int64_t user_channel_id) {
+ LDKThirtyTwoBytes temporary_channel_id_ref;
+ CHECK(*((uint32_t*)temporary_channel_id) == 32);
+ memcpy(temporary_channel_id_ref.data, (uint8_t*)(temporary_channel_id + 4), 32);
+ LDKCVec_u8Z output_script_ref;
+ output_script_ref.datalen = *((uint32_t*)output_script);
+ output_script_ref.data = MALLOC(output_script_ref.datalen, "LDKCVec_u8Z Bytes");
+ memcpy(output_script_ref.data, (uint8_t*)(output_script + 4), output_script_ref.datalen);
+ LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
+ *ret_copy = Event_funding_generation_ready(temporary_channel_id_ref, channel_value_satoshis, output_script_ref, user_channel_id);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_Event_payment_received(int8_tArray payment_hash, int64_t amt, uint32_t purpose) {
+ LDKThirtyTwoBytes payment_hash_ref;
+ CHECK(*((uint32_t*)payment_hash) == 32);
+ memcpy(payment_hash_ref.data, (uint8_t*)(payment_hash + 4), 32);
+ void* purpose_ptr = (void*)(((uint64_t)purpose) & ~1);
+ CHECK_ACCESS(purpose_ptr);
+ LDKPaymentPurpose purpose_conv = *(LDKPaymentPurpose*)(purpose_ptr);
+ purpose_conv = PaymentPurpose_clone((LDKPaymentPurpose*)(((uint64_t)purpose) & ~1));
+ LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
+ *ret_copy = Event_payment_received(payment_hash_ref, amt, purpose_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_Event_payment_sent(int8_tArray payment_id, int8_tArray payment_preimage, int8_tArray payment_hash, uint32_t fee_paid_msat) {
+ LDKThirtyTwoBytes payment_id_ref;
+ CHECK(*((uint32_t*)payment_id) == 32);
+ memcpy(payment_id_ref.data, (uint8_t*)(payment_id + 4), 32);
+ LDKThirtyTwoBytes payment_preimage_ref;
+ CHECK(*((uint32_t*)payment_preimage) == 32);
+ memcpy(payment_preimage_ref.data, (uint8_t*)(payment_preimage + 4), 32);
+ LDKThirtyTwoBytes payment_hash_ref;
+ CHECK(*((uint32_t*)payment_hash) == 32);
+ memcpy(payment_hash_ref.data, (uint8_t*)(payment_hash + 4), 32);
+ void* fee_paid_msat_ptr = (void*)(((uint64_t)fee_paid_msat) & ~1);
+ CHECK_ACCESS(fee_paid_msat_ptr);
+ LDKCOption_u64Z fee_paid_msat_conv = *(LDKCOption_u64Z*)(fee_paid_msat_ptr);
+ fee_paid_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uint64_t)fee_paid_msat) & ~1));
+ LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
+ *ret_copy = Event_payment_sent(payment_id_ref, payment_preimage_ref, payment_hash_ref, fee_paid_msat_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_Event_payment_path_failed(int8_tArray payment_id, int8_tArray payment_hash, jboolean rejected_by_dest, uint32_t network_update, jboolean all_paths_failed, uint32_tArray path, uint32_t short_channel_id, uint32_t retry) {
+ LDKThirtyTwoBytes payment_id_ref;
+ CHECK(*((uint32_t*)payment_id) == 32);
+ memcpy(payment_id_ref.data, (uint8_t*)(payment_id + 4), 32);
+ LDKThirtyTwoBytes payment_hash_ref;
+ CHECK(*((uint32_t*)payment_hash) == 32);
+ memcpy(payment_hash_ref.data, (uint8_t*)(payment_hash + 4), 32);
+ void* network_update_ptr = (void*)(((uint64_t)network_update) & ~1);
+ CHECK_ACCESS(network_update_ptr);
+ LDKCOption_NetworkUpdateZ network_update_conv = *(LDKCOption_NetworkUpdateZ*)(network_update_ptr);
+ network_update_conv = COption_NetworkUpdateZ_clone((LDKCOption_NetworkUpdateZ*)(((uint64_t)network_update) & ~1));
+ LDKCVec_RouteHopZ path_constr;
+ path_constr.datalen = *((uint32_t*)path);
+ if (path_constr.datalen > 0)
+ path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
+ else
+ path_constr.data = NULL;
+ uint32_t* path_vals = (uint32_t*)(path + 4);
+ for (size_t k = 0; k < path_constr.datalen; k++) {
+ uint32_t path_conv_10 = path_vals[k];
+ LDKRouteHop path_conv_10_conv;
+ path_conv_10_conv.inner = (void*)(path_conv_10 & (~1));
+ path_conv_10_conv.is_owned = (path_conv_10 & 1) || (path_conv_10 == 0);
+ 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;
+ }
+ void* short_channel_id_ptr = (void*)(((uint64_t)short_channel_id) & ~1);
+ CHECK_ACCESS(short_channel_id_ptr);
+ LDKCOption_u64Z short_channel_id_conv = *(LDKCOption_u64Z*)(short_channel_id_ptr);
+ short_channel_id_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uint64_t)short_channel_id) & ~1));
+ LDKRouteParameters retry_conv;
+ retry_conv.inner = (void*)(retry & (~1));
+ retry_conv.is_owned = (retry & 1) || (retry == 0);
+ 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);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_Event_pending_htlcs_forwardable(int64_t time_forwardable) {
+ LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
+ *ret_copy = Event_pending_htlcs_forwardable(time_forwardable);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_Event_spendable_outputs(uint32_tArray outputs) {
+ LDKCVec_SpendableOutputDescriptorZ outputs_constr;
+ outputs_constr.datalen = *((uint32_t*)outputs);
+ if (outputs_constr.datalen > 0)
+ outputs_constr.data = MALLOC(outputs_constr.datalen * sizeof(LDKSpendableOutputDescriptor), "LDKCVec_SpendableOutputDescriptorZ Elements");
+ else
+ outputs_constr.data = NULL;
+ uint32_t* outputs_vals = (uint32_t*)(outputs + 4);
+ for (size_t b = 0; b < outputs_constr.datalen; b++) {
+ uint32_t outputs_conv_27 = outputs_vals[b];
+ void* outputs_conv_27_ptr = (void*)(((uint64_t)outputs_conv_27) & ~1);
+ CHECK_ACCESS(outputs_conv_27_ptr);
+ LDKSpendableOutputDescriptor outputs_conv_27_conv = *(LDKSpendableOutputDescriptor*)(outputs_conv_27_ptr);
+ outputs_conv_27_conv = SpendableOutputDescriptor_clone((LDKSpendableOutputDescriptor*)(((uint64_t)outputs_conv_27) & ~1));
+ outputs_constr.data[b] = outputs_conv_27_conv;
+ }
+ LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
+ *ret_copy = Event_spendable_outputs(outputs_constr);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_Event_payment_forwarded(uint32_t fee_earned_msat, jboolean claim_from_onchain_tx) {
+ void* fee_earned_msat_ptr = (void*)(((uint64_t)fee_earned_msat) & ~1);
+ CHECK_ACCESS(fee_earned_msat_ptr);
+ LDKCOption_u64Z fee_earned_msat_conv = *(LDKCOption_u64Z*)(fee_earned_msat_ptr);
+ fee_earned_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uint64_t)fee_earned_msat) & ~1));
+ LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
+ *ret_copy = Event_payment_forwarded(fee_earned_msat_conv, claim_from_onchain_tx);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_Event_channel_closed(int8_tArray channel_id, int64_t user_channel_id, uint32_t reason) {
+ LDKThirtyTwoBytes channel_id_ref;
+ CHECK(*((uint32_t*)channel_id) == 32);
+ memcpy(channel_id_ref.data, (uint8_t*)(channel_id + 4), 32);
+ void* reason_ptr = (void*)(((uint64_t)reason) & ~1);
+ CHECK_ACCESS(reason_ptr);
+ LDKClosureReason reason_conv = *(LDKClosureReason*)(reason_ptr);
+ reason_conv = ClosureReason_clone((LDKClosureReason*)(((uint64_t)reason) & ~1));
+ LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
+ *ret_copy = Event_channel_closed(channel_id_ref, user_channel_id, reason_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_Event_discard_funding(int8_tArray channel_id, int8_tArray transaction) {
+ LDKThirtyTwoBytes channel_id_ref;
+ CHECK(*((uint32_t*)channel_id) == 32);
+ memcpy(channel_id_ref.data, (uint8_t*)(channel_id + 4), 32);
+ LDKTransaction transaction_ref;
+ transaction_ref.datalen = *((uint32_t*)transaction);
+ transaction_ref.data = MALLOC(transaction_ref.datalen, "LDKTransaction Bytes");
+ memcpy(transaction_ref.data, (uint8_t*)(transaction + 4), transaction_ref.datalen);
+ transaction_ref.data_is_owned = true;
+ LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
+ *ret_copy = Event_discard_funding(channel_id_ref, transaction_ref);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+int8_tArray __attribute__((visibility("default"))) TS_Event_write(uint32_t obj) {
+ LDKEvent* obj_conv = (LDKEvent*)obj;
+ LDKCVec_u8Z ret_var = Event_write(obj_conv);
+ int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
+ memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
+ CVec_u8Z_free(ret_var);
+ return ret_arr;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_Event_read(int8_tArray ser) {
+ LDKu8slice ser_ref;
+ ser_ref.datalen = *((uint32_t*)ser);
+ ser_ref.data = (int8_t*)(ser + 4);
+ LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
+ *ret_conv = Event_read(ser_ref);
+ return (uint64_t)ret_conv;
+}
+
+void __attribute__((visibility("default"))) TS_MessageSendEvent_free(uint32_t this_ptr) {
+ if ((this_ptr & 1) != 0) return;
+ void* this_ptr_ptr = (void*)(((uint64_t)this_ptr) & ~1);
+ CHECK_ACCESS(this_ptr_ptr);
+ LDKMessageSendEvent this_ptr_conv = *(LDKMessageSendEvent*)(this_ptr_ptr);
+ FREE((void*)this_ptr);
+ MessageSendEvent_free(this_ptr_conv);
+}
+
+static inline uint64_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg) {
+ LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
+ *ret_copy = MessageSendEvent_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_MessageSendEvent_clone_ptr(uint32_t arg) {
+ LDKMessageSendEvent* arg_conv = (LDKMessageSendEvent*)arg;
+ int64_t ret_val = MessageSendEvent_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_MessageSendEvent_clone(uint32_t orig) {
+ LDKMessageSendEvent* orig_conv = (LDKMessageSendEvent*)orig;
+ LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
+ *ret_copy = MessageSendEvent_clone(orig_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_MessageSendEvent_send_accept_channel(int8_tArray node_id, uint32_t msg) {
+ LDKPublicKey node_id_ref;
+ CHECK(*((uint32_t*)node_id) == 33);
+ memcpy(node_id_ref.compressed_form, (uint8_t*)(node_id + 4), 33);
+ LDKAcceptChannel msg_conv;
+ msg_conv.inner = (void*)(msg & (~1));
+ msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
+ msg_conv = AcceptChannel_clone(&msg_conv);
+ LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
+ *ret_copy = MessageSendEvent_send_accept_channel(node_id_ref, msg_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_MessageSendEvent_send_open_channel(int8_tArray node_id, uint32_t msg) {
+ LDKPublicKey node_id_ref;
+ CHECK(*((uint32_t*)node_id) == 33);
+ memcpy(node_id_ref.compressed_form, (uint8_t*)(node_id + 4), 33);
+ LDKOpenChannel msg_conv;
+ msg_conv.inner = (void*)(msg & (~1));
+ msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
+ msg_conv = OpenChannel_clone(&msg_conv);
+ LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
+ *ret_copy = MessageSendEvent_send_open_channel(node_id_ref, msg_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_MessageSendEvent_send_funding_created(int8_tArray node_id, uint32_t msg) {
+ LDKPublicKey node_id_ref;
+ CHECK(*((uint32_t*)node_id) == 33);
+ memcpy(node_id_ref.compressed_form, (uint8_t*)(node_id + 4), 33);
+ LDKFundingCreated msg_conv;
+ msg_conv.inner = (void*)(msg & (~1));
+ msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
+ msg_conv = FundingCreated_clone(&msg_conv);
+ LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
+ *ret_copy = MessageSendEvent_send_funding_created(node_id_ref, msg_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_MessageSendEvent_send_funding_signed(int8_tArray node_id, uint32_t msg) {
+ LDKPublicKey node_id_ref;
+ CHECK(*((uint32_t*)node_id) == 33);
+ memcpy(node_id_ref.compressed_form, (uint8_t*)(node_id + 4), 33);
+ LDKFundingSigned msg_conv;
+ msg_conv.inner = (void*)(msg & (~1));
+ msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
+ msg_conv = FundingSigned_clone(&msg_conv);
+ LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
+ *ret_copy = MessageSendEvent_send_funding_signed(node_id_ref, msg_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_MessageSendEvent_send_funding_locked(int8_tArray node_id, uint32_t msg) {
+ LDKPublicKey node_id_ref;
+ CHECK(*((uint32_t*)node_id) == 33);
+ memcpy(node_id_ref.compressed_form, (uint8_t*)(node_id + 4), 33);
+ LDKFundingLocked msg_conv;
+ msg_conv.inner = (void*)(msg & (~1));
+ msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
+ msg_conv = FundingLocked_clone(&msg_conv);
+ LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
+ *ret_copy = MessageSendEvent_send_funding_locked(node_id_ref, msg_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_MessageSendEvent_send_announcement_signatures(int8_tArray node_id, uint32_t msg) {
+ LDKPublicKey node_id_ref;
+ CHECK(*((uint32_t*)node_id) == 33);
+ memcpy(node_id_ref.compressed_form, (uint8_t*)(node_id + 4), 33);
+ LDKAnnouncementSignatures msg_conv;
+ msg_conv.inner = (void*)(msg & (~1));
+ msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
+ msg_conv = AnnouncementSignatures_clone(&msg_conv);
+ LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
+ *ret_copy = MessageSendEvent_send_announcement_signatures(node_id_ref, msg_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_MessageSendEvent_update_htlcs(int8_tArray node_id, uint32_t updates) {
+ LDKPublicKey node_id_ref;
+ CHECK(*((uint32_t*)node_id) == 33);
+ memcpy(node_id_ref.compressed_form, (uint8_t*)(node_id + 4), 33);
+ LDKCommitmentUpdate updates_conv;
+ updates_conv.inner = (void*)(updates & (~1));
+ updates_conv.is_owned = (updates & 1) || (updates == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(updates_conv);
+ updates_conv = CommitmentUpdate_clone(&updates_conv);
+ LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
+ *ret_copy = MessageSendEvent_update_htlcs(node_id_ref, updates_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_MessageSendEvent_send_revoke_and_ack(int8_tArray node_id, uint32_t msg) {
+ LDKPublicKey node_id_ref;
+ CHECK(*((uint32_t*)node_id) == 33);
+ memcpy(node_id_ref.compressed_form, (uint8_t*)(node_id + 4), 33);
+ LDKRevokeAndACK msg_conv;
+ msg_conv.inner = (void*)(msg & (~1));
+ msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
+ msg_conv = RevokeAndACK_clone(&msg_conv);
+ LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
+ *ret_copy = MessageSendEvent_send_revoke_and_ack(node_id_ref, msg_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_MessageSendEvent_send_closing_signed(int8_tArray node_id, uint32_t msg) {
+ LDKPublicKey node_id_ref;
+ CHECK(*((uint32_t*)node_id) == 33);
+ memcpy(node_id_ref.compressed_form, (uint8_t*)(node_id + 4), 33);
+ LDKClosingSigned msg_conv;
+ msg_conv.inner = (void*)(msg & (~1));
+ msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
+ msg_conv = ClosingSigned_clone(&msg_conv);
+ LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
+ *ret_copy = MessageSendEvent_send_closing_signed(node_id_ref, msg_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_MessageSendEvent_send_shutdown(int8_tArray node_id, uint32_t msg) {
+ LDKPublicKey node_id_ref;
+ CHECK(*((uint32_t*)node_id) == 33);
+ memcpy(node_id_ref.compressed_form, (uint8_t*)(node_id + 4), 33);
+ LDKShutdown msg_conv;
+ msg_conv.inner = (void*)(msg & (~1));
+ msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
+ msg_conv = Shutdown_clone(&msg_conv);
+ LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
+ *ret_copy = MessageSendEvent_send_shutdown(node_id_ref, msg_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_MessageSendEvent_send_channel_reestablish(int8_tArray node_id, uint32_t msg) {
+ LDKPublicKey node_id_ref;
+ CHECK(*((uint32_t*)node_id) == 33);
+ memcpy(node_id_ref.compressed_form, (uint8_t*)(node_id + 4), 33);
+ LDKChannelReestablish msg_conv;
+ msg_conv.inner = (void*)(msg & (~1));
+ msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
+ msg_conv = ChannelReestablish_clone(&msg_conv);
+ LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
+ *ret_copy = MessageSendEvent_send_channel_reestablish(node_id_ref, msg_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_MessageSendEvent_broadcast_channel_announcement(uint32_t msg, uint32_t update_msg) {
+ LDKChannelAnnouncement msg_conv;
+ msg_conv.inner = (void*)(msg & (~1));
+ msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
+ msg_conv = ChannelAnnouncement_clone(&msg_conv);
+ LDKChannelUpdate update_msg_conv;
+ update_msg_conv.inner = (void*)(update_msg & (~1));
+ update_msg_conv.is_owned = (update_msg & 1) || (update_msg == 0);
+ 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);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_MessageSendEvent_broadcast_node_announcement(uint32_t msg) {
+ LDKNodeAnnouncement msg_conv;
+ msg_conv.inner = (void*)(msg & (~1));
+ msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
+ msg_conv = NodeAnnouncement_clone(&msg_conv);
+ LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
+ *ret_copy = MessageSendEvent_broadcast_node_announcement(msg_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_MessageSendEvent_broadcast_channel_update(uint32_t msg) {
+ LDKChannelUpdate msg_conv;
+ msg_conv.inner = (void*)(msg & (~1));
+ msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
+ msg_conv = ChannelUpdate_clone(&msg_conv);
+ LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
+ *ret_copy = MessageSendEvent_broadcast_channel_update(msg_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_MessageSendEvent_send_channel_update(int8_tArray node_id, uint32_t msg) {
+ LDKPublicKey node_id_ref;
+ CHECK(*((uint32_t*)node_id) == 33);
+ memcpy(node_id_ref.compressed_form, (uint8_t*)(node_id + 4), 33);
+ LDKChannelUpdate msg_conv;
+ msg_conv.inner = (void*)(msg & (~1));
+ msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
+ msg_conv = ChannelUpdate_clone(&msg_conv);
+ LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
+ *ret_copy = MessageSendEvent_send_channel_update(node_id_ref, msg_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_MessageSendEvent_handle_error(int8_tArray node_id, uint32_t action) {
+ LDKPublicKey node_id_ref;
+ CHECK(*((uint32_t*)node_id) == 33);
+ memcpy(node_id_ref.compressed_form, (uint8_t*)(node_id + 4), 33);
+ void* action_ptr = (void*)(((uint64_t)action) & ~1);
+ CHECK_ACCESS(action_ptr);
+ LDKErrorAction action_conv = *(LDKErrorAction*)(action_ptr);
+ action_conv = ErrorAction_clone((LDKErrorAction*)(((uint64_t)action) & ~1));
+ LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
+ *ret_copy = MessageSendEvent_handle_error(node_id_ref, action_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_MessageSendEvent_send_channel_range_query(int8_tArray node_id, uint32_t msg) {
+ LDKPublicKey node_id_ref;
+ CHECK(*((uint32_t*)node_id) == 33);
+ memcpy(node_id_ref.compressed_form, (uint8_t*)(node_id + 4), 33);
+ LDKQueryChannelRange msg_conv;
+ msg_conv.inner = (void*)(msg & (~1));
+ msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
+ msg_conv = QueryChannelRange_clone(&msg_conv);
+ LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
+ *ret_copy = MessageSendEvent_send_channel_range_query(node_id_ref, msg_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_MessageSendEvent_send_short_ids_query(int8_tArray node_id, uint32_t msg) {
+ LDKPublicKey node_id_ref;
+ CHECK(*((uint32_t*)node_id) == 33);
+ memcpy(node_id_ref.compressed_form, (uint8_t*)(node_id + 4), 33);
+ LDKQueryShortChannelIds msg_conv;
+ msg_conv.inner = (void*)(msg & (~1));
+ msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
+ msg_conv = QueryShortChannelIds_clone(&msg_conv);
+ LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
+ *ret_copy = MessageSendEvent_send_short_ids_query(node_id_ref, msg_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_MessageSendEvent_send_reply_channel_range(int8_tArray node_id, uint32_t msg) {
+ LDKPublicKey node_id_ref;
+ CHECK(*((uint32_t*)node_id) == 33);
+ memcpy(node_id_ref.compressed_form, (uint8_t*)(node_id + 4), 33);
+ LDKReplyChannelRange msg_conv;
+ msg_conv.inner = (void*)(msg & (~1));
+ msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
+ msg_conv = ReplyChannelRange_clone(&msg_conv);
+ LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
+ *ret_copy = MessageSendEvent_send_reply_channel_range(node_id_ref, msg_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+void __attribute__((visibility("default"))) TS_MessageSendEventsProvider_free(uint32_t this_ptr) {
+ if ((this_ptr & 1) != 0) return;
+ void* this_ptr_ptr = (void*)(((uint64_t)this_ptr) & ~1);
+ CHECK_ACCESS(this_ptr_ptr);
+ LDKMessageSendEventsProvider this_ptr_conv = *(LDKMessageSendEventsProvider*)(this_ptr_ptr);
+ FREE((void*)this_ptr);
+ MessageSendEventsProvider_free(this_ptr_conv);
+}
+
+void __attribute__((visibility("default"))) TS_EventsProvider_free(uint32_t this_ptr) {
+ if ((this_ptr & 1) != 0) return;
+ void* this_ptr_ptr = (void*)(((uint64_t)this_ptr) & ~1);
+ CHECK_ACCESS(this_ptr_ptr);
+ LDKEventsProvider this_ptr_conv = *(LDKEventsProvider*)(this_ptr_ptr);
+ FREE((void*)this_ptr);
+ EventsProvider_free(this_ptr_conv);
+}
+
+void __attribute__((visibility("default"))) TS_EventHandler_free(uint32_t this_ptr) {
+ if ((this_ptr & 1) != 0) return;
+ void* this_ptr_ptr = (void*)(((uint64_t)this_ptr) & ~1);
+ CHECK_ACCESS(this_ptr_ptr);
+ LDKEventHandler this_ptr_conv = *(LDKEventHandler*)(this_ptr_ptr);
+ FREE((void*)this_ptr);
+ EventHandler_free(this_ptr_conv);
+}
+
+void __attribute__((visibility("default"))) TS_APIError_free(uint32_t this_ptr) {
+ if ((this_ptr & 1) != 0) return;
+ void* this_ptr_ptr = (void*)(((uint64_t)this_ptr) & ~1);
+ CHECK_ACCESS(this_ptr_ptr);
+ LDKAPIError this_ptr_conv = *(LDKAPIError*)(this_ptr_ptr);
+ FREE((void*)this_ptr);
+ APIError_free(this_ptr_conv);
+}
+
+static inline uint64_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg) {
+ LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
+ *ret_copy = APIError_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_APIError_clone_ptr(uint32_t arg) {
+ LDKAPIError* arg_conv = (LDKAPIError*)arg;
+ int64_t ret_val = APIError_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_APIError_clone(uint32_t orig) {
+ LDKAPIError* orig_conv = (LDKAPIError*)orig;
+ LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
+ *ret_copy = APIError_clone(orig_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_APIError_apimisuse_error(jstring err) {
+ LDKStr err_conv = str_ref_to_owned_c(err);
+ LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
+ *ret_copy = APIError_apimisuse_error(err_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_APIError_fee_rate_too_high(jstring err, int32_t feerate) {
+ LDKStr err_conv = str_ref_to_owned_c(err);
+ LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
+ *ret_copy = APIError_fee_rate_too_high(err_conv, feerate);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_APIError_route_error(jstring err) {
+ LDKStr err_conv = str_ref_to_owned_c(err);
+ LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
+ *ret_copy = APIError_route_error(err_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_APIError_channel_unavailable(jstring err) {
+ LDKStr err_conv = str_ref_to_owned_c(err);
+ LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
+ *ret_copy = APIError_channel_unavailable(err_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_APIError_monitor_update_failed() {
+ LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
+ *ret_copy = APIError_monitor_update_failed();
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_APIError_incompatible_shutdown_script(uint32_t script) {
+ LDKShutdownScript script_conv;
+ script_conv.inner = (void*)(script & (~1));
+ script_conv.is_owned = (script & 1) || (script == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(script_conv);
+ script_conv = ShutdownScript_clone(&script_conv);
+ LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
+ *ret_copy = APIError_incompatible_shutdown_script(script_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_sign(int8_tArray msg, int8_tArray sk) {
+ LDKu8slice msg_ref;
+ msg_ref.datalen = *((uint32_t*)msg);
+ msg_ref.data = (int8_t*)(msg + 4);
+ unsigned char sk_arr[32];
+ CHECK(*((uint32_t*)sk) == 32);
+ memcpy(sk_arr, (uint8_t*)(sk + 4), 32);
+ unsigned char (*sk_ref)[32] = &sk_arr;
+ LDKCResult_StringErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StringErrorZ), "LDKCResult_StringErrorZ");
+ *ret_conv = sign(msg_ref, sk_ref);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_recover_pk(int8_tArray msg, jstring sig) {
+ LDKu8slice msg_ref;
+ msg_ref.datalen = *((uint32_t*)msg);
+ msg_ref.data = (int8_t*)(msg + 4);
+ LDKStr sig_conv = str_ref_to_owned_c(sig);
+ LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
+ *ret_conv = recover_pk(msg_ref, sig_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_verify(int8_tArray msg, jstring sig, int8_tArray pk) {
+ LDKu8slice msg_ref;
+ msg_ref.datalen = *((uint32_t*)msg);
+ msg_ref.data = (int8_t*)(msg + 4);
+ LDKStr sig_conv = str_ref_to_owned_c(sig);
+ LDKPublicKey pk_ref;
+ CHECK(*((uint32_t*)pk) == 33);
+ memcpy(pk_ref.compressed_form, (uint8_t*)(pk + 4), 33);
+ jboolean ret_val = verify(msg_ref, sig_conv, pk_ref);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_Level_clone(uint32_t orig) {
+ LDKLevel* orig_conv = (LDKLevel*)(orig & ~1);
+ uint32_t ret_conv = LDKLevel_to_js(Level_clone(orig_conv));
+ return ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_Level_trace() {
+ uint32_t ret_conv = LDKLevel_to_js(Level_trace());
+ return ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_Level_debug() {
+ uint32_t ret_conv = LDKLevel_to_js(Level_debug());
+ return ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_Level_info() {
+ uint32_t ret_conv = LDKLevel_to_js(Level_info());
+ return ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_Level_warn() {
+ uint32_t ret_conv = LDKLevel_to_js(Level_warn());
+ return ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_Level_error() {
+ uint32_t ret_conv = LDKLevel_to_js(Level_error());
+ return ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_Level_eq(uint32_t a, uint32_t b) {
+ LDKLevel* a_conv = (LDKLevel*)(a & ~1);
+ LDKLevel* b_conv = (LDKLevel*)(b & ~1);
+ jboolean ret_val = Level_eq(a_conv, b_conv);
+ return ret_val;
+}
+
+int64_t __attribute__((visibility("default"))) TS_Level_hash(uint32_t o) {
+ LDKLevel* o_conv = (LDKLevel*)(o & ~1);
+ int64_t ret_val = Level_hash(o_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_Level_max() {
+ uint32_t ret_conv = LDKLevel_to_js(Level_max());
+ return ret_conv;
+}
+
+void __attribute__((visibility("default"))) TS_Record_free(uint32_t this_obj) {
+ LDKRecord this_obj_conv;
+ this_obj_conv.inner = (void*)(this_obj & (~1));
+ this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
+ Record_free(this_obj_conv);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_Record_get_level(uint32_t this_ptr) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ uint32_t ret_conv = LDKLevel_to_js(Record_get_level(&this_ptr_conv));
+ return ret_conv;
+}
+
+void __attribute__((visibility("default"))) TS_Record_set_level(uint32_t this_ptr, uint32_t val) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKLevel val_conv = LDKLevel_from_js(val);
+ Record_set_level(&this_ptr_conv, val_conv);
+}
+
+jstring __attribute__((visibility("default"))) TS_Record_get_args(uint32_t this_ptr) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKStr ret_str = Record_get_args(&this_ptr_conv);
+ jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
+ Str_free(ret_str);
+ return ret_conv;
+}
+
+void __attribute__((visibility("default"))) TS_Record_set_args(uint32_t this_ptr, jstring val) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKStr val_conv = str_ref_to_owned_c(val);
+ Record_set_args(&this_ptr_conv, val_conv);
+}
+
+jstring __attribute__((visibility("default"))) TS_Record_get_module_path(uint32_t this_ptr) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKStr ret_str = Record_get_module_path(&this_ptr_conv);
+ jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
+ Str_free(ret_str);
+ return ret_conv;
+}
+
+void __attribute__((visibility("default"))) TS_Record_set_module_path(uint32_t this_ptr, jstring val) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKStr val_conv = str_ref_to_owned_c(val);
+ Record_set_module_path(&this_ptr_conv, val_conv);
+}
+
+jstring __attribute__((visibility("default"))) TS_Record_get_file(uint32_t this_ptr) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKStr ret_str = Record_get_file(&this_ptr_conv);
+ jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
+ Str_free(ret_str);
+ return ret_conv;
+}
+
+void __attribute__((visibility("default"))) TS_Record_set_file(uint32_t this_ptr, jstring val) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKStr val_conv = str_ref_to_owned_c(val);
+ Record_set_file(&this_ptr_conv, val_conv);
+}
+
+int32_t __attribute__((visibility("default"))) TS_Record_get_line(uint32_t this_ptr) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ int32_t ret_val = Record_get_line(&this_ptr_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_Record_set_line(uint32_t this_ptr, int32_t val) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ Record_set_line(&this_ptr_conv, val);
+}
+
+static inline uint64_t Record_clone_ptr(LDKRecord *NONNULL_PTR arg) {
+ LDKRecord ret_var = Record_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_Record_clone_ptr(uint32_t arg) {
+ LDKRecord arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Record_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_Record_clone(uint32_t orig) {
+ LDKRecord orig_conv;
+ orig_conv.inner = (void*)(orig & (~1));
+ orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
+ LDKRecord ret_var = Record_clone(&orig_conv);
+ uint64_t ret_ref = 0;
+ CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = (uint64_t)ret_var.inner;
+ if (ret_var.is_owned) {
+ ret_ref |= 1;
+ }
+ return ret_ref;
+}
+
+void __attribute__((visibility("default"))) TS_Logger_free(uint32_t this_ptr) {
+ if ((this_ptr & 1) != 0) return;
+ void* this_ptr_ptr = (void*)(((uint64_t)this_ptr) & ~1);
+ CHECK_ACCESS(this_ptr_ptr);
+ LDKLogger this_ptr_conv = *(LDKLogger*)(this_ptr_ptr);
+ FREE((void*)this_ptr);
+ Logger_free(this_ptr_conv);
+}
+
+void __attribute__((visibility("default"))) TS_ChannelHandshakeConfig_free(uint32_t this_obj) {
+ LDKChannelHandshakeConfig this_obj_conv;
+ this_obj_conv.inner = (void*)(this_obj & (~1));
+ this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
+ ChannelHandshakeConfig_free(this_obj_conv);
+}
+
+int32_t __attribute__((visibility("default"))) TS_ChannelHandshakeConfig_get_minimum_depth(uint32_t this_ptr) {
+ LDKChannelHandshakeConfig this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ int32_t ret_val = ChannelHandshakeConfig_get_minimum_depth(&this_ptr_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_ChannelHandshakeConfig_set_minimum_depth(uint32_t this_ptr, int32_t val) {
+ LDKChannelHandshakeConfig this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ ChannelHandshakeConfig_set_minimum_depth(&this_ptr_conv, val);
+}
+
+int16_t __attribute__((visibility("default"))) TS_ChannelHandshakeConfig_get_our_to_self_delay(uint32_t this_ptr) {
+ LDKChannelHandshakeConfig this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ int16_t ret_val = ChannelHandshakeConfig_get_our_to_self_delay(&this_ptr_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_ChannelHandshakeConfig_set_our_to_self_delay(uint32_t this_ptr, int16_t val) {
+ LDKChannelHandshakeConfig this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ ChannelHandshakeConfig_set_our_to_self_delay(&this_ptr_conv, val);
+}
+
+int64_t __attribute__((visibility("default"))) TS_ChannelHandshakeConfig_get_our_htlc_minimum_msat(uint32_t this_ptr) {
+ LDKChannelHandshakeConfig this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ int64_t ret_val = ChannelHandshakeConfig_get_our_htlc_minimum_msat(&this_ptr_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_ChannelHandshakeConfig_set_our_htlc_minimum_msat(uint32_t this_ptr, int64_t val) {
+ LDKChannelHandshakeConfig this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ ChannelHandshakeConfig_set_our_htlc_minimum_msat(&this_ptr_conv, val);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_ChannelHandshakeConfig_new(int32_t minimum_depth_arg, int16_t our_to_self_delay_arg, int64_t our_htlc_minimum_msat_arg) {
+ LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_new(minimum_depth_arg, our_to_self_delay_arg, our_htlc_minimum_msat_arg);
+ uint64_t ret_ref = 0;
+ CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = (uint64_t)ret_var.inner;
+ if (ret_var.is_owned) {
+ ret_ref |= 1;
+ }
+ return ret_ref;
+}
+
+static inline uint64_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg) {
+ LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ChannelHandshakeConfig_clone_ptr(uint32_t arg) {
+ LDKChannelHandshakeConfig arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelHandshakeConfig_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_ChannelHandshakeConfig_clone(uint32_t orig) {
+ LDKChannelHandshakeConfig orig_conv;
+ orig_conv.inner = (void*)(orig & (~1));
+ orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
+ LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_clone(&orig_conv);
+ uint64_t ret_ref = 0;
+ CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = (uint64_t)ret_var.inner;
+ if (ret_var.is_owned) {
+ ret_ref |= 1;
+ }
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_ChannelHandshakeConfig_default() {
+ LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_default();
+ uint64_t ret_ref = 0;
+ CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = (uint64_t)ret_var.inner;
+ if (ret_var.is_owned) {
+ ret_ref |= 1;
+ }
+ return ret_ref;
+}
+
+void __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_free(uint32_t this_obj) {
+ LDKChannelHandshakeLimits this_obj_conv;
+ this_obj_conv.inner = (void*)(this_obj & (~1));
+ this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
+ ChannelHandshakeLimits_free(this_obj_conv);
+}
+
+int64_t __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_get_min_funding_satoshis(uint32_t this_ptr) {
+ LDKChannelHandshakeLimits this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ int64_t ret_val = ChannelHandshakeLimits_get_min_funding_satoshis(&this_ptr_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_set_min_funding_satoshis(uint32_t this_ptr, int64_t val) {
+ LDKChannelHandshakeLimits this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ ChannelHandshakeLimits_set_min_funding_satoshis(&this_ptr_conv, val);
+}
+
+int64_t __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_get_max_htlc_minimum_msat(uint32_t this_ptr) {
+ LDKChannelHandshakeLimits this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ int64_t ret_val = ChannelHandshakeLimits_get_max_htlc_minimum_msat(&this_ptr_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_set_max_htlc_minimum_msat(uint32_t this_ptr, int64_t val) {
+ LDKChannelHandshakeLimits this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ ChannelHandshakeLimits_set_max_htlc_minimum_msat(&this_ptr_conv, val);
+}
+
+int64_t __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(uint32_t this_ptr) {
+ LDKChannelHandshakeLimits this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ int64_t ret_val = ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(&this_ptr_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(uint32_t this_ptr, int64_t val) {
+ LDKChannelHandshakeLimits this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
+}
+
+int64_t __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_get_max_channel_reserve_satoshis(uint32_t this_ptr) {
+ LDKChannelHandshakeLimits this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ int64_t ret_val = ChannelHandshakeLimits_get_max_channel_reserve_satoshis(&this_ptr_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_set_max_channel_reserve_satoshis(uint32_t this_ptr, int64_t val) {
+ LDKChannelHandshakeLimits this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ ChannelHandshakeLimits_set_max_channel_reserve_satoshis(&this_ptr_conv, val);
+}
+
+int16_t __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_get_min_max_accepted_htlcs(uint32_t this_ptr) {
+ LDKChannelHandshakeLimits this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ int16_t ret_val = ChannelHandshakeLimits_get_min_max_accepted_htlcs(&this_ptr_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_set_min_max_accepted_htlcs(uint32_t this_ptr, int16_t val) {
+ LDKChannelHandshakeLimits this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ ChannelHandshakeLimits_set_min_max_accepted_htlcs(&this_ptr_conv, val);
+}
+
+int32_t __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_get_max_minimum_depth(uint32_t this_ptr) {
+ LDKChannelHandshakeLimits this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ int32_t ret_val = ChannelHandshakeLimits_get_max_minimum_depth(&this_ptr_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_set_max_minimum_depth(uint32_t this_ptr, int32_t val) {
+ LDKChannelHandshakeLimits this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ ChannelHandshakeLimits_set_max_minimum_depth(&this_ptr_conv, val);
+}
+
+jboolean __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_get_force_announced_channel_preference(uint32_t this_ptr) {
+ LDKChannelHandshakeLimits this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ jboolean ret_val = ChannelHandshakeLimits_get_force_announced_channel_preference(&this_ptr_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_set_force_announced_channel_preference(uint32_t this_ptr, jboolean val) {
+ LDKChannelHandshakeLimits this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ ChannelHandshakeLimits_set_force_announced_channel_preference(&this_ptr_conv, val);
+}
+
+int16_t __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_get_their_to_self_delay(uint32_t this_ptr) {
+ LDKChannelHandshakeLimits this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ int16_t ret_val = ChannelHandshakeLimits_get_their_to_self_delay(&this_ptr_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_set_their_to_self_delay(uint32_t this_ptr, int16_t val) {
+ LDKChannelHandshakeLimits this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ ChannelHandshakeLimits_set_their_to_self_delay(&this_ptr_conv, val);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_new(int64_t min_funding_satoshis_arg, int64_t max_htlc_minimum_msat_arg, int64_t min_max_htlc_value_in_flight_msat_arg, int64_t max_channel_reserve_satoshis_arg, int16_t min_max_accepted_htlcs_arg, int32_t max_minimum_depth_arg, jboolean force_announced_channel_preference_arg, int16_t their_to_self_delay_arg) {
+ LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_new(min_funding_satoshis_arg, max_htlc_minimum_msat_arg, min_max_htlc_value_in_flight_msat_arg, max_channel_reserve_satoshis_arg, min_max_accepted_htlcs_arg, max_minimum_depth_arg, force_announced_channel_preference_arg, their_to_self_delay_arg);
+ uint64_t ret_ref = 0;
+ CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = (uint64_t)ret_var.inner;
+ if (ret_var.is_owned) {
+ ret_ref |= 1;
+ }
+ return ret_ref;
+}
+
+static inline uint64_t ChannelHandshakeLimits_clone_ptr(LDKChannelHandshakeLimits *NONNULL_PTR arg) {
+ LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_clone_ptr(uint32_t arg) {
+ LDKChannelHandshakeLimits arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelHandshakeLimits_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_clone(uint32_t orig) {
+ LDKChannelHandshakeLimits orig_conv;
+ orig_conv.inner = (void*)(orig & (~1));
+ orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
+ LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_clone(&orig_conv);
+ uint64_t ret_ref = 0;
+ CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = (uint64_t)ret_var.inner;
+ if (ret_var.is_owned) {
+ ret_ref |= 1;
+ }
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_default() {
+ LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_default();
+ uint64_t ret_ref = 0;
+ CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = (uint64_t)ret_var.inner;
+ if (ret_var.is_owned) {
+ ret_ref |= 1;
+ }
+ return ret_ref;
+}
+
+void __attribute__((visibility("default"))) TS_ChannelConfig_free(uint32_t this_obj) {
+ LDKChannelConfig this_obj_conv;
+ this_obj_conv.inner = (void*)(this_obj & (~1));
+ this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
+ ChannelConfig_free(this_obj_conv);