2 // On OSX jlong (ie long long) is not equivalent to int64_t, so we override here
4 #include "org_ldk_impl_bindings.h"
10 #define DEBUG_PRINT(...) fprintf(stderr, __VA_ARGS__)
11 #define MALLOC(a, _) malloc(a)
12 #define FREE(p) if ((uint64_t)(p) > 1024) { free(p); }
13 #define DO_ASSERT(a) (void)(a)
16 static jmethodID ordinal_meth = NULL;
17 static jmethodID slicedef_meth = NULL;
18 static jclass slicedef_cls = NULL;
19 JNIEXPORT void Java_org_ldk_impl_bindings_init(JNIEnv * env, jclass _b, jclass enum_class, jclass slicedef_class) {
20 ordinal_meth = (*env)->GetMethodID(env, enum_class, "ordinal", "()I");
21 CHECK(ordinal_meth != NULL);
22 slicedef_meth = (*env)->GetMethodID(env, slicedef_class, "<init>", "(JJJ)V");
23 CHECK(slicedef_meth != NULL);
24 slicedef_cls = (*env)->NewGlobalRef(env, slicedef_class);
25 CHECK(slicedef_cls != NULL);
28 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_deref_1bool (JNIEnv * env, jclass _a, jlong ptr) {
31 JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_deref_1long (JNIEnv * env, jclass _a, jlong ptr) {
34 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_free_1heap_1ptr (JNIEnv * env, jclass _a, jlong ptr) {
37 JNIEXPORT jbyteArray JNICALL Java_org_ldk_impl_bindings_read_1bytes (JNIEnv * env, jclass _b, jlong ptr, jlong len) {
38 jbyteArray ret_arr = (*env)->NewByteArray(env, len);
39 (*env)->SetByteArrayRegion(env, ret_arr, 0, len, (unsigned char*)ptr);
42 JNIEXPORT jbyteArray JNICALL Java_org_ldk_impl_bindings_get_1u8_1slice_1bytes (JNIEnv * env, jclass _b, jlong slice_ptr) {
43 LDKu8slice *slice = (LDKu8slice*)slice_ptr;
44 jbyteArray ret_arr = (*env)->NewByteArray(env, slice->datalen);
45 (*env)->SetByteArrayRegion(env, ret_arr, 0, slice->datalen, slice->data);
48 JNIEXPORT int64_t impl_bindings_bytes_1to_1u8_1vec (JNIEnv * env, jclass _b, jbyteArray bytes) {
49 LDKCVec_u8Z *vec = (LDKCVec_u8Z*)MALLOC(sizeof(LDKCVec_u8Z), "LDKCVec_u8");
50 vec->datalen = (*env)->GetArrayLength(env, bytes);
51 vec->data = (uint8_t*)MALLOC(vec->datalen, "LDKCVec_u8Z Bytes");
52 (*env)->GetByteArrayRegion (env, bytes, 0, vec->datalen, vec->data);
55 JNIEXPORT jbyteArray JNICALL Java_org_ldk_impl_bindings_txpointer_1get_1buffer (JNIEnv * env, jclass _b, jlong ptr) {
56 LDKTransaction *txdata = (LDKTransaction*)ptr;
58 slice.data = txdata->data;
59 slice.datalen = txdata->datalen;
60 return Java_org_ldk_impl_bindings_get_1u8_1slice_1bytes(env, _b, (uint64_t)&slice);
62 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_new_1txpointer_1copy_1data (JNIEnv * env, jclass _b, jbyteArray bytes) {
63 LDKTransaction *txdata = (LDKTransaction*)MALLOC(sizeof(LDKTransaction), "LDKTransaction");
64 txdata->datalen = (*env)->GetArrayLength(env, bytes);
65 txdata->data = (uint8_t*)MALLOC(txdata->datalen, "Tx Data Bytes");
66 txdata->data_is_owned = false;
67 (*env)->GetByteArrayRegion (env, bytes, 0, txdata->datalen, txdata->data);
68 return (uint64_t)txdata;
70 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_txpointer_1free (JNIEnv * env, jclass _b, jlong ptr) {
71 LDKTransaction *tx = (LDKTransaction*)ptr;
72 tx->data_is_owned = true;
73 Transaction_free(*tx);
76 JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_vec_1slice_1len (JNIEnv * env, jclass _a, jlong ptr) {
77 // Check offsets of a few Vec types are all consistent as we're meant to be generic across types
78 _Static_assert(offsetof(LDKCVec_u8Z, datalen) == offsetof(LDKCVec_SignatureZ, datalen), "Vec<*> needs to be mapped identically");
79 _Static_assert(offsetof(LDKCVec_u8Z, datalen) == offsetof(LDKCVec_MessageSendEventZ, datalen), "Vec<*> needs to be mapped identically");
80 _Static_assert(offsetof(LDKCVec_u8Z, datalen) == offsetof(LDKCVec_EventZ, datalen), "Vec<*> needs to be mapped identically");
81 _Static_assert(offsetof(LDKCVec_u8Z, datalen) == offsetof(LDKCVec_C2Tuple_usizeTransactionZZ, datalen), "Vec<*> needs to be mapped identically");
82 LDKCVec_u8Z *vec = (LDKCVec_u8Z*)ptr;
83 return (uint64_t)vec->datalen;
85 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_new_1empty_1slice_1vec (JNIEnv * env, jclass _b) {
86 // Check sizes of a few Vec types are all consistent as we're meant to be generic across types
87 _Static_assert(sizeof(LDKCVec_u8Z) == sizeof(LDKCVec_SignatureZ), "Vec<*> needs to be mapped identically");
88 _Static_assert(sizeof(LDKCVec_u8Z) == sizeof(LDKCVec_MessageSendEventZ), "Vec<*> needs to be mapped identically");
89 _Static_assert(sizeof(LDKCVec_u8Z) == sizeof(LDKCVec_EventZ), "Vec<*> needs to be mapped identically");
90 _Static_assert(sizeof(LDKCVec_u8Z) == sizeof(LDKCVec_C2Tuple_usizeTransactionZZ), "Vec<*> needs to be mapped identically");
91 LDKCVec_u8Z *vec = (LDKCVec_u8Z*)MALLOC(sizeof(LDKCVec_u8Z), "Empty LDKCVec");
97 // We assume that CVec_u8Z and u8slice are the same size and layout (and thus pointers to the two can be mixed)
98 _Static_assert(sizeof(LDKCVec_u8Z) == sizeof(LDKu8slice), "Vec<u8> and [u8] need to have been mapped identically");
99 _Static_assert(offsetof(LDKCVec_u8Z, data) == offsetof(LDKu8slice, data), "Vec<u8> and [u8] need to have been mapped identically");
100 _Static_assert(offsetof(LDKCVec_u8Z, datalen) == offsetof(LDKu8slice, datalen), "Vec<u8> and [u8] need to have been mapped identically");
102 _Static_assert(sizeof(jlong) == sizeof(int64_t), "We assume that j-types are the same as C types");
103 _Static_assert(sizeof(jbyte) == sizeof(char), "We assume that j-types are the same as C types");
104 _Static_assert(sizeof(void*) <= 8, "Pointers must fit into 64 bits");
106 typedef jlongArray int64_tArray;
107 typedef jbyteArray int8_tArray;
109 static inline jstring str_ref_to_java(JNIEnv *env, const char* chars, size_t len) {
110 // Sadly we need to create a temporary because Java can't accept a char* without a 0-terminator
111 char* conv_buf = MALLOC(len + 1, "str conv buf");
112 memcpy(conv_buf, chars, len);
114 jstring ret = (*env)->NewStringUTF(env, conv_buf);
118 static inline LDKStr java_to_owned_str(JNIEnv *env, jstring str) {
119 uint64_t str_len = (*env)->GetStringUTFLength(env, str);
120 char* newchars = MALLOC(str_len + 1, "String chars");
121 const char* jchars = (*env)->GetStringUTFChars(env, str, NULL);
122 memcpy(newchars, jchars, str_len);
123 newchars[str_len] = 0;
124 (*env)->ReleaseStringUTFChars(env, str, jchars);
128 .chars_is_owned = true
133 JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_get_1lib_1version_1string(JNIEnv *env, jclass _c) {
134 return str_ref_to_java(env, "v0.0.99.1", strlen("v0.0.99.1"));
136 JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_get_1ldk_1c_1bindings_1version(JNIEnv *env, jclass _c) {
137 return str_ref_to_java(env, check_get_ldk_bindings_version(), strlen(check_get_ldk_bindings_version()));
139 JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_get_1ldk_1version(JNIEnv *env, jclass _c) {
140 return str_ref_to_java(env, check_get_ldk_version(), strlen(check_get_ldk_version()));
142 static jclass arr_of_B_clz = NULL;
143 static jclass arr_of_J_clz = NULL;
144 JNIEXPORT void Java_org_ldk_impl_bindings_init_1class_1cache(JNIEnv * env, jclass clz) {
145 arr_of_B_clz = (*env)->FindClass(env, "[B");
146 CHECK(arr_of_B_clz != NULL);
147 arr_of_B_clz = (*env)->NewGlobalRef(env, arr_of_B_clz);
148 arr_of_J_clz = (*env)->FindClass(env, "[J");
149 CHECK(arr_of_J_clz != NULL);
150 arr_of_J_clz = (*env)->NewGlobalRef(env, arr_of_J_clz);
152 static inline struct LDKThirtyTwoBytes ThirtyTwoBytes_clone(const struct LDKThirtyTwoBytes *orig) { struct LDKThirtyTwoBytes ret; memcpy(ret.data, orig->data, 32); return ret; }
153 static inline LDKAccessError LDKAccessError_from_java(JNIEnv *env, jclass clz) {
154 switch ((*env)->CallIntMethod(env, clz, ordinal_meth)) {
155 case 0: return LDKAccessError_UnknownChain;
156 case 1: return LDKAccessError_UnknownTx;
160 static jclass AccessError_class = NULL;
161 static jfieldID AccessError_LDKAccessError_UnknownChain = NULL;
162 static jfieldID AccessError_LDKAccessError_UnknownTx = NULL;
163 JNIEXPORT void JNICALL Java_org_ldk_enums_AccessError_init (JNIEnv *env, jclass clz) {
164 AccessError_class = (*env)->NewGlobalRef(env, clz);
165 CHECK(AccessError_class != NULL);
166 AccessError_LDKAccessError_UnknownChain = (*env)->GetStaticFieldID(env, AccessError_class, "LDKAccessError_UnknownChain", "Lorg/ldk/enums/AccessError;");
167 CHECK(AccessError_LDKAccessError_UnknownChain != NULL);
168 AccessError_LDKAccessError_UnknownTx = (*env)->GetStaticFieldID(env, AccessError_class, "LDKAccessError_UnknownTx", "Lorg/ldk/enums/AccessError;");
169 CHECK(AccessError_LDKAccessError_UnknownTx != NULL);
171 static inline jclass LDKAccessError_to_java(JNIEnv *env, LDKAccessError val) {
173 case LDKAccessError_UnknownChain:
174 return (*env)->GetStaticObjectField(env, AccessError_class, AccessError_LDKAccessError_UnknownChain);
175 case LDKAccessError_UnknownTx:
176 return (*env)->GetStaticObjectField(env, AccessError_class, AccessError_LDKAccessError_UnknownTx);
181 static inline LDKChannelMonitorUpdateErr LDKChannelMonitorUpdateErr_from_java(JNIEnv *env, jclass clz) {
182 switch ((*env)->CallIntMethod(env, clz, ordinal_meth)) {
183 case 0: return LDKChannelMonitorUpdateErr_TemporaryFailure;
184 case 1: return LDKChannelMonitorUpdateErr_PermanentFailure;
188 static jclass ChannelMonitorUpdateErr_class = NULL;
189 static jfieldID ChannelMonitorUpdateErr_LDKChannelMonitorUpdateErr_TemporaryFailure = NULL;
190 static jfieldID ChannelMonitorUpdateErr_LDKChannelMonitorUpdateErr_PermanentFailure = NULL;
191 JNIEXPORT void JNICALL Java_org_ldk_enums_ChannelMonitorUpdateErr_init (JNIEnv *env, jclass clz) {
192 ChannelMonitorUpdateErr_class = (*env)->NewGlobalRef(env, clz);
193 CHECK(ChannelMonitorUpdateErr_class != NULL);
194 ChannelMonitorUpdateErr_LDKChannelMonitorUpdateErr_TemporaryFailure = (*env)->GetStaticFieldID(env, ChannelMonitorUpdateErr_class, "LDKChannelMonitorUpdateErr_TemporaryFailure", "Lorg/ldk/enums/ChannelMonitorUpdateErr;");
195 CHECK(ChannelMonitorUpdateErr_LDKChannelMonitorUpdateErr_TemporaryFailure != NULL);
196 ChannelMonitorUpdateErr_LDKChannelMonitorUpdateErr_PermanentFailure = (*env)->GetStaticFieldID(env, ChannelMonitorUpdateErr_class, "LDKChannelMonitorUpdateErr_PermanentFailure", "Lorg/ldk/enums/ChannelMonitorUpdateErr;");
197 CHECK(ChannelMonitorUpdateErr_LDKChannelMonitorUpdateErr_PermanentFailure != NULL);
199 static inline jclass LDKChannelMonitorUpdateErr_to_java(JNIEnv *env, LDKChannelMonitorUpdateErr val) {
201 case LDKChannelMonitorUpdateErr_TemporaryFailure:
202 return (*env)->GetStaticObjectField(env, ChannelMonitorUpdateErr_class, ChannelMonitorUpdateErr_LDKChannelMonitorUpdateErr_TemporaryFailure);
203 case LDKChannelMonitorUpdateErr_PermanentFailure:
204 return (*env)->GetStaticObjectField(env, ChannelMonitorUpdateErr_class, ChannelMonitorUpdateErr_LDKChannelMonitorUpdateErr_PermanentFailure);
209 static inline LDKConfirmationTarget LDKConfirmationTarget_from_java(JNIEnv *env, jclass clz) {
210 switch ((*env)->CallIntMethod(env, clz, ordinal_meth)) {
211 case 0: return LDKConfirmationTarget_Background;
212 case 1: return LDKConfirmationTarget_Normal;
213 case 2: return LDKConfirmationTarget_HighPriority;
217 static jclass ConfirmationTarget_class = NULL;
218 static jfieldID ConfirmationTarget_LDKConfirmationTarget_Background = NULL;
219 static jfieldID ConfirmationTarget_LDKConfirmationTarget_Normal = NULL;
220 static jfieldID ConfirmationTarget_LDKConfirmationTarget_HighPriority = NULL;
221 JNIEXPORT void JNICALL Java_org_ldk_enums_ConfirmationTarget_init (JNIEnv *env, jclass clz) {
222 ConfirmationTarget_class = (*env)->NewGlobalRef(env, clz);
223 CHECK(ConfirmationTarget_class != NULL);
224 ConfirmationTarget_LDKConfirmationTarget_Background = (*env)->GetStaticFieldID(env, ConfirmationTarget_class, "LDKConfirmationTarget_Background", "Lorg/ldk/enums/ConfirmationTarget;");
225 CHECK(ConfirmationTarget_LDKConfirmationTarget_Background != NULL);
226 ConfirmationTarget_LDKConfirmationTarget_Normal = (*env)->GetStaticFieldID(env, ConfirmationTarget_class, "LDKConfirmationTarget_Normal", "Lorg/ldk/enums/ConfirmationTarget;");
227 CHECK(ConfirmationTarget_LDKConfirmationTarget_Normal != NULL);
228 ConfirmationTarget_LDKConfirmationTarget_HighPriority = (*env)->GetStaticFieldID(env, ConfirmationTarget_class, "LDKConfirmationTarget_HighPriority", "Lorg/ldk/enums/ConfirmationTarget;");
229 CHECK(ConfirmationTarget_LDKConfirmationTarget_HighPriority != NULL);
231 static inline jclass LDKConfirmationTarget_to_java(JNIEnv *env, LDKConfirmationTarget val) {
233 case LDKConfirmationTarget_Background:
234 return (*env)->GetStaticObjectField(env, ConfirmationTarget_class, ConfirmationTarget_LDKConfirmationTarget_Background);
235 case LDKConfirmationTarget_Normal:
236 return (*env)->GetStaticObjectField(env, ConfirmationTarget_class, ConfirmationTarget_LDKConfirmationTarget_Normal);
237 case LDKConfirmationTarget_HighPriority:
238 return (*env)->GetStaticObjectField(env, ConfirmationTarget_class, ConfirmationTarget_LDKConfirmationTarget_HighPriority);
243 static inline LDKCreationError LDKCreationError_from_java(JNIEnv *env, jclass clz) {
244 switch ((*env)->CallIntMethod(env, clz, ordinal_meth)) {
245 case 0: return LDKCreationError_DescriptionTooLong;
246 case 1: return LDKCreationError_RouteTooLong;
247 case 2: return LDKCreationError_TimestampOutOfBounds;
248 case 3: return LDKCreationError_ExpiryTimeOutOfBounds;
252 static jclass CreationError_class = NULL;
253 static jfieldID CreationError_LDKCreationError_DescriptionTooLong = NULL;
254 static jfieldID CreationError_LDKCreationError_RouteTooLong = NULL;
255 static jfieldID CreationError_LDKCreationError_TimestampOutOfBounds = NULL;
256 static jfieldID CreationError_LDKCreationError_ExpiryTimeOutOfBounds = NULL;
257 JNIEXPORT void JNICALL Java_org_ldk_enums_CreationError_init (JNIEnv *env, jclass clz) {
258 CreationError_class = (*env)->NewGlobalRef(env, clz);
259 CHECK(CreationError_class != NULL);
260 CreationError_LDKCreationError_DescriptionTooLong = (*env)->GetStaticFieldID(env, CreationError_class, "LDKCreationError_DescriptionTooLong", "Lorg/ldk/enums/CreationError;");
261 CHECK(CreationError_LDKCreationError_DescriptionTooLong != NULL);
262 CreationError_LDKCreationError_RouteTooLong = (*env)->GetStaticFieldID(env, CreationError_class, "LDKCreationError_RouteTooLong", "Lorg/ldk/enums/CreationError;");
263 CHECK(CreationError_LDKCreationError_RouteTooLong != NULL);
264 CreationError_LDKCreationError_TimestampOutOfBounds = (*env)->GetStaticFieldID(env, CreationError_class, "LDKCreationError_TimestampOutOfBounds", "Lorg/ldk/enums/CreationError;");
265 CHECK(CreationError_LDKCreationError_TimestampOutOfBounds != NULL);
266 CreationError_LDKCreationError_ExpiryTimeOutOfBounds = (*env)->GetStaticFieldID(env, CreationError_class, "LDKCreationError_ExpiryTimeOutOfBounds", "Lorg/ldk/enums/CreationError;");
267 CHECK(CreationError_LDKCreationError_ExpiryTimeOutOfBounds != NULL);
269 static inline jclass LDKCreationError_to_java(JNIEnv *env, LDKCreationError val) {
271 case LDKCreationError_DescriptionTooLong:
272 return (*env)->GetStaticObjectField(env, CreationError_class, CreationError_LDKCreationError_DescriptionTooLong);
273 case LDKCreationError_RouteTooLong:
274 return (*env)->GetStaticObjectField(env, CreationError_class, CreationError_LDKCreationError_RouteTooLong);
275 case LDKCreationError_TimestampOutOfBounds:
276 return (*env)->GetStaticObjectField(env, CreationError_class, CreationError_LDKCreationError_TimestampOutOfBounds);
277 case LDKCreationError_ExpiryTimeOutOfBounds:
278 return (*env)->GetStaticObjectField(env, CreationError_class, CreationError_LDKCreationError_ExpiryTimeOutOfBounds);
283 static inline LDKCurrency LDKCurrency_from_java(JNIEnv *env, jclass clz) {
284 switch ((*env)->CallIntMethod(env, clz, ordinal_meth)) {
285 case 0: return LDKCurrency_Bitcoin;
286 case 1: return LDKCurrency_BitcoinTestnet;
287 case 2: return LDKCurrency_Regtest;
288 case 3: return LDKCurrency_Simnet;
289 case 4: return LDKCurrency_Signet;
293 static jclass Currency_class = NULL;
294 static jfieldID Currency_LDKCurrency_Bitcoin = NULL;
295 static jfieldID Currency_LDKCurrency_BitcoinTestnet = NULL;
296 static jfieldID Currency_LDKCurrency_Regtest = NULL;
297 static jfieldID Currency_LDKCurrency_Simnet = NULL;
298 static jfieldID Currency_LDKCurrency_Signet = NULL;
299 JNIEXPORT void JNICALL Java_org_ldk_enums_Currency_init (JNIEnv *env, jclass clz) {
300 Currency_class = (*env)->NewGlobalRef(env, clz);
301 CHECK(Currency_class != NULL);
302 Currency_LDKCurrency_Bitcoin = (*env)->GetStaticFieldID(env, Currency_class, "LDKCurrency_Bitcoin", "Lorg/ldk/enums/Currency;");
303 CHECK(Currency_LDKCurrency_Bitcoin != NULL);
304 Currency_LDKCurrency_BitcoinTestnet = (*env)->GetStaticFieldID(env, Currency_class, "LDKCurrency_BitcoinTestnet", "Lorg/ldk/enums/Currency;");
305 CHECK(Currency_LDKCurrency_BitcoinTestnet != NULL);
306 Currency_LDKCurrency_Regtest = (*env)->GetStaticFieldID(env, Currency_class, "LDKCurrency_Regtest", "Lorg/ldk/enums/Currency;");
307 CHECK(Currency_LDKCurrency_Regtest != NULL);
308 Currency_LDKCurrency_Simnet = (*env)->GetStaticFieldID(env, Currency_class, "LDKCurrency_Simnet", "Lorg/ldk/enums/Currency;");
309 CHECK(Currency_LDKCurrency_Simnet != NULL);
310 Currency_LDKCurrency_Signet = (*env)->GetStaticFieldID(env, Currency_class, "LDKCurrency_Signet", "Lorg/ldk/enums/Currency;");
311 CHECK(Currency_LDKCurrency_Signet != NULL);
313 static inline jclass LDKCurrency_to_java(JNIEnv *env, LDKCurrency val) {
315 case LDKCurrency_Bitcoin:
316 return (*env)->GetStaticObjectField(env, Currency_class, Currency_LDKCurrency_Bitcoin);
317 case LDKCurrency_BitcoinTestnet:
318 return (*env)->GetStaticObjectField(env, Currency_class, Currency_LDKCurrency_BitcoinTestnet);
319 case LDKCurrency_Regtest:
320 return (*env)->GetStaticObjectField(env, Currency_class, Currency_LDKCurrency_Regtest);
321 case LDKCurrency_Simnet:
322 return (*env)->GetStaticObjectField(env, Currency_class, Currency_LDKCurrency_Simnet);
323 case LDKCurrency_Signet:
324 return (*env)->GetStaticObjectField(env, Currency_class, Currency_LDKCurrency_Signet);
329 static inline LDKIOError LDKIOError_from_java(JNIEnv *env, jclass clz) {
330 switch ((*env)->CallIntMethod(env, clz, ordinal_meth)) {
331 case 0: return LDKIOError_NotFound;
332 case 1: return LDKIOError_PermissionDenied;
333 case 2: return LDKIOError_ConnectionRefused;
334 case 3: return LDKIOError_ConnectionReset;
335 case 4: return LDKIOError_ConnectionAborted;
336 case 5: return LDKIOError_NotConnected;
337 case 6: return LDKIOError_AddrInUse;
338 case 7: return LDKIOError_AddrNotAvailable;
339 case 8: return LDKIOError_BrokenPipe;
340 case 9: return LDKIOError_AlreadyExists;
341 case 10: return LDKIOError_WouldBlock;
342 case 11: return LDKIOError_InvalidInput;
343 case 12: return LDKIOError_InvalidData;
344 case 13: return LDKIOError_TimedOut;
345 case 14: return LDKIOError_WriteZero;
346 case 15: return LDKIOError_Interrupted;
347 case 16: return LDKIOError_Other;
348 case 17: return LDKIOError_UnexpectedEof;
352 static jclass IOError_class = NULL;
353 static jfieldID IOError_LDKIOError_NotFound = NULL;
354 static jfieldID IOError_LDKIOError_PermissionDenied = NULL;
355 static jfieldID IOError_LDKIOError_ConnectionRefused = NULL;
356 static jfieldID IOError_LDKIOError_ConnectionReset = NULL;
357 static jfieldID IOError_LDKIOError_ConnectionAborted = NULL;
358 static jfieldID IOError_LDKIOError_NotConnected = NULL;
359 static jfieldID IOError_LDKIOError_AddrInUse = NULL;
360 static jfieldID IOError_LDKIOError_AddrNotAvailable = NULL;
361 static jfieldID IOError_LDKIOError_BrokenPipe = NULL;
362 static jfieldID IOError_LDKIOError_AlreadyExists = NULL;
363 static jfieldID IOError_LDKIOError_WouldBlock = NULL;
364 static jfieldID IOError_LDKIOError_InvalidInput = NULL;
365 static jfieldID IOError_LDKIOError_InvalidData = NULL;
366 static jfieldID IOError_LDKIOError_TimedOut = NULL;
367 static jfieldID IOError_LDKIOError_WriteZero = NULL;
368 static jfieldID IOError_LDKIOError_Interrupted = NULL;
369 static jfieldID IOError_LDKIOError_Other = NULL;
370 static jfieldID IOError_LDKIOError_UnexpectedEof = NULL;
371 JNIEXPORT void JNICALL Java_org_ldk_enums_IOError_init (JNIEnv *env, jclass clz) {
372 IOError_class = (*env)->NewGlobalRef(env, clz);
373 CHECK(IOError_class != NULL);
374 IOError_LDKIOError_NotFound = (*env)->GetStaticFieldID(env, IOError_class, "LDKIOError_NotFound", "Lorg/ldk/enums/IOError;");
375 CHECK(IOError_LDKIOError_NotFound != NULL);
376 IOError_LDKIOError_PermissionDenied = (*env)->GetStaticFieldID(env, IOError_class, "LDKIOError_PermissionDenied", "Lorg/ldk/enums/IOError;");
377 CHECK(IOError_LDKIOError_PermissionDenied != NULL);
378 IOError_LDKIOError_ConnectionRefused = (*env)->GetStaticFieldID(env, IOError_class, "LDKIOError_ConnectionRefused", "Lorg/ldk/enums/IOError;");
379 CHECK(IOError_LDKIOError_ConnectionRefused != NULL);
380 IOError_LDKIOError_ConnectionReset = (*env)->GetStaticFieldID(env, IOError_class, "LDKIOError_ConnectionReset", "Lorg/ldk/enums/IOError;");
381 CHECK(IOError_LDKIOError_ConnectionReset != NULL);
382 IOError_LDKIOError_ConnectionAborted = (*env)->GetStaticFieldID(env, IOError_class, "LDKIOError_ConnectionAborted", "Lorg/ldk/enums/IOError;");
383 CHECK(IOError_LDKIOError_ConnectionAborted != NULL);
384 IOError_LDKIOError_NotConnected = (*env)->GetStaticFieldID(env, IOError_class, "LDKIOError_NotConnected", "Lorg/ldk/enums/IOError;");
385 CHECK(IOError_LDKIOError_NotConnected != NULL);
386 IOError_LDKIOError_AddrInUse = (*env)->GetStaticFieldID(env, IOError_class, "LDKIOError_AddrInUse", "Lorg/ldk/enums/IOError;");
387 CHECK(IOError_LDKIOError_AddrInUse != NULL);
388 IOError_LDKIOError_AddrNotAvailable = (*env)->GetStaticFieldID(env, IOError_class, "LDKIOError_AddrNotAvailable", "Lorg/ldk/enums/IOError;");
389 CHECK(IOError_LDKIOError_AddrNotAvailable != NULL);
390 IOError_LDKIOError_BrokenPipe = (*env)->GetStaticFieldID(env, IOError_class, "LDKIOError_BrokenPipe", "Lorg/ldk/enums/IOError;");
391 CHECK(IOError_LDKIOError_BrokenPipe != NULL);
392 IOError_LDKIOError_AlreadyExists = (*env)->GetStaticFieldID(env, IOError_class, "LDKIOError_AlreadyExists", "Lorg/ldk/enums/IOError;");
393 CHECK(IOError_LDKIOError_AlreadyExists != NULL);
394 IOError_LDKIOError_WouldBlock = (*env)->GetStaticFieldID(env, IOError_class, "LDKIOError_WouldBlock", "Lorg/ldk/enums/IOError;");
395 CHECK(IOError_LDKIOError_WouldBlock != NULL);
396 IOError_LDKIOError_InvalidInput = (*env)->GetStaticFieldID(env, IOError_class, "LDKIOError_InvalidInput", "Lorg/ldk/enums/IOError;");
397 CHECK(IOError_LDKIOError_InvalidInput != NULL);
398 IOError_LDKIOError_InvalidData = (*env)->GetStaticFieldID(env, IOError_class, "LDKIOError_InvalidData", "Lorg/ldk/enums/IOError;");
399 CHECK(IOError_LDKIOError_InvalidData != NULL);
400 IOError_LDKIOError_TimedOut = (*env)->GetStaticFieldID(env, IOError_class, "LDKIOError_TimedOut", "Lorg/ldk/enums/IOError;");
401 CHECK(IOError_LDKIOError_TimedOut != NULL);
402 IOError_LDKIOError_WriteZero = (*env)->GetStaticFieldID(env, IOError_class, "LDKIOError_WriteZero", "Lorg/ldk/enums/IOError;");
403 CHECK(IOError_LDKIOError_WriteZero != NULL);
404 IOError_LDKIOError_Interrupted = (*env)->GetStaticFieldID(env, IOError_class, "LDKIOError_Interrupted", "Lorg/ldk/enums/IOError;");
405 CHECK(IOError_LDKIOError_Interrupted != NULL);
406 IOError_LDKIOError_Other = (*env)->GetStaticFieldID(env, IOError_class, "LDKIOError_Other", "Lorg/ldk/enums/IOError;");
407 CHECK(IOError_LDKIOError_Other != NULL);
408 IOError_LDKIOError_UnexpectedEof = (*env)->GetStaticFieldID(env, IOError_class, "LDKIOError_UnexpectedEof", "Lorg/ldk/enums/IOError;");
409 CHECK(IOError_LDKIOError_UnexpectedEof != NULL);
411 static inline jclass LDKIOError_to_java(JNIEnv *env, LDKIOError val) {
413 case LDKIOError_NotFound:
414 return (*env)->GetStaticObjectField(env, IOError_class, IOError_LDKIOError_NotFound);
415 case LDKIOError_PermissionDenied:
416 return (*env)->GetStaticObjectField(env, IOError_class, IOError_LDKIOError_PermissionDenied);
417 case LDKIOError_ConnectionRefused:
418 return (*env)->GetStaticObjectField(env, IOError_class, IOError_LDKIOError_ConnectionRefused);
419 case LDKIOError_ConnectionReset:
420 return (*env)->GetStaticObjectField(env, IOError_class, IOError_LDKIOError_ConnectionReset);
421 case LDKIOError_ConnectionAborted:
422 return (*env)->GetStaticObjectField(env, IOError_class, IOError_LDKIOError_ConnectionAborted);
423 case LDKIOError_NotConnected:
424 return (*env)->GetStaticObjectField(env, IOError_class, IOError_LDKIOError_NotConnected);
425 case LDKIOError_AddrInUse:
426 return (*env)->GetStaticObjectField(env, IOError_class, IOError_LDKIOError_AddrInUse);
427 case LDKIOError_AddrNotAvailable:
428 return (*env)->GetStaticObjectField(env, IOError_class, IOError_LDKIOError_AddrNotAvailable);
429 case LDKIOError_BrokenPipe:
430 return (*env)->GetStaticObjectField(env, IOError_class, IOError_LDKIOError_BrokenPipe);
431 case LDKIOError_AlreadyExists:
432 return (*env)->GetStaticObjectField(env, IOError_class, IOError_LDKIOError_AlreadyExists);
433 case LDKIOError_WouldBlock:
434 return (*env)->GetStaticObjectField(env, IOError_class, IOError_LDKIOError_WouldBlock);
435 case LDKIOError_InvalidInput:
436 return (*env)->GetStaticObjectField(env, IOError_class, IOError_LDKIOError_InvalidInput);
437 case LDKIOError_InvalidData:
438 return (*env)->GetStaticObjectField(env, IOError_class, IOError_LDKIOError_InvalidData);
439 case LDKIOError_TimedOut:
440 return (*env)->GetStaticObjectField(env, IOError_class, IOError_LDKIOError_TimedOut);
441 case LDKIOError_WriteZero:
442 return (*env)->GetStaticObjectField(env, IOError_class, IOError_LDKIOError_WriteZero);
443 case LDKIOError_Interrupted:
444 return (*env)->GetStaticObjectField(env, IOError_class, IOError_LDKIOError_Interrupted);
445 case LDKIOError_Other:
446 return (*env)->GetStaticObjectField(env, IOError_class, IOError_LDKIOError_Other);
447 case LDKIOError_UnexpectedEof:
448 return (*env)->GetStaticObjectField(env, IOError_class, IOError_LDKIOError_UnexpectedEof);
453 static inline LDKLevel LDKLevel_from_java(JNIEnv *env, jclass clz) {
454 switch ((*env)->CallIntMethod(env, clz, ordinal_meth)) {
455 case 0: return LDKLevel_Trace;
456 case 1: return LDKLevel_Debug;
457 case 2: return LDKLevel_Info;
458 case 3: return LDKLevel_Warn;
459 case 4: return LDKLevel_Error;
463 static jclass Level_class = NULL;
464 static jfieldID Level_LDKLevel_Trace = NULL;
465 static jfieldID Level_LDKLevel_Debug = NULL;
466 static jfieldID Level_LDKLevel_Info = NULL;
467 static jfieldID Level_LDKLevel_Warn = NULL;
468 static jfieldID Level_LDKLevel_Error = NULL;
469 JNIEXPORT void JNICALL Java_org_ldk_enums_Level_init (JNIEnv *env, jclass clz) {
470 Level_class = (*env)->NewGlobalRef(env, clz);
471 CHECK(Level_class != NULL);
472 Level_LDKLevel_Trace = (*env)->GetStaticFieldID(env, Level_class, "LDKLevel_Trace", "Lorg/ldk/enums/Level;");
473 CHECK(Level_LDKLevel_Trace != NULL);
474 Level_LDKLevel_Debug = (*env)->GetStaticFieldID(env, Level_class, "LDKLevel_Debug", "Lorg/ldk/enums/Level;");
475 CHECK(Level_LDKLevel_Debug != NULL);
476 Level_LDKLevel_Info = (*env)->GetStaticFieldID(env, Level_class, "LDKLevel_Info", "Lorg/ldk/enums/Level;");
477 CHECK(Level_LDKLevel_Info != NULL);
478 Level_LDKLevel_Warn = (*env)->GetStaticFieldID(env, Level_class, "LDKLevel_Warn", "Lorg/ldk/enums/Level;");
479 CHECK(Level_LDKLevel_Warn != NULL);
480 Level_LDKLevel_Error = (*env)->GetStaticFieldID(env, Level_class, "LDKLevel_Error", "Lorg/ldk/enums/Level;");
481 CHECK(Level_LDKLevel_Error != NULL);
483 static inline jclass LDKLevel_to_java(JNIEnv *env, LDKLevel val) {
486 return (*env)->GetStaticObjectField(env, Level_class, Level_LDKLevel_Trace);
488 return (*env)->GetStaticObjectField(env, Level_class, Level_LDKLevel_Debug);
490 return (*env)->GetStaticObjectField(env, Level_class, Level_LDKLevel_Info);
492 return (*env)->GetStaticObjectField(env, Level_class, Level_LDKLevel_Warn);
494 return (*env)->GetStaticObjectField(env, Level_class, Level_LDKLevel_Error);
499 static inline LDKNetwork LDKNetwork_from_java(JNIEnv *env, jclass clz) {
500 switch ((*env)->CallIntMethod(env, clz, ordinal_meth)) {
501 case 0: return LDKNetwork_Bitcoin;
502 case 1: return LDKNetwork_Testnet;
503 case 2: return LDKNetwork_Regtest;
504 case 3: return LDKNetwork_Signet;
508 static jclass Network_class = NULL;
509 static jfieldID Network_LDKNetwork_Bitcoin = NULL;
510 static jfieldID Network_LDKNetwork_Testnet = NULL;
511 static jfieldID Network_LDKNetwork_Regtest = NULL;
512 static jfieldID Network_LDKNetwork_Signet = NULL;
513 JNIEXPORT void JNICALL Java_org_ldk_enums_Network_init (JNIEnv *env, jclass clz) {
514 Network_class = (*env)->NewGlobalRef(env, clz);
515 CHECK(Network_class != NULL);
516 Network_LDKNetwork_Bitcoin = (*env)->GetStaticFieldID(env, Network_class, "LDKNetwork_Bitcoin", "Lorg/ldk/enums/Network;");
517 CHECK(Network_LDKNetwork_Bitcoin != NULL);
518 Network_LDKNetwork_Testnet = (*env)->GetStaticFieldID(env, Network_class, "LDKNetwork_Testnet", "Lorg/ldk/enums/Network;");
519 CHECK(Network_LDKNetwork_Testnet != NULL);
520 Network_LDKNetwork_Regtest = (*env)->GetStaticFieldID(env, Network_class, "LDKNetwork_Regtest", "Lorg/ldk/enums/Network;");
521 CHECK(Network_LDKNetwork_Regtest != NULL);
522 Network_LDKNetwork_Signet = (*env)->GetStaticFieldID(env, Network_class, "LDKNetwork_Signet", "Lorg/ldk/enums/Network;");
523 CHECK(Network_LDKNetwork_Signet != NULL);
525 static inline jclass LDKNetwork_to_java(JNIEnv *env, LDKNetwork val) {
527 case LDKNetwork_Bitcoin:
528 return (*env)->GetStaticObjectField(env, Network_class, Network_LDKNetwork_Bitcoin);
529 case LDKNetwork_Testnet:
530 return (*env)->GetStaticObjectField(env, Network_class, Network_LDKNetwork_Testnet);
531 case LDKNetwork_Regtest:
532 return (*env)->GetStaticObjectField(env, Network_class, Network_LDKNetwork_Regtest);
533 case LDKNetwork_Signet:
534 return (*env)->GetStaticObjectField(env, Network_class, Network_LDKNetwork_Signet);
539 static inline LDKSecp256k1Error LDKSecp256k1Error_from_java(JNIEnv *env, jclass clz) {
540 switch ((*env)->CallIntMethod(env, clz, ordinal_meth)) {
541 case 0: return LDKSecp256k1Error_IncorrectSignature;
542 case 1: return LDKSecp256k1Error_InvalidMessage;
543 case 2: return LDKSecp256k1Error_InvalidPublicKey;
544 case 3: return LDKSecp256k1Error_InvalidSignature;
545 case 4: return LDKSecp256k1Error_InvalidSecretKey;
546 case 5: return LDKSecp256k1Error_InvalidRecoveryId;
547 case 6: return LDKSecp256k1Error_InvalidTweak;
548 case 7: return LDKSecp256k1Error_TweakCheckFailed;
549 case 8: return LDKSecp256k1Error_NotEnoughMemory;
553 static jclass Secp256k1Error_class = NULL;
554 static jfieldID Secp256k1Error_LDKSecp256k1Error_IncorrectSignature = NULL;
555 static jfieldID Secp256k1Error_LDKSecp256k1Error_InvalidMessage = NULL;
556 static jfieldID Secp256k1Error_LDKSecp256k1Error_InvalidPublicKey = NULL;
557 static jfieldID Secp256k1Error_LDKSecp256k1Error_InvalidSignature = NULL;
558 static jfieldID Secp256k1Error_LDKSecp256k1Error_InvalidSecretKey = NULL;
559 static jfieldID Secp256k1Error_LDKSecp256k1Error_InvalidRecoveryId = NULL;
560 static jfieldID Secp256k1Error_LDKSecp256k1Error_InvalidTweak = NULL;
561 static jfieldID Secp256k1Error_LDKSecp256k1Error_TweakCheckFailed = NULL;
562 static jfieldID Secp256k1Error_LDKSecp256k1Error_NotEnoughMemory = NULL;
563 JNIEXPORT void JNICALL Java_org_ldk_enums_Secp256k1Error_init (JNIEnv *env, jclass clz) {
564 Secp256k1Error_class = (*env)->NewGlobalRef(env, clz);
565 CHECK(Secp256k1Error_class != NULL);
566 Secp256k1Error_LDKSecp256k1Error_IncorrectSignature = (*env)->GetStaticFieldID(env, Secp256k1Error_class, "LDKSecp256k1Error_IncorrectSignature", "Lorg/ldk/enums/Secp256k1Error;");
567 CHECK(Secp256k1Error_LDKSecp256k1Error_IncorrectSignature != NULL);
568 Secp256k1Error_LDKSecp256k1Error_InvalidMessage = (*env)->GetStaticFieldID(env, Secp256k1Error_class, "LDKSecp256k1Error_InvalidMessage", "Lorg/ldk/enums/Secp256k1Error;");
569 CHECK(Secp256k1Error_LDKSecp256k1Error_InvalidMessage != NULL);
570 Secp256k1Error_LDKSecp256k1Error_InvalidPublicKey = (*env)->GetStaticFieldID(env, Secp256k1Error_class, "LDKSecp256k1Error_InvalidPublicKey", "Lorg/ldk/enums/Secp256k1Error;");
571 CHECK(Secp256k1Error_LDKSecp256k1Error_InvalidPublicKey != NULL);
572 Secp256k1Error_LDKSecp256k1Error_InvalidSignature = (*env)->GetStaticFieldID(env, Secp256k1Error_class, "LDKSecp256k1Error_InvalidSignature", "Lorg/ldk/enums/Secp256k1Error;");
573 CHECK(Secp256k1Error_LDKSecp256k1Error_InvalidSignature != NULL);
574 Secp256k1Error_LDKSecp256k1Error_InvalidSecretKey = (*env)->GetStaticFieldID(env, Secp256k1Error_class, "LDKSecp256k1Error_InvalidSecretKey", "Lorg/ldk/enums/Secp256k1Error;");
575 CHECK(Secp256k1Error_LDKSecp256k1Error_InvalidSecretKey != NULL);
576 Secp256k1Error_LDKSecp256k1Error_InvalidRecoveryId = (*env)->GetStaticFieldID(env, Secp256k1Error_class, "LDKSecp256k1Error_InvalidRecoveryId", "Lorg/ldk/enums/Secp256k1Error;");
577 CHECK(Secp256k1Error_LDKSecp256k1Error_InvalidRecoveryId != NULL);
578 Secp256k1Error_LDKSecp256k1Error_InvalidTweak = (*env)->GetStaticFieldID(env, Secp256k1Error_class, "LDKSecp256k1Error_InvalidTweak", "Lorg/ldk/enums/Secp256k1Error;");
579 CHECK(Secp256k1Error_LDKSecp256k1Error_InvalidTweak != NULL);
580 Secp256k1Error_LDKSecp256k1Error_TweakCheckFailed = (*env)->GetStaticFieldID(env, Secp256k1Error_class, "LDKSecp256k1Error_TweakCheckFailed", "Lorg/ldk/enums/Secp256k1Error;");
581 CHECK(Secp256k1Error_LDKSecp256k1Error_TweakCheckFailed != NULL);
582 Secp256k1Error_LDKSecp256k1Error_NotEnoughMemory = (*env)->GetStaticFieldID(env, Secp256k1Error_class, "LDKSecp256k1Error_NotEnoughMemory", "Lorg/ldk/enums/Secp256k1Error;");
583 CHECK(Secp256k1Error_LDKSecp256k1Error_NotEnoughMemory != NULL);
585 static inline jclass LDKSecp256k1Error_to_java(JNIEnv *env, LDKSecp256k1Error val) {
587 case LDKSecp256k1Error_IncorrectSignature:
588 return (*env)->GetStaticObjectField(env, Secp256k1Error_class, Secp256k1Error_LDKSecp256k1Error_IncorrectSignature);
589 case LDKSecp256k1Error_InvalidMessage:
590 return (*env)->GetStaticObjectField(env, Secp256k1Error_class, Secp256k1Error_LDKSecp256k1Error_InvalidMessage);
591 case LDKSecp256k1Error_InvalidPublicKey:
592 return (*env)->GetStaticObjectField(env, Secp256k1Error_class, Secp256k1Error_LDKSecp256k1Error_InvalidPublicKey);
593 case LDKSecp256k1Error_InvalidSignature:
594 return (*env)->GetStaticObjectField(env, Secp256k1Error_class, Secp256k1Error_LDKSecp256k1Error_InvalidSignature);
595 case LDKSecp256k1Error_InvalidSecretKey:
596 return (*env)->GetStaticObjectField(env, Secp256k1Error_class, Secp256k1Error_LDKSecp256k1Error_InvalidSecretKey);
597 case LDKSecp256k1Error_InvalidRecoveryId:
598 return (*env)->GetStaticObjectField(env, Secp256k1Error_class, Secp256k1Error_LDKSecp256k1Error_InvalidRecoveryId);
599 case LDKSecp256k1Error_InvalidTweak:
600 return (*env)->GetStaticObjectField(env, Secp256k1Error_class, Secp256k1Error_LDKSecp256k1Error_InvalidTweak);
601 case LDKSecp256k1Error_TweakCheckFailed:
602 return (*env)->GetStaticObjectField(env, Secp256k1Error_class, Secp256k1Error_LDKSecp256k1Error_TweakCheckFailed);
603 case LDKSecp256k1Error_NotEnoughMemory:
604 return (*env)->GetStaticObjectField(env, Secp256k1Error_class, Secp256k1Error_LDKSecp256k1Error_NotEnoughMemory);
609 static inline LDKSemanticError LDKSemanticError_from_java(JNIEnv *env, jclass clz) {
610 switch ((*env)->CallIntMethod(env, clz, ordinal_meth)) {
611 case 0: return LDKSemanticError_NoPaymentHash;
612 case 1: return LDKSemanticError_MultiplePaymentHashes;
613 case 2: return LDKSemanticError_NoDescription;
614 case 3: return LDKSemanticError_MultipleDescriptions;
615 case 4: return LDKSemanticError_MultiplePaymentSecrets;
616 case 5: return LDKSemanticError_InvalidFeatures;
617 case 6: return LDKSemanticError_InvalidRecoveryId;
618 case 7: return LDKSemanticError_InvalidSignature;
622 static jclass SemanticError_class = NULL;
623 static jfieldID SemanticError_LDKSemanticError_NoPaymentHash = NULL;
624 static jfieldID SemanticError_LDKSemanticError_MultiplePaymentHashes = NULL;
625 static jfieldID SemanticError_LDKSemanticError_NoDescription = NULL;
626 static jfieldID SemanticError_LDKSemanticError_MultipleDescriptions = NULL;
627 static jfieldID SemanticError_LDKSemanticError_MultiplePaymentSecrets = NULL;
628 static jfieldID SemanticError_LDKSemanticError_InvalidFeatures = NULL;
629 static jfieldID SemanticError_LDKSemanticError_InvalidRecoveryId = NULL;
630 static jfieldID SemanticError_LDKSemanticError_InvalidSignature = NULL;
631 JNIEXPORT void JNICALL Java_org_ldk_enums_SemanticError_init (JNIEnv *env, jclass clz) {
632 SemanticError_class = (*env)->NewGlobalRef(env, clz);
633 CHECK(SemanticError_class != NULL);
634 SemanticError_LDKSemanticError_NoPaymentHash = (*env)->GetStaticFieldID(env, SemanticError_class, "LDKSemanticError_NoPaymentHash", "Lorg/ldk/enums/SemanticError;");
635 CHECK(SemanticError_LDKSemanticError_NoPaymentHash != NULL);
636 SemanticError_LDKSemanticError_MultiplePaymentHashes = (*env)->GetStaticFieldID(env, SemanticError_class, "LDKSemanticError_MultiplePaymentHashes", "Lorg/ldk/enums/SemanticError;");
637 CHECK(SemanticError_LDKSemanticError_MultiplePaymentHashes != NULL);
638 SemanticError_LDKSemanticError_NoDescription = (*env)->GetStaticFieldID(env, SemanticError_class, "LDKSemanticError_NoDescription", "Lorg/ldk/enums/SemanticError;");
639 CHECK(SemanticError_LDKSemanticError_NoDescription != NULL);
640 SemanticError_LDKSemanticError_MultipleDescriptions = (*env)->GetStaticFieldID(env, SemanticError_class, "LDKSemanticError_MultipleDescriptions", "Lorg/ldk/enums/SemanticError;");
641 CHECK(SemanticError_LDKSemanticError_MultipleDescriptions != NULL);
642 SemanticError_LDKSemanticError_MultiplePaymentSecrets = (*env)->GetStaticFieldID(env, SemanticError_class, "LDKSemanticError_MultiplePaymentSecrets", "Lorg/ldk/enums/SemanticError;");
643 CHECK(SemanticError_LDKSemanticError_MultiplePaymentSecrets != NULL);
644 SemanticError_LDKSemanticError_InvalidFeatures = (*env)->GetStaticFieldID(env, SemanticError_class, "LDKSemanticError_InvalidFeatures", "Lorg/ldk/enums/SemanticError;");
645 CHECK(SemanticError_LDKSemanticError_InvalidFeatures != NULL);
646 SemanticError_LDKSemanticError_InvalidRecoveryId = (*env)->GetStaticFieldID(env, SemanticError_class, "LDKSemanticError_InvalidRecoveryId", "Lorg/ldk/enums/SemanticError;");
647 CHECK(SemanticError_LDKSemanticError_InvalidRecoveryId != NULL);
648 SemanticError_LDKSemanticError_InvalidSignature = (*env)->GetStaticFieldID(env, SemanticError_class, "LDKSemanticError_InvalidSignature", "Lorg/ldk/enums/SemanticError;");
649 CHECK(SemanticError_LDKSemanticError_InvalidSignature != NULL);
651 static inline jclass LDKSemanticError_to_java(JNIEnv *env, LDKSemanticError val) {
653 case LDKSemanticError_NoPaymentHash:
654 return (*env)->GetStaticObjectField(env, SemanticError_class, SemanticError_LDKSemanticError_NoPaymentHash);
655 case LDKSemanticError_MultiplePaymentHashes:
656 return (*env)->GetStaticObjectField(env, SemanticError_class, SemanticError_LDKSemanticError_MultiplePaymentHashes);
657 case LDKSemanticError_NoDescription:
658 return (*env)->GetStaticObjectField(env, SemanticError_class, SemanticError_LDKSemanticError_NoDescription);
659 case LDKSemanticError_MultipleDescriptions:
660 return (*env)->GetStaticObjectField(env, SemanticError_class, SemanticError_LDKSemanticError_MultipleDescriptions);
661 case LDKSemanticError_MultiplePaymentSecrets:
662 return (*env)->GetStaticObjectField(env, SemanticError_class, SemanticError_LDKSemanticError_MultiplePaymentSecrets);
663 case LDKSemanticError_InvalidFeatures:
664 return (*env)->GetStaticObjectField(env, SemanticError_class, SemanticError_LDKSemanticError_InvalidFeatures);
665 case LDKSemanticError_InvalidRecoveryId:
666 return (*env)->GetStaticObjectField(env, SemanticError_class, SemanticError_LDKSemanticError_InvalidRecoveryId);
667 case LDKSemanticError_InvalidSignature:
668 return (*env)->GetStaticObjectField(env, SemanticError_class, SemanticError_LDKSemanticError_InvalidSignature);
673 static inline LDKSiPrefix LDKSiPrefix_from_java(JNIEnv *env, jclass clz) {
674 switch ((*env)->CallIntMethod(env, clz, ordinal_meth)) {
675 case 0: return LDKSiPrefix_Milli;
676 case 1: return LDKSiPrefix_Micro;
677 case 2: return LDKSiPrefix_Nano;
678 case 3: return LDKSiPrefix_Pico;
682 static jclass SiPrefix_class = NULL;
683 static jfieldID SiPrefix_LDKSiPrefix_Milli = NULL;
684 static jfieldID SiPrefix_LDKSiPrefix_Micro = NULL;
685 static jfieldID SiPrefix_LDKSiPrefix_Nano = NULL;
686 static jfieldID SiPrefix_LDKSiPrefix_Pico = NULL;
687 JNIEXPORT void JNICALL Java_org_ldk_enums_SiPrefix_init (JNIEnv *env, jclass clz) {
688 SiPrefix_class = (*env)->NewGlobalRef(env, clz);
689 CHECK(SiPrefix_class != NULL);
690 SiPrefix_LDKSiPrefix_Milli = (*env)->GetStaticFieldID(env, SiPrefix_class, "LDKSiPrefix_Milli", "Lorg/ldk/enums/SiPrefix;");
691 CHECK(SiPrefix_LDKSiPrefix_Milli != NULL);
692 SiPrefix_LDKSiPrefix_Micro = (*env)->GetStaticFieldID(env, SiPrefix_class, "LDKSiPrefix_Micro", "Lorg/ldk/enums/SiPrefix;");
693 CHECK(SiPrefix_LDKSiPrefix_Micro != NULL);
694 SiPrefix_LDKSiPrefix_Nano = (*env)->GetStaticFieldID(env, SiPrefix_class, "LDKSiPrefix_Nano", "Lorg/ldk/enums/SiPrefix;");
695 CHECK(SiPrefix_LDKSiPrefix_Nano != NULL);
696 SiPrefix_LDKSiPrefix_Pico = (*env)->GetStaticFieldID(env, SiPrefix_class, "LDKSiPrefix_Pico", "Lorg/ldk/enums/SiPrefix;");
697 CHECK(SiPrefix_LDKSiPrefix_Pico != NULL);
699 static inline jclass LDKSiPrefix_to_java(JNIEnv *env, LDKSiPrefix val) {
701 case LDKSiPrefix_Milli:
702 return (*env)->GetStaticObjectField(env, SiPrefix_class, SiPrefix_LDKSiPrefix_Milli);
703 case LDKSiPrefix_Micro:
704 return (*env)->GetStaticObjectField(env, SiPrefix_class, SiPrefix_LDKSiPrefix_Micro);
705 case LDKSiPrefix_Nano:
706 return (*env)->GetStaticObjectField(env, SiPrefix_class, SiPrefix_LDKSiPrefix_Nano);
707 case LDKSiPrefix_Pico:
708 return (*env)->GetStaticObjectField(env, SiPrefix_class, SiPrefix_LDKSiPrefix_Pico);
713 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1u8Z_1new(JNIEnv *env, jclass clz, int8_tArray elems) {
714 LDKCVec_u8Z *ret = MALLOC(sizeof(LDKCVec_u8Z), "LDKCVec_u8Z");
715 ret->datalen = (*env)->GetArrayLength(env, elems);
716 if (ret->datalen == 0) {
719 ret->data = MALLOC(sizeof(uint8_t) * ret->datalen, "LDKCVec_u8Z Data");
720 int8_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
721 for (size_t i = 0; i < ret->datalen; i++) {
722 ret->data[i] = java_elems[i];
724 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
726 return (uint64_t)ret;
728 static inline LDKCVec_u8Z CVec_u8Z_clone(const LDKCVec_u8Z *orig) {
729 LDKCVec_u8Z ret = { .data = MALLOC(sizeof(int8_t) * orig->datalen, "LDKCVec_u8Z clone bytes"), .datalen = orig->datalen };
730 memcpy(ret.data, orig->data, sizeof(int8_t) * ret.datalen);
733 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SecretKeyErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
734 return ((LDKCResult_SecretKeyErrorZ*)arg)->result_ok;
736 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SecretKeyErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
737 LDKCResult_SecretKeyErrorZ *val = (LDKCResult_SecretKeyErrorZ*)(arg & ~1);
738 CHECK(val->result_ok);
739 int8_tArray res_arr = (*env)->NewByteArray(env, 32);
740 (*env)->SetByteArrayRegion(env, res_arr, 0, 32, (*val->contents.result).bytes);
743 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SecretKeyErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
744 LDKCResult_SecretKeyErrorZ *val = (LDKCResult_SecretKeyErrorZ*)(arg & ~1);
745 CHECK(!val->result_ok);
746 jclass err_conv = LDKSecp256k1Error_to_java(env, (*val->contents.err));
749 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PublicKeyErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
750 return ((LDKCResult_PublicKeyErrorZ*)arg)->result_ok;
752 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PublicKeyErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
753 LDKCResult_PublicKeyErrorZ *val = (LDKCResult_PublicKeyErrorZ*)(arg & ~1);
754 CHECK(val->result_ok);
755 int8_tArray res_arr = (*env)->NewByteArray(env, 33);
756 (*env)->SetByteArrayRegion(env, res_arr, 0, 33, (*val->contents.result).compressed_form);
759 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PublicKeyErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
760 LDKCResult_PublicKeyErrorZ *val = (LDKCResult_PublicKeyErrorZ*)(arg & ~1);
761 CHECK(!val->result_ok);
762 jclass err_conv = LDKSecp256k1Error_to_java(env, (*val->contents.err));
765 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxCreationKeysDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
766 return ((LDKCResult_TxCreationKeysDecodeErrorZ*)arg)->result_ok;
768 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxCreationKeysDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
769 LDKCResult_TxCreationKeysDecodeErrorZ *val = (LDKCResult_TxCreationKeysDecodeErrorZ*)(arg & ~1);
770 CHECK(val->result_ok);
771 LDKTxCreationKeys res_var = (*val->contents.result);
772 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
773 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
774 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
777 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxCreationKeysDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
778 LDKCResult_TxCreationKeysDecodeErrorZ *val = (LDKCResult_TxCreationKeysDecodeErrorZ*)(arg & ~1);
779 CHECK(!val->result_ok);
780 LDKDecodeError err_var = (*val->contents.err);
781 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
782 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
783 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
786 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelPublicKeysDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
787 return ((LDKCResult_ChannelPublicKeysDecodeErrorZ*)arg)->result_ok;
789 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelPublicKeysDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
790 LDKCResult_ChannelPublicKeysDecodeErrorZ *val = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)(arg & ~1);
791 CHECK(val->result_ok);
792 LDKChannelPublicKeys res_var = (*val->contents.result);
793 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
794 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
795 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
798 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelPublicKeysDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
799 LDKCResult_ChannelPublicKeysDecodeErrorZ *val = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)(arg & ~1);
800 CHECK(!val->result_ok);
801 LDKDecodeError err_var = (*val->contents.err);
802 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
803 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
804 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
807 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxCreationKeysErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
808 return ((LDKCResult_TxCreationKeysErrorZ*)arg)->result_ok;
810 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxCreationKeysErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
811 LDKCResult_TxCreationKeysErrorZ *val = (LDKCResult_TxCreationKeysErrorZ*)(arg & ~1);
812 CHECK(val->result_ok);
813 LDKTxCreationKeys res_var = (*val->contents.result);
814 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
815 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
816 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
819 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxCreationKeysErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
820 LDKCResult_TxCreationKeysErrorZ *val = (LDKCResult_TxCreationKeysErrorZ*)(arg & ~1);
821 CHECK(!val->result_ok);
822 jclass err_conv = LDKSecp256k1Error_to_java(env, (*val->contents.err));
825 static jclass LDKCOption_u32Z_Some_class = NULL;
826 static jmethodID LDKCOption_u32Z_Some_meth = NULL;
827 static jclass LDKCOption_u32Z_None_class = NULL;
828 static jmethodID LDKCOption_u32Z_None_meth = NULL;
829 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKCOption_1u32Z_init (JNIEnv *env, jclass clz) {
830 LDKCOption_u32Z_Some_class =
831 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKCOption_u32Z$Some;"));
832 CHECK(LDKCOption_u32Z_Some_class != NULL);
833 LDKCOption_u32Z_Some_meth = (*env)->GetMethodID(env, LDKCOption_u32Z_Some_class, "<init>", "(I)V");
834 CHECK(LDKCOption_u32Z_Some_meth != NULL);
835 LDKCOption_u32Z_None_class =
836 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKCOption_u32Z$None;"));
837 CHECK(LDKCOption_u32Z_None_class != NULL);
838 LDKCOption_u32Z_None_meth = (*env)->GetMethodID(env, LDKCOption_u32Z_None_class, "<init>", "()V");
839 CHECK(LDKCOption_u32Z_None_meth != NULL);
841 JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCOption_1u32Z_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
842 LDKCOption_u32Z *obj = (LDKCOption_u32Z*)(ptr & ~1);
844 case LDKCOption_u32Z_Some: {
845 return (*env)->NewObject(env, LDKCOption_u32Z_Some_class, LDKCOption_u32Z_Some_meth, obj->some);
847 case LDKCOption_u32Z_None: {
848 return (*env)->NewObject(env, LDKCOption_u32Z_None_class, LDKCOption_u32Z_None_meth);
853 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HTLCOutputInCommitmentDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
854 return ((LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)arg)->result_ok;
856 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HTLCOutputInCommitmentDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
857 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *val = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(arg & ~1);
858 CHECK(val->result_ok);
859 LDKHTLCOutputInCommitment res_var = (*val->contents.result);
860 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
861 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
862 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
865 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HTLCOutputInCommitmentDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
866 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *val = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(arg & ~1);
867 CHECK(!val->result_ok);
868 LDKDecodeError err_var = (*val->contents.err);
869 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
870 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
871 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
874 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CounterpartyChannelTransactionParametersDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
875 return ((LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)arg)->result_ok;
877 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CounterpartyChannelTransactionParametersDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
878 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *val = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(arg & ~1);
879 CHECK(val->result_ok);
880 LDKCounterpartyChannelTransactionParameters res_var = (*val->contents.result);
881 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
882 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
883 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
886 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CounterpartyChannelTransactionParametersDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
887 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *val = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(arg & ~1);
888 CHECK(!val->result_ok);
889 LDKDecodeError err_var = (*val->contents.err);
890 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
891 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
892 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
895 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelTransactionParametersDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
896 return ((LDKCResult_ChannelTransactionParametersDecodeErrorZ*)arg)->result_ok;
898 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelTransactionParametersDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
899 LDKCResult_ChannelTransactionParametersDecodeErrorZ *val = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(arg & ~1);
900 CHECK(val->result_ok);
901 LDKChannelTransactionParameters res_var = (*val->contents.result);
902 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
903 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
904 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
907 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelTransactionParametersDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
908 LDKCResult_ChannelTransactionParametersDecodeErrorZ *val = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(arg & ~1);
909 CHECK(!val->result_ok);
910 LDKDecodeError err_var = (*val->contents.err);
911 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
912 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
913 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
916 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HolderCommitmentTransactionDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
917 return ((LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)arg)->result_ok;
919 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HolderCommitmentTransactionDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
920 LDKCResult_HolderCommitmentTransactionDecodeErrorZ *val = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(arg & ~1);
921 CHECK(val->result_ok);
922 LDKHolderCommitmentTransaction res_var = (*val->contents.result);
923 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
924 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
925 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
928 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HolderCommitmentTransactionDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
929 LDKCResult_HolderCommitmentTransactionDecodeErrorZ *val = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(arg & ~1);
930 CHECK(!val->result_ok);
931 LDKDecodeError err_var = (*val->contents.err);
932 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
933 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
934 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
937 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1BuiltCommitmentTransactionDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
938 return ((LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)arg)->result_ok;
940 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1BuiltCommitmentTransactionDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
941 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *val = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(arg & ~1);
942 CHECK(val->result_ok);
943 LDKBuiltCommitmentTransaction res_var = (*val->contents.result);
944 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
945 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
946 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
949 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1BuiltCommitmentTransactionDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
950 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *val = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(arg & ~1);
951 CHECK(!val->result_ok);
952 LDKDecodeError err_var = (*val->contents.err);
953 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
954 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
955 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
958 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CommitmentTransactionDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
959 return ((LDKCResult_CommitmentTransactionDecodeErrorZ*)arg)->result_ok;
961 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CommitmentTransactionDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
962 LDKCResult_CommitmentTransactionDecodeErrorZ *val = (LDKCResult_CommitmentTransactionDecodeErrorZ*)(arg & ~1);
963 CHECK(val->result_ok);
964 LDKCommitmentTransaction res_var = (*val->contents.result);
965 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
966 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
967 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
970 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CommitmentTransactionDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
971 LDKCResult_CommitmentTransactionDecodeErrorZ *val = (LDKCResult_CommitmentTransactionDecodeErrorZ*)(arg & ~1);
972 CHECK(!val->result_ok);
973 LDKDecodeError err_var = (*val->contents.err);
974 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
975 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
976 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
979 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TrustedCommitmentTransactionNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
980 return ((LDKCResult_TrustedCommitmentTransactionNoneZ*)arg)->result_ok;
982 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TrustedCommitmentTransactionNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
983 LDKCResult_TrustedCommitmentTransactionNoneZ *val = (LDKCResult_TrustedCommitmentTransactionNoneZ*)(arg & ~1);
984 CHECK(val->result_ok);
985 LDKTrustedCommitmentTransaction res_var = (*val->contents.result);
986 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
987 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
988 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
991 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TrustedCommitmentTransactionNoneZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
992 LDKCResult_TrustedCommitmentTransactionNoneZ *val = (LDKCResult_TrustedCommitmentTransactionNoneZ*)(arg & ~1);
993 CHECK(!val->result_ok);
994 return *val->contents.err;
996 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1SignatureZNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
997 return ((LDKCResult_CVec_SignatureZNoneZ*)arg)->result_ok;
999 JNIEXPORT jobjectArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1SignatureZNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1000 LDKCResult_CVec_SignatureZNoneZ *val = (LDKCResult_CVec_SignatureZNoneZ*)(arg & ~1);
1001 CHECK(val->result_ok);
1002 LDKCVec_SignatureZ res_var = (*val->contents.result);
1003 jobjectArray res_arr = (*env)->NewObjectArray(env, res_var.datalen, arr_of_B_clz, NULL);
1005 for (size_t i = 0; i < res_var.datalen; i++) {
1006 int8_tArray res_conv_8_arr = (*env)->NewByteArray(env, 64);
1007 (*env)->SetByteArrayRegion(env, res_conv_8_arr, 0, 64, res_var.data[i].compact_form);
1008 (*env)->SetObjectArrayElement(env, res_arr, i, res_conv_8_arr);
1012 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1SignatureZNoneZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
1013 LDKCResult_CVec_SignatureZNoneZ *val = (LDKCResult_CVec_SignatureZNoneZ*)(arg & ~1);
1014 CHECK(!val->result_ok);
1015 return *val->contents.err;
1017 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1018 return ((LDKCResult_NoneErrorZ*)arg)->result_ok;
1020 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1021 LDKCResult_NoneErrorZ *val = (LDKCResult_NoneErrorZ*)(arg & ~1);
1022 CHECK(val->result_ok);
1023 return *val->contents.result;
1025 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
1026 LDKCResult_NoneErrorZ *val = (LDKCResult_NoneErrorZ*)(arg & ~1);
1027 CHECK(!val->result_ok);
1028 jclass err_conv = LDKIOError_to_java(env, (*val->contents.err));
1031 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteHopDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1032 return ((LDKCResult_RouteHopDecodeErrorZ*)arg)->result_ok;
1034 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteHopDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1035 LDKCResult_RouteHopDecodeErrorZ *val = (LDKCResult_RouteHopDecodeErrorZ*)(arg & ~1);
1036 CHECK(val->result_ok);
1037 LDKRouteHop res_var = (*val->contents.result);
1038 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1039 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1040 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
1043 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteHopDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
1044 LDKCResult_RouteHopDecodeErrorZ *val = (LDKCResult_RouteHopDecodeErrorZ*)(arg & ~1);
1045 CHECK(!val->result_ok);
1046 LDKDecodeError err_var = (*val->contents.err);
1047 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1048 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1049 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
1052 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1RouteHopZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
1053 LDKCVec_RouteHopZ *ret = MALLOC(sizeof(LDKCVec_RouteHopZ), "LDKCVec_RouteHopZ");
1054 ret->datalen = (*env)->GetArrayLength(env, elems);
1055 if (ret->datalen == 0) {
1058 ret->data = MALLOC(sizeof(LDKRouteHop) * ret->datalen, "LDKCVec_RouteHopZ Data");
1059 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
1060 for (size_t i = 0; i < ret->datalen; i++) {
1061 int64_t arr_elem = java_elems[i];
1062 LDKRouteHop arr_elem_conv;
1063 arr_elem_conv.inner = (void*)(arr_elem & (~1));
1064 arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
1065 arr_elem_conv = RouteHop_clone(&arr_elem_conv);
1066 ret->data[i] = arr_elem_conv;
1068 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
1070 return (uint64_t)ret;
1072 static inline LDKCVec_RouteHopZ CVec_RouteHopZ_clone(const LDKCVec_RouteHopZ *orig) {
1073 LDKCVec_RouteHopZ ret = { .data = MALLOC(sizeof(LDKRouteHop) * orig->datalen, "LDKCVec_RouteHopZ clone bytes"), .datalen = orig->datalen };
1074 for (size_t i = 0; i < ret.datalen; i++) {
1075 ret.data[i] = RouteHop_clone(&orig->data[i]);
1079 static inline LDKCVec_CVec_RouteHopZZ CVec_CVec_RouteHopZZ_clone(const LDKCVec_CVec_RouteHopZZ *orig) {
1080 LDKCVec_CVec_RouteHopZZ ret = { .data = MALLOC(sizeof(LDKCVec_RouteHopZ) * orig->datalen, "LDKCVec_CVec_RouteHopZZ clone bytes"), .datalen = orig->datalen };
1081 for (size_t i = 0; i < ret.datalen; i++) {
1082 ret.data[i] = CVec_RouteHopZ_clone(&orig->data[i]);
1086 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1087 return ((LDKCResult_RouteDecodeErrorZ*)arg)->result_ok;
1089 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1090 LDKCResult_RouteDecodeErrorZ *val = (LDKCResult_RouteDecodeErrorZ*)(arg & ~1);
1091 CHECK(val->result_ok);
1092 LDKRoute res_var = (*val->contents.result);
1093 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1094 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1095 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
1098 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
1099 LDKCResult_RouteDecodeErrorZ *val = (LDKCResult_RouteDecodeErrorZ*)(arg & ~1);
1100 CHECK(!val->result_ok);
1101 LDKDecodeError err_var = (*val->contents.err);
1102 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1103 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1104 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
1107 static jclass LDKCOption_u64Z_Some_class = NULL;
1108 static jmethodID LDKCOption_u64Z_Some_meth = NULL;
1109 static jclass LDKCOption_u64Z_None_class = NULL;
1110 static jmethodID LDKCOption_u64Z_None_meth = NULL;
1111 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKCOption_1u64Z_init (JNIEnv *env, jclass clz) {
1112 LDKCOption_u64Z_Some_class =
1113 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKCOption_u64Z$Some;"));
1114 CHECK(LDKCOption_u64Z_Some_class != NULL);
1115 LDKCOption_u64Z_Some_meth = (*env)->GetMethodID(env, LDKCOption_u64Z_Some_class, "<init>", "(J)V");
1116 CHECK(LDKCOption_u64Z_Some_meth != NULL);
1117 LDKCOption_u64Z_None_class =
1118 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKCOption_u64Z$None;"));
1119 CHECK(LDKCOption_u64Z_None_class != NULL);
1120 LDKCOption_u64Z_None_meth = (*env)->GetMethodID(env, LDKCOption_u64Z_None_class, "<init>", "()V");
1121 CHECK(LDKCOption_u64Z_None_meth != NULL);
1123 JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCOption_1u64Z_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
1124 LDKCOption_u64Z *obj = (LDKCOption_u64Z*)(ptr & ~1);
1126 case LDKCOption_u64Z_Some: {
1127 return (*env)->NewObject(env, LDKCOption_u64Z_Some_class, LDKCOption_u64Z_Some_meth, obj->some);
1129 case LDKCOption_u64Z_None: {
1130 return (*env)->NewObject(env, LDKCOption_u64Z_None_class, LDKCOption_u64Z_None_meth);
1135 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1ChannelDetailsZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
1136 LDKCVec_ChannelDetailsZ *ret = MALLOC(sizeof(LDKCVec_ChannelDetailsZ), "LDKCVec_ChannelDetailsZ");
1137 ret->datalen = (*env)->GetArrayLength(env, elems);
1138 if (ret->datalen == 0) {
1141 ret->data = MALLOC(sizeof(LDKChannelDetails) * ret->datalen, "LDKCVec_ChannelDetailsZ Data");
1142 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
1143 for (size_t i = 0; i < ret->datalen; i++) {
1144 int64_t arr_elem = java_elems[i];
1145 LDKChannelDetails arr_elem_conv;
1146 arr_elem_conv.inner = (void*)(arr_elem & (~1));
1147 arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
1148 arr_elem_conv = ChannelDetails_clone(&arr_elem_conv);
1149 ret->data[i] = arr_elem_conv;
1151 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
1153 return (uint64_t)ret;
1155 static inline LDKCVec_ChannelDetailsZ CVec_ChannelDetailsZ_clone(const LDKCVec_ChannelDetailsZ *orig) {
1156 LDKCVec_ChannelDetailsZ ret = { .data = MALLOC(sizeof(LDKChannelDetails) * orig->datalen, "LDKCVec_ChannelDetailsZ clone bytes"), .datalen = orig->datalen };
1157 for (size_t i = 0; i < ret.datalen; i++) {
1158 ret.data[i] = ChannelDetails_clone(&orig->data[i]);
1162 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1RouteHintZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
1163 LDKCVec_RouteHintZ *ret = MALLOC(sizeof(LDKCVec_RouteHintZ), "LDKCVec_RouteHintZ");
1164 ret->datalen = (*env)->GetArrayLength(env, elems);
1165 if (ret->datalen == 0) {
1168 ret->data = MALLOC(sizeof(LDKRouteHint) * ret->datalen, "LDKCVec_RouteHintZ Data");
1169 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
1170 for (size_t i = 0; i < ret->datalen; i++) {
1171 int64_t arr_elem = java_elems[i];
1172 LDKRouteHint arr_elem_conv;
1173 arr_elem_conv.inner = (void*)(arr_elem & (~1));
1174 arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
1175 arr_elem_conv = RouteHint_clone(&arr_elem_conv);
1176 ret->data[i] = arr_elem_conv;
1178 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
1180 return (uint64_t)ret;
1182 static inline LDKCVec_RouteHintZ CVec_RouteHintZ_clone(const LDKCVec_RouteHintZ *orig) {
1183 LDKCVec_RouteHintZ ret = { .data = MALLOC(sizeof(LDKRouteHint) * orig->datalen, "LDKCVec_RouteHintZ clone bytes"), .datalen = orig->datalen };
1184 for (size_t i = 0; i < ret.datalen; i++) {
1185 ret.data[i] = RouteHint_clone(&orig->data[i]);
1189 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteLightningErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1190 return ((LDKCResult_RouteLightningErrorZ*)arg)->result_ok;
1192 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteLightningErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1193 LDKCResult_RouteLightningErrorZ *val = (LDKCResult_RouteLightningErrorZ*)(arg & ~1);
1194 CHECK(val->result_ok);
1195 LDKRoute res_var = (*val->contents.result);
1196 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1197 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1198 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
1201 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteLightningErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
1202 LDKCResult_RouteLightningErrorZ *val = (LDKCResult_RouteLightningErrorZ*)(arg & ~1);
1203 CHECK(!val->result_ok);
1204 LDKLightningError err_var = (*val->contents.err);
1205 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1206 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1207 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
1210 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxOutAccessErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1211 return ((LDKCResult_TxOutAccessErrorZ*)arg)->result_ok;
1213 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxOutAccessErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1214 LDKCResult_TxOutAccessErrorZ *val = (LDKCResult_TxOutAccessErrorZ*)(arg & ~1);
1215 CHECK(val->result_ok);
1216 uint64_t res_ref = ((uint64_t)&(*val->contents.result)) | 1;
1217 return (uint64_t)res_ref;
1219 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxOutAccessErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
1220 LDKCResult_TxOutAccessErrorZ *val = (LDKCResult_TxOutAccessErrorZ*)(arg & ~1);
1221 CHECK(!val->result_ok);
1222 jclass err_conv = LDKAccessError_to_java(env, (*val->contents.err));
1225 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1usizeTransactionZ_1new(JNIEnv *env, jclass clz, int64_t a, int8_tArray b) {
1226 LDKC2Tuple_usizeTransactionZ* ret = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
1228 LDKTransaction b_ref;
1229 b_ref.datalen = (*env)->GetArrayLength(env, b);
1230 b_ref.data = MALLOC(b_ref.datalen, "LDKTransaction Bytes");
1231 (*env)->GetByteArrayRegion(env, b, 0, b_ref.datalen, b_ref.data);
1232 b_ref.data_is_owned = false;
1234 return (uint64_t)ret;
1236 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1usizeTransactionZ_1get_1a(JNIEnv *env, jclass clz, int64_t ptr) {
1237 LDKC2Tuple_usizeTransactionZ *tuple = (LDKC2Tuple_usizeTransactionZ*)(ptr & ~1);
1240 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1usizeTransactionZ_1get_1b(JNIEnv *env, jclass clz, int64_t ptr) {
1241 LDKC2Tuple_usizeTransactionZ *tuple = (LDKC2Tuple_usizeTransactionZ*)(ptr & ~1);
1242 LDKTransaction b_var = tuple->b;
1243 int8_tArray b_arr = (*env)->NewByteArray(env, b_var.datalen);
1244 (*env)->SetByteArrayRegion(env, b_arr, 0, b_var.datalen, b_var.data);
1247 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C2Tuple_1usizeTransactionZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
1248 LDKCVec_C2Tuple_usizeTransactionZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_usizeTransactionZZ), "LDKCVec_C2Tuple_usizeTransactionZZ");
1249 ret->datalen = (*env)->GetArrayLength(env, elems);
1250 if (ret->datalen == 0) {
1253 ret->data = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ) * ret->datalen, "LDKCVec_C2Tuple_usizeTransactionZZ Data");
1254 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
1255 for (size_t i = 0; i < ret->datalen; i++) {
1256 int64_t arr_elem = java_elems[i];
1257 LDKC2Tuple_usizeTransactionZ arr_elem_conv = *(LDKC2Tuple_usizeTransactionZ*)(((uint64_t)arr_elem) & ~1);
1258 arr_elem_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)(((uint64_t)arr_elem) & ~1));
1259 ret->data[i] = arr_elem_conv;
1261 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
1263 return (uint64_t)ret;
1265 static inline LDKCVec_C2Tuple_usizeTransactionZZ CVec_C2Tuple_usizeTransactionZZ_clone(const LDKCVec_C2Tuple_usizeTransactionZZ *orig) {
1266 LDKCVec_C2Tuple_usizeTransactionZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ) * orig->datalen, "LDKCVec_C2Tuple_usizeTransactionZZ clone bytes"), .datalen = orig->datalen };
1267 for (size_t i = 0; i < ret.datalen; i++) {
1268 ret.data[i] = C2Tuple_usizeTransactionZ_clone(&orig->data[i]);
1272 static inline LDKCVec_TxidZ CVec_ThirtyTwoBytesZ_clone(const LDKCVec_TxidZ *orig) {
1273 LDKCVec_TxidZ ret = { .data = MALLOC(sizeof(LDKThirtyTwoBytes) * orig->datalen, "LDKCVec_TxidZ clone bytes"), .datalen = orig->datalen };
1274 for (size_t i = 0; i < ret.datalen; i++) {
1275 ret.data[i] = ThirtyTwoBytes_clone(&orig->data[i]);
1279 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneChannelMonitorUpdateErrZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1280 return ((LDKCResult_NoneChannelMonitorUpdateErrZ*)arg)->result_ok;
1282 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneChannelMonitorUpdateErrZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1283 LDKCResult_NoneChannelMonitorUpdateErrZ *val = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(arg & ~1);
1284 CHECK(val->result_ok);
1285 return *val->contents.result;
1287 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneChannelMonitorUpdateErrZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
1288 LDKCResult_NoneChannelMonitorUpdateErrZ *val = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(arg & ~1);
1289 CHECK(!val->result_ok);
1290 jclass err_conv = LDKChannelMonitorUpdateErr_to_java(env, (*val->contents.err));
1293 static jclass LDKMonitorEvent_HTLCEvent_class = NULL;
1294 static jmethodID LDKMonitorEvent_HTLCEvent_meth = NULL;
1295 static jclass LDKMonitorEvent_CommitmentTxBroadcasted_class = NULL;
1296 static jmethodID LDKMonitorEvent_CommitmentTxBroadcasted_meth = NULL;
1297 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKMonitorEvent_init (JNIEnv *env, jclass clz) {
1298 LDKMonitorEvent_HTLCEvent_class =
1299 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMonitorEvent$HTLCEvent;"));
1300 CHECK(LDKMonitorEvent_HTLCEvent_class != NULL);
1301 LDKMonitorEvent_HTLCEvent_meth = (*env)->GetMethodID(env, LDKMonitorEvent_HTLCEvent_class, "<init>", "(J)V");
1302 CHECK(LDKMonitorEvent_HTLCEvent_meth != NULL);
1303 LDKMonitorEvent_CommitmentTxBroadcasted_class =
1304 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMonitorEvent$CommitmentTxBroadcasted;"));
1305 CHECK(LDKMonitorEvent_CommitmentTxBroadcasted_class != NULL);
1306 LDKMonitorEvent_CommitmentTxBroadcasted_meth = (*env)->GetMethodID(env, LDKMonitorEvent_CommitmentTxBroadcasted_class, "<init>", "(J)V");
1307 CHECK(LDKMonitorEvent_CommitmentTxBroadcasted_meth != NULL);
1309 JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKMonitorEvent_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
1310 LDKMonitorEvent *obj = (LDKMonitorEvent*)(ptr & ~1);
1312 case LDKMonitorEvent_HTLCEvent: {
1313 LDKHTLCUpdate htlc_event_var = obj->htlc_event;
1314 CHECK((((uint64_t)htlc_event_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1315 CHECK((((uint64_t)&htlc_event_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1316 uint64_t htlc_event_ref = (uint64_t)htlc_event_var.inner & ~1;
1317 return (*env)->NewObject(env, LDKMonitorEvent_HTLCEvent_class, LDKMonitorEvent_HTLCEvent_meth, htlc_event_ref);
1319 case LDKMonitorEvent_CommitmentTxBroadcasted: {
1320 LDKOutPoint commitment_tx_broadcasted_var = obj->commitment_tx_broadcasted;
1321 CHECK((((uint64_t)commitment_tx_broadcasted_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1322 CHECK((((uint64_t)&commitment_tx_broadcasted_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1323 uint64_t commitment_tx_broadcasted_ref = (uint64_t)commitment_tx_broadcasted_var.inner & ~1;
1324 return (*env)->NewObject(env, LDKMonitorEvent_CommitmentTxBroadcasted_class, LDKMonitorEvent_CommitmentTxBroadcasted_meth, commitment_tx_broadcasted_ref);
1329 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1MonitorEventZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
1330 LDKCVec_MonitorEventZ *ret = MALLOC(sizeof(LDKCVec_MonitorEventZ), "LDKCVec_MonitorEventZ");
1331 ret->datalen = (*env)->GetArrayLength(env, elems);
1332 if (ret->datalen == 0) {
1335 ret->data = MALLOC(sizeof(LDKMonitorEvent) * ret->datalen, "LDKCVec_MonitorEventZ Data");
1336 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
1337 for (size_t i = 0; i < ret->datalen; i++) {
1338 int64_t arr_elem = java_elems[i];
1339 LDKMonitorEvent arr_elem_conv = *(LDKMonitorEvent*)(((uint64_t)arr_elem) & ~1);
1340 arr_elem_conv = MonitorEvent_clone((LDKMonitorEvent*)(((uint64_t)arr_elem) & ~1));
1341 ret->data[i] = arr_elem_conv;
1343 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
1345 return (uint64_t)ret;
1347 static inline LDKCVec_MonitorEventZ CVec_MonitorEventZ_clone(const LDKCVec_MonitorEventZ *orig) {
1348 LDKCVec_MonitorEventZ ret = { .data = MALLOC(sizeof(LDKMonitorEvent) * orig->datalen, "LDKCVec_MonitorEventZ clone bytes"), .datalen = orig->datalen };
1349 for (size_t i = 0; i < ret.datalen; i++) {
1350 ret.data[i] = MonitorEvent_clone(&orig->data[i]);
1354 static jclass LDKCOption_C2Tuple_usizeTransactionZZ_Some_class = NULL;
1355 static jmethodID LDKCOption_C2Tuple_usizeTransactionZZ_Some_meth = NULL;
1356 static jclass LDKCOption_C2Tuple_usizeTransactionZZ_None_class = NULL;
1357 static jmethodID LDKCOption_C2Tuple_usizeTransactionZZ_None_meth = NULL;
1358 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKCOption_1C2Tuple_1usizeTransactionZZ_init (JNIEnv *env, jclass clz) {
1359 LDKCOption_C2Tuple_usizeTransactionZZ_Some_class =
1360 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKCOption_C2Tuple_usizeTransactionZZ$Some;"));
1361 CHECK(LDKCOption_C2Tuple_usizeTransactionZZ_Some_class != NULL);
1362 LDKCOption_C2Tuple_usizeTransactionZZ_Some_meth = (*env)->GetMethodID(env, LDKCOption_C2Tuple_usizeTransactionZZ_Some_class, "<init>", "(J)V");
1363 CHECK(LDKCOption_C2Tuple_usizeTransactionZZ_Some_meth != NULL);
1364 LDKCOption_C2Tuple_usizeTransactionZZ_None_class =
1365 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKCOption_C2Tuple_usizeTransactionZZ$None;"));
1366 CHECK(LDKCOption_C2Tuple_usizeTransactionZZ_None_class != NULL);
1367 LDKCOption_C2Tuple_usizeTransactionZZ_None_meth = (*env)->GetMethodID(env, LDKCOption_C2Tuple_usizeTransactionZZ_None_class, "<init>", "()V");
1368 CHECK(LDKCOption_C2Tuple_usizeTransactionZZ_None_meth != NULL);
1370 JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCOption_1C2Tuple_1usizeTransactionZZ_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
1371 LDKCOption_C2Tuple_usizeTransactionZZ *obj = (LDKCOption_C2Tuple_usizeTransactionZZ*)(ptr & ~1);
1373 case LDKCOption_C2Tuple_usizeTransactionZZ_Some: {
1374 uint64_t some_ref = (uint64_t)(&obj->some) | 1;
1375 return (*env)->NewObject(env, LDKCOption_C2Tuple_usizeTransactionZZ_Some_class, LDKCOption_C2Tuple_usizeTransactionZZ_Some_meth, some_ref);
1377 case LDKCOption_C2Tuple_usizeTransactionZZ_None: {
1378 return (*env)->NewObject(env, LDKCOption_C2Tuple_usizeTransactionZZ_None_class, LDKCOption_C2Tuple_usizeTransactionZZ_None_meth);
1383 static jclass LDKSpendableOutputDescriptor_StaticOutput_class = NULL;
1384 static jmethodID LDKSpendableOutputDescriptor_StaticOutput_meth = NULL;
1385 static jclass LDKSpendableOutputDescriptor_DelayedPaymentOutput_class = NULL;
1386 static jmethodID LDKSpendableOutputDescriptor_DelayedPaymentOutput_meth = NULL;
1387 static jclass LDKSpendableOutputDescriptor_StaticPaymentOutput_class = NULL;
1388 static jmethodID LDKSpendableOutputDescriptor_StaticPaymentOutput_meth = NULL;
1389 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKSpendableOutputDescriptor_init (JNIEnv *env, jclass clz) {
1390 LDKSpendableOutputDescriptor_StaticOutput_class =
1391 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKSpendableOutputDescriptor$StaticOutput;"));
1392 CHECK(LDKSpendableOutputDescriptor_StaticOutput_class != NULL);
1393 LDKSpendableOutputDescriptor_StaticOutput_meth = (*env)->GetMethodID(env, LDKSpendableOutputDescriptor_StaticOutput_class, "<init>", "(JJ)V");
1394 CHECK(LDKSpendableOutputDescriptor_StaticOutput_meth != NULL);
1395 LDKSpendableOutputDescriptor_DelayedPaymentOutput_class =
1396 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKSpendableOutputDescriptor$DelayedPaymentOutput;"));
1397 CHECK(LDKSpendableOutputDescriptor_DelayedPaymentOutput_class != NULL);
1398 LDKSpendableOutputDescriptor_DelayedPaymentOutput_meth = (*env)->GetMethodID(env, LDKSpendableOutputDescriptor_DelayedPaymentOutput_class, "<init>", "(J)V");
1399 CHECK(LDKSpendableOutputDescriptor_DelayedPaymentOutput_meth != NULL);
1400 LDKSpendableOutputDescriptor_StaticPaymentOutput_class =
1401 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKSpendableOutputDescriptor$StaticPaymentOutput;"));
1402 CHECK(LDKSpendableOutputDescriptor_StaticPaymentOutput_class != NULL);
1403 LDKSpendableOutputDescriptor_StaticPaymentOutput_meth = (*env)->GetMethodID(env, LDKSpendableOutputDescriptor_StaticPaymentOutput_class, "<init>", "(J)V");
1404 CHECK(LDKSpendableOutputDescriptor_StaticPaymentOutput_meth != NULL);
1406 JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKSpendableOutputDescriptor_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
1407 LDKSpendableOutputDescriptor *obj = (LDKSpendableOutputDescriptor*)(ptr & ~1);
1409 case LDKSpendableOutputDescriptor_StaticOutput: {
1410 LDKOutPoint outpoint_var = obj->static_output.outpoint;
1411 CHECK((((uint64_t)outpoint_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1412 CHECK((((uint64_t)&outpoint_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1413 uint64_t outpoint_ref = (uint64_t)outpoint_var.inner & ~1;
1414 uint64_t output_ref = ((uint64_t)&obj->static_output.output) | 1;
1415 return (*env)->NewObject(env, LDKSpendableOutputDescriptor_StaticOutput_class, LDKSpendableOutputDescriptor_StaticOutput_meth, outpoint_ref, (uint64_t)output_ref);
1417 case LDKSpendableOutputDescriptor_DelayedPaymentOutput: {
1418 LDKDelayedPaymentOutputDescriptor delayed_payment_output_var = obj->delayed_payment_output;
1419 CHECK((((uint64_t)delayed_payment_output_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1420 CHECK((((uint64_t)&delayed_payment_output_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1421 uint64_t delayed_payment_output_ref = (uint64_t)delayed_payment_output_var.inner & ~1;
1422 return (*env)->NewObject(env, LDKSpendableOutputDescriptor_DelayedPaymentOutput_class, LDKSpendableOutputDescriptor_DelayedPaymentOutput_meth, delayed_payment_output_ref);
1424 case LDKSpendableOutputDescriptor_StaticPaymentOutput: {
1425 LDKStaticPaymentOutputDescriptor static_payment_output_var = obj->static_payment_output;
1426 CHECK((((uint64_t)static_payment_output_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1427 CHECK((((uint64_t)&static_payment_output_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1428 uint64_t static_payment_output_ref = (uint64_t)static_payment_output_var.inner & ~1;
1429 return (*env)->NewObject(env, LDKSpendableOutputDescriptor_StaticPaymentOutput_class, LDKSpendableOutputDescriptor_StaticPaymentOutput_meth, static_payment_output_ref);
1434 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1SpendableOutputDescriptorZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
1435 LDKCVec_SpendableOutputDescriptorZ *ret = MALLOC(sizeof(LDKCVec_SpendableOutputDescriptorZ), "LDKCVec_SpendableOutputDescriptorZ");
1436 ret->datalen = (*env)->GetArrayLength(env, elems);
1437 if (ret->datalen == 0) {
1440 ret->data = MALLOC(sizeof(LDKSpendableOutputDescriptor) * ret->datalen, "LDKCVec_SpendableOutputDescriptorZ Data");
1441 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
1442 for (size_t i = 0; i < ret->datalen; i++) {
1443 int64_t arr_elem = java_elems[i];
1444 LDKSpendableOutputDescriptor arr_elem_conv = *(LDKSpendableOutputDescriptor*)(((uint64_t)arr_elem) & ~1);
1445 arr_elem_conv = SpendableOutputDescriptor_clone((LDKSpendableOutputDescriptor*)(((uint64_t)arr_elem) & ~1));
1446 ret->data[i] = arr_elem_conv;
1448 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
1450 return (uint64_t)ret;
1452 static inline LDKCVec_SpendableOutputDescriptorZ CVec_SpendableOutputDescriptorZ_clone(const LDKCVec_SpendableOutputDescriptorZ *orig) {
1453 LDKCVec_SpendableOutputDescriptorZ ret = { .data = MALLOC(sizeof(LDKSpendableOutputDescriptor) * orig->datalen, "LDKCVec_SpendableOutputDescriptorZ clone bytes"), .datalen = orig->datalen };
1454 for (size_t i = 0; i < ret.datalen; i++) {
1455 ret.data[i] = SpendableOutputDescriptor_clone(&orig->data[i]);
1459 static jclass LDKErrorAction_DisconnectPeer_class = NULL;
1460 static jmethodID LDKErrorAction_DisconnectPeer_meth = NULL;
1461 static jclass LDKErrorAction_IgnoreError_class = NULL;
1462 static jmethodID LDKErrorAction_IgnoreError_meth = NULL;
1463 static jclass LDKErrorAction_IgnoreAndLog_class = NULL;
1464 static jmethodID LDKErrorAction_IgnoreAndLog_meth = NULL;
1465 static jclass LDKErrorAction_SendErrorMessage_class = NULL;
1466 static jmethodID LDKErrorAction_SendErrorMessage_meth = NULL;
1467 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKErrorAction_init (JNIEnv *env, jclass clz) {
1468 LDKErrorAction_DisconnectPeer_class =
1469 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKErrorAction$DisconnectPeer;"));
1470 CHECK(LDKErrorAction_DisconnectPeer_class != NULL);
1471 LDKErrorAction_DisconnectPeer_meth = (*env)->GetMethodID(env, LDKErrorAction_DisconnectPeer_class, "<init>", "(J)V");
1472 CHECK(LDKErrorAction_DisconnectPeer_meth != NULL);
1473 LDKErrorAction_IgnoreError_class =
1474 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKErrorAction$IgnoreError;"));
1475 CHECK(LDKErrorAction_IgnoreError_class != NULL);
1476 LDKErrorAction_IgnoreError_meth = (*env)->GetMethodID(env, LDKErrorAction_IgnoreError_class, "<init>", "()V");
1477 CHECK(LDKErrorAction_IgnoreError_meth != NULL);
1478 LDKErrorAction_IgnoreAndLog_class =
1479 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKErrorAction$IgnoreAndLog;"));
1480 CHECK(LDKErrorAction_IgnoreAndLog_class != NULL);
1481 LDKErrorAction_IgnoreAndLog_meth = (*env)->GetMethodID(env, LDKErrorAction_IgnoreAndLog_class, "<init>", "(Lorg/ldk/enums/Level;)V");
1482 CHECK(LDKErrorAction_IgnoreAndLog_meth != NULL);
1483 LDKErrorAction_SendErrorMessage_class =
1484 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKErrorAction$SendErrorMessage;"));
1485 CHECK(LDKErrorAction_SendErrorMessage_class != NULL);
1486 LDKErrorAction_SendErrorMessage_meth = (*env)->GetMethodID(env, LDKErrorAction_SendErrorMessage_class, "<init>", "(J)V");
1487 CHECK(LDKErrorAction_SendErrorMessage_meth != NULL);
1489 JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKErrorAction_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
1490 LDKErrorAction *obj = (LDKErrorAction*)(ptr & ~1);
1492 case LDKErrorAction_DisconnectPeer: {
1493 LDKErrorMessage msg_var = obj->disconnect_peer.msg;
1494 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1495 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1496 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1497 return (*env)->NewObject(env, LDKErrorAction_DisconnectPeer_class, LDKErrorAction_DisconnectPeer_meth, msg_ref);
1499 case LDKErrorAction_IgnoreError: {
1500 return (*env)->NewObject(env, LDKErrorAction_IgnoreError_class, LDKErrorAction_IgnoreError_meth);
1502 case LDKErrorAction_IgnoreAndLog: {
1503 jclass ignore_and_log_conv = LDKLevel_to_java(env, obj->ignore_and_log);
1504 return (*env)->NewObject(env, LDKErrorAction_IgnoreAndLog_class, LDKErrorAction_IgnoreAndLog_meth, ignore_and_log_conv);
1506 case LDKErrorAction_SendErrorMessage: {
1507 LDKErrorMessage msg_var = obj->send_error_message.msg;
1508 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1509 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1510 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1511 return (*env)->NewObject(env, LDKErrorAction_SendErrorMessage_class, LDKErrorAction_SendErrorMessage_meth, msg_ref);
1516 static jclass LDKHTLCFailChannelUpdate_ChannelUpdateMessage_class = NULL;
1517 static jmethodID LDKHTLCFailChannelUpdate_ChannelUpdateMessage_meth = NULL;
1518 static jclass LDKHTLCFailChannelUpdate_ChannelClosed_class = NULL;
1519 static jmethodID LDKHTLCFailChannelUpdate_ChannelClosed_meth = NULL;
1520 static jclass LDKHTLCFailChannelUpdate_NodeFailure_class = NULL;
1521 static jmethodID LDKHTLCFailChannelUpdate_NodeFailure_meth = NULL;
1522 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKHTLCFailChannelUpdate_init (JNIEnv *env, jclass clz) {
1523 LDKHTLCFailChannelUpdate_ChannelUpdateMessage_class =
1524 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKHTLCFailChannelUpdate$ChannelUpdateMessage;"));
1525 CHECK(LDKHTLCFailChannelUpdate_ChannelUpdateMessage_class != NULL);
1526 LDKHTLCFailChannelUpdate_ChannelUpdateMessage_meth = (*env)->GetMethodID(env, LDKHTLCFailChannelUpdate_ChannelUpdateMessage_class, "<init>", "(J)V");
1527 CHECK(LDKHTLCFailChannelUpdate_ChannelUpdateMessage_meth != NULL);
1528 LDKHTLCFailChannelUpdate_ChannelClosed_class =
1529 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKHTLCFailChannelUpdate$ChannelClosed;"));
1530 CHECK(LDKHTLCFailChannelUpdate_ChannelClosed_class != NULL);
1531 LDKHTLCFailChannelUpdate_ChannelClosed_meth = (*env)->GetMethodID(env, LDKHTLCFailChannelUpdate_ChannelClosed_class, "<init>", "(JZ)V");
1532 CHECK(LDKHTLCFailChannelUpdate_ChannelClosed_meth != NULL);
1533 LDKHTLCFailChannelUpdate_NodeFailure_class =
1534 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKHTLCFailChannelUpdate$NodeFailure;"));
1535 CHECK(LDKHTLCFailChannelUpdate_NodeFailure_class != NULL);
1536 LDKHTLCFailChannelUpdate_NodeFailure_meth = (*env)->GetMethodID(env, LDKHTLCFailChannelUpdate_NodeFailure_class, "<init>", "([BZ)V");
1537 CHECK(LDKHTLCFailChannelUpdate_NodeFailure_meth != NULL);
1539 JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKHTLCFailChannelUpdate_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
1540 LDKHTLCFailChannelUpdate *obj = (LDKHTLCFailChannelUpdate*)(ptr & ~1);
1542 case LDKHTLCFailChannelUpdate_ChannelUpdateMessage: {
1543 LDKChannelUpdate msg_var = obj->channel_update_message.msg;
1544 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1545 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1546 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1547 return (*env)->NewObject(env, LDKHTLCFailChannelUpdate_ChannelUpdateMessage_class, LDKHTLCFailChannelUpdate_ChannelUpdateMessage_meth, msg_ref);
1549 case LDKHTLCFailChannelUpdate_ChannelClosed: {
1550 return (*env)->NewObject(env, LDKHTLCFailChannelUpdate_ChannelClosed_class, LDKHTLCFailChannelUpdate_ChannelClosed_meth, obj->channel_closed.short_channel_id, obj->channel_closed.is_permanent);
1552 case LDKHTLCFailChannelUpdate_NodeFailure: {
1553 int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
1554 (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->node_failure.node_id.compressed_form);
1555 return (*env)->NewObject(env, LDKHTLCFailChannelUpdate_NodeFailure_class, LDKHTLCFailChannelUpdate_NodeFailure_meth, node_id_arr, obj->node_failure.is_permanent);
1560 static jclass LDKMessageSendEvent_SendAcceptChannel_class = NULL;
1561 static jmethodID LDKMessageSendEvent_SendAcceptChannel_meth = NULL;
1562 static jclass LDKMessageSendEvent_SendOpenChannel_class = NULL;
1563 static jmethodID LDKMessageSendEvent_SendOpenChannel_meth = NULL;
1564 static jclass LDKMessageSendEvent_SendFundingCreated_class = NULL;
1565 static jmethodID LDKMessageSendEvent_SendFundingCreated_meth = NULL;
1566 static jclass LDKMessageSendEvent_SendFundingSigned_class = NULL;
1567 static jmethodID LDKMessageSendEvent_SendFundingSigned_meth = NULL;
1568 static jclass LDKMessageSendEvent_SendFundingLocked_class = NULL;
1569 static jmethodID LDKMessageSendEvent_SendFundingLocked_meth = NULL;
1570 static jclass LDKMessageSendEvent_SendAnnouncementSignatures_class = NULL;
1571 static jmethodID LDKMessageSendEvent_SendAnnouncementSignatures_meth = NULL;
1572 static jclass LDKMessageSendEvent_UpdateHTLCs_class = NULL;
1573 static jmethodID LDKMessageSendEvent_UpdateHTLCs_meth = NULL;
1574 static jclass LDKMessageSendEvent_SendRevokeAndACK_class = NULL;
1575 static jmethodID LDKMessageSendEvent_SendRevokeAndACK_meth = NULL;
1576 static jclass LDKMessageSendEvent_SendClosingSigned_class = NULL;
1577 static jmethodID LDKMessageSendEvent_SendClosingSigned_meth = NULL;
1578 static jclass LDKMessageSendEvent_SendShutdown_class = NULL;
1579 static jmethodID LDKMessageSendEvent_SendShutdown_meth = NULL;
1580 static jclass LDKMessageSendEvent_SendChannelReestablish_class = NULL;
1581 static jmethodID LDKMessageSendEvent_SendChannelReestablish_meth = NULL;
1582 static jclass LDKMessageSendEvent_BroadcastChannelAnnouncement_class = NULL;
1583 static jmethodID LDKMessageSendEvent_BroadcastChannelAnnouncement_meth = NULL;
1584 static jclass LDKMessageSendEvent_BroadcastNodeAnnouncement_class = NULL;
1585 static jmethodID LDKMessageSendEvent_BroadcastNodeAnnouncement_meth = NULL;
1586 static jclass LDKMessageSendEvent_BroadcastChannelUpdate_class = NULL;
1587 static jmethodID LDKMessageSendEvent_BroadcastChannelUpdate_meth = NULL;
1588 static jclass LDKMessageSendEvent_SendChannelUpdate_class = NULL;
1589 static jmethodID LDKMessageSendEvent_SendChannelUpdate_meth = NULL;
1590 static jclass LDKMessageSendEvent_HandleError_class = NULL;
1591 static jmethodID LDKMessageSendEvent_HandleError_meth = NULL;
1592 static jclass LDKMessageSendEvent_PaymentFailureNetworkUpdate_class = NULL;
1593 static jmethodID LDKMessageSendEvent_PaymentFailureNetworkUpdate_meth = NULL;
1594 static jclass LDKMessageSendEvent_SendChannelRangeQuery_class = NULL;
1595 static jmethodID LDKMessageSendEvent_SendChannelRangeQuery_meth = NULL;
1596 static jclass LDKMessageSendEvent_SendShortIdsQuery_class = NULL;
1597 static jmethodID LDKMessageSendEvent_SendShortIdsQuery_meth = NULL;
1598 static jclass LDKMessageSendEvent_SendReplyChannelRange_class = NULL;
1599 static jmethodID LDKMessageSendEvent_SendReplyChannelRange_meth = NULL;
1600 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKMessageSendEvent_init (JNIEnv *env, jclass clz) {
1601 LDKMessageSendEvent_SendAcceptChannel_class =
1602 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendAcceptChannel;"));
1603 CHECK(LDKMessageSendEvent_SendAcceptChannel_class != NULL);
1604 LDKMessageSendEvent_SendAcceptChannel_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendAcceptChannel_class, "<init>", "([BJ)V");
1605 CHECK(LDKMessageSendEvent_SendAcceptChannel_meth != NULL);
1606 LDKMessageSendEvent_SendOpenChannel_class =
1607 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendOpenChannel;"));
1608 CHECK(LDKMessageSendEvent_SendOpenChannel_class != NULL);
1609 LDKMessageSendEvent_SendOpenChannel_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendOpenChannel_class, "<init>", "([BJ)V");
1610 CHECK(LDKMessageSendEvent_SendOpenChannel_meth != NULL);
1611 LDKMessageSendEvent_SendFundingCreated_class =
1612 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendFundingCreated;"));
1613 CHECK(LDKMessageSendEvent_SendFundingCreated_class != NULL);
1614 LDKMessageSendEvent_SendFundingCreated_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendFundingCreated_class, "<init>", "([BJ)V");
1615 CHECK(LDKMessageSendEvent_SendFundingCreated_meth != NULL);
1616 LDKMessageSendEvent_SendFundingSigned_class =
1617 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendFundingSigned;"));
1618 CHECK(LDKMessageSendEvent_SendFundingSigned_class != NULL);
1619 LDKMessageSendEvent_SendFundingSigned_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendFundingSigned_class, "<init>", "([BJ)V");
1620 CHECK(LDKMessageSendEvent_SendFundingSigned_meth != NULL);
1621 LDKMessageSendEvent_SendFundingLocked_class =
1622 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendFundingLocked;"));
1623 CHECK(LDKMessageSendEvent_SendFundingLocked_class != NULL);
1624 LDKMessageSendEvent_SendFundingLocked_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendFundingLocked_class, "<init>", "([BJ)V");
1625 CHECK(LDKMessageSendEvent_SendFundingLocked_meth != NULL);
1626 LDKMessageSendEvent_SendAnnouncementSignatures_class =
1627 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendAnnouncementSignatures;"));
1628 CHECK(LDKMessageSendEvent_SendAnnouncementSignatures_class != NULL);
1629 LDKMessageSendEvent_SendAnnouncementSignatures_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendAnnouncementSignatures_class, "<init>", "([BJ)V");
1630 CHECK(LDKMessageSendEvent_SendAnnouncementSignatures_meth != NULL);
1631 LDKMessageSendEvent_UpdateHTLCs_class =
1632 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$UpdateHTLCs;"));
1633 CHECK(LDKMessageSendEvent_UpdateHTLCs_class != NULL);
1634 LDKMessageSendEvent_UpdateHTLCs_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_UpdateHTLCs_class, "<init>", "([BJ)V");
1635 CHECK(LDKMessageSendEvent_UpdateHTLCs_meth != NULL);
1636 LDKMessageSendEvent_SendRevokeAndACK_class =
1637 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendRevokeAndACK;"));
1638 CHECK(LDKMessageSendEvent_SendRevokeAndACK_class != NULL);
1639 LDKMessageSendEvent_SendRevokeAndACK_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendRevokeAndACK_class, "<init>", "([BJ)V");
1640 CHECK(LDKMessageSendEvent_SendRevokeAndACK_meth != NULL);
1641 LDKMessageSendEvent_SendClosingSigned_class =
1642 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendClosingSigned;"));
1643 CHECK(LDKMessageSendEvent_SendClosingSigned_class != NULL);
1644 LDKMessageSendEvent_SendClosingSigned_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendClosingSigned_class, "<init>", "([BJ)V");
1645 CHECK(LDKMessageSendEvent_SendClosingSigned_meth != NULL);
1646 LDKMessageSendEvent_SendShutdown_class =
1647 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendShutdown;"));
1648 CHECK(LDKMessageSendEvent_SendShutdown_class != NULL);
1649 LDKMessageSendEvent_SendShutdown_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendShutdown_class, "<init>", "([BJ)V");
1650 CHECK(LDKMessageSendEvent_SendShutdown_meth != NULL);
1651 LDKMessageSendEvent_SendChannelReestablish_class =
1652 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendChannelReestablish;"));
1653 CHECK(LDKMessageSendEvent_SendChannelReestablish_class != NULL);
1654 LDKMessageSendEvent_SendChannelReestablish_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendChannelReestablish_class, "<init>", "([BJ)V");
1655 CHECK(LDKMessageSendEvent_SendChannelReestablish_meth != NULL);
1656 LDKMessageSendEvent_BroadcastChannelAnnouncement_class =
1657 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$BroadcastChannelAnnouncement;"));
1658 CHECK(LDKMessageSendEvent_BroadcastChannelAnnouncement_class != NULL);
1659 LDKMessageSendEvent_BroadcastChannelAnnouncement_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_BroadcastChannelAnnouncement_class, "<init>", "(JJ)V");
1660 CHECK(LDKMessageSendEvent_BroadcastChannelAnnouncement_meth != NULL);
1661 LDKMessageSendEvent_BroadcastNodeAnnouncement_class =
1662 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$BroadcastNodeAnnouncement;"));
1663 CHECK(LDKMessageSendEvent_BroadcastNodeAnnouncement_class != NULL);
1664 LDKMessageSendEvent_BroadcastNodeAnnouncement_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_BroadcastNodeAnnouncement_class, "<init>", "(J)V");
1665 CHECK(LDKMessageSendEvent_BroadcastNodeAnnouncement_meth != NULL);
1666 LDKMessageSendEvent_BroadcastChannelUpdate_class =
1667 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$BroadcastChannelUpdate;"));
1668 CHECK(LDKMessageSendEvent_BroadcastChannelUpdate_class != NULL);
1669 LDKMessageSendEvent_BroadcastChannelUpdate_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_BroadcastChannelUpdate_class, "<init>", "(J)V");
1670 CHECK(LDKMessageSendEvent_BroadcastChannelUpdate_meth != NULL);
1671 LDKMessageSendEvent_SendChannelUpdate_class =
1672 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendChannelUpdate;"));
1673 CHECK(LDKMessageSendEvent_SendChannelUpdate_class != NULL);
1674 LDKMessageSendEvent_SendChannelUpdate_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendChannelUpdate_class, "<init>", "([BJ)V");
1675 CHECK(LDKMessageSendEvent_SendChannelUpdate_meth != NULL);
1676 LDKMessageSendEvent_HandleError_class =
1677 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$HandleError;"));
1678 CHECK(LDKMessageSendEvent_HandleError_class != NULL);
1679 LDKMessageSendEvent_HandleError_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_HandleError_class, "<init>", "([BJ)V");
1680 CHECK(LDKMessageSendEvent_HandleError_meth != NULL);
1681 LDKMessageSendEvent_PaymentFailureNetworkUpdate_class =
1682 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$PaymentFailureNetworkUpdate;"));
1683 CHECK(LDKMessageSendEvent_PaymentFailureNetworkUpdate_class != NULL);
1684 LDKMessageSendEvent_PaymentFailureNetworkUpdate_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_PaymentFailureNetworkUpdate_class, "<init>", "(J)V");
1685 CHECK(LDKMessageSendEvent_PaymentFailureNetworkUpdate_meth != NULL);
1686 LDKMessageSendEvent_SendChannelRangeQuery_class =
1687 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendChannelRangeQuery;"));
1688 CHECK(LDKMessageSendEvent_SendChannelRangeQuery_class != NULL);
1689 LDKMessageSendEvent_SendChannelRangeQuery_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendChannelRangeQuery_class, "<init>", "([BJ)V");
1690 CHECK(LDKMessageSendEvent_SendChannelRangeQuery_meth != NULL);
1691 LDKMessageSendEvent_SendShortIdsQuery_class =
1692 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendShortIdsQuery;"));
1693 CHECK(LDKMessageSendEvent_SendShortIdsQuery_class != NULL);
1694 LDKMessageSendEvent_SendShortIdsQuery_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendShortIdsQuery_class, "<init>", "([BJ)V");
1695 CHECK(LDKMessageSendEvent_SendShortIdsQuery_meth != NULL);
1696 LDKMessageSendEvent_SendReplyChannelRange_class =
1697 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendReplyChannelRange;"));
1698 CHECK(LDKMessageSendEvent_SendReplyChannelRange_class != NULL);
1699 LDKMessageSendEvent_SendReplyChannelRange_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendReplyChannelRange_class, "<init>", "([BJ)V");
1700 CHECK(LDKMessageSendEvent_SendReplyChannelRange_meth != NULL);
1702 JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKMessageSendEvent_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
1703 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
1705 case LDKMessageSendEvent_SendAcceptChannel: {
1706 int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
1707 (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->send_accept_channel.node_id.compressed_form);
1708 LDKAcceptChannel msg_var = obj->send_accept_channel.msg;
1709 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1710 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1711 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1712 return (*env)->NewObject(env, LDKMessageSendEvent_SendAcceptChannel_class, LDKMessageSendEvent_SendAcceptChannel_meth, node_id_arr, msg_ref);
1714 case LDKMessageSendEvent_SendOpenChannel: {
1715 int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
1716 (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->send_open_channel.node_id.compressed_form);
1717 LDKOpenChannel msg_var = obj->send_open_channel.msg;
1718 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1719 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1720 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1721 return (*env)->NewObject(env, LDKMessageSendEvent_SendOpenChannel_class, LDKMessageSendEvent_SendOpenChannel_meth, node_id_arr, msg_ref);
1723 case LDKMessageSendEvent_SendFundingCreated: {
1724 int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
1725 (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->send_funding_created.node_id.compressed_form);
1726 LDKFundingCreated msg_var = obj->send_funding_created.msg;
1727 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1728 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1729 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1730 return (*env)->NewObject(env, LDKMessageSendEvent_SendFundingCreated_class, LDKMessageSendEvent_SendFundingCreated_meth, node_id_arr, msg_ref);
1732 case LDKMessageSendEvent_SendFundingSigned: {
1733 int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
1734 (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->send_funding_signed.node_id.compressed_form);
1735 LDKFundingSigned msg_var = obj->send_funding_signed.msg;
1736 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1737 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1738 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1739 return (*env)->NewObject(env, LDKMessageSendEvent_SendFundingSigned_class, LDKMessageSendEvent_SendFundingSigned_meth, node_id_arr, msg_ref);
1741 case LDKMessageSendEvent_SendFundingLocked: {
1742 int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
1743 (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->send_funding_locked.node_id.compressed_form);
1744 LDKFundingLocked msg_var = obj->send_funding_locked.msg;
1745 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1746 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1747 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1748 return (*env)->NewObject(env, LDKMessageSendEvent_SendFundingLocked_class, LDKMessageSendEvent_SendFundingLocked_meth, node_id_arr, msg_ref);
1750 case LDKMessageSendEvent_SendAnnouncementSignatures: {
1751 int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
1752 (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->send_announcement_signatures.node_id.compressed_form);
1753 LDKAnnouncementSignatures msg_var = obj->send_announcement_signatures.msg;
1754 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1755 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1756 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1757 return (*env)->NewObject(env, LDKMessageSendEvent_SendAnnouncementSignatures_class, LDKMessageSendEvent_SendAnnouncementSignatures_meth, node_id_arr, msg_ref);
1759 case LDKMessageSendEvent_UpdateHTLCs: {
1760 int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
1761 (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->update_htl_cs.node_id.compressed_form);
1762 LDKCommitmentUpdate updates_var = obj->update_htl_cs.updates;
1763 CHECK((((uint64_t)updates_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1764 CHECK((((uint64_t)&updates_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1765 uint64_t updates_ref = (uint64_t)updates_var.inner & ~1;
1766 return (*env)->NewObject(env, LDKMessageSendEvent_UpdateHTLCs_class, LDKMessageSendEvent_UpdateHTLCs_meth, node_id_arr, updates_ref);
1768 case LDKMessageSendEvent_SendRevokeAndACK: {
1769 int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
1770 (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->send_revoke_and_ack.node_id.compressed_form);
1771 LDKRevokeAndACK msg_var = obj->send_revoke_and_ack.msg;
1772 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1773 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1774 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1775 return (*env)->NewObject(env, LDKMessageSendEvent_SendRevokeAndACK_class, LDKMessageSendEvent_SendRevokeAndACK_meth, node_id_arr, msg_ref);
1777 case LDKMessageSendEvent_SendClosingSigned: {
1778 int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
1779 (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->send_closing_signed.node_id.compressed_form);
1780 LDKClosingSigned msg_var = obj->send_closing_signed.msg;
1781 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1782 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1783 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1784 return (*env)->NewObject(env, LDKMessageSendEvent_SendClosingSigned_class, LDKMessageSendEvent_SendClosingSigned_meth, node_id_arr, msg_ref);
1786 case LDKMessageSendEvent_SendShutdown: {
1787 int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
1788 (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->send_shutdown.node_id.compressed_form);
1789 LDKShutdown msg_var = obj->send_shutdown.msg;
1790 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1791 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1792 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1793 return (*env)->NewObject(env, LDKMessageSendEvent_SendShutdown_class, LDKMessageSendEvent_SendShutdown_meth, node_id_arr, msg_ref);
1795 case LDKMessageSendEvent_SendChannelReestablish: {
1796 int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
1797 (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->send_channel_reestablish.node_id.compressed_form);
1798 LDKChannelReestablish msg_var = obj->send_channel_reestablish.msg;
1799 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1800 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1801 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1802 return (*env)->NewObject(env, LDKMessageSendEvent_SendChannelReestablish_class, LDKMessageSendEvent_SendChannelReestablish_meth, node_id_arr, msg_ref);
1804 case LDKMessageSendEvent_BroadcastChannelAnnouncement: {
1805 LDKChannelAnnouncement msg_var = obj->broadcast_channel_announcement.msg;
1806 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1807 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1808 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1809 LDKChannelUpdate update_msg_var = obj->broadcast_channel_announcement.update_msg;
1810 CHECK((((uint64_t)update_msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1811 CHECK((((uint64_t)&update_msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1812 uint64_t update_msg_ref = (uint64_t)update_msg_var.inner & ~1;
1813 return (*env)->NewObject(env, LDKMessageSendEvent_BroadcastChannelAnnouncement_class, LDKMessageSendEvent_BroadcastChannelAnnouncement_meth, msg_ref, update_msg_ref);
1815 case LDKMessageSendEvent_BroadcastNodeAnnouncement: {
1816 LDKNodeAnnouncement msg_var = obj->broadcast_node_announcement.msg;
1817 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1818 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1819 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1820 return (*env)->NewObject(env, LDKMessageSendEvent_BroadcastNodeAnnouncement_class, LDKMessageSendEvent_BroadcastNodeAnnouncement_meth, msg_ref);
1822 case LDKMessageSendEvent_BroadcastChannelUpdate: {
1823 LDKChannelUpdate msg_var = obj->broadcast_channel_update.msg;
1824 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1825 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1826 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1827 return (*env)->NewObject(env, LDKMessageSendEvent_BroadcastChannelUpdate_class, LDKMessageSendEvent_BroadcastChannelUpdate_meth, msg_ref);
1829 case LDKMessageSendEvent_SendChannelUpdate: {
1830 int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
1831 (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->send_channel_update.node_id.compressed_form);
1832 LDKChannelUpdate msg_var = obj->send_channel_update.msg;
1833 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1834 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1835 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1836 return (*env)->NewObject(env, LDKMessageSendEvent_SendChannelUpdate_class, LDKMessageSendEvent_SendChannelUpdate_meth, node_id_arr, msg_ref);
1838 case LDKMessageSendEvent_HandleError: {
1839 int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
1840 (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->handle_error.node_id.compressed_form);
1841 uint64_t action_ref = ((uint64_t)&obj->handle_error.action) | 1;
1842 return (*env)->NewObject(env, LDKMessageSendEvent_HandleError_class, LDKMessageSendEvent_HandleError_meth, node_id_arr, action_ref);
1844 case LDKMessageSendEvent_PaymentFailureNetworkUpdate: {
1845 uint64_t update_ref = ((uint64_t)&obj->payment_failure_network_update.update) | 1;
1846 return (*env)->NewObject(env, LDKMessageSendEvent_PaymentFailureNetworkUpdate_class, LDKMessageSendEvent_PaymentFailureNetworkUpdate_meth, update_ref);
1848 case LDKMessageSendEvent_SendChannelRangeQuery: {
1849 int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
1850 (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->send_channel_range_query.node_id.compressed_form);
1851 LDKQueryChannelRange msg_var = obj->send_channel_range_query.msg;
1852 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1853 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1854 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1855 return (*env)->NewObject(env, LDKMessageSendEvent_SendChannelRangeQuery_class, LDKMessageSendEvent_SendChannelRangeQuery_meth, node_id_arr, msg_ref);
1857 case LDKMessageSendEvent_SendShortIdsQuery: {
1858 int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
1859 (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->send_short_ids_query.node_id.compressed_form);
1860 LDKQueryShortChannelIds msg_var = obj->send_short_ids_query.msg;
1861 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1862 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1863 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1864 return (*env)->NewObject(env, LDKMessageSendEvent_SendShortIdsQuery_class, LDKMessageSendEvent_SendShortIdsQuery_meth, node_id_arr, msg_ref);
1866 case LDKMessageSendEvent_SendReplyChannelRange: {
1867 int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
1868 (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->send_reply_channel_range.node_id.compressed_form);
1869 LDKReplyChannelRange msg_var = obj->send_reply_channel_range.msg;
1870 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1871 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1872 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1873 return (*env)->NewObject(env, LDKMessageSendEvent_SendReplyChannelRange_class, LDKMessageSendEvent_SendReplyChannelRange_meth, node_id_arr, msg_ref);
1878 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1MessageSendEventZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
1879 LDKCVec_MessageSendEventZ *ret = MALLOC(sizeof(LDKCVec_MessageSendEventZ), "LDKCVec_MessageSendEventZ");
1880 ret->datalen = (*env)->GetArrayLength(env, elems);
1881 if (ret->datalen == 0) {
1884 ret->data = MALLOC(sizeof(LDKMessageSendEvent) * ret->datalen, "LDKCVec_MessageSendEventZ Data");
1885 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
1886 for (size_t i = 0; i < ret->datalen; i++) {
1887 int64_t arr_elem = java_elems[i];
1888 LDKMessageSendEvent arr_elem_conv = *(LDKMessageSendEvent*)(((uint64_t)arr_elem) & ~1);
1889 arr_elem_conv = MessageSendEvent_clone((LDKMessageSendEvent*)(((uint64_t)arr_elem) & ~1));
1890 ret->data[i] = arr_elem_conv;
1892 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
1894 return (uint64_t)ret;
1896 static inline LDKCVec_MessageSendEventZ CVec_MessageSendEventZ_clone(const LDKCVec_MessageSendEventZ *orig) {
1897 LDKCVec_MessageSendEventZ ret = { .data = MALLOC(sizeof(LDKMessageSendEvent) * orig->datalen, "LDKCVec_MessageSendEventZ clone bytes"), .datalen = orig->datalen };
1898 for (size_t i = 0; i < ret.datalen; i++) {
1899 ret.data[i] = MessageSendEvent_clone(&orig->data[i]);
1903 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitFeaturesDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1904 return ((LDKCResult_InitFeaturesDecodeErrorZ*)arg)->result_ok;
1906 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitFeaturesDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1907 LDKCResult_InitFeaturesDecodeErrorZ *val = (LDKCResult_InitFeaturesDecodeErrorZ*)(arg & ~1);
1908 CHECK(val->result_ok);
1909 LDKInitFeatures res_var = (*val->contents.result);
1910 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1911 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1912 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
1915 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitFeaturesDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
1916 LDKCResult_InitFeaturesDecodeErrorZ *val = (LDKCResult_InitFeaturesDecodeErrorZ*)(arg & ~1);
1917 CHECK(!val->result_ok);
1918 LDKDecodeError err_var = (*val->contents.err);
1919 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1920 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1921 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
1924 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeFeaturesDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1925 return ((LDKCResult_NodeFeaturesDecodeErrorZ*)arg)->result_ok;
1927 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeFeaturesDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1928 LDKCResult_NodeFeaturesDecodeErrorZ *val = (LDKCResult_NodeFeaturesDecodeErrorZ*)(arg & ~1);
1929 CHECK(val->result_ok);
1930 LDKNodeFeatures res_var = (*val->contents.result);
1931 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1932 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1933 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
1936 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeFeaturesDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
1937 LDKCResult_NodeFeaturesDecodeErrorZ *val = (LDKCResult_NodeFeaturesDecodeErrorZ*)(arg & ~1);
1938 CHECK(!val->result_ok);
1939 LDKDecodeError err_var = (*val->contents.err);
1940 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1941 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1942 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
1945 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelFeaturesDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1946 return ((LDKCResult_ChannelFeaturesDecodeErrorZ*)arg)->result_ok;
1948 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelFeaturesDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1949 LDKCResult_ChannelFeaturesDecodeErrorZ *val = (LDKCResult_ChannelFeaturesDecodeErrorZ*)(arg & ~1);
1950 CHECK(val->result_ok);
1951 LDKChannelFeatures res_var = (*val->contents.result);
1952 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1953 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1954 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
1957 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelFeaturesDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
1958 LDKCResult_ChannelFeaturesDecodeErrorZ *val = (LDKCResult_ChannelFeaturesDecodeErrorZ*)(arg & ~1);
1959 CHECK(!val->result_ok);
1960 LDKDecodeError err_var = (*val->contents.err);
1961 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1962 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1963 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
1966 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceFeaturesDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1967 return ((LDKCResult_InvoiceFeaturesDecodeErrorZ*)arg)->result_ok;
1969 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceFeaturesDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1970 LDKCResult_InvoiceFeaturesDecodeErrorZ *val = (LDKCResult_InvoiceFeaturesDecodeErrorZ*)(arg & ~1);
1971 CHECK(val->result_ok);
1972 LDKInvoiceFeatures res_var = (*val->contents.result);
1973 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1974 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1975 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
1978 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceFeaturesDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
1979 LDKCResult_InvoiceFeaturesDecodeErrorZ *val = (LDKCResult_InvoiceFeaturesDecodeErrorZ*)(arg & ~1);
1980 CHECK(!val->result_ok);
1981 LDKDecodeError err_var = (*val->contents.err);
1982 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1983 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1984 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
1987 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1DelayedPaymentOutputDescriptorDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1988 return ((LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)arg)->result_ok;
1990 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1DelayedPaymentOutputDescriptorDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1991 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *val = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(arg & ~1);
1992 CHECK(val->result_ok);
1993 LDKDelayedPaymentOutputDescriptor res_var = (*val->contents.result);
1994 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1995 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1996 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
1999 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1DelayedPaymentOutputDescriptorDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
2000 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *val = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(arg & ~1);
2001 CHECK(!val->result_ok);
2002 LDKDecodeError err_var = (*val->contents.err);
2003 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2004 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2005 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
2008 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1StaticPaymentOutputDescriptorDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
2009 return ((LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)arg)->result_ok;
2011 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1StaticPaymentOutputDescriptorDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
2012 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *val = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(arg & ~1);
2013 CHECK(val->result_ok);
2014 LDKStaticPaymentOutputDescriptor res_var = (*val->contents.result);
2015 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2016 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2017 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
2020 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1StaticPaymentOutputDescriptorDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
2021 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *val = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(arg & ~1);
2022 CHECK(!val->result_ok);
2023 LDKDecodeError err_var = (*val->contents.err);
2024 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2025 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2026 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
2029 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SpendableOutputDescriptorDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
2030 return ((LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)arg)->result_ok;
2032 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SpendableOutputDescriptorDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
2033 LDKCResult_SpendableOutputDescriptorDecodeErrorZ *val = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(arg & ~1);
2034 CHECK(val->result_ok);
2035 uint64_t res_ref = ((uint64_t)&(*val->contents.result)) | 1;
2038 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SpendableOutputDescriptorDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
2039 LDKCResult_SpendableOutputDescriptorDecodeErrorZ *val = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(arg & ~1);
2040 CHECK(!val->result_ok);
2041 LDKDecodeError err_var = (*val->contents.err);
2042 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2043 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2044 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
2047 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1SignatureCVec_1SignatureZZ_1new(JNIEnv *env, jclass clz, int8_tArray a, jobjectArray b) {
2048 LDKC2Tuple_SignatureCVec_SignatureZZ* ret = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
2050 CHECK((*env)->GetArrayLength(env, a) == 64);
2051 (*env)->GetByteArrayRegion(env, a, 0, 64, a_ref.compact_form);
2053 LDKCVec_SignatureZ b_constr;
2054 b_constr.datalen = (*env)->GetArrayLength(env, b);
2055 if (b_constr.datalen > 0)
2056 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
2058 b_constr.data = NULL;
2059 for (size_t i = 0; i < b_constr.datalen; i++) {
2060 int8_tArray b_conv_8 = (*env)->GetObjectArrayElement(env, b, i);
2061 LDKSignature b_conv_8_ref;
2062 CHECK((*env)->GetArrayLength(env, b_conv_8) == 64);
2063 (*env)->GetByteArrayRegion(env, b_conv_8, 0, 64, b_conv_8_ref.compact_form);
2064 b_constr.data[i] = b_conv_8_ref;
2067 return (uint64_t)ret;
2069 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1SignatureCVec_1SignatureZZ_1get_1a(JNIEnv *env, jclass clz, int64_t ptr) {
2070 LDKC2Tuple_SignatureCVec_SignatureZZ *tuple = (LDKC2Tuple_SignatureCVec_SignatureZZ*)(ptr & ~1);
2071 int8_tArray a_arr = (*env)->NewByteArray(env, 64);
2072 (*env)->SetByteArrayRegion(env, a_arr, 0, 64, tuple->a.compact_form);
2075 JNIEXPORT jobjectArray JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1SignatureCVec_1SignatureZZ_1get_1b(JNIEnv *env, jclass clz, int64_t ptr) {
2076 LDKC2Tuple_SignatureCVec_SignatureZZ *tuple = (LDKC2Tuple_SignatureCVec_SignatureZZ*)(ptr & ~1);
2077 LDKCVec_SignatureZ b_var = tuple->b;
2078 jobjectArray b_arr = (*env)->NewObjectArray(env, b_var.datalen, arr_of_B_clz, NULL);
2080 for (size_t i = 0; i < b_var.datalen; i++) {
2081 int8_tArray b_conv_8_arr = (*env)->NewByteArray(env, 64);
2082 (*env)->SetByteArrayRegion(env, b_conv_8_arr, 0, 64, b_var.data[i].compact_form);
2083 (*env)->SetObjectArrayElement(env, b_arr, i, b_conv_8_arr);
2087 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1SignatureCVec_1SignatureZZNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
2088 return ((LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)arg)->result_ok;
2090 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1SignatureCVec_1SignatureZZNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
2091 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *val = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(arg & ~1);
2092 CHECK(val->result_ok);
2093 uint64_t res_ref = (uint64_t)(&(*val->contents.result)) | 1;
2096 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1SignatureCVec_1SignatureZZNoneZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
2097 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *val = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(arg & ~1);
2098 CHECK(!val->result_ok);
2099 return *val->contents.err;
2101 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SignatureNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
2102 return ((LDKCResult_SignatureNoneZ*)arg)->result_ok;
2104 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SignatureNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
2105 LDKCResult_SignatureNoneZ *val = (LDKCResult_SignatureNoneZ*)(arg & ~1);
2106 CHECK(val->result_ok);
2107 int8_tArray res_arr = (*env)->NewByteArray(env, 64);
2108 (*env)->SetByteArrayRegion(env, res_arr, 0, 64, (*val->contents.result).compact_form);
2111 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SignatureNoneZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
2112 LDKCResult_SignatureNoneZ *val = (LDKCResult_SignatureNoneZ*)(arg & ~1);
2113 CHECK(!val->result_ok);
2114 return *val->contents.err;
2116 typedef struct LDKBaseSign_JCalls {
2117 atomic_size_t refcnt;
2120 jmethodID get_per_commitment_point_meth;
2121 jmethodID release_commitment_secret_meth;
2122 jmethodID channel_keys_id_meth;
2123 jmethodID sign_counterparty_commitment_meth;
2124 jmethodID sign_holder_commitment_and_htlcs_meth;
2125 jmethodID sign_justice_revoked_output_meth;
2126 jmethodID sign_justice_revoked_htlc_meth;
2127 jmethodID sign_counterparty_htlc_transaction_meth;
2128 jmethodID sign_closing_transaction_meth;
2129 jmethodID sign_channel_announcement_meth;
2130 jmethodID ready_channel_meth;
2131 } LDKBaseSign_JCalls;
2132 static void LDKBaseSign_JCalls_free(void* this_arg) {
2133 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
2134 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
2136 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
2137 if (get_jenv_res == JNI_EDETACHED) {
2138 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
2140 DO_ASSERT(get_jenv_res == JNI_OK);
2142 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
2143 if (get_jenv_res == JNI_EDETACHED) {
2144 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
2149 LDKPublicKey get_per_commitment_point_LDKBaseSign_jcall(const void* this_arg, uint64_t idx) {
2150 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
2152 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
2153 if (get_jenv_res == JNI_EDETACHED) {
2154 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
2156 DO_ASSERT(get_jenv_res == JNI_OK);
2158 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
2160 int8_tArray ret = (*env)->CallObjectMethod(env, obj, j_calls->get_per_commitment_point_meth, idx);
2161 if ((*env)->ExceptionCheck(env)) {
2162 (*env)->ExceptionDescribe(env);
2163 (*env)->FatalError(env, "A call to get_per_commitment_point in LDKBaseSign from rust threw an exception.");
2165 LDKPublicKey ret_ref;
2166 CHECK((*env)->GetArrayLength(env, ret) == 33);
2167 (*env)->GetByteArrayRegion(env, ret, 0, 33, ret_ref.compressed_form);
2168 if (get_jenv_res == JNI_EDETACHED) {
2169 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
2173 LDKThirtyTwoBytes release_commitment_secret_LDKBaseSign_jcall(const void* this_arg, uint64_t idx) {
2174 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
2176 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
2177 if (get_jenv_res == JNI_EDETACHED) {
2178 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
2180 DO_ASSERT(get_jenv_res == JNI_OK);
2182 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
2184 int8_tArray ret = (*env)->CallObjectMethod(env, obj, j_calls->release_commitment_secret_meth, idx);
2185 if ((*env)->ExceptionCheck(env)) {
2186 (*env)->ExceptionDescribe(env);
2187 (*env)->FatalError(env, "A call to release_commitment_secret in LDKBaseSign from rust threw an exception.");
2189 LDKThirtyTwoBytes ret_ref;
2190 CHECK((*env)->GetArrayLength(env, ret) == 32);
2191 (*env)->GetByteArrayRegion(env, ret, 0, 32, ret_ref.data);
2192 if (get_jenv_res == JNI_EDETACHED) {
2193 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
2197 LDKThirtyTwoBytes channel_keys_id_LDKBaseSign_jcall(const void* this_arg) {
2198 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
2200 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
2201 if (get_jenv_res == JNI_EDETACHED) {
2202 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
2204 DO_ASSERT(get_jenv_res == JNI_OK);
2206 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
2208 int8_tArray ret = (*env)->CallObjectMethod(env, obj, j_calls->channel_keys_id_meth);
2209 if ((*env)->ExceptionCheck(env)) {
2210 (*env)->ExceptionDescribe(env);
2211 (*env)->FatalError(env, "A call to channel_keys_id in LDKBaseSign from rust threw an exception.");
2213 LDKThirtyTwoBytes ret_ref;
2214 CHECK((*env)->GetArrayLength(env, ret) == 32);
2215 (*env)->GetByteArrayRegion(env, ret, 0, 32, ret_ref.data);
2216 if (get_jenv_res == JNI_EDETACHED) {
2217 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
2221 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_counterparty_commitment_LDKBaseSign_jcall(const void* this_arg, const LDKCommitmentTransaction * commitment_tx) {
2222 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
2224 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
2225 if (get_jenv_res == JNI_EDETACHED) {
2226 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
2228 DO_ASSERT(get_jenv_res == JNI_OK);
2230 LDKCommitmentTransaction commitment_tx_var = *commitment_tx;
2231 commitment_tx_var = CommitmentTransaction_clone(commitment_tx);
2232 CHECK((((uint64_t)commitment_tx_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2233 CHECK((((uint64_t)&commitment_tx_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2234 uint64_t commitment_tx_ref = (uint64_t)commitment_tx_var.inner;
2235 if (commitment_tx_var.is_owned) {
2236 commitment_tx_ref |= 1;
2238 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
2240 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(*env)->CallLongMethod(env, obj, j_calls->sign_counterparty_commitment_meth, commitment_tx_ref);
2241 if ((*env)->ExceptionCheck(env)) {
2242 (*env)->ExceptionDescribe(env);
2243 (*env)->FatalError(env, "A call to sign_counterparty_commitment in LDKBaseSign from rust threw an exception.");
2245 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ret_conv = *(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(((uint64_t)ret) & ~1);
2246 ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone((LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(((uint64_t)ret) & ~1));
2247 if (get_jenv_res == JNI_EDETACHED) {
2248 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
2252 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_holder_commitment_and_htlcs_LDKBaseSign_jcall(const void* this_arg, const LDKHolderCommitmentTransaction * commitment_tx) {
2253 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
2255 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
2256 if (get_jenv_res == JNI_EDETACHED) {
2257 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
2259 DO_ASSERT(get_jenv_res == JNI_OK);
2261 LDKHolderCommitmentTransaction commitment_tx_var = *commitment_tx;
2262 commitment_tx_var = HolderCommitmentTransaction_clone(commitment_tx);
2263 CHECK((((uint64_t)commitment_tx_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2264 CHECK((((uint64_t)&commitment_tx_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2265 uint64_t commitment_tx_ref = (uint64_t)commitment_tx_var.inner;
2266 if (commitment_tx_var.is_owned) {
2267 commitment_tx_ref |= 1;
2269 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
2271 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(*env)->CallLongMethod(env, obj, j_calls->sign_holder_commitment_and_htlcs_meth, commitment_tx_ref);
2272 if ((*env)->ExceptionCheck(env)) {
2273 (*env)->ExceptionDescribe(env);
2274 (*env)->FatalError(env, "A call to sign_holder_commitment_and_htlcs in LDKBaseSign from rust threw an exception.");
2276 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ret_conv = *(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(((uint64_t)ret) & ~1);
2277 ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone((LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(((uint64_t)ret) & ~1));
2278 if (get_jenv_res == JNI_EDETACHED) {
2279 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
2283 LDKCResult_SignatureNoneZ sign_justice_revoked_output_LDKBaseSign_jcall(const void* this_arg, LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (* per_commitment_key)[32]) {
2284 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
2286 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
2287 if (get_jenv_res == JNI_EDETACHED) {
2288 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
2290 DO_ASSERT(get_jenv_res == JNI_OK);
2292 LDKTransaction justice_tx_var = justice_tx;
2293 int8_tArray justice_tx_arr = (*env)->NewByteArray(env, justice_tx_var.datalen);
2294 (*env)->SetByteArrayRegion(env, justice_tx_arr, 0, justice_tx_var.datalen, justice_tx_var.data);
2295 Transaction_free(justice_tx_var);
2296 int8_tArray per_commitment_key_arr = (*env)->NewByteArray(env, 32);
2297 (*env)->SetByteArrayRegion(env, per_commitment_key_arr, 0, 32, *per_commitment_key);
2298 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
2300 LDKCResult_SignatureNoneZ* ret = (LDKCResult_SignatureNoneZ*)(*env)->CallLongMethod(env, obj, j_calls->sign_justice_revoked_output_meth, justice_tx_arr, input, amount, per_commitment_key_arr);
2301 if ((*env)->ExceptionCheck(env)) {
2302 (*env)->ExceptionDescribe(env);
2303 (*env)->FatalError(env, "A call to sign_justice_revoked_output in LDKBaseSign from rust threw an exception.");
2305 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1);
2306 ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1));
2307 if (get_jenv_res == JNI_EDETACHED) {
2308 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
2312 LDKCResult_SignatureNoneZ sign_justice_revoked_htlc_LDKBaseSign_jcall(const void* this_arg, LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (* per_commitment_key)[32], const LDKHTLCOutputInCommitment * htlc) {
2313 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
2315 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
2316 if (get_jenv_res == JNI_EDETACHED) {
2317 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
2319 DO_ASSERT(get_jenv_res == JNI_OK);
2321 LDKTransaction justice_tx_var = justice_tx;
2322 int8_tArray justice_tx_arr = (*env)->NewByteArray(env, justice_tx_var.datalen);
2323 (*env)->SetByteArrayRegion(env, justice_tx_arr, 0, justice_tx_var.datalen, justice_tx_var.data);
2324 Transaction_free(justice_tx_var);
2325 int8_tArray per_commitment_key_arr = (*env)->NewByteArray(env, 32);
2326 (*env)->SetByteArrayRegion(env, per_commitment_key_arr, 0, 32, *per_commitment_key);
2327 LDKHTLCOutputInCommitment htlc_var = *htlc;
2328 htlc_var = HTLCOutputInCommitment_clone(htlc);
2329 CHECK((((uint64_t)htlc_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2330 CHECK((((uint64_t)&htlc_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2331 uint64_t htlc_ref = (uint64_t)htlc_var.inner;
2332 if (htlc_var.is_owned) {
2335 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
2337 LDKCResult_SignatureNoneZ* ret = (LDKCResult_SignatureNoneZ*)(*env)->CallLongMethod(env, obj, j_calls->sign_justice_revoked_htlc_meth, justice_tx_arr, input, amount, per_commitment_key_arr, htlc_ref);
2338 if ((*env)->ExceptionCheck(env)) {
2339 (*env)->ExceptionDescribe(env);
2340 (*env)->FatalError(env, "A call to sign_justice_revoked_htlc in LDKBaseSign from rust threw an exception.");
2342 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1);
2343 ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1));
2344 if (get_jenv_res == JNI_EDETACHED) {
2345 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
2349 LDKCResult_SignatureNoneZ sign_counterparty_htlc_transaction_LDKBaseSign_jcall(const void* this_arg, LDKTransaction htlc_tx, uintptr_t input, uint64_t amount, LDKPublicKey per_commitment_point, const LDKHTLCOutputInCommitment * htlc) {
2350 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
2352 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
2353 if (get_jenv_res == JNI_EDETACHED) {
2354 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
2356 DO_ASSERT(get_jenv_res == JNI_OK);
2358 LDKTransaction htlc_tx_var = htlc_tx;
2359 int8_tArray htlc_tx_arr = (*env)->NewByteArray(env, htlc_tx_var.datalen);
2360 (*env)->SetByteArrayRegion(env, htlc_tx_arr, 0, htlc_tx_var.datalen, htlc_tx_var.data);
2361 Transaction_free(htlc_tx_var);
2362 int8_tArray per_commitment_point_arr = (*env)->NewByteArray(env, 33);
2363 (*env)->SetByteArrayRegion(env, per_commitment_point_arr, 0, 33, per_commitment_point.compressed_form);
2364 LDKHTLCOutputInCommitment htlc_var = *htlc;
2365 htlc_var = HTLCOutputInCommitment_clone(htlc);
2366 CHECK((((uint64_t)htlc_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2367 CHECK((((uint64_t)&htlc_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2368 uint64_t htlc_ref = (uint64_t)htlc_var.inner;
2369 if (htlc_var.is_owned) {
2372 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
2374 LDKCResult_SignatureNoneZ* ret = (LDKCResult_SignatureNoneZ*)(*env)->CallLongMethod(env, obj, j_calls->sign_counterparty_htlc_transaction_meth, htlc_tx_arr, input, amount, per_commitment_point_arr, htlc_ref);
2375 if ((*env)->ExceptionCheck(env)) {
2376 (*env)->ExceptionDescribe(env);
2377 (*env)->FatalError(env, "A call to sign_counterparty_htlc_transaction in LDKBaseSign from rust threw an exception.");
2379 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1);
2380 ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1));
2381 if (get_jenv_res == JNI_EDETACHED) {
2382 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
2386 LDKCResult_SignatureNoneZ sign_closing_transaction_LDKBaseSign_jcall(const void* this_arg, LDKTransaction closing_tx) {
2387 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
2389 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
2390 if (get_jenv_res == JNI_EDETACHED) {
2391 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
2393 DO_ASSERT(get_jenv_res == JNI_OK);
2395 LDKTransaction closing_tx_var = closing_tx;
2396 int8_tArray closing_tx_arr = (*env)->NewByteArray(env, closing_tx_var.datalen);
2397 (*env)->SetByteArrayRegion(env, closing_tx_arr, 0, closing_tx_var.datalen, closing_tx_var.data);
2398 Transaction_free(closing_tx_var);
2399 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
2401 LDKCResult_SignatureNoneZ* ret = (LDKCResult_SignatureNoneZ*)(*env)->CallLongMethod(env, obj, j_calls->sign_closing_transaction_meth, closing_tx_arr);
2402 if ((*env)->ExceptionCheck(env)) {
2403 (*env)->ExceptionDescribe(env);
2404 (*env)->FatalError(env, "A call to sign_closing_transaction in LDKBaseSign from rust threw an exception.");
2406 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1);
2407 ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1));
2408 if (get_jenv_res == JNI_EDETACHED) {
2409 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
2413 LDKCResult_SignatureNoneZ sign_channel_announcement_LDKBaseSign_jcall(const void* this_arg, const LDKUnsignedChannelAnnouncement * msg) {
2414 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
2416 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
2417 if (get_jenv_res == JNI_EDETACHED) {
2418 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
2420 DO_ASSERT(get_jenv_res == JNI_OK);
2422 LDKUnsignedChannelAnnouncement msg_var = *msg;
2423 msg_var = UnsignedChannelAnnouncement_clone(msg);
2424 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2425 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2426 uint64_t msg_ref = (uint64_t)msg_var.inner;
2427 if (msg_var.is_owned) {
2430 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
2432 LDKCResult_SignatureNoneZ* ret = (LDKCResult_SignatureNoneZ*)(*env)->CallLongMethod(env, obj, j_calls->sign_channel_announcement_meth, msg_ref);
2433 if ((*env)->ExceptionCheck(env)) {
2434 (*env)->ExceptionDescribe(env);
2435 (*env)->FatalError(env, "A call to sign_channel_announcement in LDKBaseSign from rust threw an exception.");
2437 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1);
2438 ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1));
2439 if (get_jenv_res == JNI_EDETACHED) {
2440 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
2444 void ready_channel_LDKBaseSign_jcall(void* this_arg, const LDKChannelTransactionParameters * channel_parameters) {
2445 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
2447 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
2448 if (get_jenv_res == JNI_EDETACHED) {
2449 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
2451 DO_ASSERT(get_jenv_res == JNI_OK);
2453 LDKChannelTransactionParameters channel_parameters_var = *channel_parameters;
2454 channel_parameters_var = ChannelTransactionParameters_clone(channel_parameters);
2455 CHECK((((uint64_t)channel_parameters_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2456 CHECK((((uint64_t)&channel_parameters_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2457 uint64_t channel_parameters_ref = (uint64_t)channel_parameters_var.inner;
2458 if (channel_parameters_var.is_owned) {
2459 channel_parameters_ref |= 1;
2461 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
2463 (*env)->CallVoidMethod(env, obj, j_calls->ready_channel_meth, channel_parameters_ref);
2464 if ((*env)->ExceptionCheck(env)) {
2465 (*env)->ExceptionDescribe(env);
2466 (*env)->FatalError(env, "A call to ready_channel in LDKBaseSign from rust threw an exception.");
2468 if (get_jenv_res == JNI_EDETACHED) {
2469 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
2472 static void* LDKBaseSign_JCalls_clone(const void* this_arg) {
2473 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
2474 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
2475 return (void*) this_arg;
2477 static inline LDKBaseSign LDKBaseSign_init (JNIEnv *env, jclass clz, jobject o, int64_t pubkeys) {
2478 jclass c = (*env)->GetObjectClass(env, o);
2480 LDKBaseSign_JCalls *calls = MALLOC(sizeof(LDKBaseSign_JCalls), "LDKBaseSign_JCalls");
2481 atomic_init(&calls->refcnt, 1);
2482 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
2483 calls->o = (*env)->NewWeakGlobalRef(env, o);
2484 calls->get_per_commitment_point_meth = (*env)->GetMethodID(env, c, "get_per_commitment_point", "(J)[B");
2485 CHECK(calls->get_per_commitment_point_meth != NULL);
2486 calls->release_commitment_secret_meth = (*env)->GetMethodID(env, c, "release_commitment_secret", "(J)[B");
2487 CHECK(calls->release_commitment_secret_meth != NULL);
2488 calls->channel_keys_id_meth = (*env)->GetMethodID(env, c, "channel_keys_id", "()[B");
2489 CHECK(calls->channel_keys_id_meth != NULL);
2490 calls->sign_counterparty_commitment_meth = (*env)->GetMethodID(env, c, "sign_counterparty_commitment", "(J)J");
2491 CHECK(calls->sign_counterparty_commitment_meth != NULL);
2492 calls->sign_holder_commitment_and_htlcs_meth = (*env)->GetMethodID(env, c, "sign_holder_commitment_and_htlcs", "(J)J");
2493 CHECK(calls->sign_holder_commitment_and_htlcs_meth != NULL);
2494 calls->sign_justice_revoked_output_meth = (*env)->GetMethodID(env, c, "sign_justice_revoked_output", "([BJJ[B)J");
2495 CHECK(calls->sign_justice_revoked_output_meth != NULL);
2496 calls->sign_justice_revoked_htlc_meth = (*env)->GetMethodID(env, c, "sign_justice_revoked_htlc", "([BJJ[BJ)J");
2497 CHECK(calls->sign_justice_revoked_htlc_meth != NULL);
2498 calls->sign_counterparty_htlc_transaction_meth = (*env)->GetMethodID(env, c, "sign_counterparty_htlc_transaction", "([BJJ[BJ)J");
2499 CHECK(calls->sign_counterparty_htlc_transaction_meth != NULL);
2500 calls->sign_closing_transaction_meth = (*env)->GetMethodID(env, c, "sign_closing_transaction", "([B)J");
2501 CHECK(calls->sign_closing_transaction_meth != NULL);
2502 calls->sign_channel_announcement_meth = (*env)->GetMethodID(env, c, "sign_channel_announcement", "(J)J");
2503 CHECK(calls->sign_channel_announcement_meth != NULL);
2504 calls->ready_channel_meth = (*env)->GetMethodID(env, c, "ready_channel", "(J)V");
2505 CHECK(calls->ready_channel_meth != NULL);
2507 LDKChannelPublicKeys pubkeys_conv;
2508 pubkeys_conv.inner = (void*)(pubkeys & (~1));
2509 pubkeys_conv.is_owned = (pubkeys & 1) || (pubkeys == 0);
2510 pubkeys_conv = ChannelPublicKeys_clone(&pubkeys_conv);
2513 .this_arg = (void*) calls,
2514 .get_per_commitment_point = get_per_commitment_point_LDKBaseSign_jcall,
2515 .release_commitment_secret = release_commitment_secret_LDKBaseSign_jcall,
2516 .channel_keys_id = channel_keys_id_LDKBaseSign_jcall,
2517 .sign_counterparty_commitment = sign_counterparty_commitment_LDKBaseSign_jcall,
2518 .sign_holder_commitment_and_htlcs = sign_holder_commitment_and_htlcs_LDKBaseSign_jcall,
2519 .sign_justice_revoked_output = sign_justice_revoked_output_LDKBaseSign_jcall,
2520 .sign_justice_revoked_htlc = sign_justice_revoked_htlc_LDKBaseSign_jcall,
2521 .sign_counterparty_htlc_transaction = sign_counterparty_htlc_transaction_LDKBaseSign_jcall,
2522 .sign_closing_transaction = sign_closing_transaction_LDKBaseSign_jcall,
2523 .sign_channel_announcement = sign_channel_announcement_LDKBaseSign_jcall,
2524 .ready_channel = ready_channel_LDKBaseSign_jcall,
2525 .free = LDKBaseSign_JCalls_free,
2526 .pubkeys = pubkeys_conv,
2527 .set_pubkeys = NULL,
2531 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKBaseSign_1new(JNIEnv *env, jclass clz, jobject o, int64_t pubkeys) {
2532 LDKBaseSign *res_ptr = MALLOC(sizeof(LDKBaseSign), "LDKBaseSign");
2533 *res_ptr = LDKBaseSign_init(env, clz, o, pubkeys);
2534 return (uint64_t)res_ptr;
2536 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_BaseSign_1get_1per_1commitment_1point(JNIEnv *env, jclass clz, int64_t this_arg, int64_t idx) {
2537 LDKBaseSign* this_arg_conv = (LDKBaseSign*)(((uint64_t)this_arg) & ~1);
2538 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
2539 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, (this_arg_conv->get_per_commitment_point)(this_arg_conv->this_arg, idx).compressed_form);
2543 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_BaseSign_1release_1commitment_1secret(JNIEnv *env, jclass clz, int64_t this_arg, int64_t idx) {
2544 LDKBaseSign* this_arg_conv = (LDKBaseSign*)(((uint64_t)this_arg) & ~1);
2545 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
2546 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, (this_arg_conv->release_commitment_secret)(this_arg_conv->this_arg, idx).data);
2550 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_BaseSign_1channel_1keys_1id(JNIEnv *env, jclass clz, int64_t this_arg) {
2551 LDKBaseSign* this_arg_conv = (LDKBaseSign*)(((uint64_t)this_arg) & ~1);
2552 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
2553 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, (this_arg_conv->channel_keys_id)(this_arg_conv->this_arg).data);
2557 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_BaseSign_1sign_1counterparty_1commitment(JNIEnv *env, jclass clz, int64_t this_arg, int64_t commitment_tx) {
2558 LDKBaseSign* this_arg_conv = (LDKBaseSign*)(((uint64_t)this_arg) & ~1);
2559 LDKCommitmentTransaction commitment_tx_conv;
2560 commitment_tx_conv.inner = (void*)(commitment_tx & (~1));
2561 commitment_tx_conv.is_owned = false;
2562 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
2563 *ret_conv = (this_arg_conv->sign_counterparty_commitment)(this_arg_conv->this_arg, &commitment_tx_conv);
2564 return (uint64_t)ret_conv;
2567 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_BaseSign_1sign_1holder_1commitment_1and_1htlcs(JNIEnv *env, jclass clz, int64_t this_arg, int64_t commitment_tx) {
2568 LDKBaseSign* this_arg_conv = (LDKBaseSign*)(((uint64_t)this_arg) & ~1);
2569 LDKHolderCommitmentTransaction commitment_tx_conv;
2570 commitment_tx_conv.inner = (void*)(commitment_tx & (~1));
2571 commitment_tx_conv.is_owned = false;
2572 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
2573 *ret_conv = (this_arg_conv->sign_holder_commitment_and_htlcs)(this_arg_conv->this_arg, &commitment_tx_conv);
2574 return (uint64_t)ret_conv;
2577 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_BaseSign_1sign_1justice_1revoked_1output(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray justice_tx, int64_t input, int64_t amount, int8_tArray per_commitment_key) {
2578 LDKBaseSign* this_arg_conv = (LDKBaseSign*)(((uint64_t)this_arg) & ~1);
2579 LDKTransaction justice_tx_ref;
2580 justice_tx_ref.datalen = (*env)->GetArrayLength(env, justice_tx);
2581 justice_tx_ref.data = MALLOC(justice_tx_ref.datalen, "LDKTransaction Bytes");
2582 (*env)->GetByteArrayRegion(env, justice_tx, 0, justice_tx_ref.datalen, justice_tx_ref.data);
2583 justice_tx_ref.data_is_owned = true;
2584 unsigned char per_commitment_key_arr[32];
2585 CHECK((*env)->GetArrayLength(env, per_commitment_key) == 32);
2586 (*env)->GetByteArrayRegion(env, per_commitment_key, 0, 32, per_commitment_key_arr);
2587 unsigned char (*per_commitment_key_ref)[32] = &per_commitment_key_arr;
2588 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
2589 *ret_conv = (this_arg_conv->sign_justice_revoked_output)(this_arg_conv->this_arg, justice_tx_ref, input, amount, per_commitment_key_ref);
2590 return (uint64_t)ret_conv;
2593 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_BaseSign_1sign_1justice_1revoked_1htlc(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray justice_tx, int64_t input, int64_t amount, int8_tArray per_commitment_key, int64_t htlc) {
2594 LDKBaseSign* this_arg_conv = (LDKBaseSign*)(((uint64_t)this_arg) & ~1);
2595 LDKTransaction justice_tx_ref;
2596 justice_tx_ref.datalen = (*env)->GetArrayLength(env, justice_tx);
2597 justice_tx_ref.data = MALLOC(justice_tx_ref.datalen, "LDKTransaction Bytes");
2598 (*env)->GetByteArrayRegion(env, justice_tx, 0, justice_tx_ref.datalen, justice_tx_ref.data);
2599 justice_tx_ref.data_is_owned = true;
2600 unsigned char per_commitment_key_arr[32];
2601 CHECK((*env)->GetArrayLength(env, per_commitment_key) == 32);
2602 (*env)->GetByteArrayRegion(env, per_commitment_key, 0, 32, per_commitment_key_arr);
2603 unsigned char (*per_commitment_key_ref)[32] = &per_commitment_key_arr;
2604 LDKHTLCOutputInCommitment htlc_conv;
2605 htlc_conv.inner = (void*)(htlc & (~1));
2606 htlc_conv.is_owned = false;
2607 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
2608 *ret_conv = (this_arg_conv->sign_justice_revoked_htlc)(this_arg_conv->this_arg, justice_tx_ref, input, amount, per_commitment_key_ref, &htlc_conv);
2609 return (uint64_t)ret_conv;
2612 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_BaseSign_1sign_1counterparty_1htlc_1transaction(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray htlc_tx, int64_t input, int64_t amount, int8_tArray per_commitment_point, int64_t htlc) {
2613 LDKBaseSign* this_arg_conv = (LDKBaseSign*)(((uint64_t)this_arg) & ~1);
2614 LDKTransaction htlc_tx_ref;
2615 htlc_tx_ref.datalen = (*env)->GetArrayLength(env, htlc_tx);
2616 htlc_tx_ref.data = MALLOC(htlc_tx_ref.datalen, "LDKTransaction Bytes");
2617 (*env)->GetByteArrayRegion(env, htlc_tx, 0, htlc_tx_ref.datalen, htlc_tx_ref.data);
2618 htlc_tx_ref.data_is_owned = true;
2619 LDKPublicKey per_commitment_point_ref;
2620 CHECK((*env)->GetArrayLength(env, per_commitment_point) == 33);
2621 (*env)->GetByteArrayRegion(env, per_commitment_point, 0, 33, per_commitment_point_ref.compressed_form);
2622 LDKHTLCOutputInCommitment htlc_conv;
2623 htlc_conv.inner = (void*)(htlc & (~1));
2624 htlc_conv.is_owned = false;
2625 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
2626 *ret_conv = (this_arg_conv->sign_counterparty_htlc_transaction)(this_arg_conv->this_arg, htlc_tx_ref, input, amount, per_commitment_point_ref, &htlc_conv);
2627 return (uint64_t)ret_conv;
2630 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_BaseSign_1sign_1closing_1transaction(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray closing_tx) {
2631 LDKBaseSign* this_arg_conv = (LDKBaseSign*)(((uint64_t)this_arg) & ~1);
2632 LDKTransaction closing_tx_ref;
2633 closing_tx_ref.datalen = (*env)->GetArrayLength(env, closing_tx);
2634 closing_tx_ref.data = MALLOC(closing_tx_ref.datalen, "LDKTransaction Bytes");
2635 (*env)->GetByteArrayRegion(env, closing_tx, 0, closing_tx_ref.datalen, closing_tx_ref.data);
2636 closing_tx_ref.data_is_owned = true;
2637 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
2638 *ret_conv = (this_arg_conv->sign_closing_transaction)(this_arg_conv->this_arg, closing_tx_ref);
2639 return (uint64_t)ret_conv;
2642 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_BaseSign_1sign_1channel_1announcement(JNIEnv *env, jclass clz, int64_t this_arg, int64_t msg) {
2643 LDKBaseSign* this_arg_conv = (LDKBaseSign*)(((uint64_t)this_arg) & ~1);
2644 LDKUnsignedChannelAnnouncement msg_conv;
2645 msg_conv.inner = (void*)(msg & (~1));
2646 msg_conv.is_owned = false;
2647 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
2648 *ret_conv = (this_arg_conv->sign_channel_announcement)(this_arg_conv->this_arg, &msg_conv);
2649 return (uint64_t)ret_conv;
2652 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_BaseSign_1ready_1channel(JNIEnv *env, jclass clz, int64_t this_arg, int64_t channel_parameters) {
2653 LDKBaseSign* this_arg_conv = (LDKBaseSign*)(((uint64_t)this_arg) & ~1);
2654 LDKChannelTransactionParameters channel_parameters_conv;
2655 channel_parameters_conv.inner = (void*)(channel_parameters & (~1));
2656 channel_parameters_conv.is_owned = false;
2657 (this_arg_conv->ready_channel)(this_arg_conv->this_arg, &channel_parameters_conv);
2660 LDKChannelPublicKeys LDKBaseSign_set_get_pubkeys(LDKBaseSign* this_arg) {
2661 if (this_arg->set_pubkeys != NULL)
2662 this_arg->set_pubkeys(this_arg);
2663 return this_arg->pubkeys;
2665 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_BaseSign_1get_1pubkeys(JNIEnv *env, jclass clz, int64_t this_arg) {
2666 LDKBaseSign* this_arg_conv = (LDKBaseSign*)(((uint64_t)this_arg) & ~1);
2667 LDKChannelPublicKeys ret_var = LDKBaseSign_set_get_pubkeys(this_arg_conv);
2668 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2669 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2670 uint64_t ret_ref = (uint64_t)ret_var.inner;
2671 if (ret_var.is_owned) {
2677 typedef struct LDKSign_JCalls {
2678 atomic_size_t refcnt;
2681 LDKBaseSign_JCalls* BaseSign;
2682 jmethodID write_meth;
2684 static void LDKSign_JCalls_free(void* this_arg) {
2685 LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
2686 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
2688 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
2689 if (get_jenv_res == JNI_EDETACHED) {
2690 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
2692 DO_ASSERT(get_jenv_res == JNI_OK);
2694 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
2695 if (get_jenv_res == JNI_EDETACHED) {
2696 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
2701 LDKCVec_u8Z write_LDKSign_jcall(const void* this_arg) {
2702 LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
2704 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
2705 if (get_jenv_res == JNI_EDETACHED) {
2706 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
2708 DO_ASSERT(get_jenv_res == JNI_OK);
2710 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
2712 int8_tArray ret = (*env)->CallObjectMethod(env, obj, j_calls->write_meth);
2713 if ((*env)->ExceptionCheck(env)) {
2714 (*env)->ExceptionDescribe(env);
2715 (*env)->FatalError(env, "A call to write in LDKSign from rust threw an exception.");
2717 LDKCVec_u8Z ret_ref;
2718 ret_ref.datalen = (*env)->GetArrayLength(env, ret);
2719 ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
2720 (*env)->GetByteArrayRegion(env, ret, 0, ret_ref.datalen, ret_ref.data);
2721 if (get_jenv_res == JNI_EDETACHED) {
2722 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
2726 static void* LDKSign_JCalls_clone(const void* this_arg) {
2727 LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
2728 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
2729 atomic_fetch_add_explicit(&j_calls->BaseSign->refcnt, 1, memory_order_release);
2730 return (void*) this_arg;
2732 static inline LDKSign LDKSign_init (JNIEnv *env, jclass clz, jobject o, jobject BaseSign, int64_t pubkeys) {
2733 jclass c = (*env)->GetObjectClass(env, o);
2735 LDKSign_JCalls *calls = MALLOC(sizeof(LDKSign_JCalls), "LDKSign_JCalls");
2736 atomic_init(&calls->refcnt, 1);
2737 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
2738 calls->o = (*env)->NewWeakGlobalRef(env, o);
2739 calls->write_meth = (*env)->GetMethodID(env, c, "write", "()[B");
2740 CHECK(calls->write_meth != NULL);
2742 LDKChannelPublicKeys pubkeys_conv;
2743 pubkeys_conv.inner = (void*)(pubkeys & (~1));
2744 pubkeys_conv.is_owned = (pubkeys & 1) || (pubkeys == 0);
2745 pubkeys_conv = ChannelPublicKeys_clone(&pubkeys_conv);
2748 .this_arg = (void*) calls,
2749 .write = write_LDKSign_jcall,
2750 .clone = LDKSign_JCalls_clone,
2751 .free = LDKSign_JCalls_free,
2752 .BaseSign = LDKBaseSign_init(env, clz, BaseSign, pubkeys),
2754 calls->BaseSign = ret.BaseSign.this_arg;
2757 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKSign_1new(JNIEnv *env, jclass clz, jobject o, jobject BaseSign, int64_t pubkeys) {
2758 LDKSign *res_ptr = MALLOC(sizeof(LDKSign), "LDKSign");
2759 *res_ptr = LDKSign_init(env, clz, o, BaseSign, pubkeys);
2760 return (uint64_t)res_ptr;
2762 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_Sign_1write(JNIEnv *env, jclass clz, int64_t this_arg) {
2763 LDKSign* this_arg_conv = (LDKSign*)(((uint64_t)this_arg) & ~1);
2764 LDKCVec_u8Z ret_var = (this_arg_conv->write)(this_arg_conv->this_arg);
2765 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
2766 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
2767 CVec_u8Z_free(ret_var);
2771 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SignDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
2772 return ((LDKCResult_SignDecodeErrorZ*)arg)->result_ok;
2774 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SignDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
2775 LDKCResult_SignDecodeErrorZ *val = (LDKCResult_SignDecodeErrorZ*)(arg & ~1);
2776 CHECK(val->result_ok);
2777 LDKSign* ret = MALLOC(sizeof(LDKSign), "LDKSign");
2778 *ret = Sign_clone(&(*val->contents.result));
2779 return (uint64_t)ret;
2781 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SignDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
2782 LDKCResult_SignDecodeErrorZ *val = (LDKCResult_SignDecodeErrorZ*)(arg & ~1);
2783 CHECK(!val->result_ok);
2784 LDKDecodeError err_var = (*val->contents.err);
2785 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2786 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2787 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
2790 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RecoverableSignatureNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
2791 return ((LDKCResult_RecoverableSignatureNoneZ*)arg)->result_ok;
2793 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RecoverableSignatureNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
2794 LDKCResult_RecoverableSignatureNoneZ *val = (LDKCResult_RecoverableSignatureNoneZ*)(arg & ~1);
2795 CHECK(val->result_ok);
2796 int8_tArray es_arr = (*env)->NewByteArray(env, 68);
2797 (*env)->SetByteArrayRegion(env, es_arr, 0, 68, (*val->contents.result).serialized_form);
2800 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RecoverableSignatureNoneZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
2801 LDKCResult_RecoverableSignatureNoneZ *val = (LDKCResult_RecoverableSignatureNoneZ*)(arg & ~1);
2802 CHECK(!val->result_ok);
2803 return *val->contents.err;
2805 static inline LDKCVec_CVec_u8ZZ CVec_CVec_u8ZZ_clone(const LDKCVec_CVec_u8ZZ *orig) {
2806 LDKCVec_CVec_u8ZZ ret = { .data = MALLOC(sizeof(LDKCVec_u8Z) * orig->datalen, "LDKCVec_CVec_u8ZZ clone bytes"), .datalen = orig->datalen };
2807 for (size_t i = 0; i < ret.datalen; i++) {
2808 ret.data[i] = CVec_u8Z_clone(&orig->data[i]);
2812 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1CVec_1u8ZZNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
2813 return ((LDKCResult_CVec_CVec_u8ZZNoneZ*)arg)->result_ok;
2815 JNIEXPORT jobjectArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1CVec_1u8ZZNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
2816 LDKCResult_CVec_CVec_u8ZZNoneZ *val = (LDKCResult_CVec_CVec_u8ZZNoneZ*)(arg & ~1);
2817 CHECK(val->result_ok);
2818 LDKCVec_CVec_u8ZZ res_var = (*val->contents.result);
2819 jobjectArray res_arr = (*env)->NewObjectArray(env, res_var.datalen, arr_of_B_clz, NULL);
2821 for (size_t i = 0; i < res_var.datalen; i++) {
2822 LDKCVec_u8Z res_conv_8_var = res_var.data[i];
2823 int8_tArray res_conv_8_arr = (*env)->NewByteArray(env, res_conv_8_var.datalen);
2824 (*env)->SetByteArrayRegion(env, res_conv_8_arr, 0, res_conv_8_var.datalen, res_conv_8_var.data);
2825 (*env)->SetObjectArrayElement(env, res_arr, i, res_conv_8_arr);
2829 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1CVec_1u8ZZNoneZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
2830 LDKCResult_CVec_CVec_u8ZZNoneZ *val = (LDKCResult_CVec_CVec_u8ZZNoneZ*)(arg & ~1);
2831 CHECK(!val->result_ok);
2832 return *val->contents.err;
2834 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InMemorySignerDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
2835 return ((LDKCResult_InMemorySignerDecodeErrorZ*)arg)->result_ok;
2837 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InMemorySignerDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
2838 LDKCResult_InMemorySignerDecodeErrorZ *val = (LDKCResult_InMemorySignerDecodeErrorZ*)(arg & ~1);
2839 CHECK(val->result_ok);
2840 LDKInMemorySigner res_var = (*val->contents.result);
2841 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2842 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2843 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
2846 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InMemorySignerDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
2847 LDKCResult_InMemorySignerDecodeErrorZ *val = (LDKCResult_InMemorySignerDecodeErrorZ*)(arg & ~1);
2848 CHECK(!val->result_ok);
2849 LDKDecodeError err_var = (*val->contents.err);
2850 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2851 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2852 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
2855 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1TxOutZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
2856 LDKCVec_TxOutZ *ret = MALLOC(sizeof(LDKCVec_TxOutZ), "LDKCVec_TxOutZ");
2857 ret->datalen = (*env)->GetArrayLength(env, elems);
2858 if (ret->datalen == 0) {
2861 ret->data = MALLOC(sizeof(LDKTxOut) * ret->datalen, "LDKCVec_TxOutZ Data");
2862 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
2863 for (size_t i = 0; i < ret->datalen; i++) {
2864 int64_t arr_elem = java_elems[i];
2865 LDKTxOut arr_elem_conv = *(LDKTxOut*)(((uint64_t)arr_elem) & ~1);
2866 arr_elem_conv = TxOut_clone((LDKTxOut*)(((uint64_t)arr_elem) & ~1));
2867 ret->data[i] = arr_elem_conv;
2869 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
2871 return (uint64_t)ret;
2873 static inline LDKCVec_TxOutZ CVec_TxOutZ_clone(const LDKCVec_TxOutZ *orig) {
2874 LDKCVec_TxOutZ ret = { .data = MALLOC(sizeof(LDKTxOut) * orig->datalen, "LDKCVec_TxOutZ clone bytes"), .datalen = orig->datalen };
2875 for (size_t i = 0; i < ret.datalen; i++) {
2876 ret.data[i] = TxOut_clone(&orig->data[i]);
2880 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TransactionNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
2881 return ((LDKCResult_TransactionNoneZ*)arg)->result_ok;
2883 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TransactionNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
2884 LDKCResult_TransactionNoneZ *val = (LDKCResult_TransactionNoneZ*)(arg & ~1);
2885 CHECK(val->result_ok);
2886 LDKTransaction res_var = (*val->contents.result);
2887 int8_tArray res_arr = (*env)->NewByteArray(env, res_var.datalen);
2888 (*env)->SetByteArrayRegion(env, res_arr, 0, res_var.datalen, res_var.data);
2891 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TransactionNoneZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
2892 LDKCResult_TransactionNoneZ *val = (LDKCResult_TransactionNoneZ*)(arg & ~1);
2893 CHECK(!val->result_ok);
2894 return *val->contents.err;
2896 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1BlockHashChannelMonitorZ_1new(JNIEnv *env, jclass clz, int8_tArray a, int64_t b) {
2897 LDKC2Tuple_BlockHashChannelMonitorZ* ret = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
2898 LDKThirtyTwoBytes a_ref;
2899 CHECK((*env)->GetArrayLength(env, a) == 32);
2900 (*env)->GetByteArrayRegion(env, a, 0, 32, a_ref.data);
2902 LDKChannelMonitor b_conv;
2903 b_conv.inner = (void*)(b & (~1));
2904 b_conv.is_owned = (b & 1) || (b == 0);
2905 b_conv = ChannelMonitor_clone(&b_conv);
2907 return (uint64_t)ret;
2909 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1BlockHashChannelMonitorZ_1get_1a(JNIEnv *env, jclass clz, int64_t ptr) {
2910 LDKC2Tuple_BlockHashChannelMonitorZ *tuple = (LDKC2Tuple_BlockHashChannelMonitorZ*)(ptr & ~1);
2911 int8_tArray a_arr = (*env)->NewByteArray(env, 32);
2912 (*env)->SetByteArrayRegion(env, a_arr, 0, 32, tuple->a.data);
2915 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1BlockHashChannelMonitorZ_1get_1b(JNIEnv *env, jclass clz, int64_t ptr) {
2916 LDKC2Tuple_BlockHashChannelMonitorZ *tuple = (LDKC2Tuple_BlockHashChannelMonitorZ*)(ptr & ~1);
2917 LDKChannelMonitor b_var = tuple->b;
2918 CHECK((((uint64_t)b_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2919 CHECK((((uint64_t)&b_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2920 uint64_t b_ref = (uint64_t)b_var.inner & ~1;
2923 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C2Tuple_1BlockHashChannelMonitorZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
2924 LDKCVec_C2Tuple_BlockHashChannelMonitorZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_BlockHashChannelMonitorZZ), "LDKCVec_C2Tuple_BlockHashChannelMonitorZZ");
2925 ret->datalen = (*env)->GetArrayLength(env, elems);
2926 if (ret->datalen == 0) {
2929 ret->data = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ) * ret->datalen, "LDKCVec_C2Tuple_BlockHashChannelMonitorZZ Data");
2930 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
2931 for (size_t i = 0; i < ret->datalen; i++) {
2932 int64_t arr_elem = java_elems[i];
2933 LDKC2Tuple_BlockHashChannelMonitorZ arr_elem_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(((uint64_t)arr_elem) & ~1);
2934 // Warning: we may need a move here but no clone is available for LDKC2Tuple_BlockHashChannelMonitorZ
2935 ret->data[i] = arr_elem_conv;
2937 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
2939 return (uint64_t)ret;
2941 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1C2Tuple_1BlockHashChannelMonitorZZErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
2942 return ((LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)arg)->result_ok;
2944 JNIEXPORT int64_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1C2Tuple_1BlockHashChannelMonitorZZErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
2945 LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ *val = (LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)(arg & ~1);
2946 CHECK(val->result_ok);
2947 LDKCVec_C2Tuple_BlockHashChannelMonitorZZ res_var = (*val->contents.result);
2948 int64_tArray res_arr = (*env)->NewLongArray(env, res_var.datalen);
2949 int64_t *res_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, res_arr, NULL);
2950 for (size_t i = 0; i < res_var.datalen; i++) {
2951 uint64_t res_conv_34_ref = (uint64_t)(&res_var.data[i]) | 1;
2952 res_arr_ptr[i] = res_conv_34_ref;
2954 (*env)->ReleasePrimitiveArrayCritical(env, res_arr, res_arr_ptr, 0);
2957 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1C2Tuple_1BlockHashChannelMonitorZZErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
2958 LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ *val = (LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)(arg & ~1);
2959 CHECK(!val->result_ok);
2960 jclass err_conv = LDKIOError_to_java(env, (*val->contents.err));
2963 static jclass LDKCOption_u16Z_Some_class = NULL;
2964 static jmethodID LDKCOption_u16Z_Some_meth = NULL;
2965 static jclass LDKCOption_u16Z_None_class = NULL;
2966 static jmethodID LDKCOption_u16Z_None_meth = NULL;
2967 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKCOption_1u16Z_init (JNIEnv *env, jclass clz) {
2968 LDKCOption_u16Z_Some_class =
2969 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKCOption_u16Z$Some;"));
2970 CHECK(LDKCOption_u16Z_Some_class != NULL);
2971 LDKCOption_u16Z_Some_meth = (*env)->GetMethodID(env, LDKCOption_u16Z_Some_class, "<init>", "(S)V");
2972 CHECK(LDKCOption_u16Z_Some_meth != NULL);
2973 LDKCOption_u16Z_None_class =
2974 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKCOption_u16Z$None;"));
2975 CHECK(LDKCOption_u16Z_None_class != NULL);
2976 LDKCOption_u16Z_None_meth = (*env)->GetMethodID(env, LDKCOption_u16Z_None_class, "<init>", "()V");
2977 CHECK(LDKCOption_u16Z_None_meth != NULL);
2979 JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCOption_1u16Z_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
2980 LDKCOption_u16Z *obj = (LDKCOption_u16Z*)(ptr & ~1);
2982 case LDKCOption_u16Z_Some: {
2983 return (*env)->NewObject(env, LDKCOption_u16Z_Some_class, LDKCOption_u16Z_Some_meth, obj->some);
2985 case LDKCOption_u16Z_None: {
2986 return (*env)->NewObject(env, LDKCOption_u16Z_None_class, LDKCOption_u16Z_None_meth);
2991 static jclass LDKAPIError_APIMisuseError_class = NULL;
2992 static jmethodID LDKAPIError_APIMisuseError_meth = NULL;
2993 static jclass LDKAPIError_FeeRateTooHigh_class = NULL;
2994 static jmethodID LDKAPIError_FeeRateTooHigh_meth = NULL;
2995 static jclass LDKAPIError_RouteError_class = NULL;
2996 static jmethodID LDKAPIError_RouteError_meth = NULL;
2997 static jclass LDKAPIError_ChannelUnavailable_class = NULL;
2998 static jmethodID LDKAPIError_ChannelUnavailable_meth = NULL;
2999 static jclass LDKAPIError_MonitorUpdateFailed_class = NULL;
3000 static jmethodID LDKAPIError_MonitorUpdateFailed_meth = NULL;
3001 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKAPIError_init (JNIEnv *env, jclass clz) {
3002 LDKAPIError_APIMisuseError_class =
3003 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKAPIError$APIMisuseError;"));
3004 CHECK(LDKAPIError_APIMisuseError_class != NULL);
3005 LDKAPIError_APIMisuseError_meth = (*env)->GetMethodID(env, LDKAPIError_APIMisuseError_class, "<init>", "(Ljava/lang/String;)V");
3006 CHECK(LDKAPIError_APIMisuseError_meth != NULL);
3007 LDKAPIError_FeeRateTooHigh_class =
3008 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKAPIError$FeeRateTooHigh;"));
3009 CHECK(LDKAPIError_FeeRateTooHigh_class != NULL);
3010 LDKAPIError_FeeRateTooHigh_meth = (*env)->GetMethodID(env, LDKAPIError_FeeRateTooHigh_class, "<init>", "(Ljava/lang/String;I)V");
3011 CHECK(LDKAPIError_FeeRateTooHigh_meth != NULL);
3012 LDKAPIError_RouteError_class =
3013 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKAPIError$RouteError;"));
3014 CHECK(LDKAPIError_RouteError_class != NULL);
3015 LDKAPIError_RouteError_meth = (*env)->GetMethodID(env, LDKAPIError_RouteError_class, "<init>", "(Ljava/lang/String;)V");
3016 CHECK(LDKAPIError_RouteError_meth != NULL);
3017 LDKAPIError_ChannelUnavailable_class =
3018 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKAPIError$ChannelUnavailable;"));
3019 CHECK(LDKAPIError_ChannelUnavailable_class != NULL);
3020 LDKAPIError_ChannelUnavailable_meth = (*env)->GetMethodID(env, LDKAPIError_ChannelUnavailable_class, "<init>", "(Ljava/lang/String;)V");
3021 CHECK(LDKAPIError_ChannelUnavailable_meth != NULL);
3022 LDKAPIError_MonitorUpdateFailed_class =
3023 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKAPIError$MonitorUpdateFailed;"));
3024 CHECK(LDKAPIError_MonitorUpdateFailed_class != NULL);
3025 LDKAPIError_MonitorUpdateFailed_meth = (*env)->GetMethodID(env, LDKAPIError_MonitorUpdateFailed_class, "<init>", "()V");
3026 CHECK(LDKAPIError_MonitorUpdateFailed_meth != NULL);
3028 JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKAPIError_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
3029 LDKAPIError *obj = (LDKAPIError*)(ptr & ~1);
3031 case LDKAPIError_APIMisuseError: {
3032 LDKStr err_str = obj->api_misuse_error.err;
3033 jstring err_conv = str_ref_to_java(env, err_str.chars, err_str.len);
3034 return (*env)->NewObject(env, LDKAPIError_APIMisuseError_class, LDKAPIError_APIMisuseError_meth, err_conv);
3036 case LDKAPIError_FeeRateTooHigh: {
3037 LDKStr err_str = obj->fee_rate_too_high.err;
3038 jstring err_conv = str_ref_to_java(env, err_str.chars, err_str.len);
3039 return (*env)->NewObject(env, LDKAPIError_FeeRateTooHigh_class, LDKAPIError_FeeRateTooHigh_meth, err_conv, obj->fee_rate_too_high.feerate);
3041 case LDKAPIError_RouteError: {
3042 LDKStr err_str = obj->route_error.err;
3043 jstring err_conv = str_ref_to_java(env, err_str.chars, err_str.len);
3044 return (*env)->NewObject(env, LDKAPIError_RouteError_class, LDKAPIError_RouteError_meth, err_conv);
3046 case LDKAPIError_ChannelUnavailable: {
3047 LDKStr err_str = obj->channel_unavailable.err;
3048 jstring err_conv = str_ref_to_java(env, err_str.chars, err_str.len);
3049 return (*env)->NewObject(env, LDKAPIError_ChannelUnavailable_class, LDKAPIError_ChannelUnavailable_meth, err_conv);
3051 case LDKAPIError_MonitorUpdateFailed: {
3052 return (*env)->NewObject(env, LDKAPIError_MonitorUpdateFailed_class, LDKAPIError_MonitorUpdateFailed_meth);
3057 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneAPIErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3058 return ((LDKCResult_NoneAPIErrorZ*)arg)->result_ok;
3060 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneAPIErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3061 LDKCResult_NoneAPIErrorZ *val = (LDKCResult_NoneAPIErrorZ*)(arg & ~1);
3062 CHECK(val->result_ok);
3063 return *val->contents.result;
3065 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneAPIErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
3066 LDKCResult_NoneAPIErrorZ *val = (LDKCResult_NoneAPIErrorZ*)(arg & ~1);
3067 CHECK(!val->result_ok);
3068 uint64_t err_ref = ((uint64_t)&(*val->contents.err)) | 1;
3071 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1CResult_1NoneAPIErrorZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
3072 LDKCVec_CResult_NoneAPIErrorZZ *ret = MALLOC(sizeof(LDKCVec_CResult_NoneAPIErrorZZ), "LDKCVec_CResult_NoneAPIErrorZZ");
3073 ret->datalen = (*env)->GetArrayLength(env, elems);
3074 if (ret->datalen == 0) {
3077 ret->data = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ) * ret->datalen, "LDKCVec_CResult_NoneAPIErrorZZ Data");
3078 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
3079 for (size_t i = 0; i < ret->datalen; i++) {
3080 int64_t arr_elem = java_elems[i];
3081 LDKCResult_NoneAPIErrorZ arr_elem_conv = *(LDKCResult_NoneAPIErrorZ*)(((uint64_t)arr_elem) & ~1);
3082 arr_elem_conv = CResult_NoneAPIErrorZ_clone((LDKCResult_NoneAPIErrorZ*)(((uint64_t)arr_elem) & ~1));
3083 ret->data[i] = arr_elem_conv;
3085 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
3087 return (uint64_t)ret;
3089 static inline LDKCVec_CResult_NoneAPIErrorZZ CVec_CResult_NoneAPIErrorZZ_clone(const LDKCVec_CResult_NoneAPIErrorZZ *orig) {
3090 LDKCVec_CResult_NoneAPIErrorZZ ret = { .data = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ) * orig->datalen, "LDKCVec_CResult_NoneAPIErrorZZ clone bytes"), .datalen = orig->datalen };
3091 for (size_t i = 0; i < ret.datalen; i++) {
3092 ret.data[i] = CResult_NoneAPIErrorZ_clone(&orig->data[i]);
3096 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1APIErrorZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
3097 LDKCVec_APIErrorZ *ret = MALLOC(sizeof(LDKCVec_APIErrorZ), "LDKCVec_APIErrorZ");
3098 ret->datalen = (*env)->GetArrayLength(env, elems);
3099 if (ret->datalen == 0) {
3102 ret->data = MALLOC(sizeof(LDKAPIError) * ret->datalen, "LDKCVec_APIErrorZ Data");
3103 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
3104 for (size_t i = 0; i < ret->datalen; i++) {
3105 int64_t arr_elem = java_elems[i];
3106 LDKAPIError arr_elem_conv = *(LDKAPIError*)(((uint64_t)arr_elem) & ~1);
3107 arr_elem_conv = APIError_clone((LDKAPIError*)(((uint64_t)arr_elem) & ~1));
3108 ret->data[i] = arr_elem_conv;
3110 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
3112 return (uint64_t)ret;
3114 static inline LDKCVec_APIErrorZ CVec_APIErrorZ_clone(const LDKCVec_APIErrorZ *orig) {
3115 LDKCVec_APIErrorZ ret = { .data = MALLOC(sizeof(LDKAPIError) * orig->datalen, "LDKCVec_APIErrorZ clone bytes"), .datalen = orig->datalen };
3116 for (size_t i = 0; i < ret.datalen; i++) {
3117 ret.data[i] = APIError_clone(&orig->data[i]);
3121 static jclass LDKPaymentSendFailure_ParameterError_class = NULL;
3122 static jmethodID LDKPaymentSendFailure_ParameterError_meth = NULL;
3123 static jclass LDKPaymentSendFailure_PathParameterError_class = NULL;
3124 static jmethodID LDKPaymentSendFailure_PathParameterError_meth = NULL;
3125 static jclass LDKPaymentSendFailure_AllFailedRetrySafe_class = NULL;
3126 static jmethodID LDKPaymentSendFailure_AllFailedRetrySafe_meth = NULL;
3127 static jclass LDKPaymentSendFailure_PartialFailure_class = NULL;
3128 static jmethodID LDKPaymentSendFailure_PartialFailure_meth = NULL;
3129 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKPaymentSendFailure_init (JNIEnv *env, jclass clz) {
3130 LDKPaymentSendFailure_ParameterError_class =
3131 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKPaymentSendFailure$ParameterError;"));
3132 CHECK(LDKPaymentSendFailure_ParameterError_class != NULL);
3133 LDKPaymentSendFailure_ParameterError_meth = (*env)->GetMethodID(env, LDKPaymentSendFailure_ParameterError_class, "<init>", "(J)V");
3134 CHECK(LDKPaymentSendFailure_ParameterError_meth != NULL);
3135 LDKPaymentSendFailure_PathParameterError_class =
3136 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKPaymentSendFailure$PathParameterError;"));
3137 CHECK(LDKPaymentSendFailure_PathParameterError_class != NULL);
3138 LDKPaymentSendFailure_PathParameterError_meth = (*env)->GetMethodID(env, LDKPaymentSendFailure_PathParameterError_class, "<init>", "([J)V");
3139 CHECK(LDKPaymentSendFailure_PathParameterError_meth != NULL);
3140 LDKPaymentSendFailure_AllFailedRetrySafe_class =
3141 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKPaymentSendFailure$AllFailedRetrySafe;"));
3142 CHECK(LDKPaymentSendFailure_AllFailedRetrySafe_class != NULL);
3143 LDKPaymentSendFailure_AllFailedRetrySafe_meth = (*env)->GetMethodID(env, LDKPaymentSendFailure_AllFailedRetrySafe_class, "<init>", "([J)V");
3144 CHECK(LDKPaymentSendFailure_AllFailedRetrySafe_meth != NULL);
3145 LDKPaymentSendFailure_PartialFailure_class =
3146 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKPaymentSendFailure$PartialFailure;"));
3147 CHECK(LDKPaymentSendFailure_PartialFailure_class != NULL);
3148 LDKPaymentSendFailure_PartialFailure_meth = (*env)->GetMethodID(env, LDKPaymentSendFailure_PartialFailure_class, "<init>", "([J)V");
3149 CHECK(LDKPaymentSendFailure_PartialFailure_meth != NULL);
3151 JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKPaymentSendFailure_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
3152 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)(ptr & ~1);
3154 case LDKPaymentSendFailure_ParameterError: {
3155 uint64_t parameter_error_ref = ((uint64_t)&obj->parameter_error) | 1;
3156 return (*env)->NewObject(env, LDKPaymentSendFailure_ParameterError_class, LDKPaymentSendFailure_ParameterError_meth, parameter_error_ref);
3158 case LDKPaymentSendFailure_PathParameterError: {
3159 LDKCVec_CResult_NoneAPIErrorZZ path_parameter_error_var = obj->path_parameter_error;
3160 int64_tArray path_parameter_error_arr = (*env)->NewLongArray(env, path_parameter_error_var.datalen);
3161 int64_t *path_parameter_error_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, path_parameter_error_arr, NULL);
3162 for (size_t w = 0; w < path_parameter_error_var.datalen; w++) {
3163 LDKCResult_NoneAPIErrorZ* path_parameter_error_conv_22_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
3164 *path_parameter_error_conv_22_conv = path_parameter_error_var.data[w];
3165 *path_parameter_error_conv_22_conv = CResult_NoneAPIErrorZ_clone(path_parameter_error_conv_22_conv);
3166 path_parameter_error_arr_ptr[w] = (uint64_t)path_parameter_error_conv_22_conv;
3168 (*env)->ReleasePrimitiveArrayCritical(env, path_parameter_error_arr, path_parameter_error_arr_ptr, 0);
3169 return (*env)->NewObject(env, LDKPaymentSendFailure_PathParameterError_class, LDKPaymentSendFailure_PathParameterError_meth, path_parameter_error_arr);
3171 case LDKPaymentSendFailure_AllFailedRetrySafe: {
3172 LDKCVec_APIErrorZ all_failed_retry_safe_var = obj->all_failed_retry_safe;
3173 int64_tArray all_failed_retry_safe_arr = (*env)->NewLongArray(env, all_failed_retry_safe_var.datalen);
3174 int64_t *all_failed_retry_safe_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, all_failed_retry_safe_arr, NULL);
3175 for (size_t k = 0; k < all_failed_retry_safe_var.datalen; k++) {
3176 uint64_t all_failed_retry_safe_conv_10_ref = ((uint64_t)&all_failed_retry_safe_var.data[k]) | 1;
3177 all_failed_retry_safe_arr_ptr[k] = all_failed_retry_safe_conv_10_ref;
3179 (*env)->ReleasePrimitiveArrayCritical(env, all_failed_retry_safe_arr, all_failed_retry_safe_arr_ptr, 0);
3180 return (*env)->NewObject(env, LDKPaymentSendFailure_AllFailedRetrySafe_class, LDKPaymentSendFailure_AllFailedRetrySafe_meth, all_failed_retry_safe_arr);
3182 case LDKPaymentSendFailure_PartialFailure: {
3183 LDKCVec_CResult_NoneAPIErrorZZ partial_failure_var = obj->partial_failure;
3184 int64_tArray partial_failure_arr = (*env)->NewLongArray(env, partial_failure_var.datalen);
3185 int64_t *partial_failure_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, partial_failure_arr, NULL);
3186 for (size_t w = 0; w < partial_failure_var.datalen; w++) {
3187 LDKCResult_NoneAPIErrorZ* partial_failure_conv_22_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
3188 *partial_failure_conv_22_conv = partial_failure_var.data[w];
3189 *partial_failure_conv_22_conv = CResult_NoneAPIErrorZ_clone(partial_failure_conv_22_conv);
3190 partial_failure_arr_ptr[w] = (uint64_t)partial_failure_conv_22_conv;
3192 (*env)->ReleasePrimitiveArrayCritical(env, partial_failure_arr, partial_failure_arr_ptr, 0);
3193 return (*env)->NewObject(env, LDKPaymentSendFailure_PartialFailure_class, LDKPaymentSendFailure_PartialFailure_meth, partial_failure_arr);
3198 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePaymentSendFailureZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3199 return ((LDKCResult_NonePaymentSendFailureZ*)arg)->result_ok;
3201 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePaymentSendFailureZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3202 LDKCResult_NonePaymentSendFailureZ *val = (LDKCResult_NonePaymentSendFailureZ*)(arg & ~1);
3203 CHECK(val->result_ok);
3204 return *val->contents.result;
3206 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePaymentSendFailureZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
3207 LDKCResult_NonePaymentSendFailureZ *val = (LDKCResult_NonePaymentSendFailureZ*)(arg & ~1);
3208 CHECK(!val->result_ok);
3209 uint64_t err_ref = ((uint64_t)&(*val->contents.err)) | 1;
3212 static jclass LDKNetAddress_IPv4_class = NULL;
3213 static jmethodID LDKNetAddress_IPv4_meth = NULL;
3214 static jclass LDKNetAddress_IPv6_class = NULL;
3215 static jmethodID LDKNetAddress_IPv6_meth = NULL;
3216 static jclass LDKNetAddress_OnionV2_class = NULL;
3217 static jmethodID LDKNetAddress_OnionV2_meth = NULL;
3218 static jclass LDKNetAddress_OnionV3_class = NULL;
3219 static jmethodID LDKNetAddress_OnionV3_meth = NULL;
3220 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKNetAddress_init (JNIEnv *env, jclass clz) {
3221 LDKNetAddress_IPv4_class =
3222 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKNetAddress$IPv4;"));
3223 CHECK(LDKNetAddress_IPv4_class != NULL);
3224 LDKNetAddress_IPv4_meth = (*env)->GetMethodID(env, LDKNetAddress_IPv4_class, "<init>", "([BS)V");
3225 CHECK(LDKNetAddress_IPv4_meth != NULL);
3226 LDKNetAddress_IPv6_class =
3227 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKNetAddress$IPv6;"));
3228 CHECK(LDKNetAddress_IPv6_class != NULL);
3229 LDKNetAddress_IPv6_meth = (*env)->GetMethodID(env, LDKNetAddress_IPv6_class, "<init>", "([BS)V");
3230 CHECK(LDKNetAddress_IPv6_meth != NULL);
3231 LDKNetAddress_OnionV2_class =
3232 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKNetAddress$OnionV2;"));
3233 CHECK(LDKNetAddress_OnionV2_class != NULL);
3234 LDKNetAddress_OnionV2_meth = (*env)->GetMethodID(env, LDKNetAddress_OnionV2_class, "<init>", "([BS)V");
3235 CHECK(LDKNetAddress_OnionV2_meth != NULL);
3236 LDKNetAddress_OnionV3_class =
3237 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKNetAddress$OnionV3;"));
3238 CHECK(LDKNetAddress_OnionV3_class != NULL);
3239 LDKNetAddress_OnionV3_meth = (*env)->GetMethodID(env, LDKNetAddress_OnionV3_class, "<init>", "([BSBS)V");
3240 CHECK(LDKNetAddress_OnionV3_meth != NULL);
3242 JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKNetAddress_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
3243 LDKNetAddress *obj = (LDKNetAddress*)(ptr & ~1);
3245 case LDKNetAddress_IPv4: {
3246 int8_tArray addr_arr = (*env)->NewByteArray(env, 4);
3247 (*env)->SetByteArrayRegion(env, addr_arr, 0, 4, obj->i_pv4.addr.data);
3248 return (*env)->NewObject(env, LDKNetAddress_IPv4_class, LDKNetAddress_IPv4_meth, addr_arr, obj->i_pv4.port);
3250 case LDKNetAddress_IPv6: {
3251 int8_tArray addr_arr = (*env)->NewByteArray(env, 16);
3252 (*env)->SetByteArrayRegion(env, addr_arr, 0, 16, obj->i_pv6.addr.data);
3253 return (*env)->NewObject(env, LDKNetAddress_IPv6_class, LDKNetAddress_IPv6_meth, addr_arr, obj->i_pv6.port);
3255 case LDKNetAddress_OnionV2: {
3256 int8_tArray addr_arr = (*env)->NewByteArray(env, 10);
3257 (*env)->SetByteArrayRegion(env, addr_arr, 0, 10, obj->onion_v2.addr.data);
3258 return (*env)->NewObject(env, LDKNetAddress_OnionV2_class, LDKNetAddress_OnionV2_meth, addr_arr, obj->onion_v2.port);
3260 case LDKNetAddress_OnionV3: {
3261 int8_tArray ed25519_pubkey_arr = (*env)->NewByteArray(env, 32);
3262 (*env)->SetByteArrayRegion(env, ed25519_pubkey_arr, 0, 32, obj->onion_v3.ed25519_pubkey.data);
3263 return (*env)->NewObject(env, LDKNetAddress_OnionV3_class, LDKNetAddress_OnionV3_meth, ed25519_pubkey_arr, obj->onion_v3.checksum, obj->onion_v3.version, obj->onion_v3.port);
3268 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1NetAddressZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
3269 LDKCVec_NetAddressZ *ret = MALLOC(sizeof(LDKCVec_NetAddressZ), "LDKCVec_NetAddressZ");
3270 ret->datalen = (*env)->GetArrayLength(env, elems);
3271 if (ret->datalen == 0) {
3274 ret->data = MALLOC(sizeof(LDKNetAddress) * ret->datalen, "LDKCVec_NetAddressZ Data");
3275 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
3276 for (size_t i = 0; i < ret->datalen; i++) {
3277 int64_t arr_elem = java_elems[i];
3278 LDKNetAddress arr_elem_conv = *(LDKNetAddress*)(((uint64_t)arr_elem) & ~1);
3279 arr_elem_conv = NetAddress_clone((LDKNetAddress*)(((uint64_t)arr_elem) & ~1));
3280 ret->data[i] = arr_elem_conv;
3282 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
3284 return (uint64_t)ret;
3286 static inline LDKCVec_NetAddressZ CVec_NetAddressZ_clone(const LDKCVec_NetAddressZ *orig) {
3287 LDKCVec_NetAddressZ ret = { .data = MALLOC(sizeof(LDKNetAddress) * orig->datalen, "LDKCVec_NetAddressZ clone bytes"), .datalen = orig->datalen };
3288 for (size_t i = 0; i < ret.datalen; i++) {
3289 ret.data[i] = NetAddress_clone(&orig->data[i]);
3293 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1PaymentHashPaymentSecretZ_1new(JNIEnv *env, jclass clz, int8_tArray a, int8_tArray b) {
3294 LDKC2Tuple_PaymentHashPaymentSecretZ* ret = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
3295 LDKThirtyTwoBytes a_ref;
3296 CHECK((*env)->GetArrayLength(env, a) == 32);
3297 (*env)->GetByteArrayRegion(env, a, 0, 32, a_ref.data);
3299 LDKThirtyTwoBytes b_ref;
3300 CHECK((*env)->GetArrayLength(env, b) == 32);
3301 (*env)->GetByteArrayRegion(env, b, 0, 32, b_ref.data);
3303 return (uint64_t)ret;
3305 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1PaymentHashPaymentSecretZ_1get_1a(JNIEnv *env, jclass clz, int64_t ptr) {
3306 LDKC2Tuple_PaymentHashPaymentSecretZ *tuple = (LDKC2Tuple_PaymentHashPaymentSecretZ*)(ptr & ~1);
3307 int8_tArray a_arr = (*env)->NewByteArray(env, 32);
3308 (*env)->SetByteArrayRegion(env, a_arr, 0, 32, tuple->a.data);
3311 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1PaymentHashPaymentSecretZ_1get_1b(JNIEnv *env, jclass clz, int64_t ptr) {
3312 LDKC2Tuple_PaymentHashPaymentSecretZ *tuple = (LDKC2Tuple_PaymentHashPaymentSecretZ*)(ptr & ~1);
3313 int8_tArray b_arr = (*env)->NewByteArray(env, 32);
3314 (*env)->SetByteArrayRegion(env, b_arr, 0, 32, tuple->b.data);
3317 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PaymentSecretAPIErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3318 return ((LDKCResult_PaymentSecretAPIErrorZ*)arg)->result_ok;
3320 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PaymentSecretAPIErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3321 LDKCResult_PaymentSecretAPIErrorZ *val = (LDKCResult_PaymentSecretAPIErrorZ*)(arg & ~1);
3322 CHECK(val->result_ok);
3323 int8_tArray res_arr = (*env)->NewByteArray(env, 32);
3324 (*env)->SetByteArrayRegion(env, res_arr, 0, 32, (*val->contents.result).data);
3327 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PaymentSecretAPIErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
3328 LDKCResult_PaymentSecretAPIErrorZ *val = (LDKCResult_PaymentSecretAPIErrorZ*)(arg & ~1);
3329 CHECK(!val->result_ok);
3330 uint64_t err_ref = ((uint64_t)&(*val->contents.err)) | 1;
3333 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1ChannelMonitorZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
3334 LDKCVec_ChannelMonitorZ *ret = MALLOC(sizeof(LDKCVec_ChannelMonitorZ), "LDKCVec_ChannelMonitorZ");
3335 ret->datalen = (*env)->GetArrayLength(env, elems);
3336 if (ret->datalen == 0) {
3339 ret->data = MALLOC(sizeof(LDKChannelMonitor) * ret->datalen, "LDKCVec_ChannelMonitorZ Data");
3340 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
3341 for (size_t i = 0; i < ret->datalen; i++) {
3342 int64_t arr_elem = java_elems[i];
3343 LDKChannelMonitor arr_elem_conv;
3344 arr_elem_conv.inner = (void*)(arr_elem & (~1));
3345 arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
3346 arr_elem_conv = ChannelMonitor_clone(&arr_elem_conv);
3347 ret->data[i] = arr_elem_conv;
3349 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
3351 return (uint64_t)ret;
3353 static inline LDKCVec_ChannelMonitorZ CVec_ChannelMonitorZ_clone(const LDKCVec_ChannelMonitorZ *orig) {
3354 LDKCVec_ChannelMonitorZ ret = { .data = MALLOC(sizeof(LDKChannelMonitor) * orig->datalen, "LDKCVec_ChannelMonitorZ clone bytes"), .datalen = orig->datalen };
3355 for (size_t i = 0; i < ret.datalen; i++) {
3356 ret.data[i] = ChannelMonitor_clone(&orig->data[i]);
3360 typedef struct LDKWatch_JCalls {
3361 atomic_size_t refcnt;
3364 jmethodID watch_channel_meth;
3365 jmethodID update_channel_meth;
3366 jmethodID release_pending_monitor_events_meth;
3368 static void LDKWatch_JCalls_free(void* this_arg) {
3369 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
3370 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
3372 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
3373 if (get_jenv_res == JNI_EDETACHED) {
3374 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
3376 DO_ASSERT(get_jenv_res == JNI_OK);
3378 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
3379 if (get_jenv_res == JNI_EDETACHED) {
3380 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
3385 LDKCResult_NoneChannelMonitorUpdateErrZ watch_channel_LDKWatch_jcall(const void* this_arg, LDKOutPoint funding_txo, LDKChannelMonitor monitor) {
3386 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
3388 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
3389 if (get_jenv_res == JNI_EDETACHED) {
3390 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
3392 DO_ASSERT(get_jenv_res == JNI_OK);
3394 LDKOutPoint funding_txo_var = funding_txo;
3395 CHECK((((uint64_t)funding_txo_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3396 CHECK((((uint64_t)&funding_txo_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3397 uint64_t funding_txo_ref = (uint64_t)funding_txo_var.inner;
3398 if (funding_txo_var.is_owned) {
3399 funding_txo_ref |= 1;
3401 LDKChannelMonitor monitor_var = monitor;
3402 CHECK((((uint64_t)monitor_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3403 CHECK((((uint64_t)&monitor_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3404 uint64_t monitor_ref = (uint64_t)monitor_var.inner;
3405 if (monitor_var.is_owned) {
3408 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
3410 LDKCResult_NoneChannelMonitorUpdateErrZ* ret = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(*env)->CallLongMethod(env, obj, j_calls->watch_channel_meth, funding_txo_ref, monitor_ref);
3411 if ((*env)->ExceptionCheck(env)) {
3412 (*env)->ExceptionDescribe(env);
3413 (*env)->FatalError(env, "A call to watch_channel in LDKWatch from rust threw an exception.");
3415 LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1);
3416 ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1));
3417 if (get_jenv_res == JNI_EDETACHED) {
3418 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
3422 LDKCResult_NoneChannelMonitorUpdateErrZ update_channel_LDKWatch_jcall(const void* this_arg, LDKOutPoint funding_txo, LDKChannelMonitorUpdate update) {
3423 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
3425 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
3426 if (get_jenv_res == JNI_EDETACHED) {
3427 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
3429 DO_ASSERT(get_jenv_res == JNI_OK);
3431 LDKOutPoint funding_txo_var = funding_txo;
3432 CHECK((((uint64_t)funding_txo_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3433 CHECK((((uint64_t)&funding_txo_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3434 uint64_t funding_txo_ref = (uint64_t)funding_txo_var.inner;
3435 if (funding_txo_var.is_owned) {
3436 funding_txo_ref |= 1;
3438 LDKChannelMonitorUpdate update_var = update;
3439 CHECK((((uint64_t)update_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3440 CHECK((((uint64_t)&update_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3441 uint64_t update_ref = (uint64_t)update_var.inner;
3442 if (update_var.is_owned) {
3445 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
3447 LDKCResult_NoneChannelMonitorUpdateErrZ* ret = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(*env)->CallLongMethod(env, obj, j_calls->update_channel_meth, funding_txo_ref, update_ref);
3448 if ((*env)->ExceptionCheck(env)) {
3449 (*env)->ExceptionDescribe(env);
3450 (*env)->FatalError(env, "A call to update_channel in LDKWatch from rust threw an exception.");
3452 LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1);
3453 ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1));
3454 if (get_jenv_res == JNI_EDETACHED) {
3455 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
3459 LDKCVec_MonitorEventZ release_pending_monitor_events_LDKWatch_jcall(const void* this_arg) {
3460 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
3462 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
3463 if (get_jenv_res == JNI_EDETACHED) {
3464 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
3466 DO_ASSERT(get_jenv_res == JNI_OK);
3468 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
3470 int64_tArray ret = (*env)->CallObjectMethod(env, obj, j_calls->release_pending_monitor_events_meth);
3471 if ((*env)->ExceptionCheck(env)) {
3472 (*env)->ExceptionDescribe(env);
3473 (*env)->FatalError(env, "A call to release_pending_monitor_events in LDKWatch from rust threw an exception.");
3475 LDKCVec_MonitorEventZ ret_constr;
3476 ret_constr.datalen = (*env)->GetArrayLength(env, ret);
3477 if (ret_constr.datalen > 0)
3478 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKMonitorEvent), "LDKCVec_MonitorEventZ Elements");
3480 ret_constr.data = NULL;
3481 int64_t* ret_vals = (*env)->GetLongArrayElements (env, ret, NULL);
3482 for (size_t o = 0; o < ret_constr.datalen; o++) {
3483 int64_t ret_conv_14 = ret_vals[o];
3484 LDKMonitorEvent ret_conv_14_conv = *(LDKMonitorEvent*)(((uint64_t)ret_conv_14) & ~1);
3485 ret_conv_14_conv = MonitorEvent_clone((LDKMonitorEvent*)(((uint64_t)ret_conv_14) & ~1));
3486 ret_constr.data[o] = ret_conv_14_conv;
3488 (*env)->ReleaseLongArrayElements(env, ret, ret_vals, 0);
3489 if (get_jenv_res == JNI_EDETACHED) {
3490 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
3494 static void* LDKWatch_JCalls_clone(const void* this_arg) {
3495 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
3496 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
3497 return (void*) this_arg;
3499 static inline LDKWatch LDKWatch_init (JNIEnv *env, jclass clz, jobject o) {
3500 jclass c = (*env)->GetObjectClass(env, o);
3502 LDKWatch_JCalls *calls = MALLOC(sizeof(LDKWatch_JCalls), "LDKWatch_JCalls");
3503 atomic_init(&calls->refcnt, 1);
3504 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
3505 calls->o = (*env)->NewWeakGlobalRef(env, o);
3506 calls->watch_channel_meth = (*env)->GetMethodID(env, c, "watch_channel", "(JJ)J");
3507 CHECK(calls->watch_channel_meth != NULL);
3508 calls->update_channel_meth = (*env)->GetMethodID(env, c, "update_channel", "(JJ)J");
3509 CHECK(calls->update_channel_meth != NULL);
3510 calls->release_pending_monitor_events_meth = (*env)->GetMethodID(env, c, "release_pending_monitor_events", "()[J");
3511 CHECK(calls->release_pending_monitor_events_meth != NULL);
3514 .this_arg = (void*) calls,
3515 .watch_channel = watch_channel_LDKWatch_jcall,
3516 .update_channel = update_channel_LDKWatch_jcall,
3517 .release_pending_monitor_events = release_pending_monitor_events_LDKWatch_jcall,
3518 .free = LDKWatch_JCalls_free,
3522 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKWatch_1new(JNIEnv *env, jclass clz, jobject o) {
3523 LDKWatch *res_ptr = MALLOC(sizeof(LDKWatch), "LDKWatch");
3524 *res_ptr = LDKWatch_init(env, clz, o);
3525 return (uint64_t)res_ptr;
3527 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Watch_1watch_1channel(JNIEnv *env, jclass clz, int64_t this_arg, int64_t funding_txo, int64_t monitor) {
3528 LDKWatch* this_arg_conv = (LDKWatch*)(((uint64_t)this_arg) & ~1);
3529 LDKOutPoint funding_txo_conv;
3530 funding_txo_conv.inner = (void*)(funding_txo & (~1));
3531 funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
3532 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
3533 LDKChannelMonitor monitor_conv;
3534 monitor_conv.inner = (void*)(monitor & (~1));
3535 monitor_conv.is_owned = (monitor & 1) || (monitor == 0);
3536 monitor_conv = ChannelMonitor_clone(&monitor_conv);
3537 LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
3538 *ret_conv = (this_arg_conv->watch_channel)(this_arg_conv->this_arg, funding_txo_conv, monitor_conv);
3539 return (uint64_t)ret_conv;
3542 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Watch_1update_1channel(JNIEnv *env, jclass clz, int64_t this_arg, int64_t funding_txo, int64_t update) {
3543 LDKWatch* this_arg_conv = (LDKWatch*)(((uint64_t)this_arg) & ~1);
3544 LDKOutPoint funding_txo_conv;
3545 funding_txo_conv.inner = (void*)(funding_txo & (~1));
3546 funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
3547 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
3548 LDKChannelMonitorUpdate update_conv;
3549 update_conv.inner = (void*)(update & (~1));
3550 update_conv.is_owned = (update & 1) || (update == 0);
3551 update_conv = ChannelMonitorUpdate_clone(&update_conv);
3552 LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
3553 *ret_conv = (this_arg_conv->update_channel)(this_arg_conv->this_arg, funding_txo_conv, update_conv);
3554 return (uint64_t)ret_conv;
3557 JNIEXPORT int64_tArray JNICALL Java_org_ldk_impl_bindings_Watch_1release_1pending_1monitor_1events(JNIEnv *env, jclass clz, int64_t this_arg) {
3558 LDKWatch* this_arg_conv = (LDKWatch*)(((uint64_t)this_arg) & ~1);
3559 LDKCVec_MonitorEventZ ret_var = (this_arg_conv->release_pending_monitor_events)(this_arg_conv->this_arg);
3560 int64_tArray ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
3561 int64_t *ret_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, ret_arr, NULL);
3562 for (size_t o = 0; o < ret_var.datalen; o++) {
3563 LDKMonitorEvent *ret_conv_14_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
3564 *ret_conv_14_copy = MonitorEvent_clone(&ret_var.data[o]);
3565 uint64_t ret_conv_14_ref = (uint64_t)ret_conv_14_copy;
3566 ret_arr_ptr[o] = ret_conv_14_ref;
3568 (*env)->ReleasePrimitiveArrayCritical(env, ret_arr, ret_arr_ptr, 0);
3573 typedef struct LDKBroadcasterInterface_JCalls {
3574 atomic_size_t refcnt;
3577 jmethodID broadcast_transaction_meth;
3578 } LDKBroadcasterInterface_JCalls;
3579 static void LDKBroadcasterInterface_JCalls_free(void* this_arg) {
3580 LDKBroadcasterInterface_JCalls *j_calls = (LDKBroadcasterInterface_JCalls*) this_arg;
3581 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
3583 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
3584 if (get_jenv_res == JNI_EDETACHED) {
3585 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
3587 DO_ASSERT(get_jenv_res == JNI_OK);
3589 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
3590 if (get_jenv_res == JNI_EDETACHED) {
3591 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
3596 void broadcast_transaction_LDKBroadcasterInterface_jcall(const void* this_arg, LDKTransaction tx) {
3597 LDKBroadcasterInterface_JCalls *j_calls = (LDKBroadcasterInterface_JCalls*) this_arg;
3599 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
3600 if (get_jenv_res == JNI_EDETACHED) {
3601 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
3603 DO_ASSERT(get_jenv_res == JNI_OK);
3605 LDKTransaction tx_var = tx;
3606 int8_tArray tx_arr = (*env)->NewByteArray(env, tx_var.datalen);
3607 (*env)->SetByteArrayRegion(env, tx_arr, 0, tx_var.datalen, tx_var.data);
3608 Transaction_free(tx_var);
3609 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
3611 (*env)->CallVoidMethod(env, obj, j_calls->broadcast_transaction_meth, tx_arr);
3612 if ((*env)->ExceptionCheck(env)) {
3613 (*env)->ExceptionDescribe(env);
3614 (*env)->FatalError(env, "A call to broadcast_transaction in LDKBroadcasterInterface from rust threw an exception.");
3616 if (get_jenv_res == JNI_EDETACHED) {
3617 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
3620 static void* LDKBroadcasterInterface_JCalls_clone(const void* this_arg) {
3621 LDKBroadcasterInterface_JCalls *j_calls = (LDKBroadcasterInterface_JCalls*) this_arg;
3622 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
3623 return (void*) this_arg;
3625 static inline LDKBroadcasterInterface LDKBroadcasterInterface_init (JNIEnv *env, jclass clz, jobject o) {
3626 jclass c = (*env)->GetObjectClass(env, o);
3628 LDKBroadcasterInterface_JCalls *calls = MALLOC(sizeof(LDKBroadcasterInterface_JCalls), "LDKBroadcasterInterface_JCalls");
3629 atomic_init(&calls->refcnt, 1);
3630 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
3631 calls->o = (*env)->NewWeakGlobalRef(env, o);
3632 calls->broadcast_transaction_meth = (*env)->GetMethodID(env, c, "broadcast_transaction", "([B)V");
3633 CHECK(calls->broadcast_transaction_meth != NULL);
3635 LDKBroadcasterInterface ret = {
3636 .this_arg = (void*) calls,
3637 .broadcast_transaction = broadcast_transaction_LDKBroadcasterInterface_jcall,
3638 .free = LDKBroadcasterInterface_JCalls_free,
3642 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKBroadcasterInterface_1new(JNIEnv *env, jclass clz, jobject o) {
3643 LDKBroadcasterInterface *res_ptr = MALLOC(sizeof(LDKBroadcasterInterface), "LDKBroadcasterInterface");
3644 *res_ptr = LDKBroadcasterInterface_init(env, clz, o);
3645 return (uint64_t)res_ptr;
3647 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_BroadcasterInterface_1broadcast_1transaction(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray tx) {
3648 LDKBroadcasterInterface* this_arg_conv = (LDKBroadcasterInterface*)(((uint64_t)this_arg) & ~1);
3649 LDKTransaction tx_ref;
3650 tx_ref.datalen = (*env)->GetArrayLength(env, tx);
3651 tx_ref.data = MALLOC(tx_ref.datalen, "LDKTransaction Bytes");
3652 (*env)->GetByteArrayRegion(env, tx, 0, tx_ref.datalen, tx_ref.data);
3653 tx_ref.data_is_owned = true;
3654 (this_arg_conv->broadcast_transaction)(this_arg_conv->this_arg, tx_ref);
3657 typedef struct LDKKeysInterface_JCalls {
3658 atomic_size_t refcnt;
3661 jmethodID get_node_secret_meth;
3662 jmethodID get_destination_script_meth;
3663 jmethodID get_shutdown_pubkey_meth;
3664 jmethodID get_channel_signer_meth;
3665 jmethodID get_secure_random_bytes_meth;
3666 jmethodID read_chan_signer_meth;
3667 jmethodID sign_invoice_meth;
3668 } LDKKeysInterface_JCalls;
3669 static void LDKKeysInterface_JCalls_free(void* this_arg) {
3670 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
3671 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
3673 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
3674 if (get_jenv_res == JNI_EDETACHED) {
3675 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
3677 DO_ASSERT(get_jenv_res == JNI_OK);
3679 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
3680 if (get_jenv_res == JNI_EDETACHED) {
3681 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
3686 LDKSecretKey get_node_secret_LDKKeysInterface_jcall(const void* this_arg) {
3687 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
3689 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
3690 if (get_jenv_res == JNI_EDETACHED) {
3691 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
3693 DO_ASSERT(get_jenv_res == JNI_OK);
3695 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
3697 int8_tArray ret = (*env)->CallObjectMethod(env, obj, j_calls->get_node_secret_meth);
3698 if ((*env)->ExceptionCheck(env)) {
3699 (*env)->ExceptionDescribe(env);
3700 (*env)->FatalError(env, "A call to get_node_secret in LDKKeysInterface from rust threw an exception.");
3702 LDKSecretKey ret_ref;
3703 CHECK((*env)->GetArrayLength(env, ret) == 32);
3704 (*env)->GetByteArrayRegion(env, ret, 0, 32, ret_ref.bytes);
3705 if (get_jenv_res == JNI_EDETACHED) {
3706 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
3710 LDKCVec_u8Z get_destination_script_LDKKeysInterface_jcall(const void* this_arg) {
3711 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
3713 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
3714 if (get_jenv_res == JNI_EDETACHED) {
3715 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
3717 DO_ASSERT(get_jenv_res == JNI_OK);
3719 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
3721 int8_tArray ret = (*env)->CallObjectMethod(env, obj, j_calls->get_destination_script_meth);
3722 if ((*env)->ExceptionCheck(env)) {
3723 (*env)->ExceptionDescribe(env);
3724 (*env)->FatalError(env, "A call to get_destination_script in LDKKeysInterface from rust threw an exception.");
3726 LDKCVec_u8Z ret_ref;
3727 ret_ref.datalen = (*env)->GetArrayLength(env, ret);
3728 ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
3729 (*env)->GetByteArrayRegion(env, ret, 0, ret_ref.datalen, ret_ref.data);
3730 if (get_jenv_res == JNI_EDETACHED) {
3731 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
3735 LDKPublicKey get_shutdown_pubkey_LDKKeysInterface_jcall(const void* this_arg) {
3736 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
3738 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
3739 if (get_jenv_res == JNI_EDETACHED) {
3740 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
3742 DO_ASSERT(get_jenv_res == JNI_OK);
3744 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
3746 int8_tArray ret = (*env)->CallObjectMethod(env, obj, j_calls->get_shutdown_pubkey_meth);
3747 if ((*env)->ExceptionCheck(env)) {
3748 (*env)->ExceptionDescribe(env);
3749 (*env)->FatalError(env, "A call to get_shutdown_pubkey in LDKKeysInterface from rust threw an exception.");
3751 LDKPublicKey ret_ref;
3752 CHECK((*env)->GetArrayLength(env, ret) == 33);
3753 (*env)->GetByteArrayRegion(env, ret, 0, 33, ret_ref.compressed_form);
3754 if (get_jenv_res == JNI_EDETACHED) {
3755 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
3759 LDKSign get_channel_signer_LDKKeysInterface_jcall(const void* this_arg, bool inbound, uint64_t channel_value_satoshis) {
3760 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
3762 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
3763 if (get_jenv_res == JNI_EDETACHED) {
3764 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
3766 DO_ASSERT(get_jenv_res == JNI_OK);
3768 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
3770 LDKSign* ret = (LDKSign*)(*env)->CallLongMethod(env, obj, j_calls->get_channel_signer_meth, inbound, channel_value_satoshis);
3771 if ((*env)->ExceptionCheck(env)) {
3772 (*env)->ExceptionDescribe(env);
3773 (*env)->FatalError(env, "A call to get_channel_signer in LDKKeysInterface from rust threw an exception.");
3775 LDKSign ret_conv = *(LDKSign*)(((uint64_t)ret) & ~1);
3776 ret_conv = Sign_clone(ret);
3777 if (get_jenv_res == JNI_EDETACHED) {
3778 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
3782 LDKThirtyTwoBytes get_secure_random_bytes_LDKKeysInterface_jcall(const void* this_arg) {
3783 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
3785 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
3786 if (get_jenv_res == JNI_EDETACHED) {
3787 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
3789 DO_ASSERT(get_jenv_res == JNI_OK);
3791 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
3793 int8_tArray ret = (*env)->CallObjectMethod(env, obj, j_calls->get_secure_random_bytes_meth);
3794 if ((*env)->ExceptionCheck(env)) {
3795 (*env)->ExceptionDescribe(env);
3796 (*env)->FatalError(env, "A call to get_secure_random_bytes in LDKKeysInterface from rust threw an exception.");
3798 LDKThirtyTwoBytes ret_ref;
3799 CHECK((*env)->GetArrayLength(env, ret) == 32);
3800 (*env)->GetByteArrayRegion(env, ret, 0, 32, ret_ref.data);
3801 if (get_jenv_res == JNI_EDETACHED) {
3802 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
3806 LDKCResult_SignDecodeErrorZ read_chan_signer_LDKKeysInterface_jcall(const void* this_arg, LDKu8slice reader) {
3807 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
3809 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
3810 if (get_jenv_res == JNI_EDETACHED) {
3811 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
3813 DO_ASSERT(get_jenv_res == JNI_OK);
3815 LDKu8slice reader_var = reader;
3816 int8_tArray reader_arr = (*env)->NewByteArray(env, reader_var.datalen);
3817 (*env)->SetByteArrayRegion(env, reader_arr, 0, reader_var.datalen, reader_var.data);
3818 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
3820 LDKCResult_SignDecodeErrorZ* ret = (LDKCResult_SignDecodeErrorZ*)(*env)->CallLongMethod(env, obj, j_calls->read_chan_signer_meth, reader_arr);
3821 if ((*env)->ExceptionCheck(env)) {
3822 (*env)->ExceptionDescribe(env);
3823 (*env)->FatalError(env, "A call to read_chan_signer in LDKKeysInterface from rust threw an exception.");
3825 LDKCResult_SignDecodeErrorZ ret_conv = *(LDKCResult_SignDecodeErrorZ*)(((uint64_t)ret) & ~1);
3826 ret_conv = CResult_SignDecodeErrorZ_clone((LDKCResult_SignDecodeErrorZ*)(((uint64_t)ret) & ~1));
3827 if (get_jenv_res == JNI_EDETACHED) {
3828 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
3832 LDKCResult_RecoverableSignatureNoneZ sign_invoice_LDKKeysInterface_jcall(const void* this_arg, LDKCVec_u8Z invoice_preimage) {
3833 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
3835 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
3836 if (get_jenv_res == JNI_EDETACHED) {
3837 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
3839 DO_ASSERT(get_jenv_res == JNI_OK);
3841 LDKCVec_u8Z invoice_preimage_var = invoice_preimage;
3842 int8_tArray invoice_preimage_arr = (*env)->NewByteArray(env, invoice_preimage_var.datalen);
3843 (*env)->SetByteArrayRegion(env, invoice_preimage_arr, 0, invoice_preimage_var.datalen, invoice_preimage_var.data);
3844 CVec_u8Z_free(invoice_preimage_var);
3845 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
3847 LDKCResult_RecoverableSignatureNoneZ* ret = (LDKCResult_RecoverableSignatureNoneZ*)(*env)->CallLongMethod(env, obj, j_calls->sign_invoice_meth, invoice_preimage_arr);
3848 if ((*env)->ExceptionCheck(env)) {
3849 (*env)->ExceptionDescribe(env);
3850 (*env)->FatalError(env, "A call to sign_invoice in LDKKeysInterface from rust threw an exception.");
3852 LDKCResult_RecoverableSignatureNoneZ ret_conv = *(LDKCResult_RecoverableSignatureNoneZ*)(((uint64_t)ret) & ~1);
3853 ret_conv = CResult_RecoverableSignatureNoneZ_clone((LDKCResult_RecoverableSignatureNoneZ*)(((uint64_t)ret) & ~1));
3854 if (get_jenv_res == JNI_EDETACHED) {
3855 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
3859 static void* LDKKeysInterface_JCalls_clone(const void* this_arg) {
3860 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
3861 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
3862 return (void*) this_arg;
3864 static inline LDKKeysInterface LDKKeysInterface_init (JNIEnv *env, jclass clz, jobject o) {
3865 jclass c = (*env)->GetObjectClass(env, o);
3867 LDKKeysInterface_JCalls *calls = MALLOC(sizeof(LDKKeysInterface_JCalls), "LDKKeysInterface_JCalls");
3868 atomic_init(&calls->refcnt, 1);
3869 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
3870 calls->o = (*env)->NewWeakGlobalRef(env, o);
3871 calls->get_node_secret_meth = (*env)->GetMethodID(env, c, "get_node_secret", "()[B");
3872 CHECK(calls->get_node_secret_meth != NULL);
3873 calls->get_destination_script_meth = (*env)->GetMethodID(env, c, "get_destination_script", "()[B");
3874 CHECK(calls->get_destination_script_meth != NULL);
3875 calls->get_shutdown_pubkey_meth = (*env)->GetMethodID(env, c, "get_shutdown_pubkey", "()[B");
3876 CHECK(calls->get_shutdown_pubkey_meth != NULL);
3877 calls->get_channel_signer_meth = (*env)->GetMethodID(env, c, "get_channel_signer", "(ZJ)J");
3878 CHECK(calls->get_channel_signer_meth != NULL);
3879 calls->get_secure_random_bytes_meth = (*env)->GetMethodID(env, c, "get_secure_random_bytes", "()[B");
3880 CHECK(calls->get_secure_random_bytes_meth != NULL);
3881 calls->read_chan_signer_meth = (*env)->GetMethodID(env, c, "read_chan_signer", "([B)J");
3882 CHECK(calls->read_chan_signer_meth != NULL);
3883 calls->sign_invoice_meth = (*env)->GetMethodID(env, c, "sign_invoice", "([B)J");
3884 CHECK(calls->sign_invoice_meth != NULL);
3886 LDKKeysInterface ret = {
3887 .this_arg = (void*) calls,
3888 .get_node_secret = get_node_secret_LDKKeysInterface_jcall,
3889 .get_destination_script = get_destination_script_LDKKeysInterface_jcall,
3890 .get_shutdown_pubkey = get_shutdown_pubkey_LDKKeysInterface_jcall,
3891 .get_channel_signer = get_channel_signer_LDKKeysInterface_jcall,
3892 .get_secure_random_bytes = get_secure_random_bytes_LDKKeysInterface_jcall,
3893 .read_chan_signer = read_chan_signer_LDKKeysInterface_jcall,
3894 .sign_invoice = sign_invoice_LDKKeysInterface_jcall,
3895 .free = LDKKeysInterface_JCalls_free,
3899 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKKeysInterface_1new(JNIEnv *env, jclass clz, jobject o) {
3900 LDKKeysInterface *res_ptr = MALLOC(sizeof(LDKKeysInterface), "LDKKeysInterface");
3901 *res_ptr = LDKKeysInterface_init(env, clz, o);
3902 return (uint64_t)res_ptr;
3904 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_KeysInterface_1get_1node_1secret(JNIEnv *env, jclass clz, int64_t this_arg) {
3905 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)(((uint64_t)this_arg) & ~1);
3906 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
3907 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, (this_arg_conv->get_node_secret)(this_arg_conv->this_arg).bytes);
3911 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_KeysInterface_1get_1destination_1script(JNIEnv *env, jclass clz, int64_t this_arg) {
3912 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)(((uint64_t)this_arg) & ~1);
3913 LDKCVec_u8Z ret_var = (this_arg_conv->get_destination_script)(this_arg_conv->this_arg);
3914 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
3915 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
3916 CVec_u8Z_free(ret_var);
3920 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_KeysInterface_1get_1shutdown_1pubkey(JNIEnv *env, jclass clz, int64_t this_arg) {
3921 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)(((uint64_t)this_arg) & ~1);
3922 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
3923 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, (this_arg_conv->get_shutdown_pubkey)(this_arg_conv->this_arg).compressed_form);
3927 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_KeysInterface_1get_1channel_1signer(JNIEnv *env, jclass clz, int64_t this_arg, jboolean inbound, int64_t channel_value_satoshis) {
3928 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)(((uint64_t)this_arg) & ~1);
3929 LDKSign* ret = MALLOC(sizeof(LDKSign), "LDKSign");
3930 *ret = (this_arg_conv->get_channel_signer)(this_arg_conv->this_arg, inbound, channel_value_satoshis);
3931 return (uint64_t)ret;
3934 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_KeysInterface_1get_1secure_1random_1bytes(JNIEnv *env, jclass clz, int64_t this_arg) {
3935 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)(((uint64_t)this_arg) & ~1);
3936 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
3937 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, (this_arg_conv->get_secure_random_bytes)(this_arg_conv->this_arg).data);
3941 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_KeysInterface_1read_1chan_1signer(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray reader) {
3942 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)(((uint64_t)this_arg) & ~1);
3943 LDKu8slice reader_ref;
3944 reader_ref.datalen = (*env)->GetArrayLength(env, reader);
3945 reader_ref.data = (*env)->GetByteArrayElements (env, reader, NULL);
3946 LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
3947 *ret_conv = (this_arg_conv->read_chan_signer)(this_arg_conv->this_arg, reader_ref);
3948 (*env)->ReleaseByteArrayElements(env, reader, (int8_t*)reader_ref.data, 0);
3949 return (uint64_t)ret_conv;
3952 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_KeysInterface_1sign_1invoice(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray invoice_preimage) {
3953 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)(((uint64_t)this_arg) & ~1);
3954 LDKCVec_u8Z invoice_preimage_ref;
3955 invoice_preimage_ref.datalen = (*env)->GetArrayLength(env, invoice_preimage);
3956 invoice_preimage_ref.data = MALLOC(invoice_preimage_ref.datalen, "LDKCVec_u8Z Bytes");
3957 (*env)->GetByteArrayRegion(env, invoice_preimage, 0, invoice_preimage_ref.datalen, invoice_preimage_ref.data);
3958 LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
3959 *ret_conv = (this_arg_conv->sign_invoice)(this_arg_conv->this_arg, invoice_preimage_ref);
3960 return (uint64_t)ret_conv;
3963 typedef struct LDKFeeEstimator_JCalls {
3964 atomic_size_t refcnt;
3967 jmethodID get_est_sat_per_1000_weight_meth;
3968 } LDKFeeEstimator_JCalls;
3969 static void LDKFeeEstimator_JCalls_free(void* this_arg) {
3970 LDKFeeEstimator_JCalls *j_calls = (LDKFeeEstimator_JCalls*) this_arg;
3971 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
3973 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
3974 if (get_jenv_res == JNI_EDETACHED) {
3975 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
3977 DO_ASSERT(get_jenv_res == JNI_OK);
3979 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
3980 if (get_jenv_res == JNI_EDETACHED) {
3981 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
3986 uint32_t get_est_sat_per_1000_weight_LDKFeeEstimator_jcall(const void* this_arg, LDKConfirmationTarget confirmation_target) {
3987 LDKFeeEstimator_JCalls *j_calls = (LDKFeeEstimator_JCalls*) this_arg;
3989 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
3990 if (get_jenv_res == JNI_EDETACHED) {
3991 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
3993 DO_ASSERT(get_jenv_res == JNI_OK);
3995 jclass confirmation_target_conv = LDKConfirmationTarget_to_java(env, confirmation_target);
3996 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
3998 int32_t ret = (*env)->CallIntMethod(env, obj, j_calls->get_est_sat_per_1000_weight_meth, confirmation_target_conv);
3999 if ((*env)->ExceptionCheck(env)) {
4000 (*env)->ExceptionDescribe(env);
4001 (*env)->FatalError(env, "A call to get_est_sat_per_1000_weight in LDKFeeEstimator from rust threw an exception.");
4003 if (get_jenv_res == JNI_EDETACHED) {
4004 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
4008 static void* LDKFeeEstimator_JCalls_clone(const void* this_arg) {
4009 LDKFeeEstimator_JCalls *j_calls = (LDKFeeEstimator_JCalls*) this_arg;
4010 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
4011 return (void*) this_arg;
4013 static inline LDKFeeEstimator LDKFeeEstimator_init (JNIEnv *env, jclass clz, jobject o) {
4014 jclass c = (*env)->GetObjectClass(env, o);
4016 LDKFeeEstimator_JCalls *calls = MALLOC(sizeof(LDKFeeEstimator_JCalls), "LDKFeeEstimator_JCalls");
4017 atomic_init(&calls->refcnt, 1);
4018 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
4019 calls->o = (*env)->NewWeakGlobalRef(env, o);
4020 calls->get_est_sat_per_1000_weight_meth = (*env)->GetMethodID(env, c, "get_est_sat_per_1000_weight", "(Lorg/ldk/enums/ConfirmationTarget;)I");
4021 CHECK(calls->get_est_sat_per_1000_weight_meth != NULL);
4023 LDKFeeEstimator ret = {
4024 .this_arg = (void*) calls,
4025 .get_est_sat_per_1000_weight = get_est_sat_per_1000_weight_LDKFeeEstimator_jcall,
4026 .free = LDKFeeEstimator_JCalls_free,
4030 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKFeeEstimator_1new(JNIEnv *env, jclass clz, jobject o) {
4031 LDKFeeEstimator *res_ptr = MALLOC(sizeof(LDKFeeEstimator), "LDKFeeEstimator");
4032 *res_ptr = LDKFeeEstimator_init(env, clz, o);
4033 return (uint64_t)res_ptr;
4035 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_FeeEstimator_1get_1est_1sat_1per_11000_1weight(JNIEnv *env, jclass clz, int64_t this_arg, jclass confirmation_target) {
4036 LDKFeeEstimator* this_arg_conv = (LDKFeeEstimator*)(((uint64_t)this_arg) & ~1);
4037 LDKConfirmationTarget confirmation_target_conv = LDKConfirmationTarget_from_java(env, confirmation_target);
4038 int32_t ret_val = (this_arg_conv->get_est_sat_per_1000_weight)(this_arg_conv->this_arg, confirmation_target_conv);
4042 typedef struct LDKLogger_JCalls {
4043 atomic_size_t refcnt;
4048 static void LDKLogger_JCalls_free(void* this_arg) {
4049 LDKLogger_JCalls *j_calls = (LDKLogger_JCalls*) this_arg;
4050 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
4052 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
4053 if (get_jenv_res == JNI_EDETACHED) {
4054 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
4056 DO_ASSERT(get_jenv_res == JNI_OK);
4058 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
4059 if (get_jenv_res == JNI_EDETACHED) {
4060 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
4065 void log_LDKLogger_jcall(const void* this_arg, const char* record) {
4066 LDKLogger_JCalls *j_calls = (LDKLogger_JCalls*) this_arg;
4068 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
4069 if (get_jenv_res == JNI_EDETACHED) {
4070 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
4072 DO_ASSERT(get_jenv_res == JNI_OK);
4074 const char* record_str = record;
4075 jstring record_conv = str_ref_to_java(env, record_str, strlen(record_str));
4076 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
4078 (*env)->CallVoidMethod(env, obj, j_calls->log_meth, record_conv);
4079 if ((*env)->ExceptionCheck(env)) {
4080 (*env)->ExceptionDescribe(env);
4081 (*env)->FatalError(env, "A call to log in LDKLogger from rust threw an exception.");
4083 if (get_jenv_res == JNI_EDETACHED) {
4084 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
4087 static void* LDKLogger_JCalls_clone(const void* this_arg) {
4088 LDKLogger_JCalls *j_calls = (LDKLogger_JCalls*) this_arg;
4089 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
4090 return (void*) this_arg;
4092 static inline LDKLogger LDKLogger_init (JNIEnv *env, jclass clz, jobject o) {
4093 jclass c = (*env)->GetObjectClass(env, o);
4095 LDKLogger_JCalls *calls = MALLOC(sizeof(LDKLogger_JCalls), "LDKLogger_JCalls");
4096 atomic_init(&calls->refcnt, 1);
4097 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
4098 calls->o = (*env)->NewWeakGlobalRef(env, o);
4099 calls->log_meth = (*env)->GetMethodID(env, c, "log", "(Ljava/lang/String;)V");
4100 CHECK(calls->log_meth != NULL);
4103 .this_arg = (void*) calls,
4104 .log = log_LDKLogger_jcall,
4105 .free = LDKLogger_JCalls_free,
4109 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKLogger_1new(JNIEnv *env, jclass clz, jobject o) {
4110 LDKLogger *res_ptr = MALLOC(sizeof(LDKLogger), "LDKLogger");
4111 *res_ptr = LDKLogger_init(env, clz, o);
4112 return (uint64_t)res_ptr;
4114 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1BlockHashChannelManagerZ_1new(JNIEnv *env, jclass clz, int8_tArray a, int64_t b) {
4115 LDKC2Tuple_BlockHashChannelManagerZ* ret = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelManagerZ), "LDKC2Tuple_BlockHashChannelManagerZ");
4116 LDKThirtyTwoBytes a_ref;
4117 CHECK((*env)->GetArrayLength(env, a) == 32);
4118 (*env)->GetByteArrayRegion(env, a, 0, 32, a_ref.data);
4120 LDKChannelManager b_conv;
4121 b_conv.inner = (void*)(b & (~1));
4122 b_conv.is_owned = (b & 1) || (b == 0);
4123 // Warning: we need a move here but no clone is available for LDKChannelManager
4125 return (uint64_t)ret;
4127 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1BlockHashChannelManagerZ_1get_1a(JNIEnv *env, jclass clz, int64_t ptr) {
4128 LDKC2Tuple_BlockHashChannelManagerZ *tuple = (LDKC2Tuple_BlockHashChannelManagerZ*)(ptr & ~1);
4129 int8_tArray a_arr = (*env)->NewByteArray(env, 32);
4130 (*env)->SetByteArrayRegion(env, a_arr, 0, 32, tuple->a.data);
4133 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1BlockHashChannelManagerZ_1get_1b(JNIEnv *env, jclass clz, int64_t ptr) {
4134 LDKC2Tuple_BlockHashChannelManagerZ *tuple = (LDKC2Tuple_BlockHashChannelManagerZ*)(ptr & ~1);
4135 LDKChannelManager b_var = tuple->b;
4136 CHECK((((uint64_t)b_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4137 CHECK((((uint64_t)&b_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4138 uint64_t b_ref = (uint64_t)b_var.inner & ~1;
4141 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1BlockHashChannelManagerZDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4142 return ((LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)arg)->result_ok;
4144 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1BlockHashChannelManagerZDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4145 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *val = (LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)(arg & ~1);
4146 CHECK(val->result_ok);
4147 uint64_t res_ref = (uint64_t)(&(*val->contents.result)) | 1;
4150 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1BlockHashChannelManagerZDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4151 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *val = (LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)(arg & ~1);
4152 CHECK(!val->result_ok);
4153 LDKDecodeError err_var = (*val->contents.err);
4154 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4155 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4156 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4159 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelConfigDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4160 return ((LDKCResult_ChannelConfigDecodeErrorZ*)arg)->result_ok;
4162 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelConfigDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4163 LDKCResult_ChannelConfigDecodeErrorZ *val = (LDKCResult_ChannelConfigDecodeErrorZ*)(arg & ~1);
4164 CHECK(val->result_ok);
4165 LDKChannelConfig res_var = (*val->contents.result);
4166 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4167 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4168 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4171 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelConfigDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4172 LDKCResult_ChannelConfigDecodeErrorZ *val = (LDKCResult_ChannelConfigDecodeErrorZ*)(arg & ~1);
4173 CHECK(!val->result_ok);
4174 LDKDecodeError err_var = (*val->contents.err);
4175 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4176 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4177 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4180 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1OutPointDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4181 return ((LDKCResult_OutPointDecodeErrorZ*)arg)->result_ok;
4183 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1OutPointDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4184 LDKCResult_OutPointDecodeErrorZ *val = (LDKCResult_OutPointDecodeErrorZ*)(arg & ~1);
4185 CHECK(val->result_ok);
4186 LDKOutPoint res_var = (*val->contents.result);
4187 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4188 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4189 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4192 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1OutPointDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4193 LDKCResult_OutPointDecodeErrorZ *val = (LDKCResult_OutPointDecodeErrorZ*)(arg & ~1);
4194 CHECK(!val->result_ok);
4195 LDKDecodeError err_var = (*val->contents.err);
4196 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4197 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4198 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4201 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SiPrefixNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4202 return ((LDKCResult_SiPrefixNoneZ*)arg)->result_ok;
4204 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SiPrefixNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4205 LDKCResult_SiPrefixNoneZ *val = (LDKCResult_SiPrefixNoneZ*)(arg & ~1);
4206 CHECK(val->result_ok);
4207 jclass res_conv = LDKSiPrefix_to_java(env, (*val->contents.result));
4210 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SiPrefixNoneZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4211 LDKCResult_SiPrefixNoneZ *val = (LDKCResult_SiPrefixNoneZ*)(arg & ~1);
4212 CHECK(!val->result_ok);
4213 return *val->contents.err;
4215 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4216 return ((LDKCResult_InvoiceNoneZ*)arg)->result_ok;
4218 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4219 LDKCResult_InvoiceNoneZ *val = (LDKCResult_InvoiceNoneZ*)(arg & ~1);
4220 CHECK(val->result_ok);
4221 LDKInvoice res_var = (*val->contents.result);
4222 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4223 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4224 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4227 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceNoneZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4228 LDKCResult_InvoiceNoneZ *val = (LDKCResult_InvoiceNoneZ*)(arg & ~1);
4229 CHECK(!val->result_ok);
4230 return *val->contents.err;
4232 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SignedRawInvoiceNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4233 return ((LDKCResult_SignedRawInvoiceNoneZ*)arg)->result_ok;
4235 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SignedRawInvoiceNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4236 LDKCResult_SignedRawInvoiceNoneZ *val = (LDKCResult_SignedRawInvoiceNoneZ*)(arg & ~1);
4237 CHECK(val->result_ok);
4238 LDKSignedRawInvoice res_var = (*val->contents.result);
4239 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4240 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4241 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4244 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SignedRawInvoiceNoneZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4245 LDKCResult_SignedRawInvoiceNoneZ *val = (LDKCResult_SignedRawInvoiceNoneZ*)(arg & ~1);
4246 CHECK(!val->result_ok);
4247 return *val->contents.err;
4249 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC3Tuple_1RawInvoice_1u832InvoiceSignatureZ_1new(JNIEnv *env, jclass clz, int64_t a, int8_tArray b, int64_t c) {
4250 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
4251 LDKRawInvoice a_conv;
4252 a_conv.inner = (void*)(a & (~1));
4253 a_conv.is_owned = (a & 1) || (a == 0);
4254 a_conv = RawInvoice_clone(&a_conv);
4256 LDKThirtyTwoBytes b_ref;
4257 CHECK((*env)->GetArrayLength(env, b) == 32);
4258 (*env)->GetByteArrayRegion(env, b, 0, 32, b_ref.data);
4260 LDKInvoiceSignature c_conv;
4261 c_conv.inner = (void*)(c & (~1));
4262 c_conv.is_owned = (c & 1) || (c == 0);
4263 c_conv = InvoiceSignature_clone(&c_conv);
4265 return (uint64_t)ret;
4267 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC3Tuple_1RawInvoice_1u832InvoiceSignatureZ_1get_1a(JNIEnv *env, jclass clz, int64_t ptr) {
4268 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *tuple = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(ptr & ~1);
4269 LDKRawInvoice a_var = tuple->a;
4270 CHECK((((uint64_t)a_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4271 CHECK((((uint64_t)&a_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4272 uint64_t a_ref = (uint64_t)a_var.inner & ~1;
4275 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKC3Tuple_1RawInvoice_1u832InvoiceSignatureZ_1get_1b(JNIEnv *env, jclass clz, int64_t ptr) {
4276 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *tuple = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(ptr & ~1);
4277 int8_tArray b_arr = (*env)->NewByteArray(env, 32);
4278 (*env)->SetByteArrayRegion(env, b_arr, 0, 32, tuple->b.data);
4281 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC3Tuple_1RawInvoice_1u832InvoiceSignatureZ_1get_1c(JNIEnv *env, jclass clz, int64_t ptr) {
4282 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *tuple = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(ptr & ~1);
4283 LDKInvoiceSignature c_var = tuple->c;
4284 CHECK((((uint64_t)c_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4285 CHECK((((uint64_t)&c_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4286 uint64_t c_ref = (uint64_t)c_var.inner & ~1;
4289 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PayeePubKeyErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4290 return ((LDKCResult_PayeePubKeyErrorZ*)arg)->result_ok;
4292 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PayeePubKeyErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4293 LDKCResult_PayeePubKeyErrorZ *val = (LDKCResult_PayeePubKeyErrorZ*)(arg & ~1);
4294 CHECK(val->result_ok);
4295 LDKPayeePubKey res_var = (*val->contents.result);
4296 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4297 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4298 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4301 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PayeePubKeyErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4302 LDKCResult_PayeePubKeyErrorZ *val = (LDKCResult_PayeePubKeyErrorZ*)(arg & ~1);
4303 CHECK(!val->result_ok);
4304 jclass err_conv = LDKSecp256k1Error_to_java(env, (*val->contents.err));
4307 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1PrivateRouteZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
4308 LDKCVec_PrivateRouteZ *ret = MALLOC(sizeof(LDKCVec_PrivateRouteZ), "LDKCVec_PrivateRouteZ");
4309 ret->datalen = (*env)->GetArrayLength(env, elems);
4310 if (ret->datalen == 0) {
4313 ret->data = MALLOC(sizeof(LDKPrivateRoute) * ret->datalen, "LDKCVec_PrivateRouteZ Data");
4314 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
4315 for (size_t i = 0; i < ret->datalen; i++) {
4316 int64_t arr_elem = java_elems[i];
4317 LDKPrivateRoute arr_elem_conv;
4318 arr_elem_conv.inner = (void*)(arr_elem & (~1));
4319 arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
4320 arr_elem_conv = PrivateRoute_clone(&arr_elem_conv);
4321 ret->data[i] = arr_elem_conv;
4323 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
4325 return (uint64_t)ret;
4327 static inline LDKCVec_PrivateRouteZ CVec_PrivateRouteZ_clone(const LDKCVec_PrivateRouteZ *orig) {
4328 LDKCVec_PrivateRouteZ ret = { .data = MALLOC(sizeof(LDKPrivateRoute) * orig->datalen, "LDKCVec_PrivateRouteZ clone bytes"), .datalen = orig->datalen };
4329 for (size_t i = 0; i < ret.datalen; i++) {
4330 ret.data[i] = PrivateRoute_clone(&orig->data[i]);
4334 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PositiveTimestampCreationErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4335 return ((LDKCResult_PositiveTimestampCreationErrorZ*)arg)->result_ok;
4337 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PositiveTimestampCreationErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4338 LDKCResult_PositiveTimestampCreationErrorZ *val = (LDKCResult_PositiveTimestampCreationErrorZ*)(arg & ~1);
4339 CHECK(val->result_ok);
4340 LDKPositiveTimestamp res_var = (*val->contents.result);
4341 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4342 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4343 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4346 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PositiveTimestampCreationErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4347 LDKCResult_PositiveTimestampCreationErrorZ *val = (LDKCResult_PositiveTimestampCreationErrorZ*)(arg & ~1);
4348 CHECK(!val->result_ok);
4349 jclass err_conv = LDKCreationError_to_java(env, (*val->contents.err));
4352 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneSemanticErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4353 return ((LDKCResult_NoneSemanticErrorZ*)arg)->result_ok;
4355 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneSemanticErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4356 LDKCResult_NoneSemanticErrorZ *val = (LDKCResult_NoneSemanticErrorZ*)(arg & ~1);
4357 CHECK(val->result_ok);
4358 return *val->contents.result;
4360 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneSemanticErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4361 LDKCResult_NoneSemanticErrorZ *val = (LDKCResult_NoneSemanticErrorZ*)(arg & ~1);
4362 CHECK(!val->result_ok);
4363 jclass err_conv = LDKSemanticError_to_java(env, (*val->contents.err));
4366 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceSemanticErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4367 return ((LDKCResult_InvoiceSemanticErrorZ*)arg)->result_ok;
4369 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceSemanticErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4370 LDKCResult_InvoiceSemanticErrorZ *val = (LDKCResult_InvoiceSemanticErrorZ*)(arg & ~1);
4371 CHECK(val->result_ok);
4372 LDKInvoice res_var = (*val->contents.result);
4373 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4374 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4375 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4378 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceSemanticErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4379 LDKCResult_InvoiceSemanticErrorZ *val = (LDKCResult_InvoiceSemanticErrorZ*)(arg & ~1);
4380 CHECK(!val->result_ok);
4381 jclass err_conv = LDKSemanticError_to_java(env, (*val->contents.err));
4384 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1DescriptionCreationErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4385 return ((LDKCResult_DescriptionCreationErrorZ*)arg)->result_ok;
4387 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1DescriptionCreationErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4388 LDKCResult_DescriptionCreationErrorZ *val = (LDKCResult_DescriptionCreationErrorZ*)(arg & ~1);
4389 CHECK(val->result_ok);
4390 LDKDescription res_var = (*val->contents.result);
4391 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4392 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4393 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4396 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_LDKCResult_1DescriptionCreationErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4397 LDKCResult_DescriptionCreationErrorZ *val = (LDKCResult_DescriptionCreationErrorZ*)(arg & ~1);
4398 CHECK(!val->result_ok);
4399 jclass err_conv = LDKCreationError_to_java(env, (*val->contents.err));
4402 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ExpiryTimeCreationErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4403 return ((LDKCResult_ExpiryTimeCreationErrorZ*)arg)->result_ok;
4405 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ExpiryTimeCreationErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4406 LDKCResult_ExpiryTimeCreationErrorZ *val = (LDKCResult_ExpiryTimeCreationErrorZ*)(arg & ~1);
4407 CHECK(val->result_ok);
4408 LDKExpiryTime res_var = (*val->contents.result);
4409 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4410 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4411 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4414 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ExpiryTimeCreationErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4415 LDKCResult_ExpiryTimeCreationErrorZ *val = (LDKCResult_ExpiryTimeCreationErrorZ*)(arg & ~1);
4416 CHECK(!val->result_ok);
4417 jclass err_conv = LDKCreationError_to_java(env, (*val->contents.err));
4420 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PrivateRouteCreationErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4421 return ((LDKCResult_PrivateRouteCreationErrorZ*)arg)->result_ok;
4423 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PrivateRouteCreationErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4424 LDKCResult_PrivateRouteCreationErrorZ *val = (LDKCResult_PrivateRouteCreationErrorZ*)(arg & ~1);
4425 CHECK(val->result_ok);
4426 LDKPrivateRoute res_var = (*val->contents.result);
4427 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4428 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4429 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4432 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PrivateRouteCreationErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4433 LDKCResult_PrivateRouteCreationErrorZ *val = (LDKCResult_PrivateRouteCreationErrorZ*)(arg & ~1);
4434 CHECK(!val->result_ok);
4435 jclass err_conv = LDKCreationError_to_java(env, (*val->contents.err));
4438 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1StringErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4439 return ((LDKCResult_StringErrorZ*)arg)->result_ok;
4441 JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_LDKCResult_1StringErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4442 LDKCResult_StringErrorZ *val = (LDKCResult_StringErrorZ*)(arg & ~1);
4443 CHECK(val->result_ok);
4444 LDKStr res_str = (*val->contents.result);
4445 jstring res_conv = str_ref_to_java(env, res_str.chars, res_str.len);
4448 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_LDKCResult_1StringErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4449 LDKCResult_StringErrorZ *val = (LDKCResult_StringErrorZ*)(arg & ~1);
4450 CHECK(!val->result_ok);
4451 jclass err_conv = LDKSecp256k1Error_to_java(env, (*val->contents.err));
4454 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelMonitorUpdateDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4455 return ((LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)arg)->result_ok;
4457 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelMonitorUpdateDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4458 LDKCResult_ChannelMonitorUpdateDecodeErrorZ *val = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(arg & ~1);
4459 CHECK(val->result_ok);
4460 LDKChannelMonitorUpdate res_var = (*val->contents.result);
4461 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4462 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4463 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4466 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelMonitorUpdateDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4467 LDKCResult_ChannelMonitorUpdateDecodeErrorZ *val = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(arg & ~1);
4468 CHECK(!val->result_ok);
4469 LDKDecodeError err_var = (*val->contents.err);
4470 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4471 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4472 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4475 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HTLCUpdateDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4476 return ((LDKCResult_HTLCUpdateDecodeErrorZ*)arg)->result_ok;
4478 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HTLCUpdateDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4479 LDKCResult_HTLCUpdateDecodeErrorZ *val = (LDKCResult_HTLCUpdateDecodeErrorZ*)(arg & ~1);
4480 CHECK(val->result_ok);
4481 LDKHTLCUpdate res_var = (*val->contents.result);
4482 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4483 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4484 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4487 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HTLCUpdateDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4488 LDKCResult_HTLCUpdateDecodeErrorZ *val = (LDKCResult_HTLCUpdateDecodeErrorZ*)(arg & ~1);
4489 CHECK(!val->result_ok);
4490 LDKDecodeError err_var = (*val->contents.err);
4491 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4492 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4493 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4496 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneMonitorUpdateErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4497 return ((LDKCResult_NoneMonitorUpdateErrorZ*)arg)->result_ok;
4499 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneMonitorUpdateErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4500 LDKCResult_NoneMonitorUpdateErrorZ *val = (LDKCResult_NoneMonitorUpdateErrorZ*)(arg & ~1);
4501 CHECK(val->result_ok);
4502 return *val->contents.result;
4504 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneMonitorUpdateErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4505 LDKCResult_NoneMonitorUpdateErrorZ *val = (LDKCResult_NoneMonitorUpdateErrorZ*)(arg & ~1);
4506 CHECK(!val->result_ok);
4507 LDKMonitorUpdateError err_var = (*val->contents.err);
4508 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4509 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4510 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4513 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1OutPointScriptZ_1new(JNIEnv *env, jclass clz, int64_t a, int8_tArray b) {
4514 LDKC2Tuple_OutPointScriptZ* ret = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
4516 a_conv.inner = (void*)(a & (~1));
4517 a_conv.is_owned = (a & 1) || (a == 0);
4518 a_conv = OutPoint_clone(&a_conv);
4521 b_ref.datalen = (*env)->GetArrayLength(env, b);
4522 b_ref.data = MALLOC(b_ref.datalen, "LDKCVec_u8Z Bytes");
4523 (*env)->GetByteArrayRegion(env, b, 0, b_ref.datalen, b_ref.data);
4525 return (uint64_t)ret;
4527 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1OutPointScriptZ_1get_1a(JNIEnv *env, jclass clz, int64_t ptr) {
4528 LDKC2Tuple_OutPointScriptZ *tuple = (LDKC2Tuple_OutPointScriptZ*)(ptr & ~1);
4529 LDKOutPoint a_var = tuple->a;
4530 CHECK((((uint64_t)a_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4531 CHECK((((uint64_t)&a_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4532 uint64_t a_ref = (uint64_t)a_var.inner & ~1;
4535 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1OutPointScriptZ_1get_1b(JNIEnv *env, jclass clz, int64_t ptr) {
4536 LDKC2Tuple_OutPointScriptZ *tuple = (LDKC2Tuple_OutPointScriptZ*)(ptr & ~1);
4537 LDKCVec_u8Z b_var = tuple->b;
4538 int8_tArray b_arr = (*env)->NewByteArray(env, b_var.datalen);
4539 (*env)->SetByteArrayRegion(env, b_arr, 0, b_var.datalen, b_var.data);
4542 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1u32ScriptZ_1new(JNIEnv *env, jclass clz, int32_t a, int8_tArray b) {
4543 LDKC2Tuple_u32ScriptZ* ret = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
4546 b_ref.datalen = (*env)->GetArrayLength(env, b);
4547 b_ref.data = MALLOC(b_ref.datalen, "LDKCVec_u8Z Bytes");
4548 (*env)->GetByteArrayRegion(env, b, 0, b_ref.datalen, b_ref.data);
4550 return (uint64_t)ret;
4552 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1u32ScriptZ_1get_1a(JNIEnv *env, jclass clz, int64_t ptr) {
4553 LDKC2Tuple_u32ScriptZ *tuple = (LDKC2Tuple_u32ScriptZ*)(ptr & ~1);
4556 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1u32ScriptZ_1get_1b(JNIEnv *env, jclass clz, int64_t ptr) {
4557 LDKC2Tuple_u32ScriptZ *tuple = (LDKC2Tuple_u32ScriptZ*)(ptr & ~1);
4558 LDKCVec_u8Z b_var = tuple->b;
4559 int8_tArray b_arr = (*env)->NewByteArray(env, b_var.datalen);
4560 (*env)->SetByteArrayRegion(env, b_arr, 0, b_var.datalen, b_var.data);
4563 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C2Tuple_1u32ScriptZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
4564 LDKCVec_C2Tuple_u32ScriptZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_u32ScriptZZ), "LDKCVec_C2Tuple_u32ScriptZZ");
4565 ret->datalen = (*env)->GetArrayLength(env, elems);
4566 if (ret->datalen == 0) {
4569 ret->data = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ) * ret->datalen, "LDKCVec_C2Tuple_u32ScriptZZ Data");
4570 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
4571 for (size_t i = 0; i < ret->datalen; i++) {
4572 int64_t arr_elem = java_elems[i];
4573 LDKC2Tuple_u32ScriptZ arr_elem_conv = *(LDKC2Tuple_u32ScriptZ*)(((uint64_t)arr_elem) & ~1);
4574 arr_elem_conv = C2Tuple_u32ScriptZ_clone((LDKC2Tuple_u32ScriptZ*)(((uint64_t)arr_elem) & ~1));
4575 ret->data[i] = arr_elem_conv;
4577 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
4579 return (uint64_t)ret;
4581 static inline LDKCVec_C2Tuple_u32ScriptZZ CVec_C2Tuple_u32ScriptZZ_clone(const LDKCVec_C2Tuple_u32ScriptZZ *orig) {
4582 LDKCVec_C2Tuple_u32ScriptZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ) * orig->datalen, "LDKCVec_C2Tuple_u32ScriptZZ clone bytes"), .datalen = orig->datalen };
4583 for (size_t i = 0; i < ret.datalen; i++) {
4584 ret.data[i] = C2Tuple_u32ScriptZ_clone(&orig->data[i]);
4588 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1TxidCVec_1C2Tuple_1u32ScriptZZZ_1new(JNIEnv *env, jclass clz, int8_tArray a, int64_tArray b) {
4589 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
4590 LDKThirtyTwoBytes a_ref;
4591 CHECK((*env)->GetArrayLength(env, a) == 32);
4592 (*env)->GetByteArrayRegion(env, a, 0, 32, a_ref.data);
4594 LDKCVec_C2Tuple_u32ScriptZZ b_constr;
4595 b_constr.datalen = (*env)->GetArrayLength(env, b);
4596 if (b_constr.datalen > 0)
4597 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKC2Tuple_u32ScriptZ), "LDKCVec_C2Tuple_u32ScriptZZ Elements");
4599 b_constr.data = NULL;
4600 int64_t* b_vals = (*env)->GetLongArrayElements (env, b, NULL);
4601 for (size_t b = 0; b < b_constr.datalen; b++) {
4602 int64_t b_conv_27 = b_vals[b];
4603 LDKC2Tuple_u32ScriptZ b_conv_27_conv = *(LDKC2Tuple_u32ScriptZ*)(((uint64_t)b_conv_27) & ~1);
4604 b_conv_27_conv = C2Tuple_u32ScriptZ_clone((LDKC2Tuple_u32ScriptZ*)(((uint64_t)b_conv_27) & ~1));
4605 b_constr.data[b] = b_conv_27_conv;
4607 (*env)->ReleaseLongArrayElements(env, b, b_vals, 0);
4609 return (uint64_t)ret;
4611 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1TxidCVec_1C2Tuple_1u32ScriptZZZ_1get_1a(JNIEnv *env, jclass clz, int64_t ptr) {
4612 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *tuple = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(ptr & ~1);
4613 int8_tArray a_arr = (*env)->NewByteArray(env, 32);
4614 (*env)->SetByteArrayRegion(env, a_arr, 0, 32, tuple->a.data);
4617 JNIEXPORT int64_tArray JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1TxidCVec_1C2Tuple_1u32ScriptZZZ_1get_1b(JNIEnv *env, jclass clz, int64_t ptr) {
4618 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *tuple = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(ptr & ~1);
4619 LDKCVec_C2Tuple_u32ScriptZZ b_var = tuple->b;
4620 int64_tArray b_arr = (*env)->NewLongArray(env, b_var.datalen);
4621 int64_t *b_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, b_arr, NULL);
4622 for (size_t b = 0; b < b_var.datalen; b++) {
4623 uint64_t b_conv_27_ref = (uint64_t)(&b_var.data[b]) | 1;
4624 b_arr_ptr[b] = b_conv_27_ref;
4626 (*env)->ReleasePrimitiveArrayCritical(env, b_arr, b_arr_ptr, 0);
4629 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C2Tuple_1TxidCVec_1C2Tuple_1u32ScriptZZZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
4630 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ), "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ");
4631 ret->datalen = (*env)->GetArrayLength(env, elems);
4632 if (ret->datalen == 0) {
4635 ret->data = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ) * ret->datalen, "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ Data");
4636 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
4637 for (size_t i = 0; i < ret->datalen; i++) {
4638 int64_t arr_elem = java_elems[i];
4639 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ arr_elem_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(((uint64_t)arr_elem) & ~1);
4640 arr_elem_conv = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone((LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(((uint64_t)arr_elem) & ~1));
4641 ret->data[i] = arr_elem_conv;
4643 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
4645 return (uint64_t)ret;
4647 static inline LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_clone(const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ *orig) {
4648 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ) * orig->datalen, "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ clone bytes"), .datalen = orig->datalen };
4649 for (size_t i = 0; i < ret.datalen; i++) {
4650 ret.data[i] = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(&orig->data[i]);
4654 static jclass LDKEvent_FundingGenerationReady_class = NULL;
4655 static jmethodID LDKEvent_FundingGenerationReady_meth = NULL;
4656 static jclass LDKEvent_PaymentReceived_class = NULL;
4657 static jmethodID LDKEvent_PaymentReceived_meth = NULL;
4658 static jclass LDKEvent_PaymentSent_class = NULL;
4659 static jmethodID LDKEvent_PaymentSent_meth = NULL;
4660 static jclass LDKEvent_PaymentFailed_class = NULL;
4661 static jmethodID LDKEvent_PaymentFailed_meth = NULL;
4662 static jclass LDKEvent_PendingHTLCsForwardable_class = NULL;
4663 static jmethodID LDKEvent_PendingHTLCsForwardable_meth = NULL;
4664 static jclass LDKEvent_SpendableOutputs_class = NULL;
4665 static jmethodID LDKEvent_SpendableOutputs_meth = NULL;
4666 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKEvent_init (JNIEnv *env, jclass clz) {
4667 LDKEvent_FundingGenerationReady_class =
4668 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$FundingGenerationReady;"));
4669 CHECK(LDKEvent_FundingGenerationReady_class != NULL);
4670 LDKEvent_FundingGenerationReady_meth = (*env)->GetMethodID(env, LDKEvent_FundingGenerationReady_class, "<init>", "([BJ[BJ)V");
4671 CHECK(LDKEvent_FundingGenerationReady_meth != NULL);
4672 LDKEvent_PaymentReceived_class =
4673 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$PaymentReceived;"));
4674 CHECK(LDKEvent_PaymentReceived_class != NULL);
4675 LDKEvent_PaymentReceived_meth = (*env)->GetMethodID(env, LDKEvent_PaymentReceived_class, "<init>", "([B[B[BJJ)V");
4676 CHECK(LDKEvent_PaymentReceived_meth != NULL);
4677 LDKEvent_PaymentSent_class =
4678 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$PaymentSent;"));
4679 CHECK(LDKEvent_PaymentSent_class != NULL);
4680 LDKEvent_PaymentSent_meth = (*env)->GetMethodID(env, LDKEvent_PaymentSent_class, "<init>", "([B)V");
4681 CHECK(LDKEvent_PaymentSent_meth != NULL);
4682 LDKEvent_PaymentFailed_class =
4683 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$PaymentFailed;"));
4684 CHECK(LDKEvent_PaymentFailed_class != NULL);
4685 LDKEvent_PaymentFailed_meth = (*env)->GetMethodID(env, LDKEvent_PaymentFailed_class, "<init>", "([BZ)V");
4686 CHECK(LDKEvent_PaymentFailed_meth != NULL);
4687 LDKEvent_PendingHTLCsForwardable_class =
4688 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$PendingHTLCsForwardable;"));
4689 CHECK(LDKEvent_PendingHTLCsForwardable_class != NULL);
4690 LDKEvent_PendingHTLCsForwardable_meth = (*env)->GetMethodID(env, LDKEvent_PendingHTLCsForwardable_class, "<init>", "(J)V");
4691 CHECK(LDKEvent_PendingHTLCsForwardable_meth != NULL);
4692 LDKEvent_SpendableOutputs_class =
4693 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$SpendableOutputs;"));
4694 CHECK(LDKEvent_SpendableOutputs_class != NULL);
4695 LDKEvent_SpendableOutputs_meth = (*env)->GetMethodID(env, LDKEvent_SpendableOutputs_class, "<init>", "([J)V");
4696 CHECK(LDKEvent_SpendableOutputs_meth != NULL);
4698 JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKEvent_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
4699 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
4701 case LDKEvent_FundingGenerationReady: {
4702 int8_tArray temporary_channel_id_arr = (*env)->NewByteArray(env, 32);
4703 (*env)->SetByteArrayRegion(env, temporary_channel_id_arr, 0, 32, obj->funding_generation_ready.temporary_channel_id.data);
4704 LDKCVec_u8Z output_script_var = obj->funding_generation_ready.output_script;
4705 int8_tArray output_script_arr = (*env)->NewByteArray(env, output_script_var.datalen);
4706 (*env)->SetByteArrayRegion(env, output_script_arr, 0, output_script_var.datalen, output_script_var.data);
4707 return (*env)->NewObject(env, LDKEvent_FundingGenerationReady_class, LDKEvent_FundingGenerationReady_meth, temporary_channel_id_arr, obj->funding_generation_ready.channel_value_satoshis, output_script_arr, obj->funding_generation_ready.user_channel_id);
4709 case LDKEvent_PaymentReceived: {
4710 int8_tArray payment_hash_arr = (*env)->NewByteArray(env, 32);
4711 (*env)->SetByteArrayRegion(env, payment_hash_arr, 0, 32, obj->payment_received.payment_hash.data);
4712 int8_tArray payment_preimage_arr = (*env)->NewByteArray(env, 32);
4713 (*env)->SetByteArrayRegion(env, payment_preimage_arr, 0, 32, obj->payment_received.payment_preimage.data);
4714 int8_tArray payment_secret_arr = (*env)->NewByteArray(env, 32);
4715 (*env)->SetByteArrayRegion(env, payment_secret_arr, 0, 32, obj->payment_received.payment_secret.data);
4716 return (*env)->NewObject(env, LDKEvent_PaymentReceived_class, LDKEvent_PaymentReceived_meth, payment_hash_arr, payment_preimage_arr, payment_secret_arr, obj->payment_received.amt, obj->payment_received.user_payment_id);
4718 case LDKEvent_PaymentSent: {
4719 int8_tArray payment_preimage_arr = (*env)->NewByteArray(env, 32);
4720 (*env)->SetByteArrayRegion(env, payment_preimage_arr, 0, 32, obj->payment_sent.payment_preimage.data);
4721 return (*env)->NewObject(env, LDKEvent_PaymentSent_class, LDKEvent_PaymentSent_meth, payment_preimage_arr);
4723 case LDKEvent_PaymentFailed: {
4724 int8_tArray payment_hash_arr = (*env)->NewByteArray(env, 32);
4725 (*env)->SetByteArrayRegion(env, payment_hash_arr, 0, 32, obj->payment_failed.payment_hash.data);
4726 return (*env)->NewObject(env, LDKEvent_PaymentFailed_class, LDKEvent_PaymentFailed_meth, payment_hash_arr, obj->payment_failed.rejected_by_dest);
4728 case LDKEvent_PendingHTLCsForwardable: {
4729 return (*env)->NewObject(env, LDKEvent_PendingHTLCsForwardable_class, LDKEvent_PendingHTLCsForwardable_meth, obj->pending_htl_cs_forwardable.time_forwardable);
4731 case LDKEvent_SpendableOutputs: {
4732 LDKCVec_SpendableOutputDescriptorZ outputs_var = obj->spendable_outputs.outputs;
4733 int64_tArray outputs_arr = (*env)->NewLongArray(env, outputs_var.datalen);
4734 int64_t *outputs_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, outputs_arr, NULL);
4735 for (size_t b = 0; b < outputs_var.datalen; b++) {
4736 uint64_t outputs_conv_27_ref = ((uint64_t)&outputs_var.data[b]) | 1;
4737 outputs_arr_ptr[b] = outputs_conv_27_ref;
4739 (*env)->ReleasePrimitiveArrayCritical(env, outputs_arr, outputs_arr_ptr, 0);
4740 return (*env)->NewObject(env, LDKEvent_SpendableOutputs_class, LDKEvent_SpendableOutputs_meth, outputs_arr);
4745 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1EventZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
4746 LDKCVec_EventZ *ret = MALLOC(sizeof(LDKCVec_EventZ), "LDKCVec_EventZ");
4747 ret->datalen = (*env)->GetArrayLength(env, elems);
4748 if (ret->datalen == 0) {
4751 ret->data = MALLOC(sizeof(LDKEvent) * ret->datalen, "LDKCVec_EventZ Data");
4752 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
4753 for (size_t i = 0; i < ret->datalen; i++) {
4754 int64_t arr_elem = java_elems[i];
4755 LDKEvent arr_elem_conv = *(LDKEvent*)(((uint64_t)arr_elem) & ~1);
4756 arr_elem_conv = Event_clone((LDKEvent*)(((uint64_t)arr_elem) & ~1));
4757 ret->data[i] = arr_elem_conv;
4759 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
4761 return (uint64_t)ret;
4763 static inline LDKCVec_EventZ CVec_EventZ_clone(const LDKCVec_EventZ *orig) {
4764 LDKCVec_EventZ ret = { .data = MALLOC(sizeof(LDKEvent) * orig->datalen, "LDKCVec_EventZ clone bytes"), .datalen = orig->datalen };
4765 for (size_t i = 0; i < ret.datalen; i++) {
4766 ret.data[i] = Event_clone(&orig->data[i]);
4770 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1u32TxOutZ_1new(JNIEnv *env, jclass clz, int32_t a, int64_t b) {
4771 LDKC2Tuple_u32TxOutZ* ret = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
4773 LDKTxOut b_conv = *(LDKTxOut*)(((uint64_t)b) & ~1);
4774 b_conv = TxOut_clone((LDKTxOut*)(((uint64_t)b) & ~1));
4776 return (uint64_t)ret;
4778 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1u32TxOutZ_1get_1a(JNIEnv *env, jclass clz, int64_t ptr) {
4779 LDKC2Tuple_u32TxOutZ *tuple = (LDKC2Tuple_u32TxOutZ*)(ptr & ~1);
4782 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1u32TxOutZ_1get_1b(JNIEnv *env, jclass clz, int64_t ptr) {
4783 LDKC2Tuple_u32TxOutZ *tuple = (LDKC2Tuple_u32TxOutZ*)(ptr & ~1);
4784 uint64_t b_ref = ((uint64_t)&tuple->b) | 1;
4785 return (uint64_t)b_ref;
4787 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C2Tuple_1u32TxOutZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
4788 LDKCVec_C2Tuple_u32TxOutZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_u32TxOutZZ), "LDKCVec_C2Tuple_u32TxOutZZ");
4789 ret->datalen = (*env)->GetArrayLength(env, elems);
4790 if (ret->datalen == 0) {
4793 ret->data = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ) * ret->datalen, "LDKCVec_C2Tuple_u32TxOutZZ Data");
4794 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
4795 for (size_t i = 0; i < ret->datalen; i++) {
4796 int64_t arr_elem = java_elems[i];
4797 LDKC2Tuple_u32TxOutZ arr_elem_conv = *(LDKC2Tuple_u32TxOutZ*)(((uint64_t)arr_elem) & ~1);
4798 arr_elem_conv = C2Tuple_u32TxOutZ_clone((LDKC2Tuple_u32TxOutZ*)(((uint64_t)arr_elem) & ~1));
4799 ret->data[i] = arr_elem_conv;
4801 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
4803 return (uint64_t)ret;
4805 static inline LDKCVec_C2Tuple_u32TxOutZZ CVec_C2Tuple_u32TxOutZZ_clone(const LDKCVec_C2Tuple_u32TxOutZZ *orig) {
4806 LDKCVec_C2Tuple_u32TxOutZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ) * orig->datalen, "LDKCVec_C2Tuple_u32TxOutZZ clone bytes"), .datalen = orig->datalen };
4807 for (size_t i = 0; i < ret.datalen; i++) {
4808 ret.data[i] = C2Tuple_u32TxOutZ_clone(&orig->data[i]);
4812 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1TxidCVec_1C2Tuple_1u32TxOutZZZ_1new(JNIEnv *env, jclass clz, int8_tArray a, int64_tArray b) {
4813 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
4814 LDKThirtyTwoBytes a_ref;
4815 CHECK((*env)->GetArrayLength(env, a) == 32);
4816 (*env)->GetByteArrayRegion(env, a, 0, 32, a_ref.data);
4818 LDKCVec_C2Tuple_u32TxOutZZ b_constr;
4819 b_constr.datalen = (*env)->GetArrayLength(env, b);
4820 if (b_constr.datalen > 0)
4821 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKC2Tuple_u32TxOutZ), "LDKCVec_C2Tuple_u32TxOutZZ Elements");
4823 b_constr.data = NULL;
4824 int64_t* b_vals = (*env)->GetLongArrayElements (env, b, NULL);
4825 for (size_t a = 0; a < b_constr.datalen; a++) {
4826 int64_t b_conv_26 = b_vals[a];
4827 LDKC2Tuple_u32TxOutZ b_conv_26_conv = *(LDKC2Tuple_u32TxOutZ*)(((uint64_t)b_conv_26) & ~1);
4828 b_conv_26_conv = C2Tuple_u32TxOutZ_clone((LDKC2Tuple_u32TxOutZ*)(((uint64_t)b_conv_26) & ~1));
4829 b_constr.data[a] = b_conv_26_conv;
4831 (*env)->ReleaseLongArrayElements(env, b, b_vals, 0);
4833 return (uint64_t)ret;
4835 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1TxidCVec_1C2Tuple_1u32TxOutZZZ_1get_1a(JNIEnv *env, jclass clz, int64_t ptr) {
4836 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *tuple = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(ptr & ~1);
4837 int8_tArray a_arr = (*env)->NewByteArray(env, 32);
4838 (*env)->SetByteArrayRegion(env, a_arr, 0, 32, tuple->a.data);
4841 JNIEXPORT int64_tArray JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1TxidCVec_1C2Tuple_1u32TxOutZZZ_1get_1b(JNIEnv *env, jclass clz, int64_t ptr) {
4842 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *tuple = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(ptr & ~1);
4843 LDKCVec_C2Tuple_u32TxOutZZ b_var = tuple->b;
4844 int64_tArray b_arr = (*env)->NewLongArray(env, b_var.datalen);
4845 int64_t *b_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, b_arr, NULL);
4846 for (size_t a = 0; a < b_var.datalen; a++) {
4847 uint64_t b_conv_26_ref = (uint64_t)(&b_var.data[a]) | 1;
4848 b_arr_ptr[a] = b_conv_26_ref;
4850 (*env)->ReleasePrimitiveArrayCritical(env, b_arr, b_arr_ptr, 0);
4853 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C2Tuple_1TxidCVec_1C2Tuple_1u32TxOutZZZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
4854 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ), "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ");
4855 ret->datalen = (*env)->GetArrayLength(env, elems);
4856 if (ret->datalen == 0) {
4859 ret->data = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ) * ret->datalen, "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ Data");
4860 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
4861 for (size_t i = 0; i < ret->datalen; i++) {
4862 int64_t arr_elem = java_elems[i];
4863 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ arr_elem_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(((uint64_t)arr_elem) & ~1);
4864 arr_elem_conv = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone((LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(((uint64_t)arr_elem) & ~1));
4865 ret->data[i] = arr_elem_conv;
4867 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
4869 return (uint64_t)ret;
4871 static inline LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_clone(const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ *orig) {
4872 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ) * orig->datalen, "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ clone bytes"), .datalen = orig->datalen };
4873 for (size_t i = 0; i < ret.datalen; i++) {
4874 ret.data[i] = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(&orig->data[i]);
4878 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1BlockHashChannelMonitorZDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4879 return ((LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)arg)->result_ok;
4881 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1BlockHashChannelMonitorZDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4882 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *val = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(arg & ~1);
4883 CHECK(val->result_ok);
4884 uint64_t res_ref = (uint64_t)(&(*val->contents.result)) | 1;
4887 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1BlockHashChannelMonitorZDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4888 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *val = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(arg & ~1);
4889 CHECK(!val->result_ok);
4890 LDKDecodeError err_var = (*val->contents.err);
4891 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4892 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4893 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4896 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolLightningErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4897 return ((LDKCResult_boolLightningErrorZ*)arg)->result_ok;
4899 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolLightningErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4900 LDKCResult_boolLightningErrorZ *val = (LDKCResult_boolLightningErrorZ*)(arg & ~1);
4901 CHECK(val->result_ok);
4902 return *val->contents.result;
4904 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolLightningErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4905 LDKCResult_boolLightningErrorZ *val = (LDKCResult_boolLightningErrorZ*)(arg & ~1);
4906 CHECK(!val->result_ok);
4907 LDKLightningError err_var = (*val->contents.err);
4908 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4909 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4910 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4913 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1new(JNIEnv *env, jclass clz, int64_t a, int64_t b, int64_t c) {
4914 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
4915 LDKChannelAnnouncement a_conv;
4916 a_conv.inner = (void*)(a & (~1));
4917 a_conv.is_owned = (a & 1) || (a == 0);
4918 a_conv = ChannelAnnouncement_clone(&a_conv);
4920 LDKChannelUpdate b_conv;
4921 b_conv.inner = (void*)(b & (~1));
4922 b_conv.is_owned = (b & 1) || (b == 0);
4923 b_conv = ChannelUpdate_clone(&b_conv);
4925 LDKChannelUpdate c_conv;
4926 c_conv.inner = (void*)(c & (~1));
4927 c_conv.is_owned = (c & 1) || (c == 0);
4928 c_conv = ChannelUpdate_clone(&c_conv);
4930 return (uint64_t)ret;
4932 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1get_1a(JNIEnv *env, jclass clz, int64_t ptr) {
4933 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *tuple = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(ptr & ~1);
4934 LDKChannelAnnouncement a_var = tuple->a;
4935 CHECK((((uint64_t)a_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4936 CHECK((((uint64_t)&a_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4937 uint64_t a_ref = (uint64_t)a_var.inner & ~1;
4940 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1get_1b(JNIEnv *env, jclass clz, int64_t ptr) {
4941 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *tuple = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(ptr & ~1);
4942 LDKChannelUpdate b_var = tuple->b;
4943 CHECK((((uint64_t)b_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4944 CHECK((((uint64_t)&b_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4945 uint64_t b_ref = (uint64_t)b_var.inner & ~1;
4948 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1get_1c(JNIEnv *env, jclass clz, int64_t ptr) {
4949 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *tuple = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(ptr & ~1);
4950 LDKChannelUpdate c_var = tuple->c;
4951 CHECK((((uint64_t)c_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4952 CHECK((((uint64_t)&c_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4953 uint64_t c_ref = (uint64_t)c_var.inner & ~1;
4956 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
4957 LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret = MALLOC(sizeof(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
4958 ret->datalen = (*env)->GetArrayLength(env, elems);
4959 if (ret->datalen == 0) {
4962 ret->data = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ) * ret->datalen, "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ Data");
4963 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
4964 for (size_t i = 0; i < ret->datalen; i++) {
4965 int64_t arr_elem = java_elems[i];
4966 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ arr_elem_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)arr_elem) & ~1);
4967 arr_elem_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone((LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)arr_elem) & ~1));
4968 ret->data[i] = arr_elem_conv;
4970 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
4972 return (uint64_t)ret;
4974 static inline LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(const LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *orig) {
4975 LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret = { .data = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ) * orig->datalen, "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ clone bytes"), .datalen = orig->datalen };
4976 for (size_t i = 0; i < ret.datalen; i++) {
4977 ret.data[i] = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(&orig->data[i]);
4981 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1NodeAnnouncementZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
4982 LDKCVec_NodeAnnouncementZ *ret = MALLOC(sizeof(LDKCVec_NodeAnnouncementZ), "LDKCVec_NodeAnnouncementZ");
4983 ret->datalen = (*env)->GetArrayLength(env, elems);
4984 if (ret->datalen == 0) {
4987 ret->data = MALLOC(sizeof(LDKNodeAnnouncement) * ret->datalen, "LDKCVec_NodeAnnouncementZ Data");
4988 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
4989 for (size_t i = 0; i < ret->datalen; i++) {
4990 int64_t arr_elem = java_elems[i];
4991 LDKNodeAnnouncement arr_elem_conv;
4992 arr_elem_conv.inner = (void*)(arr_elem & (~1));
4993 arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
4994 arr_elem_conv = NodeAnnouncement_clone(&arr_elem_conv);
4995 ret->data[i] = arr_elem_conv;
4997 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
4999 return (uint64_t)ret;
5001 static inline LDKCVec_NodeAnnouncementZ CVec_NodeAnnouncementZ_clone(const LDKCVec_NodeAnnouncementZ *orig) {
5002 LDKCVec_NodeAnnouncementZ ret = { .data = MALLOC(sizeof(LDKNodeAnnouncement) * orig->datalen, "LDKCVec_NodeAnnouncementZ clone bytes"), .datalen = orig->datalen };
5003 for (size_t i = 0; i < ret.datalen; i++) {
5004 ret.data[i] = NodeAnnouncement_clone(&orig->data[i]);
5008 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneLightningErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5009 return ((LDKCResult_NoneLightningErrorZ*)arg)->result_ok;
5011 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneLightningErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5012 LDKCResult_NoneLightningErrorZ *val = (LDKCResult_NoneLightningErrorZ*)(arg & ~1);
5013 CHECK(val->result_ok);
5014 return *val->contents.result;
5016 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneLightningErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5017 LDKCResult_NoneLightningErrorZ *val = (LDKCResult_NoneLightningErrorZ*)(arg & ~1);
5018 CHECK(!val->result_ok);
5019 LDKLightningError err_var = (*val->contents.err);
5020 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5021 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5022 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5025 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1u8ZPeerHandleErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5026 return ((LDKCResult_CVec_u8ZPeerHandleErrorZ*)arg)->result_ok;
5028 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1u8ZPeerHandleErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5029 LDKCResult_CVec_u8ZPeerHandleErrorZ *val = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(arg & ~1);
5030 CHECK(val->result_ok);
5031 LDKCVec_u8Z res_var = (*val->contents.result);
5032 int8_tArray res_arr = (*env)->NewByteArray(env, res_var.datalen);
5033 (*env)->SetByteArrayRegion(env, res_arr, 0, res_var.datalen, res_var.data);
5036 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1u8ZPeerHandleErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5037 LDKCResult_CVec_u8ZPeerHandleErrorZ *val = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(arg & ~1);
5038 CHECK(!val->result_ok);
5039 LDKPeerHandleError err_var = (*val->contents.err);
5040 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5041 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5042 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5045 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePeerHandleErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5046 return ((LDKCResult_NonePeerHandleErrorZ*)arg)->result_ok;
5048 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePeerHandleErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5049 LDKCResult_NonePeerHandleErrorZ *val = (LDKCResult_NonePeerHandleErrorZ*)(arg & ~1);
5050 CHECK(val->result_ok);
5051 return *val->contents.result;
5053 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePeerHandleErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5054 LDKCResult_NonePeerHandleErrorZ *val = (LDKCResult_NonePeerHandleErrorZ*)(arg & ~1);
5055 CHECK(!val->result_ok);
5056 LDKPeerHandleError err_var = (*val->contents.err);
5057 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5058 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5059 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5062 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolPeerHandleErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5063 return ((LDKCResult_boolPeerHandleErrorZ*)arg)->result_ok;
5065 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolPeerHandleErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5066 LDKCResult_boolPeerHandleErrorZ *val = (LDKCResult_boolPeerHandleErrorZ*)(arg & ~1);
5067 CHECK(val->result_ok);
5068 return *val->contents.result;
5070 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolPeerHandleErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5071 LDKCResult_boolPeerHandleErrorZ *val = (LDKCResult_boolPeerHandleErrorZ*)(arg & ~1);
5072 CHECK(!val->result_ok);
5073 LDKPeerHandleError err_var = (*val->contents.err);
5074 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5075 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5076 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5079 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1DirectionalChannelInfoDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5080 return ((LDKCResult_DirectionalChannelInfoDecodeErrorZ*)arg)->result_ok;
5082 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1DirectionalChannelInfoDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5083 LDKCResult_DirectionalChannelInfoDecodeErrorZ *val = (LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(arg & ~1);
5084 CHECK(val->result_ok);
5085 LDKDirectionalChannelInfo res_var = (*val->contents.result);
5086 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5087 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5088 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5091 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1DirectionalChannelInfoDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5092 LDKCResult_DirectionalChannelInfoDecodeErrorZ *val = (LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(arg & ~1);
5093 CHECK(!val->result_ok);
5094 LDKDecodeError err_var = (*val->contents.err);
5095 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5096 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5097 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5100 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelInfoDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5101 return ((LDKCResult_ChannelInfoDecodeErrorZ*)arg)->result_ok;
5103 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelInfoDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5104 LDKCResult_ChannelInfoDecodeErrorZ *val = (LDKCResult_ChannelInfoDecodeErrorZ*)(arg & ~1);
5105 CHECK(val->result_ok);
5106 LDKChannelInfo res_var = (*val->contents.result);
5107 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5108 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5109 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5112 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelInfoDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5113 LDKCResult_ChannelInfoDecodeErrorZ *val = (LDKCResult_ChannelInfoDecodeErrorZ*)(arg & ~1);
5114 CHECK(!val->result_ok);
5115 LDKDecodeError err_var = (*val->contents.err);
5116 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5117 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5118 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5121 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RoutingFeesDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5122 return ((LDKCResult_RoutingFeesDecodeErrorZ*)arg)->result_ok;
5124 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RoutingFeesDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5125 LDKCResult_RoutingFeesDecodeErrorZ *val = (LDKCResult_RoutingFeesDecodeErrorZ*)(arg & ~1);
5126 CHECK(val->result_ok);
5127 LDKRoutingFees res_var = (*val->contents.result);
5128 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5129 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5130 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5133 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RoutingFeesDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5134 LDKCResult_RoutingFeesDecodeErrorZ *val = (LDKCResult_RoutingFeesDecodeErrorZ*)(arg & ~1);
5135 CHECK(!val->result_ok);
5136 LDKDecodeError err_var = (*val->contents.err);
5137 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5138 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5139 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5142 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeAnnouncementInfoDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5143 return ((LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)arg)->result_ok;
5145 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeAnnouncementInfoDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5146 LDKCResult_NodeAnnouncementInfoDecodeErrorZ *val = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(arg & ~1);
5147 CHECK(val->result_ok);
5148 LDKNodeAnnouncementInfo res_var = (*val->contents.result);
5149 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5150 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5151 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5154 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeAnnouncementInfoDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5155 LDKCResult_NodeAnnouncementInfoDecodeErrorZ *val = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(arg & ~1);
5156 CHECK(!val->result_ok);
5157 LDKDecodeError err_var = (*val->contents.err);
5158 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5159 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5160 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5163 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1u64Z_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
5164 LDKCVec_u64Z *ret = MALLOC(sizeof(LDKCVec_u64Z), "LDKCVec_u64Z");
5165 ret->datalen = (*env)->GetArrayLength(env, elems);
5166 if (ret->datalen == 0) {
5169 ret->data = MALLOC(sizeof(uint64_t) * ret->datalen, "LDKCVec_u64Z Data");
5170 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
5171 for (size_t i = 0; i < ret->datalen; i++) {
5172 ret->data[i] = java_elems[i];
5174 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
5176 return (uint64_t)ret;
5178 static inline LDKCVec_u64Z CVec_u64Z_clone(const LDKCVec_u64Z *orig) {
5179 LDKCVec_u64Z ret = { .data = MALLOC(sizeof(int64_t) * orig->datalen, "LDKCVec_u64Z clone bytes"), .datalen = orig->datalen };
5180 memcpy(ret.data, orig->data, sizeof(int64_t) * ret.datalen);
5183 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeInfoDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5184 return ((LDKCResult_NodeInfoDecodeErrorZ*)arg)->result_ok;
5186 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeInfoDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5187 LDKCResult_NodeInfoDecodeErrorZ *val = (LDKCResult_NodeInfoDecodeErrorZ*)(arg & ~1);
5188 CHECK(val->result_ok);
5189 LDKNodeInfo res_var = (*val->contents.result);
5190 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5191 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5192 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5195 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeInfoDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5196 LDKCResult_NodeInfoDecodeErrorZ *val = (LDKCResult_NodeInfoDecodeErrorZ*)(arg & ~1);
5197 CHECK(!val->result_ok);
5198 LDKDecodeError err_var = (*val->contents.err);
5199 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5200 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5201 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5204 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NetworkGraphDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5205 return ((LDKCResult_NetworkGraphDecodeErrorZ*)arg)->result_ok;
5207 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NetworkGraphDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5208 LDKCResult_NetworkGraphDecodeErrorZ *val = (LDKCResult_NetworkGraphDecodeErrorZ*)(arg & ~1);
5209 CHECK(val->result_ok);
5210 LDKNetworkGraph res_var = (*val->contents.result);
5211 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5212 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5213 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5216 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NetworkGraphDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5217 LDKCResult_NetworkGraphDecodeErrorZ *val = (LDKCResult_NetworkGraphDecodeErrorZ*)(arg & ~1);
5218 CHECK(!val->result_ok);
5219 LDKDecodeError err_var = (*val->contents.err);
5220 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5221 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5222 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5225 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NetAddressu8Z_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5226 return ((LDKCResult_NetAddressu8Z*)arg)->result_ok;
5228 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NetAddressu8Z_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5229 LDKCResult_NetAddressu8Z *val = (LDKCResult_NetAddressu8Z*)(arg & ~1);
5230 CHECK(val->result_ok);
5231 uint64_t res_ref = ((uint64_t)&(*val->contents.result)) | 1;
5234 JNIEXPORT int8_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NetAddressu8Z_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5235 LDKCResult_NetAddressu8Z *val = (LDKCResult_NetAddressu8Z*)(arg & ~1);
5236 CHECK(!val->result_ok);
5237 return *val->contents.err;
5239 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CResult_1NetAddressu8ZDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5240 return ((LDKCResult_CResult_NetAddressu8ZDecodeErrorZ*)arg)->result_ok;
5242 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CResult_1NetAddressu8ZDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5243 LDKCResult_CResult_NetAddressu8ZDecodeErrorZ *val = (LDKCResult_CResult_NetAddressu8ZDecodeErrorZ*)(arg & ~1);
5244 CHECK(val->result_ok);
5245 LDKCResult_NetAddressu8Z* res_conv = MALLOC(sizeof(LDKCResult_NetAddressu8Z), "LDKCResult_NetAddressu8Z");
5246 *res_conv = (*val->contents.result);
5247 *res_conv = CResult_NetAddressu8Z_clone(res_conv);
5248 return (uint64_t)res_conv;
5250 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CResult_1NetAddressu8ZDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5251 LDKCResult_CResult_NetAddressu8ZDecodeErrorZ *val = (LDKCResult_CResult_NetAddressu8ZDecodeErrorZ*)(arg & ~1);
5252 CHECK(!val->result_ok);
5253 LDKDecodeError err_var = (*val->contents.err);
5254 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5255 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5256 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5259 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NetAddressDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5260 return ((LDKCResult_NetAddressDecodeErrorZ*)arg)->result_ok;
5262 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NetAddressDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5263 LDKCResult_NetAddressDecodeErrorZ *val = (LDKCResult_NetAddressDecodeErrorZ*)(arg & ~1);
5264 CHECK(val->result_ok);
5265 uint64_t res_ref = ((uint64_t)&(*val->contents.result)) | 1;
5268 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NetAddressDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5269 LDKCResult_NetAddressDecodeErrorZ *val = (LDKCResult_NetAddressDecodeErrorZ*)(arg & ~1);
5270 CHECK(!val->result_ok);
5271 LDKDecodeError err_var = (*val->contents.err);
5272 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5273 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5274 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5277 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1UpdateAddHTLCZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
5278 LDKCVec_UpdateAddHTLCZ *ret = MALLOC(sizeof(LDKCVec_UpdateAddHTLCZ), "LDKCVec_UpdateAddHTLCZ");
5279 ret->datalen = (*env)->GetArrayLength(env, elems);
5280 if (ret->datalen == 0) {
5283 ret->data = MALLOC(sizeof(LDKUpdateAddHTLC) * ret->datalen, "LDKCVec_UpdateAddHTLCZ Data");
5284 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
5285 for (size_t i = 0; i < ret->datalen; i++) {
5286 int64_t arr_elem = java_elems[i];
5287 LDKUpdateAddHTLC arr_elem_conv;
5288 arr_elem_conv.inner = (void*)(arr_elem & (~1));
5289 arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
5290 arr_elem_conv = UpdateAddHTLC_clone(&arr_elem_conv);
5291 ret->data[i] = arr_elem_conv;
5293 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
5295 return (uint64_t)ret;
5297 static inline LDKCVec_UpdateAddHTLCZ CVec_UpdateAddHTLCZ_clone(const LDKCVec_UpdateAddHTLCZ *orig) {
5298 LDKCVec_UpdateAddHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateAddHTLC) * orig->datalen, "LDKCVec_UpdateAddHTLCZ clone bytes"), .datalen = orig->datalen };
5299 for (size_t i = 0; i < ret.datalen; i++) {
5300 ret.data[i] = UpdateAddHTLC_clone(&orig->data[i]);
5304 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1UpdateFulfillHTLCZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
5305 LDKCVec_UpdateFulfillHTLCZ *ret = MALLOC(sizeof(LDKCVec_UpdateFulfillHTLCZ), "LDKCVec_UpdateFulfillHTLCZ");
5306 ret->datalen = (*env)->GetArrayLength(env, elems);
5307 if (ret->datalen == 0) {
5310 ret->data = MALLOC(sizeof(LDKUpdateFulfillHTLC) * ret->datalen, "LDKCVec_UpdateFulfillHTLCZ Data");
5311 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
5312 for (size_t i = 0; i < ret->datalen; i++) {
5313 int64_t arr_elem = java_elems[i];
5314 LDKUpdateFulfillHTLC arr_elem_conv;
5315 arr_elem_conv.inner = (void*)(arr_elem & (~1));
5316 arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
5317 arr_elem_conv = UpdateFulfillHTLC_clone(&arr_elem_conv);
5318 ret->data[i] = arr_elem_conv;
5320 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
5322 return (uint64_t)ret;
5324 static inline LDKCVec_UpdateFulfillHTLCZ CVec_UpdateFulfillHTLCZ_clone(const LDKCVec_UpdateFulfillHTLCZ *orig) {
5325 LDKCVec_UpdateFulfillHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFulfillHTLC) * orig->datalen, "LDKCVec_UpdateFulfillHTLCZ clone bytes"), .datalen = orig->datalen };
5326 for (size_t i = 0; i < ret.datalen; i++) {
5327 ret.data[i] = UpdateFulfillHTLC_clone(&orig->data[i]);
5331 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1UpdateFailHTLCZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
5332 LDKCVec_UpdateFailHTLCZ *ret = MALLOC(sizeof(LDKCVec_UpdateFailHTLCZ), "LDKCVec_UpdateFailHTLCZ");
5333 ret->datalen = (*env)->GetArrayLength(env, elems);
5334 if (ret->datalen == 0) {
5337 ret->data = MALLOC(sizeof(LDKUpdateFailHTLC) * ret->datalen, "LDKCVec_UpdateFailHTLCZ Data");
5338 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
5339 for (size_t i = 0; i < ret->datalen; i++) {
5340 int64_t arr_elem = java_elems[i];
5341 LDKUpdateFailHTLC arr_elem_conv;
5342 arr_elem_conv.inner = (void*)(arr_elem & (~1));
5343 arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
5344 arr_elem_conv = UpdateFailHTLC_clone(&arr_elem_conv);
5345 ret->data[i] = arr_elem_conv;
5347 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
5349 return (uint64_t)ret;
5351 static inline LDKCVec_UpdateFailHTLCZ CVec_UpdateFailHTLCZ_clone(const LDKCVec_UpdateFailHTLCZ *orig) {
5352 LDKCVec_UpdateFailHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFailHTLC) * orig->datalen, "LDKCVec_UpdateFailHTLCZ clone bytes"), .datalen = orig->datalen };
5353 for (size_t i = 0; i < ret.datalen; i++) {
5354 ret.data[i] = UpdateFailHTLC_clone(&orig->data[i]);
5358 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1UpdateFailMalformedHTLCZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
5359 LDKCVec_UpdateFailMalformedHTLCZ *ret = MALLOC(sizeof(LDKCVec_UpdateFailMalformedHTLCZ), "LDKCVec_UpdateFailMalformedHTLCZ");
5360 ret->datalen = (*env)->GetArrayLength(env, elems);
5361 if (ret->datalen == 0) {
5364 ret->data = MALLOC(sizeof(LDKUpdateFailMalformedHTLC) * ret->datalen, "LDKCVec_UpdateFailMalformedHTLCZ Data");
5365 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
5366 for (size_t i = 0; i < ret->datalen; i++) {
5367 int64_t arr_elem = java_elems[i];
5368 LDKUpdateFailMalformedHTLC arr_elem_conv;
5369 arr_elem_conv.inner = (void*)(arr_elem & (~1));
5370 arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
5371 arr_elem_conv = UpdateFailMalformedHTLC_clone(&arr_elem_conv);
5372 ret->data[i] = arr_elem_conv;
5374 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
5376 return (uint64_t)ret;
5378 static inline LDKCVec_UpdateFailMalformedHTLCZ CVec_UpdateFailMalformedHTLCZ_clone(const LDKCVec_UpdateFailMalformedHTLCZ *orig) {
5379 LDKCVec_UpdateFailMalformedHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFailMalformedHTLC) * orig->datalen, "LDKCVec_UpdateFailMalformedHTLCZ clone bytes"), .datalen = orig->datalen };
5380 for (size_t i = 0; i < ret.datalen; i++) {
5381 ret.data[i] = UpdateFailMalformedHTLC_clone(&orig->data[i]);
5385 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1AcceptChannelDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5386 return ((LDKCResult_AcceptChannelDecodeErrorZ*)arg)->result_ok;
5388 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1AcceptChannelDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5389 LDKCResult_AcceptChannelDecodeErrorZ *val = (LDKCResult_AcceptChannelDecodeErrorZ*)(arg & ~1);
5390 CHECK(val->result_ok);
5391 LDKAcceptChannel res_var = (*val->contents.result);
5392 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5393 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5394 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5397 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1AcceptChannelDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5398 LDKCResult_AcceptChannelDecodeErrorZ *val = (LDKCResult_AcceptChannelDecodeErrorZ*)(arg & ~1);
5399 CHECK(!val->result_ok);
5400 LDKDecodeError err_var = (*val->contents.err);
5401 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5402 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5403 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5406 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1AnnouncementSignaturesDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5407 return ((LDKCResult_AnnouncementSignaturesDecodeErrorZ*)arg)->result_ok;
5409 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1AnnouncementSignaturesDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5410 LDKCResult_AnnouncementSignaturesDecodeErrorZ *val = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(arg & ~1);
5411 CHECK(val->result_ok);
5412 LDKAnnouncementSignatures res_var = (*val->contents.result);
5413 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5414 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5415 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5418 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1AnnouncementSignaturesDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5419 LDKCResult_AnnouncementSignaturesDecodeErrorZ *val = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(arg & ~1);
5420 CHECK(!val->result_ok);
5421 LDKDecodeError err_var = (*val->contents.err);
5422 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5423 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5424 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5427 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelReestablishDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5428 return ((LDKCResult_ChannelReestablishDecodeErrorZ*)arg)->result_ok;
5430 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelReestablishDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5431 LDKCResult_ChannelReestablishDecodeErrorZ *val = (LDKCResult_ChannelReestablishDecodeErrorZ*)(arg & ~1);
5432 CHECK(val->result_ok);
5433 LDKChannelReestablish res_var = (*val->contents.result);
5434 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5435 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5436 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5439 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelReestablishDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5440 LDKCResult_ChannelReestablishDecodeErrorZ *val = (LDKCResult_ChannelReestablishDecodeErrorZ*)(arg & ~1);
5441 CHECK(!val->result_ok);
5442 LDKDecodeError err_var = (*val->contents.err);
5443 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5444 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5445 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5448 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ClosingSignedDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5449 return ((LDKCResult_ClosingSignedDecodeErrorZ*)arg)->result_ok;
5451 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ClosingSignedDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5452 LDKCResult_ClosingSignedDecodeErrorZ *val = (LDKCResult_ClosingSignedDecodeErrorZ*)(arg & ~1);
5453 CHECK(val->result_ok);
5454 LDKClosingSigned res_var = (*val->contents.result);
5455 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5456 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5457 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5460 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ClosingSignedDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5461 LDKCResult_ClosingSignedDecodeErrorZ *val = (LDKCResult_ClosingSignedDecodeErrorZ*)(arg & ~1);
5462 CHECK(!val->result_ok);
5463 LDKDecodeError err_var = (*val->contents.err);
5464 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5465 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5466 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5469 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CommitmentSignedDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5470 return ((LDKCResult_CommitmentSignedDecodeErrorZ*)arg)->result_ok;
5472 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CommitmentSignedDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5473 LDKCResult_CommitmentSignedDecodeErrorZ *val = (LDKCResult_CommitmentSignedDecodeErrorZ*)(arg & ~1);
5474 CHECK(val->result_ok);
5475 LDKCommitmentSigned res_var = (*val->contents.result);
5476 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5477 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5478 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5481 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CommitmentSignedDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5482 LDKCResult_CommitmentSignedDecodeErrorZ *val = (LDKCResult_CommitmentSignedDecodeErrorZ*)(arg & ~1);
5483 CHECK(!val->result_ok);
5484 LDKDecodeError err_var = (*val->contents.err);
5485 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5486 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5487 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5490 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingCreatedDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5491 return ((LDKCResult_FundingCreatedDecodeErrorZ*)arg)->result_ok;
5493 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingCreatedDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5494 LDKCResult_FundingCreatedDecodeErrorZ *val = (LDKCResult_FundingCreatedDecodeErrorZ*)(arg & ~1);
5495 CHECK(val->result_ok);
5496 LDKFundingCreated res_var = (*val->contents.result);
5497 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5498 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5499 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5502 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingCreatedDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5503 LDKCResult_FundingCreatedDecodeErrorZ *val = (LDKCResult_FundingCreatedDecodeErrorZ*)(arg & ~1);
5504 CHECK(!val->result_ok);
5505 LDKDecodeError err_var = (*val->contents.err);
5506 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5507 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5508 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5511 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingSignedDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5512 return ((LDKCResult_FundingSignedDecodeErrorZ*)arg)->result_ok;
5514 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingSignedDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5515 LDKCResult_FundingSignedDecodeErrorZ *val = (LDKCResult_FundingSignedDecodeErrorZ*)(arg & ~1);
5516 CHECK(val->result_ok);
5517 LDKFundingSigned res_var = (*val->contents.result);
5518 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5519 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5520 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5523 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingSignedDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5524 LDKCResult_FundingSignedDecodeErrorZ *val = (LDKCResult_FundingSignedDecodeErrorZ*)(arg & ~1);
5525 CHECK(!val->result_ok);
5526 LDKDecodeError err_var = (*val->contents.err);
5527 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5528 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5529 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5532 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingLockedDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5533 return ((LDKCResult_FundingLockedDecodeErrorZ*)arg)->result_ok;
5535 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingLockedDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5536 LDKCResult_FundingLockedDecodeErrorZ *val = (LDKCResult_FundingLockedDecodeErrorZ*)(arg & ~1);
5537 CHECK(val->result_ok);
5538 LDKFundingLocked res_var = (*val->contents.result);
5539 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5540 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5541 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5544 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingLockedDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5545 LDKCResult_FundingLockedDecodeErrorZ *val = (LDKCResult_FundingLockedDecodeErrorZ*)(arg & ~1);
5546 CHECK(!val->result_ok);
5547 LDKDecodeError err_var = (*val->contents.err);
5548 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5549 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5550 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5553 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5554 return ((LDKCResult_InitDecodeErrorZ*)arg)->result_ok;
5556 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5557 LDKCResult_InitDecodeErrorZ *val = (LDKCResult_InitDecodeErrorZ*)(arg & ~1);
5558 CHECK(val->result_ok);
5559 LDKInit res_var = (*val->contents.result);
5560 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5561 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5562 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5565 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5566 LDKCResult_InitDecodeErrorZ *val = (LDKCResult_InitDecodeErrorZ*)(arg & ~1);
5567 CHECK(!val->result_ok);
5568 LDKDecodeError err_var = (*val->contents.err);
5569 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5570 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5571 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5574 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1OpenChannelDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5575 return ((LDKCResult_OpenChannelDecodeErrorZ*)arg)->result_ok;
5577 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1OpenChannelDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5578 LDKCResult_OpenChannelDecodeErrorZ *val = (LDKCResult_OpenChannelDecodeErrorZ*)(arg & ~1);
5579 CHECK(val->result_ok);
5580 LDKOpenChannel res_var = (*val->contents.result);
5581 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5582 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5583 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5586 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1OpenChannelDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5587 LDKCResult_OpenChannelDecodeErrorZ *val = (LDKCResult_OpenChannelDecodeErrorZ*)(arg & ~1);
5588 CHECK(!val->result_ok);
5589 LDKDecodeError err_var = (*val->contents.err);
5590 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5591 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5592 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5595 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RevokeAndACKDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5596 return ((LDKCResult_RevokeAndACKDecodeErrorZ*)arg)->result_ok;
5598 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RevokeAndACKDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5599 LDKCResult_RevokeAndACKDecodeErrorZ *val = (LDKCResult_RevokeAndACKDecodeErrorZ*)(arg & ~1);
5600 CHECK(val->result_ok);
5601 LDKRevokeAndACK res_var = (*val->contents.result);
5602 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5603 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5604 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5607 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RevokeAndACKDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5608 LDKCResult_RevokeAndACKDecodeErrorZ *val = (LDKCResult_RevokeAndACKDecodeErrorZ*)(arg & ~1);
5609 CHECK(!val->result_ok);
5610 LDKDecodeError err_var = (*val->contents.err);
5611 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5612 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5613 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5616 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ShutdownDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5617 return ((LDKCResult_ShutdownDecodeErrorZ*)arg)->result_ok;
5619 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ShutdownDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5620 LDKCResult_ShutdownDecodeErrorZ *val = (LDKCResult_ShutdownDecodeErrorZ*)(arg & ~1);
5621 CHECK(val->result_ok);
5622 LDKShutdown res_var = (*val->contents.result);
5623 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5624 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5625 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5628 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ShutdownDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5629 LDKCResult_ShutdownDecodeErrorZ *val = (LDKCResult_ShutdownDecodeErrorZ*)(arg & ~1);
5630 CHECK(!val->result_ok);
5631 LDKDecodeError err_var = (*val->contents.err);
5632 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5633 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5634 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5637 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFailHTLCDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5638 return ((LDKCResult_UpdateFailHTLCDecodeErrorZ*)arg)->result_ok;
5640 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFailHTLCDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5641 LDKCResult_UpdateFailHTLCDecodeErrorZ *val = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)(arg & ~1);
5642 CHECK(val->result_ok);
5643 LDKUpdateFailHTLC res_var = (*val->contents.result);
5644 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5645 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5646 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5649 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFailHTLCDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5650 LDKCResult_UpdateFailHTLCDecodeErrorZ *val = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)(arg & ~1);
5651 CHECK(!val->result_ok);
5652 LDKDecodeError err_var = (*val->contents.err);
5653 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5654 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5655 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5658 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFailMalformedHTLCDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5659 return ((LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)arg)->result_ok;
5661 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFailMalformedHTLCDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5662 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *val = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(arg & ~1);
5663 CHECK(val->result_ok);
5664 LDKUpdateFailMalformedHTLC res_var = (*val->contents.result);
5665 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5666 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5667 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5670 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFailMalformedHTLCDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5671 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *val = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(arg & ~1);
5672 CHECK(!val->result_ok);
5673 LDKDecodeError err_var = (*val->contents.err);
5674 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5675 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5676 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5679 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFeeDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5680 return ((LDKCResult_UpdateFeeDecodeErrorZ*)arg)->result_ok;
5682 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFeeDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5683 LDKCResult_UpdateFeeDecodeErrorZ *val = (LDKCResult_UpdateFeeDecodeErrorZ*)(arg & ~1);
5684 CHECK(val->result_ok);
5685 LDKUpdateFee res_var = (*val->contents.result);
5686 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5687 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5688 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5691 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFeeDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5692 LDKCResult_UpdateFeeDecodeErrorZ *val = (LDKCResult_UpdateFeeDecodeErrorZ*)(arg & ~1);
5693 CHECK(!val->result_ok);
5694 LDKDecodeError err_var = (*val->contents.err);
5695 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5696 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5697 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5700 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFulfillHTLCDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5701 return ((LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)arg)->result_ok;
5703 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFulfillHTLCDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5704 LDKCResult_UpdateFulfillHTLCDecodeErrorZ *val = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(arg & ~1);
5705 CHECK(val->result_ok);
5706 LDKUpdateFulfillHTLC res_var = (*val->contents.result);
5707 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5708 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5709 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5712 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFulfillHTLCDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5713 LDKCResult_UpdateFulfillHTLCDecodeErrorZ *val = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(arg & ~1);
5714 CHECK(!val->result_ok);
5715 LDKDecodeError err_var = (*val->contents.err);
5716 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5717 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5718 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5721 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateAddHTLCDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5722 return ((LDKCResult_UpdateAddHTLCDecodeErrorZ*)arg)->result_ok;
5724 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateAddHTLCDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5725 LDKCResult_UpdateAddHTLCDecodeErrorZ *val = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)(arg & ~1);
5726 CHECK(val->result_ok);
5727 LDKUpdateAddHTLC res_var = (*val->contents.result);
5728 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5729 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5730 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5733 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateAddHTLCDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5734 LDKCResult_UpdateAddHTLCDecodeErrorZ *val = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)(arg & ~1);
5735 CHECK(!val->result_ok);
5736 LDKDecodeError err_var = (*val->contents.err);
5737 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5738 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5739 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5742 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PingDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5743 return ((LDKCResult_PingDecodeErrorZ*)arg)->result_ok;
5745 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PingDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5746 LDKCResult_PingDecodeErrorZ *val = (LDKCResult_PingDecodeErrorZ*)(arg & ~1);
5747 CHECK(val->result_ok);
5748 LDKPing res_var = (*val->contents.result);
5749 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5750 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5751 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5754 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PingDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5755 LDKCResult_PingDecodeErrorZ *val = (LDKCResult_PingDecodeErrorZ*)(arg & ~1);
5756 CHECK(!val->result_ok);
5757 LDKDecodeError err_var = (*val->contents.err);
5758 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5759 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5760 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5763 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PongDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5764 return ((LDKCResult_PongDecodeErrorZ*)arg)->result_ok;
5766 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PongDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5767 LDKCResult_PongDecodeErrorZ *val = (LDKCResult_PongDecodeErrorZ*)(arg & ~1);
5768 CHECK(val->result_ok);
5769 LDKPong res_var = (*val->contents.result);
5770 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5771 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5772 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5775 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PongDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5776 LDKCResult_PongDecodeErrorZ *val = (LDKCResult_PongDecodeErrorZ*)(arg & ~1);
5777 CHECK(!val->result_ok);
5778 LDKDecodeError err_var = (*val->contents.err);
5779 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5780 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5781 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5784 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedChannelAnnouncementDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5785 return ((LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)arg)->result_ok;
5787 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedChannelAnnouncementDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5788 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *val = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(arg & ~1);
5789 CHECK(val->result_ok);
5790 LDKUnsignedChannelAnnouncement res_var = (*val->contents.result);
5791 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5792 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5793 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5796 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedChannelAnnouncementDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5797 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *val = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(arg & ~1);
5798 CHECK(!val->result_ok);
5799 LDKDecodeError err_var = (*val->contents.err);
5800 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5801 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5802 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5805 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelAnnouncementDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5806 return ((LDKCResult_ChannelAnnouncementDecodeErrorZ*)arg)->result_ok;
5808 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelAnnouncementDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5809 LDKCResult_ChannelAnnouncementDecodeErrorZ *val = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)(arg & ~1);
5810 CHECK(val->result_ok);
5811 LDKChannelAnnouncement res_var = (*val->contents.result);
5812 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5813 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5814 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5817 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelAnnouncementDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5818 LDKCResult_ChannelAnnouncementDecodeErrorZ *val = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)(arg & ~1);
5819 CHECK(!val->result_ok);
5820 LDKDecodeError err_var = (*val->contents.err);
5821 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5822 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5823 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5826 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedChannelUpdateDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5827 return ((LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)arg)->result_ok;
5829 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedChannelUpdateDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5830 LDKCResult_UnsignedChannelUpdateDecodeErrorZ *val = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(arg & ~1);
5831 CHECK(val->result_ok);
5832 LDKUnsignedChannelUpdate res_var = (*val->contents.result);
5833 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5834 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5835 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5838 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedChannelUpdateDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5839 LDKCResult_UnsignedChannelUpdateDecodeErrorZ *val = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(arg & ~1);
5840 CHECK(!val->result_ok);
5841 LDKDecodeError err_var = (*val->contents.err);
5842 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5843 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5844 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5847 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelUpdateDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5848 return ((LDKCResult_ChannelUpdateDecodeErrorZ*)arg)->result_ok;
5850 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelUpdateDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5851 LDKCResult_ChannelUpdateDecodeErrorZ *val = (LDKCResult_ChannelUpdateDecodeErrorZ*)(arg & ~1);
5852 CHECK(val->result_ok);
5853 LDKChannelUpdate res_var = (*val->contents.result);
5854 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5855 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5856 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5859 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelUpdateDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5860 LDKCResult_ChannelUpdateDecodeErrorZ *val = (LDKCResult_ChannelUpdateDecodeErrorZ*)(arg & ~1);
5861 CHECK(!val->result_ok);
5862 LDKDecodeError err_var = (*val->contents.err);
5863 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5864 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5865 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5868 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ErrorMessageDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5869 return ((LDKCResult_ErrorMessageDecodeErrorZ*)arg)->result_ok;
5871 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ErrorMessageDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5872 LDKCResult_ErrorMessageDecodeErrorZ *val = (LDKCResult_ErrorMessageDecodeErrorZ*)(arg & ~1);
5873 CHECK(val->result_ok);
5874 LDKErrorMessage res_var = (*val->contents.result);
5875 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5876 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5877 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5880 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ErrorMessageDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5881 LDKCResult_ErrorMessageDecodeErrorZ *val = (LDKCResult_ErrorMessageDecodeErrorZ*)(arg & ~1);
5882 CHECK(!val->result_ok);
5883 LDKDecodeError err_var = (*val->contents.err);
5884 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5885 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5886 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5889 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedNodeAnnouncementDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5890 return ((LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)arg)->result_ok;
5892 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedNodeAnnouncementDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5893 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *val = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(arg & ~1);
5894 CHECK(val->result_ok);
5895 LDKUnsignedNodeAnnouncement res_var = (*val->contents.result);
5896 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5897 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5898 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5901 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedNodeAnnouncementDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5902 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *val = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(arg & ~1);
5903 CHECK(!val->result_ok);
5904 LDKDecodeError err_var = (*val->contents.err);
5905 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5906 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5907 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5910 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeAnnouncementDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5911 return ((LDKCResult_NodeAnnouncementDecodeErrorZ*)arg)->result_ok;
5913 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeAnnouncementDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5914 LDKCResult_NodeAnnouncementDecodeErrorZ *val = (LDKCResult_NodeAnnouncementDecodeErrorZ*)(arg & ~1);
5915 CHECK(val->result_ok);
5916 LDKNodeAnnouncement res_var = (*val->contents.result);
5917 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5918 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5919 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5922 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeAnnouncementDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5923 LDKCResult_NodeAnnouncementDecodeErrorZ *val = (LDKCResult_NodeAnnouncementDecodeErrorZ*)(arg & ~1);
5924 CHECK(!val->result_ok);
5925 LDKDecodeError err_var = (*val->contents.err);
5926 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5927 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5928 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5931 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1QueryShortChannelIdsDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5932 return ((LDKCResult_QueryShortChannelIdsDecodeErrorZ*)arg)->result_ok;
5934 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1QueryShortChannelIdsDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5935 LDKCResult_QueryShortChannelIdsDecodeErrorZ *val = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(arg & ~1);
5936 CHECK(val->result_ok);
5937 LDKQueryShortChannelIds res_var = (*val->contents.result);
5938 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5939 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5940 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5943 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1QueryShortChannelIdsDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5944 LDKCResult_QueryShortChannelIdsDecodeErrorZ *val = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(arg & ~1);
5945 CHECK(!val->result_ok);
5946 LDKDecodeError err_var = (*val->contents.err);
5947 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5948 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5949 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5952 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ReplyShortChannelIdsEndDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5953 return ((LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)arg)->result_ok;
5955 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ReplyShortChannelIdsEndDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5956 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *val = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(arg & ~1);
5957 CHECK(val->result_ok);
5958 LDKReplyShortChannelIdsEnd res_var = (*val->contents.result);
5959 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5960 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5961 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5964 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ReplyShortChannelIdsEndDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5965 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *val = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(arg & ~1);
5966 CHECK(!val->result_ok);
5967 LDKDecodeError err_var = (*val->contents.err);
5968 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5969 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5970 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5973 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1QueryChannelRangeDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5974 return ((LDKCResult_QueryChannelRangeDecodeErrorZ*)arg)->result_ok;
5976 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1QueryChannelRangeDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5977 LDKCResult_QueryChannelRangeDecodeErrorZ *val = (LDKCResult_QueryChannelRangeDecodeErrorZ*)(arg & ~1);
5978 CHECK(val->result_ok);
5979 LDKQueryChannelRange res_var = (*val->contents.result);
5980 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5981 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5982 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
5985 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1QueryChannelRangeDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
5986 LDKCResult_QueryChannelRangeDecodeErrorZ *val = (LDKCResult_QueryChannelRangeDecodeErrorZ*)(arg & ~1);
5987 CHECK(!val->result_ok);
5988 LDKDecodeError err_var = (*val->contents.err);
5989 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5990 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5991 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
5994 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ReplyChannelRangeDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5995 return ((LDKCResult_ReplyChannelRangeDecodeErrorZ*)arg)->result_ok;
5997 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ReplyChannelRangeDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
5998 LDKCResult_ReplyChannelRangeDecodeErrorZ *val = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)(arg & ~1);
5999 CHECK(val->result_ok);
6000 LDKReplyChannelRange res_var = (*val->contents.result);
6001 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6002 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6003 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
6006 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ReplyChannelRangeDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
6007 LDKCResult_ReplyChannelRangeDecodeErrorZ *val = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)(arg & ~1);
6008 CHECK(!val->result_ok);
6009 LDKDecodeError err_var = (*val->contents.err);
6010 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6011 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6012 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
6015 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1GossipTimestampFilterDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
6016 return ((LDKCResult_GossipTimestampFilterDecodeErrorZ*)arg)->result_ok;
6018 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1GossipTimestampFilterDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
6019 LDKCResult_GossipTimestampFilterDecodeErrorZ *val = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)(arg & ~1);
6020 CHECK(val->result_ok);
6021 LDKGossipTimestampFilter res_var = (*val->contents.result);
6022 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6023 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6024 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
6027 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1GossipTimestampFilterDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
6028 LDKCResult_GossipTimestampFilterDecodeErrorZ *val = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)(arg & ~1);
6029 CHECK(!val->result_ok);
6030 LDKDecodeError err_var = (*val->contents.err);
6031 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6032 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6033 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
6036 static jclass LDKSignOrCreationError_SignError_class = NULL;
6037 static jmethodID LDKSignOrCreationError_SignError_meth = NULL;
6038 static jclass LDKSignOrCreationError_CreationError_class = NULL;
6039 static jmethodID LDKSignOrCreationError_CreationError_meth = NULL;
6040 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKSignOrCreationError_init (JNIEnv *env, jclass clz) {
6041 LDKSignOrCreationError_SignError_class =
6042 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKSignOrCreationError$SignError;"));
6043 CHECK(LDKSignOrCreationError_SignError_class != NULL);
6044 LDKSignOrCreationError_SignError_meth = (*env)->GetMethodID(env, LDKSignOrCreationError_SignError_class, "<init>", "()V");
6045 CHECK(LDKSignOrCreationError_SignError_meth != NULL);
6046 LDKSignOrCreationError_CreationError_class =
6047 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKSignOrCreationError$CreationError;"));
6048 CHECK(LDKSignOrCreationError_CreationError_class != NULL);
6049 LDKSignOrCreationError_CreationError_meth = (*env)->GetMethodID(env, LDKSignOrCreationError_CreationError_class, "<init>", "(Lorg/ldk/enums/CreationError;)V");
6050 CHECK(LDKSignOrCreationError_CreationError_meth != NULL);
6052 JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKSignOrCreationError_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
6053 LDKSignOrCreationError *obj = (LDKSignOrCreationError*)(ptr & ~1);
6055 case LDKSignOrCreationError_SignError: {
6056 return (*env)->NewObject(env, LDKSignOrCreationError_SignError_class, LDKSignOrCreationError_SignError_meth);
6058 case LDKSignOrCreationError_CreationError: {
6059 jclass creation_error_conv = LDKCreationError_to_java(env, obj->creation_error);
6060 return (*env)->NewObject(env, LDKSignOrCreationError_CreationError_class, LDKSignOrCreationError_CreationError_meth, creation_error_conv);
6065 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceSignOrCreationErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
6066 return ((LDKCResult_InvoiceSignOrCreationErrorZ*)arg)->result_ok;
6068 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceSignOrCreationErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
6069 LDKCResult_InvoiceSignOrCreationErrorZ *val = (LDKCResult_InvoiceSignOrCreationErrorZ*)(arg & ~1);
6070 CHECK(val->result_ok);
6071 LDKInvoice res_var = (*val->contents.result);
6072 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6073 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6074 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
6077 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceSignOrCreationErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
6078 LDKCResult_InvoiceSignOrCreationErrorZ *val = (LDKCResult_InvoiceSignOrCreationErrorZ*)(arg & ~1);
6079 CHECK(!val->result_ok);
6080 uint64_t err_ref = ((uint64_t)&(*val->contents.err)) | 1;
6083 typedef struct LDKMessageSendEventsProvider_JCalls {
6084 atomic_size_t refcnt;
6087 jmethodID get_and_clear_pending_msg_events_meth;
6088 } LDKMessageSendEventsProvider_JCalls;
6089 static void LDKMessageSendEventsProvider_JCalls_free(void* this_arg) {
6090 LDKMessageSendEventsProvider_JCalls *j_calls = (LDKMessageSendEventsProvider_JCalls*) this_arg;
6091 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
6093 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
6094 if (get_jenv_res == JNI_EDETACHED) {
6095 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
6097 DO_ASSERT(get_jenv_res == JNI_OK);
6099 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
6100 if (get_jenv_res == JNI_EDETACHED) {
6101 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
6106 LDKCVec_MessageSendEventZ get_and_clear_pending_msg_events_LDKMessageSendEventsProvider_jcall(const void* this_arg) {
6107 LDKMessageSendEventsProvider_JCalls *j_calls = (LDKMessageSendEventsProvider_JCalls*) this_arg;
6109 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
6110 if (get_jenv_res == JNI_EDETACHED) {
6111 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
6113 DO_ASSERT(get_jenv_res == JNI_OK);
6115 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
6117 int64_tArray ret = (*env)->CallObjectMethod(env, obj, j_calls->get_and_clear_pending_msg_events_meth);
6118 if ((*env)->ExceptionCheck(env)) {
6119 (*env)->ExceptionDescribe(env);
6120 (*env)->FatalError(env, "A call to get_and_clear_pending_msg_events in LDKMessageSendEventsProvider from rust threw an exception.");
6122 LDKCVec_MessageSendEventZ ret_constr;
6123 ret_constr.datalen = (*env)->GetArrayLength(env, ret);
6124 if (ret_constr.datalen > 0)
6125 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKMessageSendEvent), "LDKCVec_MessageSendEventZ Elements");
6127 ret_constr.data = NULL;
6128 int64_t* ret_vals = (*env)->GetLongArrayElements (env, ret, NULL);
6129 for (size_t s = 0; s < ret_constr.datalen; s++) {
6130 int64_t ret_conv_18 = ret_vals[s];
6131 LDKMessageSendEvent ret_conv_18_conv = *(LDKMessageSendEvent*)(((uint64_t)ret_conv_18) & ~1);
6132 ret_conv_18_conv = MessageSendEvent_clone((LDKMessageSendEvent*)(((uint64_t)ret_conv_18) & ~1));
6133 ret_constr.data[s] = ret_conv_18_conv;
6135 (*env)->ReleaseLongArrayElements(env, ret, ret_vals, 0);
6136 if (get_jenv_res == JNI_EDETACHED) {
6137 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
6141 static void* LDKMessageSendEventsProvider_JCalls_clone(const void* this_arg) {
6142 LDKMessageSendEventsProvider_JCalls *j_calls = (LDKMessageSendEventsProvider_JCalls*) this_arg;
6143 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
6144 return (void*) this_arg;
6146 static inline LDKMessageSendEventsProvider LDKMessageSendEventsProvider_init (JNIEnv *env, jclass clz, jobject o) {
6147 jclass c = (*env)->GetObjectClass(env, o);
6149 LDKMessageSendEventsProvider_JCalls *calls = MALLOC(sizeof(LDKMessageSendEventsProvider_JCalls), "LDKMessageSendEventsProvider_JCalls");
6150 atomic_init(&calls->refcnt, 1);
6151 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
6152 calls->o = (*env)->NewWeakGlobalRef(env, o);
6153 calls->get_and_clear_pending_msg_events_meth = (*env)->GetMethodID(env, c, "get_and_clear_pending_msg_events", "()[J");
6154 CHECK(calls->get_and_clear_pending_msg_events_meth != NULL);
6156 LDKMessageSendEventsProvider ret = {
6157 .this_arg = (void*) calls,
6158 .get_and_clear_pending_msg_events = get_and_clear_pending_msg_events_LDKMessageSendEventsProvider_jcall,
6159 .free = LDKMessageSendEventsProvider_JCalls_free,
6163 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKMessageSendEventsProvider_1new(JNIEnv *env, jclass clz, jobject o) {
6164 LDKMessageSendEventsProvider *res_ptr = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
6165 *res_ptr = LDKMessageSendEventsProvider_init(env, clz, o);
6166 return (uint64_t)res_ptr;
6168 JNIEXPORT int64_tArray JNICALL Java_org_ldk_impl_bindings_MessageSendEventsProvider_1get_1and_1clear_1pending_1msg_1events(JNIEnv *env, jclass clz, int64_t this_arg) {
6169 LDKMessageSendEventsProvider* this_arg_conv = (LDKMessageSendEventsProvider*)(((uint64_t)this_arg) & ~1);
6170 LDKCVec_MessageSendEventZ ret_var = (this_arg_conv->get_and_clear_pending_msg_events)(this_arg_conv->this_arg);
6171 int64_tArray ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
6172 int64_t *ret_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, ret_arr, NULL);
6173 for (size_t s = 0; s < ret_var.datalen; s++) {
6174 LDKMessageSendEvent *ret_conv_18_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
6175 *ret_conv_18_copy = MessageSendEvent_clone(&ret_var.data[s]);
6176 uint64_t ret_conv_18_ref = (uint64_t)ret_conv_18_copy;
6177 ret_arr_ptr[s] = ret_conv_18_ref;
6179 (*env)->ReleasePrimitiveArrayCritical(env, ret_arr, ret_arr_ptr, 0);
6184 typedef struct LDKEventHandler_JCalls {
6185 atomic_size_t refcnt;
6188 jmethodID handle_event_meth;
6189 } LDKEventHandler_JCalls;
6190 static void LDKEventHandler_JCalls_free(void* this_arg) {
6191 LDKEventHandler_JCalls *j_calls = (LDKEventHandler_JCalls*) this_arg;
6192 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
6194 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
6195 if (get_jenv_res == JNI_EDETACHED) {
6196 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
6198 DO_ASSERT(get_jenv_res == JNI_OK);
6200 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
6201 if (get_jenv_res == JNI_EDETACHED) {
6202 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
6207 void handle_event_LDKEventHandler_jcall(const void* this_arg, LDKEvent event) {
6208 LDKEventHandler_JCalls *j_calls = (LDKEventHandler_JCalls*) this_arg;
6210 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
6211 if (get_jenv_res == JNI_EDETACHED) {
6212 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
6214 DO_ASSERT(get_jenv_res == JNI_OK);
6216 LDKEvent *event_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
6217 *event_copy = event;
6218 uint64_t event_ref = (uint64_t)event_copy;
6219 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
6221 (*env)->CallVoidMethod(env, obj, j_calls->handle_event_meth, event_ref);
6222 if ((*env)->ExceptionCheck(env)) {
6223 (*env)->ExceptionDescribe(env);
6224 (*env)->FatalError(env, "A call to handle_event in LDKEventHandler from rust threw an exception.");
6226 if (get_jenv_res == JNI_EDETACHED) {
6227 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
6230 static void* LDKEventHandler_JCalls_clone(const void* this_arg) {
6231 LDKEventHandler_JCalls *j_calls = (LDKEventHandler_JCalls*) this_arg;
6232 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
6233 return (void*) this_arg;
6235 static inline LDKEventHandler LDKEventHandler_init (JNIEnv *env, jclass clz, jobject o) {
6236 jclass c = (*env)->GetObjectClass(env, o);
6238 LDKEventHandler_JCalls *calls = MALLOC(sizeof(LDKEventHandler_JCalls), "LDKEventHandler_JCalls");
6239 atomic_init(&calls->refcnt, 1);
6240 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
6241 calls->o = (*env)->NewWeakGlobalRef(env, o);
6242 calls->handle_event_meth = (*env)->GetMethodID(env, c, "handle_event", "(J)V");
6243 CHECK(calls->handle_event_meth != NULL);
6245 LDKEventHandler ret = {
6246 .this_arg = (void*) calls,
6247 .handle_event = handle_event_LDKEventHandler_jcall,
6248 .free = LDKEventHandler_JCalls_free,
6252 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKEventHandler_1new(JNIEnv *env, jclass clz, jobject o) {
6253 LDKEventHandler *res_ptr = MALLOC(sizeof(LDKEventHandler), "LDKEventHandler");
6254 *res_ptr = LDKEventHandler_init(env, clz, o);
6255 return (uint64_t)res_ptr;
6257 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_EventHandler_1handle_1event(JNIEnv *env, jclass clz, int64_t this_arg, int64_t event) {
6258 LDKEventHandler* this_arg_conv = (LDKEventHandler*)(((uint64_t)this_arg) & ~1);
6259 LDKEvent event_conv = *(LDKEvent*)(((uint64_t)event) & ~1);
6260 (this_arg_conv->handle_event)(this_arg_conv->this_arg, event_conv);
6263 typedef struct LDKEventsProvider_JCalls {
6264 atomic_size_t refcnt;
6267 jmethodID process_pending_events_meth;
6268 } LDKEventsProvider_JCalls;
6269 static void LDKEventsProvider_JCalls_free(void* this_arg) {
6270 LDKEventsProvider_JCalls *j_calls = (LDKEventsProvider_JCalls*) this_arg;
6271 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
6273 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
6274 if (get_jenv_res == JNI_EDETACHED) {
6275 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
6277 DO_ASSERT(get_jenv_res == JNI_OK);
6279 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
6280 if (get_jenv_res == JNI_EDETACHED) {
6281 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
6286 void process_pending_events_LDKEventsProvider_jcall(const void* this_arg, LDKEventHandler handler) {
6287 LDKEventsProvider_JCalls *j_calls = (LDKEventsProvider_JCalls*) this_arg;
6289 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
6290 if (get_jenv_res == JNI_EDETACHED) {
6291 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
6293 DO_ASSERT(get_jenv_res == JNI_OK);
6295 LDKEventHandler* ret = MALLOC(sizeof(LDKEventHandler), "LDKEventHandler");
6297 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
6299 (*env)->CallVoidMethod(env, obj, j_calls->process_pending_events_meth, (uint64_t)ret);
6300 if ((*env)->ExceptionCheck(env)) {
6301 (*env)->ExceptionDescribe(env);
6302 (*env)->FatalError(env, "A call to process_pending_events in LDKEventsProvider from rust threw an exception.");
6304 if (get_jenv_res == JNI_EDETACHED) {
6305 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
6308 static void* LDKEventsProvider_JCalls_clone(const void* this_arg) {
6309 LDKEventsProvider_JCalls *j_calls = (LDKEventsProvider_JCalls*) this_arg;
6310 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
6311 return (void*) this_arg;
6313 static inline LDKEventsProvider LDKEventsProvider_init (JNIEnv *env, jclass clz, jobject o) {
6314 jclass c = (*env)->GetObjectClass(env, o);
6316 LDKEventsProvider_JCalls *calls = MALLOC(sizeof(LDKEventsProvider_JCalls), "LDKEventsProvider_JCalls");
6317 atomic_init(&calls->refcnt, 1);
6318 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
6319 calls->o = (*env)->NewWeakGlobalRef(env, o);
6320 calls->process_pending_events_meth = (*env)->GetMethodID(env, c, "process_pending_events", "(J)V");
6321 CHECK(calls->process_pending_events_meth != NULL);
6323 LDKEventsProvider ret = {
6324 .this_arg = (void*) calls,
6325 .process_pending_events = process_pending_events_LDKEventsProvider_jcall,
6326 .free = LDKEventsProvider_JCalls_free,
6330 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKEventsProvider_1new(JNIEnv *env, jclass clz, jobject o) {
6331 LDKEventsProvider *res_ptr = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider");
6332 *res_ptr = LDKEventsProvider_init(env, clz, o);
6333 return (uint64_t)res_ptr;
6335 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_EventsProvider_1process_1pending_1events(JNIEnv *env, jclass clz, int64_t this_arg, int64_t handler) {
6336 LDKEventsProvider* this_arg_conv = (LDKEventsProvider*)(((uint64_t)this_arg) & ~1);
6337 LDKEventHandler handler_conv = *(LDKEventHandler*)(((uint64_t)handler) & ~1);
6338 if (handler_conv.free == LDKEventHandler_JCalls_free) {
6339 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
6340 LDKEventHandler_JCalls_clone(handler_conv.this_arg);
6342 (this_arg_conv->process_pending_events)(this_arg_conv->this_arg, handler_conv);
6345 typedef struct LDKAccess_JCalls {
6346 atomic_size_t refcnt;
6349 jmethodID get_utxo_meth;
6351 static void LDKAccess_JCalls_free(void* this_arg) {
6352 LDKAccess_JCalls *j_calls = (LDKAccess_JCalls*) this_arg;
6353 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
6355 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
6356 if (get_jenv_res == JNI_EDETACHED) {
6357 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
6359 DO_ASSERT(get_jenv_res == JNI_OK);
6361 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
6362 if (get_jenv_res == JNI_EDETACHED) {
6363 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
6368 LDKCResult_TxOutAccessErrorZ get_utxo_LDKAccess_jcall(const void* this_arg, const uint8_t (* genesis_hash)[32], uint64_t short_channel_id) {
6369 LDKAccess_JCalls *j_calls = (LDKAccess_JCalls*) this_arg;
6371 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
6372 if (get_jenv_res == JNI_EDETACHED) {
6373 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
6375 DO_ASSERT(get_jenv_res == JNI_OK);
6377 int8_tArray genesis_hash_arr = (*env)->NewByteArray(env, 32);
6378 (*env)->SetByteArrayRegion(env, genesis_hash_arr, 0, 32, *genesis_hash);
6379 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
6381 LDKCResult_TxOutAccessErrorZ* ret = (LDKCResult_TxOutAccessErrorZ*)(*env)->CallLongMethod(env, obj, j_calls->get_utxo_meth, genesis_hash_arr, short_channel_id);
6382 if ((*env)->ExceptionCheck(env)) {
6383 (*env)->ExceptionDescribe(env);
6384 (*env)->FatalError(env, "A call to get_utxo in LDKAccess from rust threw an exception.");
6386 LDKCResult_TxOutAccessErrorZ ret_conv = *(LDKCResult_TxOutAccessErrorZ*)(((uint64_t)ret) & ~1);
6387 ret_conv = CResult_TxOutAccessErrorZ_clone((LDKCResult_TxOutAccessErrorZ*)(((uint64_t)ret) & ~1));
6388 if (get_jenv_res == JNI_EDETACHED) {
6389 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
6393 static void* LDKAccess_JCalls_clone(const void* this_arg) {
6394 LDKAccess_JCalls *j_calls = (LDKAccess_JCalls*) this_arg;
6395 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
6396 return (void*) this_arg;
6398 static inline LDKAccess LDKAccess_init (JNIEnv *env, jclass clz, jobject o) {
6399 jclass c = (*env)->GetObjectClass(env, o);
6401 LDKAccess_JCalls *calls = MALLOC(sizeof(LDKAccess_JCalls), "LDKAccess_JCalls");
6402 atomic_init(&calls->refcnt, 1);
6403 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
6404 calls->o = (*env)->NewWeakGlobalRef(env, o);
6405 calls->get_utxo_meth = (*env)->GetMethodID(env, c, "get_utxo", "([BJ)J");
6406 CHECK(calls->get_utxo_meth != NULL);
6409 .this_arg = (void*) calls,
6410 .get_utxo = get_utxo_LDKAccess_jcall,
6411 .free = LDKAccess_JCalls_free,
6415 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKAccess_1new(JNIEnv *env, jclass clz, jobject o) {
6416 LDKAccess *res_ptr = MALLOC(sizeof(LDKAccess), "LDKAccess");
6417 *res_ptr = LDKAccess_init(env, clz, o);
6418 return (uint64_t)res_ptr;
6420 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Access_1get_1utxo(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray genesis_hash, int64_t short_channel_id) {
6421 LDKAccess* this_arg_conv = (LDKAccess*)(((uint64_t)this_arg) & ~1);
6422 unsigned char genesis_hash_arr[32];
6423 CHECK((*env)->GetArrayLength(env, genesis_hash) == 32);
6424 (*env)->GetByteArrayRegion(env, genesis_hash, 0, 32, genesis_hash_arr);
6425 unsigned char (*genesis_hash_ref)[32] = &genesis_hash_arr;
6426 LDKCResult_TxOutAccessErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutAccessErrorZ), "LDKCResult_TxOutAccessErrorZ");
6427 *ret_conv = (this_arg_conv->get_utxo)(this_arg_conv->this_arg, genesis_hash_ref, short_channel_id);
6428 return (uint64_t)ret_conv;
6431 typedef struct LDKListen_JCalls {
6432 atomic_size_t refcnt;
6435 jmethodID block_connected_meth;
6436 jmethodID block_disconnected_meth;
6438 static void LDKListen_JCalls_free(void* this_arg) {
6439 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
6440 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
6442 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
6443 if (get_jenv_res == JNI_EDETACHED) {
6444 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
6446 DO_ASSERT(get_jenv_res == JNI_OK);
6448 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
6449 if (get_jenv_res == JNI_EDETACHED) {
6450 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
6455 void block_connected_LDKListen_jcall(const void* this_arg, LDKu8slice block, uint32_t height) {
6456 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
6458 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
6459 if (get_jenv_res == JNI_EDETACHED) {
6460 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
6462 DO_ASSERT(get_jenv_res == JNI_OK);
6464 LDKu8slice block_var = block;
6465 int8_tArray block_arr = (*env)->NewByteArray(env, block_var.datalen);
6466 (*env)->SetByteArrayRegion(env, block_arr, 0, block_var.datalen, block_var.data);
6467 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
6469 (*env)->CallVoidMethod(env, obj, j_calls->block_connected_meth, block_arr, height);
6470 if ((*env)->ExceptionCheck(env)) {
6471 (*env)->ExceptionDescribe(env);
6472 (*env)->FatalError(env, "A call to block_connected in LDKListen from rust threw an exception.");
6474 if (get_jenv_res == JNI_EDETACHED) {
6475 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
6478 void block_disconnected_LDKListen_jcall(const void* this_arg, const uint8_t (* header)[80], uint32_t height) {
6479 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
6481 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
6482 if (get_jenv_res == JNI_EDETACHED) {
6483 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
6485 DO_ASSERT(get_jenv_res == JNI_OK);
6487 int8_tArray header_arr = (*env)->NewByteArray(env, 80);
6488 (*env)->SetByteArrayRegion(env, header_arr, 0, 80, *header);
6489 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
6491 (*env)->CallVoidMethod(env, obj, j_calls->block_disconnected_meth, header_arr, height);
6492 if ((*env)->ExceptionCheck(env)) {
6493 (*env)->ExceptionDescribe(env);
6494 (*env)->FatalError(env, "A call to block_disconnected in LDKListen from rust threw an exception.");
6496 if (get_jenv_res == JNI_EDETACHED) {
6497 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
6500 static void* LDKListen_JCalls_clone(const void* this_arg) {
6501 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
6502 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
6503 return (void*) this_arg;
6505 static inline LDKListen LDKListen_init (JNIEnv *env, jclass clz, jobject o) {
6506 jclass c = (*env)->GetObjectClass(env, o);
6508 LDKListen_JCalls *calls = MALLOC(sizeof(LDKListen_JCalls), "LDKListen_JCalls");
6509 atomic_init(&calls->refcnt, 1);
6510 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
6511 calls->o = (*env)->NewWeakGlobalRef(env, o);
6512 calls->block_connected_meth = (*env)->GetMethodID(env, c, "block_connected", "([BI)V");
6513 CHECK(calls->block_connected_meth != NULL);
6514 calls->block_disconnected_meth = (*env)->GetMethodID(env, c, "block_disconnected", "([BI)V");
6515 CHECK(calls->block_disconnected_meth != NULL);
6518 .this_arg = (void*) calls,
6519 .block_connected = block_connected_LDKListen_jcall,
6520 .block_disconnected = block_disconnected_LDKListen_jcall,
6521 .free = LDKListen_JCalls_free,
6525 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKListen_1new(JNIEnv *env, jclass clz, jobject o) {
6526 LDKListen *res_ptr = MALLOC(sizeof(LDKListen), "LDKListen");
6527 *res_ptr = LDKListen_init(env, clz, o);
6528 return (uint64_t)res_ptr;
6530 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Listen_1block_1connected(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray block, int32_t height) {
6531 LDKListen* this_arg_conv = (LDKListen*)(((uint64_t)this_arg) & ~1);
6532 LDKu8slice block_ref;
6533 block_ref.datalen = (*env)->GetArrayLength(env, block);
6534 block_ref.data = (*env)->GetByteArrayElements (env, block, NULL);
6535 (this_arg_conv->block_connected)(this_arg_conv->this_arg, block_ref, height);
6536 (*env)->ReleaseByteArrayElements(env, block, (int8_t*)block_ref.data, 0);
6539 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Listen_1block_1disconnected(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray header, int32_t height) {
6540 LDKListen* this_arg_conv = (LDKListen*)(((uint64_t)this_arg) & ~1);
6541 unsigned char header_arr[80];
6542 CHECK((*env)->GetArrayLength(env, header) == 80);
6543 (*env)->GetByteArrayRegion(env, header, 0, 80, header_arr);
6544 unsigned char (*header_ref)[80] = &header_arr;
6545 (this_arg_conv->block_disconnected)(this_arg_conv->this_arg, header_ref, height);
6548 typedef struct LDKConfirm_JCalls {
6549 atomic_size_t refcnt;
6552 jmethodID transactions_confirmed_meth;
6553 jmethodID transaction_unconfirmed_meth;
6554 jmethodID best_block_updated_meth;
6555 jmethodID get_relevant_txids_meth;
6556 } LDKConfirm_JCalls;
6557 static void LDKConfirm_JCalls_free(void* this_arg) {
6558 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
6559 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
6561 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
6562 if (get_jenv_res == JNI_EDETACHED) {
6563 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
6565 DO_ASSERT(get_jenv_res == JNI_OK);
6567 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
6568 if (get_jenv_res == JNI_EDETACHED) {
6569 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
6574 void transactions_confirmed_LDKConfirm_jcall(const void* this_arg, const uint8_t (* header)[80], LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height) {
6575 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
6577 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
6578 if (get_jenv_res == JNI_EDETACHED) {
6579 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
6581 DO_ASSERT(get_jenv_res == JNI_OK);
6583 int8_tArray header_arr = (*env)->NewByteArray(env, 80);
6584 (*env)->SetByteArrayRegion(env, header_arr, 0, 80, *header);
6585 LDKCVec_C2Tuple_usizeTransactionZZ txdata_var = txdata;
6586 int64_tArray txdata_arr = (*env)->NewLongArray(env, txdata_var.datalen);
6587 int64_t *txdata_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, txdata_arr, NULL);
6588 for (size_t y = 0; y < txdata_var.datalen; y++) {
6589 LDKC2Tuple_usizeTransactionZ* txdata_conv_24_ref = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
6590 *txdata_conv_24_ref = txdata_var.data[y];
6591 txdata_arr_ptr[y] = (uint64_t)txdata_conv_24_ref;
6593 (*env)->ReleasePrimitiveArrayCritical(env, txdata_arr, txdata_arr_ptr, 0);
6594 FREE(txdata_var.data);
6595 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
6597 (*env)->CallVoidMethod(env, obj, j_calls->transactions_confirmed_meth, header_arr, txdata_arr, height);
6598 if ((*env)->ExceptionCheck(env)) {
6599 (*env)->ExceptionDescribe(env);
6600 (*env)->FatalError(env, "A call to transactions_confirmed in LDKConfirm from rust threw an exception.");
6602 if (get_jenv_res == JNI_EDETACHED) {
6603 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
6606 void transaction_unconfirmed_LDKConfirm_jcall(const void* this_arg, const uint8_t (* txid)[32]) {
6607 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
6609 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
6610 if (get_jenv_res == JNI_EDETACHED) {
6611 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
6613 DO_ASSERT(get_jenv_res == JNI_OK);
6615 int8_tArray txid_arr = (*env)->NewByteArray(env, 32);
6616 (*env)->SetByteArrayRegion(env, txid_arr, 0, 32, *txid);
6617 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
6619 (*env)->CallVoidMethod(env, obj, j_calls->transaction_unconfirmed_meth, txid_arr);
6620 if ((*env)->ExceptionCheck(env)) {
6621 (*env)->ExceptionDescribe(env);
6622 (*env)->FatalError(env, "A call to transaction_unconfirmed in LDKConfirm from rust threw an exception.");
6624 if (get_jenv_res == JNI_EDETACHED) {
6625 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
6628 void best_block_updated_LDKConfirm_jcall(const void* this_arg, const uint8_t (* header)[80], uint32_t height) {
6629 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
6631 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
6632 if (get_jenv_res == JNI_EDETACHED) {
6633 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
6635 DO_ASSERT(get_jenv_res == JNI_OK);
6637 int8_tArray header_arr = (*env)->NewByteArray(env, 80);
6638 (*env)->SetByteArrayRegion(env, header_arr, 0, 80, *header);
6639 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
6641 (*env)->CallVoidMethod(env, obj, j_calls->best_block_updated_meth, header_arr, height);
6642 if ((*env)->ExceptionCheck(env)) {
6643 (*env)->ExceptionDescribe(env);
6644 (*env)->FatalError(env, "A call to best_block_updated in LDKConfirm from rust threw an exception.");
6646 if (get_jenv_res == JNI_EDETACHED) {
6647 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
6650 LDKCVec_TxidZ get_relevant_txids_LDKConfirm_jcall(const void* this_arg) {
6651 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
6653 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
6654 if (get_jenv_res == JNI_EDETACHED) {
6655 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
6657 DO_ASSERT(get_jenv_res == JNI_OK);
6659 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
6661 jobjectArray ret = (*env)->CallObjectMethod(env, obj, j_calls->get_relevant_txids_meth);
6662 if ((*env)->ExceptionCheck(env)) {
6663 (*env)->ExceptionDescribe(env);
6664 (*env)->FatalError(env, "A call to get_relevant_txids in LDKConfirm from rust threw an exception.");
6666 LDKCVec_TxidZ ret_constr;
6667 ret_constr.datalen = (*env)->GetArrayLength(env, ret);
6668 if (ret_constr.datalen > 0)
6669 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_TxidZ Elements");
6671 ret_constr.data = NULL;
6672 for (size_t i = 0; i < ret_constr.datalen; i++) {
6673 int8_tArray ret_conv_8 = (*env)->GetObjectArrayElement(env, ret, i);
6674 LDKThirtyTwoBytes ret_conv_8_ref;
6675 CHECK((*env)->GetArrayLength(env, ret_conv_8) == 32);
6676 (*env)->GetByteArrayRegion(env, ret_conv_8, 0, 32, ret_conv_8_ref.data);
6677 ret_constr.data[i] = ret_conv_8_ref;
6679 if (get_jenv_res == JNI_EDETACHED) {
6680 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
6684 static void* LDKConfirm_JCalls_clone(const void* this_arg) {
6685 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
6686 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
6687 return (void*) this_arg;
6689 static inline LDKConfirm LDKConfirm_init (JNIEnv *env, jclass clz, jobject o) {
6690 jclass c = (*env)->GetObjectClass(env, o);
6692 LDKConfirm_JCalls *calls = MALLOC(sizeof(LDKConfirm_JCalls), "LDKConfirm_JCalls");
6693 atomic_init(&calls->refcnt, 1);
6694 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
6695 calls->o = (*env)->NewWeakGlobalRef(env, o);
6696 calls->transactions_confirmed_meth = (*env)->GetMethodID(env, c, "transactions_confirmed", "([B[JI)V");
6697 CHECK(calls->transactions_confirmed_meth != NULL);
6698 calls->transaction_unconfirmed_meth = (*env)->GetMethodID(env, c, "transaction_unconfirmed", "([B)V");
6699 CHECK(calls->transaction_unconfirmed_meth != NULL);
6700 calls->best_block_updated_meth = (*env)->GetMethodID(env, c, "best_block_updated", "([BI)V");
6701 CHECK(calls->best_block_updated_meth != NULL);
6702 calls->get_relevant_txids_meth = (*env)->GetMethodID(env, c, "get_relevant_txids", "()[[B");
6703 CHECK(calls->get_relevant_txids_meth != NULL);
6706 .this_arg = (void*) calls,
6707 .transactions_confirmed = transactions_confirmed_LDKConfirm_jcall,
6708 .transaction_unconfirmed = transaction_unconfirmed_LDKConfirm_jcall,
6709 .best_block_updated = best_block_updated_LDKConfirm_jcall,
6710 .get_relevant_txids = get_relevant_txids_LDKConfirm_jcall,
6711 .free = LDKConfirm_JCalls_free,
6715 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKConfirm_1new(JNIEnv *env, jclass clz, jobject o) {
6716 LDKConfirm *res_ptr = MALLOC(sizeof(LDKConfirm), "LDKConfirm");
6717 *res_ptr = LDKConfirm_init(env, clz, o);
6718 return (uint64_t)res_ptr;
6720 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Confirm_1transactions_1confirmed(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray header, int64_tArray txdata, int32_t height) {
6721 LDKConfirm* this_arg_conv = (LDKConfirm*)(((uint64_t)this_arg) & ~1);
6722 unsigned char header_arr[80];
6723 CHECK((*env)->GetArrayLength(env, header) == 80);
6724 (*env)->GetByteArrayRegion(env, header, 0, 80, header_arr);
6725 unsigned char (*header_ref)[80] = &header_arr;
6726 LDKCVec_C2Tuple_usizeTransactionZZ txdata_constr;
6727 txdata_constr.datalen = (*env)->GetArrayLength(env, txdata);
6728 if (txdata_constr.datalen > 0)
6729 txdata_constr.data = MALLOC(txdata_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
6731 txdata_constr.data = NULL;
6732 int64_t* txdata_vals = (*env)->GetLongArrayElements (env, txdata, NULL);
6733 for (size_t y = 0; y < txdata_constr.datalen; y++) {
6734 int64_t txdata_conv_24 = txdata_vals[y];
6735 LDKC2Tuple_usizeTransactionZ txdata_conv_24_conv = *(LDKC2Tuple_usizeTransactionZ*)(((uint64_t)txdata_conv_24) & ~1);
6736 txdata_conv_24_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)(((uint64_t)txdata_conv_24) & ~1));
6737 txdata_constr.data[y] = txdata_conv_24_conv;
6739 (*env)->ReleaseLongArrayElements(env, txdata, txdata_vals, 0);
6740 (this_arg_conv->transactions_confirmed)(this_arg_conv->this_arg, header_ref, txdata_constr, height);
6743 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Confirm_1transaction_1unconfirmed(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray txid) {
6744 LDKConfirm* this_arg_conv = (LDKConfirm*)(((uint64_t)this_arg) & ~1);
6745 unsigned char txid_arr[32];
6746 CHECK((*env)->GetArrayLength(env, txid) == 32);
6747 (*env)->GetByteArrayRegion(env, txid, 0, 32, txid_arr);
6748 unsigned char (*txid_ref)[32] = &txid_arr;
6749 (this_arg_conv->transaction_unconfirmed)(this_arg_conv->this_arg, txid_ref);
6752 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Confirm_1best_1block_1updated(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray header, int32_t height) {
6753 LDKConfirm* this_arg_conv = (LDKConfirm*)(((uint64_t)this_arg) & ~1);
6754 unsigned char header_arr[80];
6755 CHECK((*env)->GetArrayLength(env, header) == 80);
6756 (*env)->GetByteArrayRegion(env, header, 0, 80, header_arr);
6757 unsigned char (*header_ref)[80] = &header_arr;
6758 (this_arg_conv->best_block_updated)(this_arg_conv->this_arg, header_ref, height);
6761 JNIEXPORT jobjectArray JNICALL Java_org_ldk_impl_bindings_Confirm_1get_1relevant_1txids(JNIEnv *env, jclass clz, int64_t this_arg) {
6762 LDKConfirm* this_arg_conv = (LDKConfirm*)(((uint64_t)this_arg) & ~1);
6763 LDKCVec_TxidZ ret_var = (this_arg_conv->get_relevant_txids)(this_arg_conv->this_arg);
6764 jobjectArray ret_arr = (*env)->NewObjectArray(env, ret_var.datalen, arr_of_B_clz, NULL);
6766 for (size_t i = 0; i < ret_var.datalen; i++) {
6767 int8_tArray ret_conv_8_arr = (*env)->NewByteArray(env, 32);
6768 (*env)->SetByteArrayRegion(env, ret_conv_8_arr, 0, 32, ret_var.data[i].data);
6769 (*env)->SetObjectArrayElement(env, ret_arr, i, ret_conv_8_arr);
6775 typedef struct LDKFilter_JCalls {
6776 atomic_size_t refcnt;
6779 jmethodID register_tx_meth;
6780 jmethodID register_output_meth;
6782 static void LDKFilter_JCalls_free(void* this_arg) {
6783 LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg;
6784 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
6786 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
6787 if (get_jenv_res == JNI_EDETACHED) {
6788 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
6790 DO_ASSERT(get_jenv_res == JNI_OK);
6792 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
6793 if (get_jenv_res == JNI_EDETACHED) {
6794 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
6799 void register_tx_LDKFilter_jcall(const void* this_arg, const uint8_t (* txid)[32], LDKu8slice script_pubkey) {
6800 LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg;
6802 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
6803 if (get_jenv_res == JNI_EDETACHED) {
6804 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
6806 DO_ASSERT(get_jenv_res == JNI_OK);
6808 int8_tArray txid_arr = (*env)->NewByteArray(env, 32);
6809 (*env)->SetByteArrayRegion(env, txid_arr, 0, 32, *txid);
6810 LDKu8slice script_pubkey_var = script_pubkey;
6811 int8_tArray script_pubkey_arr = (*env)->NewByteArray(env, script_pubkey_var.datalen);
6812 (*env)->SetByteArrayRegion(env, script_pubkey_arr, 0, script_pubkey_var.datalen, script_pubkey_var.data);
6813 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
6815 (*env)->CallVoidMethod(env, obj, j_calls->register_tx_meth, txid_arr, script_pubkey_arr);
6816 if ((*env)->ExceptionCheck(env)) {
6817 (*env)->ExceptionDescribe(env);
6818 (*env)->FatalError(env, "A call to register_tx in LDKFilter from rust threw an exception.");
6820 if (get_jenv_res == JNI_EDETACHED) {
6821 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
6824 LDKCOption_C2Tuple_usizeTransactionZZ register_output_LDKFilter_jcall(const void* this_arg, LDKWatchedOutput output) {
6825 LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg;
6827 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
6828 if (get_jenv_res == JNI_EDETACHED) {
6829 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
6831 DO_ASSERT(get_jenv_res == JNI_OK);
6833 LDKWatchedOutput output_var = output;
6834 CHECK((((uint64_t)output_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6835 CHECK((((uint64_t)&output_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6836 uint64_t output_ref = (uint64_t)output_var.inner;
6837 if (output_var.is_owned) {
6840 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
6842 LDKCOption_C2Tuple_usizeTransactionZZ* ret = (LDKCOption_C2Tuple_usizeTransactionZZ*)(*env)->CallLongMethod(env, obj, j_calls->register_output_meth, output_ref);
6843 if ((*env)->ExceptionCheck(env)) {
6844 (*env)->ExceptionDescribe(env);
6845 (*env)->FatalError(env, "A call to register_output in LDKFilter from rust threw an exception.");
6847 LDKCOption_C2Tuple_usizeTransactionZZ ret_conv = *(LDKCOption_C2Tuple_usizeTransactionZZ*)(((uint64_t)ret) & ~1);
6848 ret_conv = COption_C2Tuple_usizeTransactionZZ_clone((LDKCOption_C2Tuple_usizeTransactionZZ*)(((uint64_t)ret) & ~1));
6849 if (get_jenv_res == JNI_EDETACHED) {
6850 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
6854 static void* LDKFilter_JCalls_clone(const void* this_arg) {
6855 LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg;
6856 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
6857 return (void*) this_arg;
6859 static inline LDKFilter LDKFilter_init (JNIEnv *env, jclass clz, jobject o) {
6860 jclass c = (*env)->GetObjectClass(env, o);
6862 LDKFilter_JCalls *calls = MALLOC(sizeof(LDKFilter_JCalls), "LDKFilter_JCalls");
6863 atomic_init(&calls->refcnt, 1);
6864 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
6865 calls->o = (*env)->NewWeakGlobalRef(env, o);
6866 calls->register_tx_meth = (*env)->GetMethodID(env, c, "register_tx", "([B[B)V");
6867 CHECK(calls->register_tx_meth != NULL);
6868 calls->register_output_meth = (*env)->GetMethodID(env, c, "register_output", "(J)J");
6869 CHECK(calls->register_output_meth != NULL);
6872 .this_arg = (void*) calls,
6873 .register_tx = register_tx_LDKFilter_jcall,
6874 .register_output = register_output_LDKFilter_jcall,
6875 .free = LDKFilter_JCalls_free,
6879 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKFilter_1new(JNIEnv *env, jclass clz, jobject o) {
6880 LDKFilter *res_ptr = MALLOC(sizeof(LDKFilter), "LDKFilter");
6881 *res_ptr = LDKFilter_init(env, clz, o);
6882 return (uint64_t)res_ptr;
6884 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Filter_1register_1tx(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray txid, int8_tArray script_pubkey) {
6885 LDKFilter* this_arg_conv = (LDKFilter*)(((uint64_t)this_arg) & ~1);
6886 unsigned char txid_arr[32];
6887 CHECK((*env)->GetArrayLength(env, txid) == 32);
6888 (*env)->GetByteArrayRegion(env, txid, 0, 32, txid_arr);
6889 unsigned char (*txid_ref)[32] = &txid_arr;
6890 LDKu8slice script_pubkey_ref;
6891 script_pubkey_ref.datalen = (*env)->GetArrayLength(env, script_pubkey);
6892 script_pubkey_ref.data = (*env)->GetByteArrayElements (env, script_pubkey, NULL);
6893 (this_arg_conv->register_tx)(this_arg_conv->this_arg, txid_ref, script_pubkey_ref);
6894 (*env)->ReleaseByteArrayElements(env, script_pubkey, (int8_t*)script_pubkey_ref.data, 0);
6897 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Filter_1register_1output(JNIEnv *env, jclass clz, int64_t this_arg, int64_t output) {
6898 LDKFilter* this_arg_conv = (LDKFilter*)(((uint64_t)this_arg) & ~1);
6899 LDKWatchedOutput output_conv;
6900 output_conv.inner = (void*)(output & (~1));
6901 output_conv.is_owned = (output & 1) || (output == 0);
6902 output_conv = WatchedOutput_clone(&output_conv);
6903 LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ");
6904 *ret_copy = (this_arg_conv->register_output)(this_arg_conv->this_arg, output_conv);
6905 uint64_t ret_ref = (uint64_t)ret_copy;
6909 typedef struct LDKPersist_JCalls {
6910 atomic_size_t refcnt;
6913 jmethodID persist_new_channel_meth;
6914 jmethodID update_persisted_channel_meth;
6915 } LDKPersist_JCalls;
6916 static void LDKPersist_JCalls_free(void* this_arg) {
6917 LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) this_arg;
6918 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
6920 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
6921 if (get_jenv_res == JNI_EDETACHED) {
6922 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
6924 DO_ASSERT(get_jenv_res == JNI_OK);
6926 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
6927 if (get_jenv_res == JNI_EDETACHED) {
6928 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
6933 LDKCResult_NoneChannelMonitorUpdateErrZ persist_new_channel_LDKPersist_jcall(const void* this_arg, LDKOutPoint id, const LDKChannelMonitor * data) {
6934 LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) this_arg;
6936 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
6937 if (get_jenv_res == JNI_EDETACHED) {
6938 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
6940 DO_ASSERT(get_jenv_res == JNI_OK);
6942 LDKOutPoint id_var = id;
6943 CHECK((((uint64_t)id_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6944 CHECK((((uint64_t)&id_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6945 uint64_t id_ref = (uint64_t)id_var.inner;
6946 if (id_var.is_owned) {
6949 LDKChannelMonitor data_var = *data;
6950 data_var = ChannelMonitor_clone(data);
6951 CHECK((((uint64_t)data_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6952 CHECK((((uint64_t)&data_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6953 uint64_t data_ref = (uint64_t)data_var.inner;
6954 if (data_var.is_owned) {
6957 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
6959 LDKCResult_NoneChannelMonitorUpdateErrZ* ret = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(*env)->CallLongMethod(env, obj, j_calls->persist_new_channel_meth, id_ref, data_ref);
6960 if ((*env)->ExceptionCheck(env)) {
6961 (*env)->ExceptionDescribe(env);
6962 (*env)->FatalError(env, "A call to persist_new_channel in LDKPersist from rust threw an exception.");
6964 LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1);
6965 ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1));
6966 if (get_jenv_res == JNI_EDETACHED) {
6967 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
6971 LDKCResult_NoneChannelMonitorUpdateErrZ update_persisted_channel_LDKPersist_jcall(const void* this_arg, LDKOutPoint id, const LDKChannelMonitorUpdate * update, const LDKChannelMonitor * data) {
6972 LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) this_arg;
6974 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
6975 if (get_jenv_res == JNI_EDETACHED) {
6976 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
6978 DO_ASSERT(get_jenv_res == JNI_OK);
6980 LDKOutPoint id_var = id;
6981 CHECK((((uint64_t)id_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6982 CHECK((((uint64_t)&id_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6983 uint64_t id_ref = (uint64_t)id_var.inner;
6984 if (id_var.is_owned) {
6987 LDKChannelMonitorUpdate update_var = *update;
6988 update_var = ChannelMonitorUpdate_clone(update);
6989 CHECK((((uint64_t)update_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6990 CHECK((((uint64_t)&update_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6991 uint64_t update_ref = (uint64_t)update_var.inner;
6992 if (update_var.is_owned) {
6995 LDKChannelMonitor data_var = *data;
6996 data_var = ChannelMonitor_clone(data);
6997 CHECK((((uint64_t)data_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6998 CHECK((((uint64_t)&data_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6999 uint64_t data_ref = (uint64_t)data_var.inner;
7000 if (data_var.is_owned) {
7003 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
7005 LDKCResult_NoneChannelMonitorUpdateErrZ* ret = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(*env)->CallLongMethod(env, obj, j_calls->update_persisted_channel_meth, id_ref, update_ref, data_ref);
7006 if ((*env)->ExceptionCheck(env)) {
7007 (*env)->ExceptionDescribe(env);
7008 (*env)->FatalError(env, "A call to update_persisted_channel in LDKPersist from rust threw an exception.");
7010 LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1);
7011 ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1));
7012 if (get_jenv_res == JNI_EDETACHED) {
7013 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
7017 static void* LDKPersist_JCalls_clone(const void* this_arg) {
7018 LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) this_arg;
7019 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
7020 return (void*) this_arg;
7022 static inline LDKPersist LDKPersist_init (JNIEnv *env, jclass clz, jobject o) {
7023 jclass c = (*env)->GetObjectClass(env, o);
7025 LDKPersist_JCalls *calls = MALLOC(sizeof(LDKPersist_JCalls), "LDKPersist_JCalls");
7026 atomic_init(&calls->refcnt, 1);
7027 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
7028 calls->o = (*env)->NewWeakGlobalRef(env, o);
7029 calls->persist_new_channel_meth = (*env)->GetMethodID(env, c, "persist_new_channel", "(JJ)J");
7030 CHECK(calls->persist_new_channel_meth != NULL);
7031 calls->update_persisted_channel_meth = (*env)->GetMethodID(env, c, "update_persisted_channel", "(JJJ)J");
7032 CHECK(calls->update_persisted_channel_meth != NULL);
7035 .this_arg = (void*) calls,
7036 .persist_new_channel = persist_new_channel_LDKPersist_jcall,
7037 .update_persisted_channel = update_persisted_channel_LDKPersist_jcall,
7038 .free = LDKPersist_JCalls_free,
7042 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKPersist_1new(JNIEnv *env, jclass clz, jobject o) {
7043 LDKPersist *res_ptr = MALLOC(sizeof(LDKPersist), "LDKPersist");
7044 *res_ptr = LDKPersist_init(env, clz, o);
7045 return (uint64_t)res_ptr;
7047 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Persist_1persist_1new_1channel(JNIEnv *env, jclass clz, int64_t this_arg, int64_t id, int64_t data) {
7048 LDKPersist* this_arg_conv = (LDKPersist*)(((uint64_t)this_arg) & ~1);
7049 LDKOutPoint id_conv;
7050 id_conv.inner = (void*)(id & (~1));
7051 id_conv.is_owned = (id & 1) || (id == 0);
7052 id_conv = OutPoint_clone(&id_conv);
7053 LDKChannelMonitor data_conv;
7054 data_conv.inner = (void*)(data & (~1));
7055 data_conv.is_owned = false;
7056 LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
7057 *ret_conv = (this_arg_conv->persist_new_channel)(this_arg_conv->this_arg, id_conv, &data_conv);
7058 return (uint64_t)ret_conv;
7061 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Persist_1update_1persisted_1channel(JNIEnv *env, jclass clz, int64_t this_arg, int64_t id, int64_t update, int64_t data) {
7062 LDKPersist* this_arg_conv = (LDKPersist*)(((uint64_t)this_arg) & ~1);
7063 LDKOutPoint id_conv;
7064 id_conv.inner = (void*)(id & (~1));
7065 id_conv.is_owned = (id & 1) || (id == 0);
7066 id_conv = OutPoint_clone(&id_conv);
7067 LDKChannelMonitorUpdate update_conv;
7068 update_conv.inner = (void*)(update & (~1));
7069 update_conv.is_owned = false;
7070 LDKChannelMonitor data_conv;
7071 data_conv.inner = (void*)(data & (~1));
7072 data_conv.is_owned = false;
7073 LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
7074 *ret_conv = (this_arg_conv->update_persisted_channel)(this_arg_conv->this_arg, id_conv, &update_conv, &data_conv);
7075 return (uint64_t)ret_conv;
7078 typedef struct LDKChannelMessageHandler_JCalls {
7079 atomic_size_t refcnt;
7082 LDKMessageSendEventsProvider_JCalls* MessageSendEventsProvider;
7083 jmethodID handle_open_channel_meth;
7084 jmethodID handle_accept_channel_meth;
7085 jmethodID handle_funding_created_meth;
7086 jmethodID handle_funding_signed_meth;
7087 jmethodID handle_funding_locked_meth;
7088 jmethodID handle_shutdown_meth;
7089 jmethodID handle_closing_signed_meth;
7090 jmethodID handle_update_add_htlc_meth;
7091 jmethodID handle_update_fulfill_htlc_meth;
7092 jmethodID handle_update_fail_htlc_meth;
7093 jmethodID handle_update_fail_malformed_htlc_meth;
7094 jmethodID handle_commitment_signed_meth;
7095 jmethodID handle_revoke_and_ack_meth;
7096 jmethodID handle_update_fee_meth;
7097 jmethodID handle_announcement_signatures_meth;
7098 jmethodID peer_disconnected_meth;
7099 jmethodID peer_connected_meth;
7100 jmethodID handle_channel_reestablish_meth;
7101 jmethodID handle_channel_update_meth;
7102 jmethodID handle_error_meth;
7103 } LDKChannelMessageHandler_JCalls;
7104 static void LDKChannelMessageHandler_JCalls_free(void* this_arg) {
7105 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
7106 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
7108 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
7109 if (get_jenv_res == JNI_EDETACHED) {
7110 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
7112 DO_ASSERT(get_jenv_res == JNI_OK);
7114 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
7115 if (get_jenv_res == JNI_EDETACHED) {
7116 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
7121 void handle_open_channel_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKInitFeatures their_features, const LDKOpenChannel * msg) {
7122 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
7124 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
7125 if (get_jenv_res == JNI_EDETACHED) {
7126 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
7128 DO_ASSERT(get_jenv_res == JNI_OK);
7130 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
7131 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
7132 LDKInitFeatures their_features_var = their_features;
7133 CHECK((((uint64_t)their_features_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7134 CHECK((((uint64_t)&their_features_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7135 uint64_t their_features_ref = (uint64_t)their_features_var.inner;
7136 if (their_features_var.is_owned) {
7137 their_features_ref |= 1;
7139 LDKOpenChannel msg_var = *msg;
7140 msg_var = OpenChannel_clone(msg);
7141 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7142 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7143 uint64_t msg_ref = (uint64_t)msg_var.inner;
7144 if (msg_var.is_owned) {
7147 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
7149 (*env)->CallVoidMethod(env, obj, j_calls->handle_open_channel_meth, their_node_id_arr, their_features_ref, msg_ref);
7150 if ((*env)->ExceptionCheck(env)) {
7151 (*env)->ExceptionDescribe(env);
7152 (*env)->FatalError(env, "A call to handle_open_channel in LDKChannelMessageHandler from rust threw an exception.");
7154 if (get_jenv_res == JNI_EDETACHED) {
7155 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
7158 void handle_accept_channel_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKInitFeatures their_features, const LDKAcceptChannel * msg) {
7159 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
7161 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
7162 if (get_jenv_res == JNI_EDETACHED) {
7163 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
7165 DO_ASSERT(get_jenv_res == JNI_OK);
7167 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
7168 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
7169 LDKInitFeatures their_features_var = their_features;
7170 CHECK((((uint64_t)their_features_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7171 CHECK((((uint64_t)&their_features_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7172 uint64_t their_features_ref = (uint64_t)their_features_var.inner;
7173 if (their_features_var.is_owned) {
7174 their_features_ref |= 1;
7176 LDKAcceptChannel msg_var = *msg;
7177 msg_var = AcceptChannel_clone(msg);
7178 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7179 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7180 uint64_t msg_ref = (uint64_t)msg_var.inner;
7181 if (msg_var.is_owned) {
7184 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
7186 (*env)->CallVoidMethod(env, obj, j_calls->handle_accept_channel_meth, their_node_id_arr, their_features_ref, msg_ref);
7187 if ((*env)->ExceptionCheck(env)) {
7188 (*env)->ExceptionDescribe(env);
7189 (*env)->FatalError(env, "A call to handle_accept_channel in LDKChannelMessageHandler from rust threw an exception.");
7191 if (get_jenv_res == JNI_EDETACHED) {
7192 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
7195 void handle_funding_created_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKFundingCreated * msg) {
7196 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
7198 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
7199 if (get_jenv_res == JNI_EDETACHED) {
7200 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
7202 DO_ASSERT(get_jenv_res == JNI_OK);
7204 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
7205 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
7206 LDKFundingCreated msg_var = *msg;
7207 msg_var = FundingCreated_clone(msg);
7208 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7209 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7210 uint64_t msg_ref = (uint64_t)msg_var.inner;
7211 if (msg_var.is_owned) {
7214 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
7216 (*env)->CallVoidMethod(env, obj, j_calls->handle_funding_created_meth, their_node_id_arr, msg_ref);
7217 if ((*env)->ExceptionCheck(env)) {
7218 (*env)->ExceptionDescribe(env);
7219 (*env)->FatalError(env, "A call to handle_funding_created in LDKChannelMessageHandler from rust threw an exception.");
7221 if (get_jenv_res == JNI_EDETACHED) {
7222 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
7225 void handle_funding_signed_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKFundingSigned * msg) {
7226 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
7228 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
7229 if (get_jenv_res == JNI_EDETACHED) {
7230 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
7232 DO_ASSERT(get_jenv_res == JNI_OK);
7234 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
7235 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
7236 LDKFundingSigned msg_var = *msg;
7237 msg_var = FundingSigned_clone(msg);
7238 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7239 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7240 uint64_t msg_ref = (uint64_t)msg_var.inner;
7241 if (msg_var.is_owned) {
7244 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
7246 (*env)->CallVoidMethod(env, obj, j_calls->handle_funding_signed_meth, their_node_id_arr, msg_ref);
7247 if ((*env)->ExceptionCheck(env)) {
7248 (*env)->ExceptionDescribe(env);
7249 (*env)->FatalError(env, "A call to handle_funding_signed in LDKChannelMessageHandler from rust threw an exception.");
7251 if (get_jenv_res == JNI_EDETACHED) {
7252 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
7255 void handle_funding_locked_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKFundingLocked * msg) {
7256 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
7258 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
7259 if (get_jenv_res == JNI_EDETACHED) {
7260 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
7262 DO_ASSERT(get_jenv_res == JNI_OK);
7264 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
7265 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
7266 LDKFundingLocked msg_var = *msg;
7267 msg_var = FundingLocked_clone(msg);
7268 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7269 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7270 uint64_t msg_ref = (uint64_t)msg_var.inner;
7271 if (msg_var.is_owned) {
7274 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
7276 (*env)->CallVoidMethod(env, obj, j_calls->handle_funding_locked_meth, their_node_id_arr, msg_ref);
7277 if ((*env)->ExceptionCheck(env)) {
7278 (*env)->ExceptionDescribe(env);
7279 (*env)->FatalError(env, "A call to handle_funding_locked in LDKChannelMessageHandler from rust threw an exception.");
7281 if (get_jenv_res == JNI_EDETACHED) {
7282 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
7285 void handle_shutdown_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInitFeatures * their_features, const LDKShutdown * msg) {
7286 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
7288 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
7289 if (get_jenv_res == JNI_EDETACHED) {
7290 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
7292 DO_ASSERT(get_jenv_res == JNI_OK);
7294 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
7295 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
7296 LDKInitFeatures their_features_var = *their_features;
7297 their_features_var = InitFeatures_clone(their_features);
7298 CHECK((((uint64_t)their_features_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7299 CHECK((((uint64_t)&their_features_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7300 uint64_t their_features_ref = (uint64_t)their_features_var.inner;
7301 if (their_features_var.is_owned) {
7302 their_features_ref |= 1;
7304 LDKShutdown msg_var = *msg;
7305 msg_var = Shutdown_clone(msg);
7306 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7307 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7308 uint64_t msg_ref = (uint64_t)msg_var.inner;
7309 if (msg_var.is_owned) {
7312 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
7314 (*env)->CallVoidMethod(env, obj, j_calls->handle_shutdown_meth, their_node_id_arr, their_features_ref, msg_ref);
7315 if ((*env)->ExceptionCheck(env)) {
7316 (*env)->ExceptionDescribe(env);
7317 (*env)->FatalError(env, "A call to handle_shutdown in LDKChannelMessageHandler from rust threw an exception.");
7319 if (get_jenv_res == JNI_EDETACHED) {
7320 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
7323 void handle_closing_signed_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKClosingSigned * msg) {
7324 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
7326 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
7327 if (get_jenv_res == JNI_EDETACHED) {
7328 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
7330 DO_ASSERT(get_jenv_res == JNI_OK);
7332 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
7333 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
7334 LDKClosingSigned msg_var = *msg;
7335 msg_var = ClosingSigned_clone(msg);
7336 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7337 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7338 uint64_t msg_ref = (uint64_t)msg_var.inner;
7339 if (msg_var.is_owned) {
7342 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
7344 (*env)->CallVoidMethod(env, obj, j_calls->handle_closing_signed_meth, their_node_id_arr, msg_ref);
7345 if ((*env)->ExceptionCheck(env)) {
7346 (*env)->ExceptionDescribe(env);
7347 (*env)->FatalError(env, "A call to handle_closing_signed in LDKChannelMessageHandler from rust threw an exception.");
7349 if (get_jenv_res == JNI_EDETACHED) {
7350 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
7353 void handle_update_add_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateAddHTLC * msg) {
7354 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
7356 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
7357 if (get_jenv_res == JNI_EDETACHED) {
7358 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
7360 DO_ASSERT(get_jenv_res == JNI_OK);
7362 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
7363 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
7364 LDKUpdateAddHTLC msg_var = *msg;
7365 msg_var = UpdateAddHTLC_clone(msg);
7366 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7367 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7368 uint64_t msg_ref = (uint64_t)msg_var.inner;
7369 if (msg_var.is_owned) {
7372 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
7374 (*env)->CallVoidMethod(env, obj, j_calls->handle_update_add_htlc_meth, their_node_id_arr, msg_ref);
7375 if ((*env)->ExceptionCheck(env)) {
7376 (*env)->ExceptionDescribe(env);
7377 (*env)->FatalError(env, "A call to handle_update_add_htlc in LDKChannelMessageHandler from rust threw an exception.");
7379 if (get_jenv_res == JNI_EDETACHED) {
7380 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
7383 void handle_update_fulfill_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFulfillHTLC * msg) {
7384 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
7386 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
7387 if (get_jenv_res == JNI_EDETACHED) {
7388 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
7390 DO_ASSERT(get_jenv_res == JNI_OK);
7392 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
7393 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
7394 LDKUpdateFulfillHTLC msg_var = *msg;
7395 msg_var = UpdateFulfillHTLC_clone(msg);
7396 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7397 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7398 uint64_t msg_ref = (uint64_t)msg_var.inner;
7399 if (msg_var.is_owned) {
7402 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
7404 (*env)->CallVoidMethod(env, obj, j_calls->handle_update_fulfill_htlc_meth, their_node_id_arr, msg_ref);
7405 if ((*env)->ExceptionCheck(env)) {
7406 (*env)->ExceptionDescribe(env);
7407 (*env)->FatalError(env, "A call to handle_update_fulfill_htlc in LDKChannelMessageHandler from rust threw an exception.");
7409 if (get_jenv_res == JNI_EDETACHED) {
7410 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
7413 void handle_update_fail_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFailHTLC * msg) {
7414 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
7416 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
7417 if (get_jenv_res == JNI_EDETACHED) {
7418 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
7420 DO_ASSERT(get_jenv_res == JNI_OK);
7422 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
7423 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
7424 LDKUpdateFailHTLC msg_var = *msg;
7425 msg_var = UpdateFailHTLC_clone(msg);
7426 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7427 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7428 uint64_t msg_ref = (uint64_t)msg_var.inner;
7429 if (msg_var.is_owned) {
7432 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
7434 (*env)->CallVoidMethod(env, obj, j_calls->handle_update_fail_htlc_meth, their_node_id_arr, msg_ref);
7435 if ((*env)->ExceptionCheck(env)) {
7436 (*env)->ExceptionDescribe(env);
7437 (*env)->FatalError(env, "A call to handle_update_fail_htlc in LDKChannelMessageHandler from rust threw an exception.");
7439 if (get_jenv_res == JNI_EDETACHED) {
7440 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
7443 void handle_update_fail_malformed_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFailMalformedHTLC * msg) {
7444 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
7446 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
7447 if (get_jenv_res == JNI_EDETACHED) {
7448 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
7450 DO_ASSERT(get_jenv_res == JNI_OK);
7452 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
7453 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
7454 LDKUpdateFailMalformedHTLC msg_var = *msg;
7455 msg_var = UpdateFailMalformedHTLC_clone(msg);
7456 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7457 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7458 uint64_t msg_ref = (uint64_t)msg_var.inner;
7459 if (msg_var.is_owned) {
7462 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
7464 (*env)->CallVoidMethod(env, obj, j_calls->handle_update_fail_malformed_htlc_meth, their_node_id_arr, msg_ref);
7465 if ((*env)->ExceptionCheck(env)) {
7466 (*env)->ExceptionDescribe(env);
7467 (*env)->FatalError(env, "A call to handle_update_fail_malformed_htlc in LDKChannelMessageHandler from rust threw an exception.");
7469 if (get_jenv_res == JNI_EDETACHED) {
7470 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
7473 void handle_commitment_signed_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKCommitmentSigned * msg) {
7474 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
7476 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
7477 if (get_jenv_res == JNI_EDETACHED) {
7478 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
7480 DO_ASSERT(get_jenv_res == JNI_OK);
7482 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
7483 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
7484 LDKCommitmentSigned msg_var = *msg;
7485 msg_var = CommitmentSigned_clone(msg);
7486 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7487 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7488 uint64_t msg_ref = (uint64_t)msg_var.inner;
7489 if (msg_var.is_owned) {
7492 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
7494 (*env)->CallVoidMethod(env, obj, j_calls->handle_commitment_signed_meth, their_node_id_arr, msg_ref);
7495 if ((*env)->ExceptionCheck(env)) {
7496 (*env)->ExceptionDescribe(env);
7497 (*env)->FatalError(env, "A call to handle_commitment_signed in LDKChannelMessageHandler from rust threw an exception.");
7499 if (get_jenv_res == JNI_EDETACHED) {
7500 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
7503 void handle_revoke_and_ack_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKRevokeAndACK * msg) {
7504 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
7506 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
7507 if (get_jenv_res == JNI_EDETACHED) {
7508 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
7510 DO_ASSERT(get_jenv_res == JNI_OK);
7512 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
7513 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
7514 LDKRevokeAndACK msg_var = *msg;
7515 msg_var = RevokeAndACK_clone(msg);
7516 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7517 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7518 uint64_t msg_ref = (uint64_t)msg_var.inner;
7519 if (msg_var.is_owned) {
7522 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
7524 (*env)->CallVoidMethod(env, obj, j_calls->handle_revoke_and_ack_meth, their_node_id_arr, msg_ref);
7525 if ((*env)->ExceptionCheck(env)) {
7526 (*env)->ExceptionDescribe(env);
7527 (*env)->FatalError(env, "A call to handle_revoke_and_ack in LDKChannelMessageHandler from rust threw an exception.");
7529 if (get_jenv_res == JNI_EDETACHED) {
7530 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
7533 void handle_update_fee_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFee * msg) {
7534 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
7536 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
7537 if (get_jenv_res == JNI_EDETACHED) {
7538 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
7540 DO_ASSERT(get_jenv_res == JNI_OK);
7542 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
7543 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
7544 LDKUpdateFee msg_var = *msg;
7545 msg_var = UpdateFee_clone(msg);
7546 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7547 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7548 uint64_t msg_ref = (uint64_t)msg_var.inner;
7549 if (msg_var.is_owned) {
7552 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
7554 (*env)->CallVoidMethod(env, obj, j_calls->handle_update_fee_meth, their_node_id_arr, msg_ref);
7555 if ((*env)->ExceptionCheck(env)) {
7556 (*env)->ExceptionDescribe(env);
7557 (*env)->FatalError(env, "A call to handle_update_fee in LDKChannelMessageHandler from rust threw an exception.");
7559 if (get_jenv_res == JNI_EDETACHED) {
7560 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
7563 void handle_announcement_signatures_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKAnnouncementSignatures * msg) {
7564 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
7566 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
7567 if (get_jenv_res == JNI_EDETACHED) {
7568 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
7570 DO_ASSERT(get_jenv_res == JNI_OK);
7572 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
7573 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
7574 LDKAnnouncementSignatures msg_var = *msg;
7575 msg_var = AnnouncementSignatures_clone(msg);
7576 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7577 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7578 uint64_t msg_ref = (uint64_t)msg_var.inner;
7579 if (msg_var.is_owned) {
7582 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
7584 (*env)->CallVoidMethod(env, obj, j_calls->handle_announcement_signatures_meth, their_node_id_arr, msg_ref);
7585 if ((*env)->ExceptionCheck(env)) {
7586 (*env)->ExceptionDescribe(env);
7587 (*env)->FatalError(env, "A call to handle_announcement_signatures in LDKChannelMessageHandler from rust threw an exception.");
7589 if (get_jenv_res == JNI_EDETACHED) {
7590 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
7593 void peer_disconnected_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, bool no_connection_possible) {
7594 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
7596 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
7597 if (get_jenv_res == JNI_EDETACHED) {
7598 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
7600 DO_ASSERT(get_jenv_res == JNI_OK);
7602 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
7603 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
7604 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
7606 (*env)->CallVoidMethod(env, obj, j_calls->peer_disconnected_meth, their_node_id_arr, no_connection_possible);
7607 if ((*env)->ExceptionCheck(env)) {
7608 (*env)->ExceptionDescribe(env);
7609 (*env)->FatalError(env, "A call to peer_disconnected in LDKChannelMessageHandler from rust threw an exception.");
7611 if (get_jenv_res == JNI_EDETACHED) {
7612 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
7615 void peer_connected_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInit * msg) {
7616 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
7618 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
7619 if (get_jenv_res == JNI_EDETACHED) {
7620 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
7622 DO_ASSERT(get_jenv_res == JNI_OK);
7624 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
7625 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
7626 LDKInit msg_var = *msg;
7627 msg_var = Init_clone(msg);
7628 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7629 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7630 uint64_t msg_ref = (uint64_t)msg_var.inner;
7631 if (msg_var.is_owned) {
7634 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
7636 (*env)->CallVoidMethod(env, obj, j_calls->peer_connected_meth, their_node_id_arr, msg_ref);
7637 if ((*env)->ExceptionCheck(env)) {
7638 (*env)->ExceptionDescribe(env);
7639 (*env)->FatalError(env, "A call to peer_connected in LDKChannelMessageHandler from rust threw an exception.");
7641 if (get_jenv_res == JNI_EDETACHED) {
7642 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
7645 void handle_channel_reestablish_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKChannelReestablish * msg) {
7646 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
7648 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
7649 if (get_jenv_res == JNI_EDETACHED) {
7650 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
7652 DO_ASSERT(get_jenv_res == JNI_OK);
7654 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
7655 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
7656 LDKChannelReestablish msg_var = *msg;
7657 msg_var = ChannelReestablish_clone(msg);
7658 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7659 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7660 uint64_t msg_ref = (uint64_t)msg_var.inner;
7661 if (msg_var.is_owned) {
7664 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
7666 (*env)->CallVoidMethod(env, obj, j_calls->handle_channel_reestablish_meth, their_node_id_arr, msg_ref);
7667 if ((*env)->ExceptionCheck(env)) {
7668 (*env)->ExceptionDescribe(env);
7669 (*env)->FatalError(env, "A call to handle_channel_reestablish in LDKChannelMessageHandler from rust threw an exception.");
7671 if (get_jenv_res == JNI_EDETACHED) {
7672 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
7675 void handle_channel_update_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKChannelUpdate * msg) {
7676 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
7678 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
7679 if (get_jenv_res == JNI_EDETACHED) {
7680 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
7682 DO_ASSERT(get_jenv_res == JNI_OK);
7684 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
7685 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
7686 LDKChannelUpdate msg_var = *msg;
7687 msg_var = ChannelUpdate_clone(msg);
7688 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7689 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7690 uint64_t msg_ref = (uint64_t)msg_var.inner;
7691 if (msg_var.is_owned) {
7694 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
7696 (*env)->CallVoidMethod(env, obj, j_calls->handle_channel_update_meth, their_node_id_arr, msg_ref);
7697 if ((*env)->ExceptionCheck(env)) {
7698 (*env)->ExceptionDescribe(env);
7699 (*env)->FatalError(env, "A call to handle_channel_update in LDKChannelMessageHandler from rust threw an exception.");
7701 if (get_jenv_res == JNI_EDETACHED) {
7702 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
7705 void handle_error_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKErrorMessage * msg) {
7706 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
7708 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
7709 if (get_jenv_res == JNI_EDETACHED) {
7710 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
7712 DO_ASSERT(get_jenv_res == JNI_OK);
7714 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
7715 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
7716 LDKErrorMessage msg_var = *msg;
7717 msg_var = ErrorMessage_clone(msg);
7718 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7719 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7720 uint64_t msg_ref = (uint64_t)msg_var.inner;
7721 if (msg_var.is_owned) {
7724 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
7726 (*env)->CallVoidMethod(env, obj, j_calls->handle_error_meth, their_node_id_arr, msg_ref);
7727 if ((*env)->ExceptionCheck(env)) {
7728 (*env)->ExceptionDescribe(env);
7729 (*env)->FatalError(env, "A call to handle_error in LDKChannelMessageHandler from rust threw an exception.");
7731 if (get_jenv_res == JNI_EDETACHED) {
7732 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
7735 static void* LDKChannelMessageHandler_JCalls_clone(const void* this_arg) {
7736 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
7737 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
7738 atomic_fetch_add_explicit(&j_calls->MessageSendEventsProvider->refcnt, 1, memory_order_release);
7739 return (void*) this_arg;
7741 static inline LDKChannelMessageHandler LDKChannelMessageHandler_init (JNIEnv *env, jclass clz, jobject o, jobject MessageSendEventsProvider) {
7742 jclass c = (*env)->GetObjectClass(env, o);
7744 LDKChannelMessageHandler_JCalls *calls = MALLOC(sizeof(LDKChannelMessageHandler_JCalls), "LDKChannelMessageHandler_JCalls");
7745 atomic_init(&calls->refcnt, 1);
7746 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
7747 calls->o = (*env)->NewWeakGlobalRef(env, o);
7748 calls->handle_open_channel_meth = (*env)->GetMethodID(env, c, "handle_open_channel", "([BJJ)V");
7749 CHECK(calls->handle_open_channel_meth != NULL);
7750 calls->handle_accept_channel_meth = (*env)->GetMethodID(env, c, "handle_accept_channel", "([BJJ)V");
7751 CHECK(calls->handle_accept_channel_meth != NULL);
7752 calls->handle_funding_created_meth = (*env)->GetMethodID(env, c, "handle_funding_created", "([BJ)V");
7753 CHECK(calls->handle_funding_created_meth != NULL);
7754 calls->handle_funding_signed_meth = (*env)->GetMethodID(env, c, "handle_funding_signed", "([BJ)V");
7755 CHECK(calls->handle_funding_signed_meth != NULL);
7756 calls->handle_funding_locked_meth = (*env)->GetMethodID(env, c, "handle_funding_locked", "([BJ)V");
7757 CHECK(calls->handle_funding_locked_meth != NULL);
7758 calls->handle_shutdown_meth = (*env)->GetMethodID(env, c, "handle_shutdown", "([BJJ)V");
7759 CHECK(calls->handle_shutdown_meth != NULL);
7760 calls->handle_closing_signed_meth = (*env)->GetMethodID(env, c, "handle_closing_signed", "([BJ)V");
7761 CHECK(calls->handle_closing_signed_meth != NULL);
7762 calls->handle_update_add_htlc_meth = (*env)->GetMethodID(env, c, "handle_update_add_htlc", "([BJ)V");
7763 CHECK(calls->handle_update_add_htlc_meth != NULL);
7764 calls->handle_update_fulfill_htlc_meth = (*env)->GetMethodID(env, c, "handle_update_fulfill_htlc", "([BJ)V");
7765 CHECK(calls->handle_update_fulfill_htlc_meth != NULL);
7766 calls->handle_update_fail_htlc_meth = (*env)->GetMethodID(env, c, "handle_update_fail_htlc", "([BJ)V");
7767 CHECK(calls->handle_update_fail_htlc_meth != NULL);
7768 calls->handle_update_fail_malformed_htlc_meth = (*env)->GetMethodID(env, c, "handle_update_fail_malformed_htlc", "([BJ)V");
7769 CHECK(calls->handle_update_fail_malformed_htlc_meth != NULL);
7770 calls->handle_commitment_signed_meth = (*env)->GetMethodID(env, c, "handle_commitment_signed", "([BJ)V");
7771 CHECK(calls->handle_commitment_signed_meth != NULL);
7772 calls->handle_revoke_and_ack_meth = (*env)->GetMethodID(env, c, "handle_revoke_and_ack", "([BJ)V");
7773 CHECK(calls->handle_revoke_and_ack_meth != NULL);
7774 calls->handle_update_fee_meth = (*env)->GetMethodID(env, c, "handle_update_fee", "([BJ)V");
7775 CHECK(calls->handle_update_fee_meth != NULL);
7776 calls->handle_announcement_signatures_meth = (*env)->GetMethodID(env, c, "handle_announcement_signatures", "([BJ)V");
7777 CHECK(calls->handle_announcement_signatures_meth != NULL);
7778 calls->peer_disconnected_meth = (*env)->GetMethodID(env, c, "peer_disconnected", "([BZ)V");
7779 CHECK(calls->peer_disconnected_meth != NULL);
7780 calls->peer_connected_meth = (*env)->GetMethodID(env, c, "peer_connected", "([BJ)V");
7781 CHECK(calls->peer_connected_meth != NULL);
7782 calls->handle_channel_reestablish_meth = (*env)->GetMethodID(env, c, "handle_channel_reestablish", "([BJ)V");
7783 CHECK(calls->handle_channel_reestablish_meth != NULL);
7784 calls->handle_channel_update_meth = (*env)->GetMethodID(env, c, "handle_channel_update", "([BJ)V");
7785 CHECK(calls->handle_channel_update_meth != NULL);
7786 calls->handle_error_meth = (*env)->GetMethodID(env, c, "handle_error", "([BJ)V");
7787 CHECK(calls->handle_error_meth != NULL);
7789 LDKChannelMessageHandler ret = {
7790 .this_arg = (void*) calls,
7791 .handle_open_channel = handle_open_channel_LDKChannelMessageHandler_jcall,
7792 .handle_accept_channel = handle_accept_channel_LDKChannelMessageHandler_jcall,
7793 .handle_funding_created = handle_funding_created_LDKChannelMessageHandler_jcall,
7794 .handle_funding_signed = handle_funding_signed_LDKChannelMessageHandler_jcall,
7795 .handle_funding_locked = handle_funding_locked_LDKChannelMessageHandler_jcall,
7796 .handle_shutdown = handle_shutdown_LDKChannelMessageHandler_jcall,
7797 .handle_closing_signed = handle_closing_signed_LDKChannelMessageHandler_jcall,
7798 .handle_update_add_htlc = handle_update_add_htlc_LDKChannelMessageHandler_jcall,
7799 .handle_update_fulfill_htlc = handle_update_fulfill_htlc_LDKChannelMessageHandler_jcall,
7800 .handle_update_fail_htlc = handle_update_fail_htlc_LDKChannelMessageHandler_jcall,
7801 .handle_update_fail_malformed_htlc = handle_update_fail_malformed_htlc_LDKChannelMessageHandler_jcall,
7802 .handle_commitment_signed = handle_commitment_signed_LDKChannelMessageHandler_jcall,
7803 .handle_revoke_and_ack = handle_revoke_and_ack_LDKChannelMessageHandler_jcall,
7804 .handle_update_fee = handle_update_fee_LDKChannelMessageHandler_jcall,
7805 .handle_announcement_signatures = handle_announcement_signatures_LDKChannelMessageHandler_jcall,
7806 .peer_disconnected = peer_disconnected_LDKChannelMessageHandler_jcall,
7807 .peer_connected = peer_connected_LDKChannelMessageHandler_jcall,
7808 .handle_channel_reestablish = handle_channel_reestablish_LDKChannelMessageHandler_jcall,
7809 .handle_channel_update = handle_channel_update_LDKChannelMessageHandler_jcall,
7810 .handle_error = handle_error_LDKChannelMessageHandler_jcall,
7811 .free = LDKChannelMessageHandler_JCalls_free,
7812 .MessageSendEventsProvider = LDKMessageSendEventsProvider_init(env, clz, MessageSendEventsProvider),
7814 calls->MessageSendEventsProvider = ret.MessageSendEventsProvider.this_arg;
7817 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKChannelMessageHandler_1new(JNIEnv *env, jclass clz, jobject o, jobject MessageSendEventsProvider) {
7818 LDKChannelMessageHandler *res_ptr = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
7819 *res_ptr = LDKChannelMessageHandler_init(env, clz, o, MessageSendEventsProvider);
7820 return (uint64_t)res_ptr;
7822 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMessageHandler_1handle_1open_1channel(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id, int64_t their_features, int64_t msg) {
7823 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
7824 LDKPublicKey their_node_id_ref;
7825 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
7826 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
7827 LDKInitFeatures their_features_conv;
7828 their_features_conv.inner = (void*)(their_features & (~1));
7829 their_features_conv.is_owned = (their_features & 1) || (their_features == 0);
7830 their_features_conv = InitFeatures_clone(&their_features_conv);
7831 LDKOpenChannel msg_conv;
7832 msg_conv.inner = (void*)(msg & (~1));
7833 msg_conv.is_owned = false;
7834 (this_arg_conv->handle_open_channel)(this_arg_conv->this_arg, their_node_id_ref, their_features_conv, &msg_conv);
7837 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMessageHandler_1handle_1accept_1channel(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id, int64_t their_features, int64_t msg) {
7838 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
7839 LDKPublicKey their_node_id_ref;
7840 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
7841 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
7842 LDKInitFeatures their_features_conv;
7843 their_features_conv.inner = (void*)(their_features & (~1));
7844 their_features_conv.is_owned = (their_features & 1) || (their_features == 0);
7845 their_features_conv = InitFeatures_clone(&their_features_conv);
7846 LDKAcceptChannel msg_conv;
7847 msg_conv.inner = (void*)(msg & (~1));
7848 msg_conv.is_owned = false;
7849 (this_arg_conv->handle_accept_channel)(this_arg_conv->this_arg, their_node_id_ref, their_features_conv, &msg_conv);
7852 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMessageHandler_1handle_1funding_1created(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id, int64_t msg) {
7853 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
7854 LDKPublicKey their_node_id_ref;
7855 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
7856 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
7857 LDKFundingCreated msg_conv;
7858 msg_conv.inner = (void*)(msg & (~1));
7859 msg_conv.is_owned = false;
7860 (this_arg_conv->handle_funding_created)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
7863 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMessageHandler_1handle_1funding_1signed(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id, int64_t msg) {
7864 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
7865 LDKPublicKey their_node_id_ref;
7866 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
7867 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
7868 LDKFundingSigned msg_conv;
7869 msg_conv.inner = (void*)(msg & (~1));
7870 msg_conv.is_owned = false;
7871 (this_arg_conv->handle_funding_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
7874 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMessageHandler_1handle_1funding_1locked(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id, int64_t msg) {
7875 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
7876 LDKPublicKey their_node_id_ref;
7877 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
7878 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
7879 LDKFundingLocked msg_conv;
7880 msg_conv.inner = (void*)(msg & (~1));
7881 msg_conv.is_owned = false;
7882 (this_arg_conv->handle_funding_locked)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
7885 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMessageHandler_1handle_1shutdown(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id, int64_t their_features, int64_t msg) {
7886 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
7887 LDKPublicKey their_node_id_ref;
7888 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
7889 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
7890 LDKInitFeatures their_features_conv;
7891 their_features_conv.inner = (void*)(their_features & (~1));
7892 their_features_conv.is_owned = false;
7893 LDKShutdown msg_conv;
7894 msg_conv.inner = (void*)(msg & (~1));
7895 msg_conv.is_owned = false;
7896 (this_arg_conv->handle_shutdown)(this_arg_conv->this_arg, their_node_id_ref, &their_features_conv, &msg_conv);
7899 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMessageHandler_1handle_1closing_1signed(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id, int64_t msg) {
7900 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
7901 LDKPublicKey their_node_id_ref;
7902 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
7903 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
7904 LDKClosingSigned msg_conv;
7905 msg_conv.inner = (void*)(msg & (~1));
7906 msg_conv.is_owned = false;
7907 (this_arg_conv->handle_closing_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
7910 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMessageHandler_1handle_1update_1add_1htlc(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id, int64_t msg) {
7911 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
7912 LDKPublicKey their_node_id_ref;
7913 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
7914 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
7915 LDKUpdateAddHTLC msg_conv;
7916 msg_conv.inner = (void*)(msg & (~1));
7917 msg_conv.is_owned = false;
7918 (this_arg_conv->handle_update_add_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
7921 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMessageHandler_1handle_1update_1fulfill_1htlc(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id, int64_t msg) {
7922 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
7923 LDKPublicKey their_node_id_ref;
7924 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
7925 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
7926 LDKUpdateFulfillHTLC msg_conv;
7927 msg_conv.inner = (void*)(msg & (~1));
7928 msg_conv.is_owned = false;
7929 (this_arg_conv->handle_update_fulfill_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
7932 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMessageHandler_1handle_1update_1fail_1htlc(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id, int64_t msg) {
7933 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
7934 LDKPublicKey their_node_id_ref;
7935 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
7936 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
7937 LDKUpdateFailHTLC msg_conv;
7938 msg_conv.inner = (void*)(msg & (~1));
7939 msg_conv.is_owned = false;
7940 (this_arg_conv->handle_update_fail_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
7943 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMessageHandler_1handle_1update_1fail_1malformed_1htlc(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id, int64_t msg) {
7944 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
7945 LDKPublicKey their_node_id_ref;
7946 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
7947 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
7948 LDKUpdateFailMalformedHTLC msg_conv;
7949 msg_conv.inner = (void*)(msg & (~1));
7950 msg_conv.is_owned = false;
7951 (this_arg_conv->handle_update_fail_malformed_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
7954 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMessageHandler_1handle_1commitment_1signed(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id, int64_t msg) {
7955 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
7956 LDKPublicKey their_node_id_ref;
7957 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
7958 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
7959 LDKCommitmentSigned msg_conv;
7960 msg_conv.inner = (void*)(msg & (~1));
7961 msg_conv.is_owned = false;
7962 (this_arg_conv->handle_commitment_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
7965 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMessageHandler_1handle_1revoke_1and_1ack(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id, int64_t msg) {
7966 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
7967 LDKPublicKey their_node_id_ref;
7968 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
7969 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
7970 LDKRevokeAndACK msg_conv;
7971 msg_conv.inner = (void*)(msg & (~1));
7972 msg_conv.is_owned = false;
7973 (this_arg_conv->handle_revoke_and_ack)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
7976 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMessageHandler_1handle_1update_1fee(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id, int64_t msg) {
7977 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
7978 LDKPublicKey their_node_id_ref;
7979 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
7980 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
7981 LDKUpdateFee msg_conv;
7982 msg_conv.inner = (void*)(msg & (~1));
7983 msg_conv.is_owned = false;
7984 (this_arg_conv->handle_update_fee)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
7987 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMessageHandler_1handle_1announcement_1signatures(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id, int64_t msg) {
7988 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
7989 LDKPublicKey their_node_id_ref;
7990 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
7991 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
7992 LDKAnnouncementSignatures msg_conv;
7993 msg_conv.inner = (void*)(msg & (~1));
7994 msg_conv.is_owned = false;
7995 (this_arg_conv->handle_announcement_signatures)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
7998 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMessageHandler_1peer_1disconnected(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id, jboolean no_connection_possible) {
7999 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
8000 LDKPublicKey their_node_id_ref;
8001 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
8002 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
8003 (this_arg_conv->peer_disconnected)(this_arg_conv->this_arg, their_node_id_ref, no_connection_possible);
8006 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMessageHandler_1peer_1connected(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id, int64_t msg) {
8007 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
8008 LDKPublicKey their_node_id_ref;
8009 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
8010 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
8012 msg_conv.inner = (void*)(msg & (~1));
8013 msg_conv.is_owned = false;
8014 (this_arg_conv->peer_connected)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
8017 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMessageHandler_1handle_1channel_1reestablish(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id, int64_t msg) {
8018 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
8019 LDKPublicKey their_node_id_ref;
8020 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
8021 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
8022 LDKChannelReestablish msg_conv;
8023 msg_conv.inner = (void*)(msg & (~1));
8024 msg_conv.is_owned = false;
8025 (this_arg_conv->handle_channel_reestablish)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
8028 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMessageHandler_1handle_1channel_1update(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id, int64_t msg) {
8029 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
8030 LDKPublicKey their_node_id_ref;
8031 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
8032 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
8033 LDKChannelUpdate msg_conv;
8034 msg_conv.inner = (void*)(msg & (~1));
8035 msg_conv.is_owned = false;
8036 (this_arg_conv->handle_channel_update)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
8039 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMessageHandler_1handle_1error(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id, int64_t msg) {
8040 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
8041 LDKPublicKey their_node_id_ref;
8042 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
8043 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
8044 LDKErrorMessage msg_conv;
8045 msg_conv.inner = (void*)(msg & (~1));
8046 msg_conv.is_owned = false;
8047 (this_arg_conv->handle_error)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
8050 typedef struct LDKRoutingMessageHandler_JCalls {
8051 atomic_size_t refcnt;
8054 LDKMessageSendEventsProvider_JCalls* MessageSendEventsProvider;
8055 jmethodID handle_node_announcement_meth;
8056 jmethodID handle_channel_announcement_meth;
8057 jmethodID handle_channel_update_meth;
8058 jmethodID handle_htlc_fail_channel_update_meth;
8059 jmethodID get_next_channel_announcements_meth;
8060 jmethodID get_next_node_announcements_meth;
8061 jmethodID sync_routing_table_meth;
8062 jmethodID handle_reply_channel_range_meth;
8063 jmethodID handle_reply_short_channel_ids_end_meth;
8064 jmethodID handle_query_channel_range_meth;
8065 jmethodID handle_query_short_channel_ids_meth;
8066 } LDKRoutingMessageHandler_JCalls;
8067 static void LDKRoutingMessageHandler_JCalls_free(void* this_arg) {
8068 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
8069 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
8071 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
8072 if (get_jenv_res == JNI_EDETACHED) {
8073 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
8075 DO_ASSERT(get_jenv_res == JNI_OK);
8077 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
8078 if (get_jenv_res == JNI_EDETACHED) {
8079 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
8084 LDKCResult_boolLightningErrorZ handle_node_announcement_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKNodeAnnouncement * msg) {
8085 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
8087 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
8088 if (get_jenv_res == JNI_EDETACHED) {
8089 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
8091 DO_ASSERT(get_jenv_res == JNI_OK);
8093 LDKNodeAnnouncement msg_var = *msg;
8094 msg_var = NodeAnnouncement_clone(msg);
8095 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8096 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8097 uint64_t msg_ref = (uint64_t)msg_var.inner;
8098 if (msg_var.is_owned) {
8101 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
8103 LDKCResult_boolLightningErrorZ* ret = (LDKCResult_boolLightningErrorZ*)(*env)->CallLongMethod(env, obj, j_calls->handle_node_announcement_meth, msg_ref);
8104 if ((*env)->ExceptionCheck(env)) {
8105 (*env)->ExceptionDescribe(env);
8106 (*env)->FatalError(env, "A call to handle_node_announcement in LDKRoutingMessageHandler from rust threw an exception.");
8108 LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(((uint64_t)ret) & ~1);
8109 ret_conv = CResult_boolLightningErrorZ_clone((LDKCResult_boolLightningErrorZ*)(((uint64_t)ret) & ~1));
8110 if (get_jenv_res == JNI_EDETACHED) {
8111 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
8115 LDKCResult_boolLightningErrorZ handle_channel_announcement_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKChannelAnnouncement * msg) {
8116 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
8118 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
8119 if (get_jenv_res == JNI_EDETACHED) {
8120 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
8122 DO_ASSERT(get_jenv_res == JNI_OK);
8124 LDKChannelAnnouncement msg_var = *msg;
8125 msg_var = ChannelAnnouncement_clone(msg);
8126 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8127 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8128 uint64_t msg_ref = (uint64_t)msg_var.inner;
8129 if (msg_var.is_owned) {
8132 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
8134 LDKCResult_boolLightningErrorZ* ret = (LDKCResult_boolLightningErrorZ*)(*env)->CallLongMethod(env, obj, j_calls->handle_channel_announcement_meth, msg_ref);
8135 if ((*env)->ExceptionCheck(env)) {
8136 (*env)->ExceptionDescribe(env);
8137 (*env)->FatalError(env, "A call to handle_channel_announcement in LDKRoutingMessageHandler from rust threw an exception.");
8139 LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(((uint64_t)ret) & ~1);
8140 ret_conv = CResult_boolLightningErrorZ_clone((LDKCResult_boolLightningErrorZ*)(((uint64_t)ret) & ~1));
8141 if (get_jenv_res == JNI_EDETACHED) {
8142 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
8146 LDKCResult_boolLightningErrorZ handle_channel_update_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKChannelUpdate * msg) {
8147 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
8149 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
8150 if (get_jenv_res == JNI_EDETACHED) {
8151 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
8153 DO_ASSERT(get_jenv_res == JNI_OK);
8155 LDKChannelUpdate msg_var = *msg;
8156 msg_var = ChannelUpdate_clone(msg);
8157 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8158 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8159 uint64_t msg_ref = (uint64_t)msg_var.inner;
8160 if (msg_var.is_owned) {
8163 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
8165 LDKCResult_boolLightningErrorZ* ret = (LDKCResult_boolLightningErrorZ*)(*env)->CallLongMethod(env, obj, j_calls->handle_channel_update_meth, msg_ref);
8166 if ((*env)->ExceptionCheck(env)) {
8167 (*env)->ExceptionDescribe(env);
8168 (*env)->FatalError(env, "A call to handle_channel_update in LDKRoutingMessageHandler from rust threw an exception.");
8170 LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(((uint64_t)ret) & ~1);
8171 ret_conv = CResult_boolLightningErrorZ_clone((LDKCResult_boolLightningErrorZ*)(((uint64_t)ret) & ~1));
8172 if (get_jenv_res == JNI_EDETACHED) {
8173 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
8177 void handle_htlc_fail_channel_update_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKHTLCFailChannelUpdate * update) {
8178 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
8180 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
8181 if (get_jenv_res == JNI_EDETACHED) {
8182 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
8184 DO_ASSERT(get_jenv_res == JNI_OK);
8186 uint64_t ret_update = (uint64_t)update;
8187 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
8189 (*env)->CallVoidMethod(env, obj, j_calls->handle_htlc_fail_channel_update_meth, ret_update);
8190 if ((*env)->ExceptionCheck(env)) {
8191 (*env)->ExceptionDescribe(env);
8192 (*env)->FatalError(env, "A call to handle_htlc_fail_channel_update in LDKRoutingMessageHandler from rust threw an exception.");
8194 if (get_jenv_res == JNI_EDETACHED) {
8195 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
8198 LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ get_next_channel_announcements_LDKRoutingMessageHandler_jcall(const void* this_arg, uint64_t starting_point, uint8_t batch_amount) {
8199 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
8201 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
8202 if (get_jenv_res == JNI_EDETACHED) {
8203 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
8205 DO_ASSERT(get_jenv_res == JNI_OK);
8207 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
8209 int64_tArray ret = (*env)->CallObjectMethod(env, obj, j_calls->get_next_channel_announcements_meth, starting_point, batch_amount);
8210 if ((*env)->ExceptionCheck(env)) {
8211 (*env)->ExceptionDescribe(env);
8212 (*env)->FatalError(env, "A call to get_next_channel_announcements in LDKRoutingMessageHandler from rust threw an exception.");
8214 LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret_constr;
8215 ret_constr.datalen = (*env)->GetArrayLength(env, ret);
8216 if (ret_constr.datalen > 0)
8217 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ Elements");
8219 ret_constr.data = NULL;
8220 int64_t* ret_vals = (*env)->GetLongArrayElements (env, ret, NULL);
8221 for (size_t l = 0; l < ret_constr.datalen; l++) {
8222 int64_t ret_conv_63 = ret_vals[l];
8223 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ ret_conv_63_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)ret_conv_63) & ~1);
8224 ret_conv_63_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone((LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)ret_conv_63) & ~1));
8225 ret_constr.data[l] = ret_conv_63_conv;
8227 (*env)->ReleaseLongArrayElements(env, ret, ret_vals, 0);
8228 if (get_jenv_res == JNI_EDETACHED) {
8229 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
8233 LDKCVec_NodeAnnouncementZ get_next_node_announcements_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey starting_point, uint8_t batch_amount) {
8234 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
8236 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
8237 if (get_jenv_res == JNI_EDETACHED) {
8238 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
8240 DO_ASSERT(get_jenv_res == JNI_OK);
8242 int8_tArray starting_point_arr = (*env)->NewByteArray(env, 33);
8243 (*env)->SetByteArrayRegion(env, starting_point_arr, 0, 33, starting_point.compressed_form);
8244 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
8246 int64_tArray ret = (*env)->CallObjectMethod(env, obj, j_calls->get_next_node_announcements_meth, starting_point_arr, batch_amount);
8247 if ((*env)->ExceptionCheck(env)) {
8248 (*env)->ExceptionDescribe(env);
8249 (*env)->FatalError(env, "A call to get_next_node_announcements in LDKRoutingMessageHandler from rust threw an exception.");
8251 LDKCVec_NodeAnnouncementZ ret_constr;
8252 ret_constr.datalen = (*env)->GetArrayLength(env, ret);
8253 if (ret_constr.datalen > 0)
8254 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKNodeAnnouncement), "LDKCVec_NodeAnnouncementZ Elements");
8256 ret_constr.data = NULL;
8257 int64_t* ret_vals = (*env)->GetLongArrayElements (env, ret, NULL);
8258 for (size_t s = 0; s < ret_constr.datalen; s++) {
8259 int64_t ret_conv_18 = ret_vals[s];
8260 LDKNodeAnnouncement ret_conv_18_conv;
8261 ret_conv_18_conv.inner = (void*)(ret_conv_18 & (~1));
8262 ret_conv_18_conv.is_owned = (ret_conv_18 & 1) || (ret_conv_18 == 0);
8263 ret_conv_18_conv = NodeAnnouncement_clone(&ret_conv_18_conv);
8264 ret_constr.data[s] = ret_conv_18_conv;
8266 (*env)->ReleaseLongArrayElements(env, ret, ret_vals, 0);
8267 if (get_jenv_res == JNI_EDETACHED) {
8268 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
8272 void sync_routing_table_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInit * init) {
8273 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
8275 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
8276 if (get_jenv_res == JNI_EDETACHED) {
8277 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
8279 DO_ASSERT(get_jenv_res == JNI_OK);
8281 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
8282 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
8283 LDKInit init_var = *init;
8284 init_var = Init_clone(init);
8285 CHECK((((uint64_t)init_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8286 CHECK((((uint64_t)&init_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8287 uint64_t init_ref = (uint64_t)init_var.inner;
8288 if (init_var.is_owned) {
8291 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
8293 (*env)->CallVoidMethod(env, obj, j_calls->sync_routing_table_meth, their_node_id_arr, init_ref);
8294 if ((*env)->ExceptionCheck(env)) {
8295 (*env)->ExceptionDescribe(env);
8296 (*env)->FatalError(env, "A call to sync_routing_table in LDKRoutingMessageHandler from rust threw an exception.");
8298 if (get_jenv_res == JNI_EDETACHED) {
8299 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
8302 LDKCResult_NoneLightningErrorZ handle_reply_channel_range_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKReplyChannelRange msg) {
8303 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
8305 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
8306 if (get_jenv_res == JNI_EDETACHED) {
8307 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
8309 DO_ASSERT(get_jenv_res == JNI_OK);
8311 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
8312 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
8313 LDKReplyChannelRange msg_var = msg;
8314 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8315 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8316 uint64_t msg_ref = (uint64_t)msg_var.inner;
8317 if (msg_var.is_owned) {
8320 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
8322 LDKCResult_NoneLightningErrorZ* ret = (LDKCResult_NoneLightningErrorZ*)(*env)->CallLongMethod(env, obj, j_calls->handle_reply_channel_range_meth, their_node_id_arr, msg_ref);
8323 if ((*env)->ExceptionCheck(env)) {
8324 (*env)->ExceptionDescribe(env);
8325 (*env)->FatalError(env, "A call to handle_reply_channel_range in LDKRoutingMessageHandler from rust threw an exception.");
8327 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1);
8328 ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1));
8329 if (get_jenv_res == JNI_EDETACHED) {
8330 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
8334 LDKCResult_NoneLightningErrorZ handle_reply_short_channel_ids_end_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKReplyShortChannelIdsEnd msg) {
8335 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
8337 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
8338 if (get_jenv_res == JNI_EDETACHED) {
8339 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
8341 DO_ASSERT(get_jenv_res == JNI_OK);
8343 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
8344 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
8345 LDKReplyShortChannelIdsEnd msg_var = msg;
8346 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8347 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8348 uint64_t msg_ref = (uint64_t)msg_var.inner;
8349 if (msg_var.is_owned) {
8352 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
8354 LDKCResult_NoneLightningErrorZ* ret = (LDKCResult_NoneLightningErrorZ*)(*env)->CallLongMethod(env, obj, j_calls->handle_reply_short_channel_ids_end_meth, their_node_id_arr, msg_ref);
8355 if ((*env)->ExceptionCheck(env)) {
8356 (*env)->ExceptionDescribe(env);
8357 (*env)->FatalError(env, "A call to handle_reply_short_channel_ids_end in LDKRoutingMessageHandler from rust threw an exception.");
8359 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1);
8360 ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1));
8361 if (get_jenv_res == JNI_EDETACHED) {
8362 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
8366 LDKCResult_NoneLightningErrorZ handle_query_channel_range_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKQueryChannelRange msg) {
8367 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
8369 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
8370 if (get_jenv_res == JNI_EDETACHED) {
8371 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
8373 DO_ASSERT(get_jenv_res == JNI_OK);
8375 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
8376 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
8377 LDKQueryChannelRange msg_var = msg;
8378 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8379 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8380 uint64_t msg_ref = (uint64_t)msg_var.inner;
8381 if (msg_var.is_owned) {
8384 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
8386 LDKCResult_NoneLightningErrorZ* ret = (LDKCResult_NoneLightningErrorZ*)(*env)->CallLongMethod(env, obj, j_calls->handle_query_channel_range_meth, their_node_id_arr, msg_ref);
8387 if ((*env)->ExceptionCheck(env)) {
8388 (*env)->ExceptionDescribe(env);
8389 (*env)->FatalError(env, "A call to handle_query_channel_range in LDKRoutingMessageHandler from rust threw an exception.");
8391 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1);
8392 ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1));
8393 if (get_jenv_res == JNI_EDETACHED) {
8394 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
8398 LDKCResult_NoneLightningErrorZ handle_query_short_channel_ids_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKQueryShortChannelIds msg) {
8399 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
8401 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
8402 if (get_jenv_res == JNI_EDETACHED) {
8403 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
8405 DO_ASSERT(get_jenv_res == JNI_OK);
8407 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
8408 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
8409 LDKQueryShortChannelIds msg_var = msg;
8410 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8411 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8412 uint64_t msg_ref = (uint64_t)msg_var.inner;
8413 if (msg_var.is_owned) {
8416 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
8418 LDKCResult_NoneLightningErrorZ* ret = (LDKCResult_NoneLightningErrorZ*)(*env)->CallLongMethod(env, obj, j_calls->handle_query_short_channel_ids_meth, their_node_id_arr, msg_ref);
8419 if ((*env)->ExceptionCheck(env)) {
8420 (*env)->ExceptionDescribe(env);
8421 (*env)->FatalError(env, "A call to handle_query_short_channel_ids in LDKRoutingMessageHandler from rust threw an exception.");
8423 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1);
8424 ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1));
8425 if (get_jenv_res == JNI_EDETACHED) {
8426 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
8430 static void* LDKRoutingMessageHandler_JCalls_clone(const void* this_arg) {
8431 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
8432 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
8433 atomic_fetch_add_explicit(&j_calls->MessageSendEventsProvider->refcnt, 1, memory_order_release);
8434 return (void*) this_arg;
8436 static inline LDKRoutingMessageHandler LDKRoutingMessageHandler_init (JNIEnv *env, jclass clz, jobject o, jobject MessageSendEventsProvider) {
8437 jclass c = (*env)->GetObjectClass(env, o);
8439 LDKRoutingMessageHandler_JCalls *calls = MALLOC(sizeof(LDKRoutingMessageHandler_JCalls), "LDKRoutingMessageHandler_JCalls");
8440 atomic_init(&calls->refcnt, 1);
8441 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
8442 calls->o = (*env)->NewWeakGlobalRef(env, o);
8443 calls->handle_node_announcement_meth = (*env)->GetMethodID(env, c, "handle_node_announcement", "(J)J");
8444 CHECK(calls->handle_node_announcement_meth != NULL);
8445 calls->handle_channel_announcement_meth = (*env)->GetMethodID(env, c, "handle_channel_announcement", "(J)J");
8446 CHECK(calls->handle_channel_announcement_meth != NULL);
8447 calls->handle_channel_update_meth = (*env)->GetMethodID(env, c, "handle_channel_update", "(J)J");
8448 CHECK(calls->handle_channel_update_meth != NULL);
8449 calls->handle_htlc_fail_channel_update_meth = (*env)->GetMethodID(env, c, "handle_htlc_fail_channel_update", "(J)V");
8450 CHECK(calls->handle_htlc_fail_channel_update_meth != NULL);
8451 calls->get_next_channel_announcements_meth = (*env)->GetMethodID(env, c, "get_next_channel_announcements", "(JB)[J");
8452 CHECK(calls->get_next_channel_announcements_meth != NULL);
8453 calls->get_next_node_announcements_meth = (*env)->GetMethodID(env, c, "get_next_node_announcements", "([BB)[J");
8454 CHECK(calls->get_next_node_announcements_meth != NULL);
8455 calls->sync_routing_table_meth = (*env)->GetMethodID(env, c, "sync_routing_table", "([BJ)V");
8456 CHECK(calls->sync_routing_table_meth != NULL);
8457 calls->handle_reply_channel_range_meth = (*env)->GetMethodID(env, c, "handle_reply_channel_range", "([BJ)J");
8458 CHECK(calls->handle_reply_channel_range_meth != NULL);
8459 calls->handle_reply_short_channel_ids_end_meth = (*env)->GetMethodID(env, c, "handle_reply_short_channel_ids_end", "([BJ)J");
8460 CHECK(calls->handle_reply_short_channel_ids_end_meth != NULL);
8461 calls->handle_query_channel_range_meth = (*env)->GetMethodID(env, c, "handle_query_channel_range", "([BJ)J");
8462 CHECK(calls->handle_query_channel_range_meth != NULL);
8463 calls->handle_query_short_channel_ids_meth = (*env)->GetMethodID(env, c, "handle_query_short_channel_ids", "([BJ)J");
8464 CHECK(calls->handle_query_short_channel_ids_meth != NULL);
8466 LDKRoutingMessageHandler ret = {
8467 .this_arg = (void*) calls,
8468 .handle_node_announcement = handle_node_announcement_LDKRoutingMessageHandler_jcall,
8469 .handle_channel_announcement = handle_channel_announcement_LDKRoutingMessageHandler_jcall,
8470 .handle_channel_update = handle_channel_update_LDKRoutingMessageHandler_jcall,
8471 .handle_htlc_fail_channel_update = handle_htlc_fail_channel_update_LDKRoutingMessageHandler_jcall,
8472 .get_next_channel_announcements = get_next_channel_announcements_LDKRoutingMessageHandler_jcall,
8473 .get_next_node_announcements = get_next_node_announcements_LDKRoutingMessageHandler_jcall,
8474 .sync_routing_table = sync_routing_table_LDKRoutingMessageHandler_jcall,
8475 .handle_reply_channel_range = handle_reply_channel_range_LDKRoutingMessageHandler_jcall,
8476 .handle_reply_short_channel_ids_end = handle_reply_short_channel_ids_end_LDKRoutingMessageHandler_jcall,
8477 .handle_query_channel_range = handle_query_channel_range_LDKRoutingMessageHandler_jcall,
8478 .handle_query_short_channel_ids = handle_query_short_channel_ids_LDKRoutingMessageHandler_jcall,
8479 .free = LDKRoutingMessageHandler_JCalls_free,
8480 .MessageSendEventsProvider = LDKMessageSendEventsProvider_init(env, clz, MessageSendEventsProvider),
8482 calls->MessageSendEventsProvider = ret.MessageSendEventsProvider.this_arg;
8485 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKRoutingMessageHandler_1new(JNIEnv *env, jclass clz, jobject o, jobject MessageSendEventsProvider) {
8486 LDKRoutingMessageHandler *res_ptr = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
8487 *res_ptr = LDKRoutingMessageHandler_init(env, clz, o, MessageSendEventsProvider);
8488 return (uint64_t)res_ptr;
8490 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RoutingMessageHandler_1handle_1node_1announcement(JNIEnv *env, jclass clz, int64_t this_arg, int64_t msg) {
8491 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1);
8492 LDKNodeAnnouncement msg_conv;
8493 msg_conv.inner = (void*)(msg & (~1));
8494 msg_conv.is_owned = false;
8495 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
8496 *ret_conv = (this_arg_conv->handle_node_announcement)(this_arg_conv->this_arg, &msg_conv);
8497 return (uint64_t)ret_conv;
8500 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RoutingMessageHandler_1handle_1channel_1announcement(JNIEnv *env, jclass clz, int64_t this_arg, int64_t msg) {
8501 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1);
8502 LDKChannelAnnouncement msg_conv;
8503 msg_conv.inner = (void*)(msg & (~1));
8504 msg_conv.is_owned = false;
8505 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
8506 *ret_conv = (this_arg_conv->handle_channel_announcement)(this_arg_conv->this_arg, &msg_conv);
8507 return (uint64_t)ret_conv;
8510 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RoutingMessageHandler_1handle_1channel_1update(JNIEnv *env, jclass clz, int64_t this_arg, int64_t msg) {
8511 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1);
8512 LDKChannelUpdate msg_conv;
8513 msg_conv.inner = (void*)(msg & (~1));
8514 msg_conv.is_owned = false;
8515 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
8516 *ret_conv = (this_arg_conv->handle_channel_update)(this_arg_conv->this_arg, &msg_conv);
8517 return (uint64_t)ret_conv;
8520 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RoutingMessageHandler_1handle_1htlc_1fail_1channel_1update(JNIEnv *env, jclass clz, int64_t this_arg, int64_t update) {
8521 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1);
8522 LDKHTLCFailChannelUpdate* update_conv = (LDKHTLCFailChannelUpdate*)update;
8523 (this_arg_conv->handle_htlc_fail_channel_update)(this_arg_conv->this_arg, update_conv);
8526 JNIEXPORT int64_tArray JNICALL Java_org_ldk_impl_bindings_RoutingMessageHandler_1get_1next_1channel_1announcements(JNIEnv *env, jclass clz, int64_t this_arg, int64_t starting_point, int8_t batch_amount) {
8527 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1);
8528 LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret_var = (this_arg_conv->get_next_channel_announcements)(this_arg_conv->this_arg, starting_point, batch_amount);
8529 int64_tArray ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
8530 int64_t *ret_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, ret_arr, NULL);
8531 for (size_t l = 0; l < ret_var.datalen; l++) {
8532 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv_63_ref = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
8533 *ret_conv_63_ref = ret_var.data[l];
8534 ret_arr_ptr[l] = (uint64_t)ret_conv_63_ref;
8536 (*env)->ReleasePrimitiveArrayCritical(env, ret_arr, ret_arr_ptr, 0);
8541 JNIEXPORT int64_tArray JNICALL Java_org_ldk_impl_bindings_RoutingMessageHandler_1get_1next_1node_1announcements(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray starting_point, int8_t batch_amount) {
8542 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1);
8543 LDKPublicKey starting_point_ref;
8544 CHECK((*env)->GetArrayLength(env, starting_point) == 33);
8545 (*env)->GetByteArrayRegion(env, starting_point, 0, 33, starting_point_ref.compressed_form);
8546 LDKCVec_NodeAnnouncementZ ret_var = (this_arg_conv->get_next_node_announcements)(this_arg_conv->this_arg, starting_point_ref, batch_amount);
8547 int64_tArray ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
8548 int64_t *ret_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, ret_arr, NULL);
8549 for (size_t s = 0; s < ret_var.datalen; s++) {
8550 LDKNodeAnnouncement ret_conv_18_var = ret_var.data[s];
8551 CHECK((((uint64_t)ret_conv_18_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8552 CHECK((((uint64_t)&ret_conv_18_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8553 uint64_t ret_conv_18_ref = (uint64_t)ret_conv_18_var.inner;
8554 if (ret_conv_18_var.is_owned) {
8555 ret_conv_18_ref |= 1;
8557 ret_arr_ptr[s] = ret_conv_18_ref;
8559 (*env)->ReleasePrimitiveArrayCritical(env, ret_arr, ret_arr_ptr, 0);
8564 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RoutingMessageHandler_1sync_1routing_1table(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id, int64_t init) {
8565 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1);
8566 LDKPublicKey their_node_id_ref;
8567 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
8568 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
8570 init_conv.inner = (void*)(init & (~1));
8571 init_conv.is_owned = false;
8572 (this_arg_conv->sync_routing_table)(this_arg_conv->this_arg, their_node_id_ref, &init_conv);
8575 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RoutingMessageHandler_1handle_1reply_1channel_1range(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id, int64_t msg) {
8576 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1);
8577 LDKPublicKey their_node_id_ref;
8578 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
8579 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
8580 LDKReplyChannelRange msg_conv;
8581 msg_conv.inner = (void*)(msg & (~1));
8582 msg_conv.is_owned = (msg & 1) || (msg == 0);
8583 msg_conv = ReplyChannelRange_clone(&msg_conv);
8584 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
8585 *ret_conv = (this_arg_conv->handle_reply_channel_range)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
8586 return (uint64_t)ret_conv;
8589 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RoutingMessageHandler_1handle_1reply_1short_1channel_1ids_1end(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id, int64_t msg) {
8590 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1);
8591 LDKPublicKey their_node_id_ref;
8592 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
8593 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
8594 LDKReplyShortChannelIdsEnd msg_conv;
8595 msg_conv.inner = (void*)(msg & (~1));
8596 msg_conv.is_owned = (msg & 1) || (msg == 0);
8597 msg_conv = ReplyShortChannelIdsEnd_clone(&msg_conv);
8598 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
8599 *ret_conv = (this_arg_conv->handle_reply_short_channel_ids_end)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
8600 return (uint64_t)ret_conv;
8603 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RoutingMessageHandler_1handle_1query_1channel_1range(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id, int64_t msg) {
8604 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1);
8605 LDKPublicKey their_node_id_ref;
8606 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
8607 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
8608 LDKQueryChannelRange msg_conv;
8609 msg_conv.inner = (void*)(msg & (~1));
8610 msg_conv.is_owned = (msg & 1) || (msg == 0);
8611 msg_conv = QueryChannelRange_clone(&msg_conv);
8612 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
8613 *ret_conv = (this_arg_conv->handle_query_channel_range)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
8614 return (uint64_t)ret_conv;
8617 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RoutingMessageHandler_1handle_1query_1short_1channel_1ids(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id, int64_t msg) {
8618 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1);
8619 LDKPublicKey their_node_id_ref;
8620 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
8621 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
8622 LDKQueryShortChannelIds msg_conv;
8623 msg_conv.inner = (void*)(msg & (~1));
8624 msg_conv.is_owned = (msg & 1) || (msg == 0);
8625 msg_conv = QueryShortChannelIds_clone(&msg_conv);
8626 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
8627 *ret_conv = (this_arg_conv->handle_query_short_channel_ids)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
8628 return (uint64_t)ret_conv;
8631 typedef struct LDKSocketDescriptor_JCalls {
8632 atomic_size_t refcnt;
8635 jmethodID send_data_meth;
8636 jmethodID disconnect_socket_meth;
8638 jmethodID hash_meth;
8639 } LDKSocketDescriptor_JCalls;
8640 static void LDKSocketDescriptor_JCalls_free(void* this_arg) {
8641 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
8642 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
8644 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
8645 if (get_jenv_res == JNI_EDETACHED) {
8646 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
8648 DO_ASSERT(get_jenv_res == JNI_OK);
8650 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
8651 if (get_jenv_res == JNI_EDETACHED) {
8652 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
8657 uintptr_t send_data_LDKSocketDescriptor_jcall(void* this_arg, LDKu8slice data, bool resume_read) {
8658 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
8660 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
8661 if (get_jenv_res == JNI_EDETACHED) {
8662 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
8664 DO_ASSERT(get_jenv_res == JNI_OK);
8666 LDKu8slice data_var = data;
8667 int8_tArray data_arr = (*env)->NewByteArray(env, data_var.datalen);
8668 (*env)->SetByteArrayRegion(env, data_arr, 0, data_var.datalen, data_var.data);
8669 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
8671 int64_t ret = (*env)->CallLongMethod(env, obj, j_calls->send_data_meth, data_arr, resume_read);
8672 if ((*env)->ExceptionCheck(env)) {
8673 (*env)->ExceptionDescribe(env);
8674 (*env)->FatalError(env, "A call to send_data in LDKSocketDescriptor from rust threw an exception.");
8676 if (get_jenv_res == JNI_EDETACHED) {
8677 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
8681 void disconnect_socket_LDKSocketDescriptor_jcall(void* this_arg) {
8682 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
8684 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
8685 if (get_jenv_res == JNI_EDETACHED) {
8686 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
8688 DO_ASSERT(get_jenv_res == JNI_OK);
8690 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
8692 (*env)->CallVoidMethod(env, obj, j_calls->disconnect_socket_meth);
8693 if ((*env)->ExceptionCheck(env)) {
8694 (*env)->ExceptionDescribe(env);
8695 (*env)->FatalError(env, "A call to disconnect_socket in LDKSocketDescriptor from rust threw an exception.");
8697 if (get_jenv_res == JNI_EDETACHED) {
8698 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
8701 bool eq_LDKSocketDescriptor_jcall(const void* this_arg, const LDKSocketDescriptor * other_arg) {
8702 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
8704 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
8705 if (get_jenv_res == JNI_EDETACHED) {
8706 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
8708 DO_ASSERT(get_jenv_res == JNI_OK);
8710 LDKSocketDescriptor *other_arg_clone = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
8711 *other_arg_clone = SocketDescriptor_clone(other_arg);
8712 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
8714 jboolean ret = (*env)->CallBooleanMethod(env, obj, j_calls->eq_meth, (uint64_t)other_arg_clone);
8715 if ((*env)->ExceptionCheck(env)) {
8716 (*env)->ExceptionDescribe(env);
8717 (*env)->FatalError(env, "A call to eq in LDKSocketDescriptor from rust threw an exception.");
8719 if (get_jenv_res == JNI_EDETACHED) {
8720 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
8724 uint64_t hash_LDKSocketDescriptor_jcall(const void* this_arg) {
8725 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
8727 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
8728 if (get_jenv_res == JNI_EDETACHED) {
8729 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
8731 DO_ASSERT(get_jenv_res == JNI_OK);
8733 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
8735 int64_t ret = (*env)->CallLongMethod(env, obj, j_calls->hash_meth);
8736 if ((*env)->ExceptionCheck(env)) {
8737 (*env)->ExceptionDescribe(env);
8738 (*env)->FatalError(env, "A call to hash in LDKSocketDescriptor from rust threw an exception.");
8740 if (get_jenv_res == JNI_EDETACHED) {
8741 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
8745 static void* LDKSocketDescriptor_JCalls_clone(const void* this_arg) {
8746 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
8747 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
8748 return (void*) this_arg;
8750 static inline LDKSocketDescriptor LDKSocketDescriptor_init (JNIEnv *env, jclass clz, jobject o) {
8751 jclass c = (*env)->GetObjectClass(env, o);
8753 LDKSocketDescriptor_JCalls *calls = MALLOC(sizeof(LDKSocketDescriptor_JCalls), "LDKSocketDescriptor_JCalls");
8754 atomic_init(&calls->refcnt, 1);
8755 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
8756 calls->o = (*env)->NewWeakGlobalRef(env, o);
8757 calls->send_data_meth = (*env)->GetMethodID(env, c, "send_data", "([BZ)J");
8758 CHECK(calls->send_data_meth != NULL);
8759 calls->disconnect_socket_meth = (*env)->GetMethodID(env, c, "disconnect_socket", "()V");
8760 CHECK(calls->disconnect_socket_meth != NULL);
8761 calls->eq_meth = (*env)->GetMethodID(env, c, "eq", "(J)Z");
8762 CHECK(calls->eq_meth != NULL);
8763 calls->hash_meth = (*env)->GetMethodID(env, c, "hash", "()J");
8764 CHECK(calls->hash_meth != NULL);
8766 LDKSocketDescriptor ret = {
8767 .this_arg = (void*) calls,
8768 .send_data = send_data_LDKSocketDescriptor_jcall,
8769 .disconnect_socket = disconnect_socket_LDKSocketDescriptor_jcall,
8770 .eq = eq_LDKSocketDescriptor_jcall,
8771 .hash = hash_LDKSocketDescriptor_jcall,
8772 .clone = LDKSocketDescriptor_JCalls_clone,
8773 .free = LDKSocketDescriptor_JCalls_free,
8777 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKSocketDescriptor_1new(JNIEnv *env, jclass clz, jobject o) {
8778 LDKSocketDescriptor *res_ptr = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
8779 *res_ptr = LDKSocketDescriptor_init(env, clz, o);
8780 return (uint64_t)res_ptr;
8782 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SocketDescriptor_1send_1data(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray data, jboolean resume_read) {
8783 LDKSocketDescriptor* this_arg_conv = (LDKSocketDescriptor*)(((uint64_t)this_arg) & ~1);
8784 LDKu8slice data_ref;
8785 data_ref.datalen = (*env)->GetArrayLength(env, data);
8786 data_ref.data = (*env)->GetByteArrayElements (env, data, NULL);
8787 int64_t ret_val = (this_arg_conv->send_data)(this_arg_conv->this_arg, data_ref, resume_read);
8788 (*env)->ReleaseByteArrayElements(env, data, (int8_t*)data_ref.data, 0);
8792 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_SocketDescriptor_1disconnect_1socket(JNIEnv *env, jclass clz, int64_t this_arg) {
8793 LDKSocketDescriptor* this_arg_conv = (LDKSocketDescriptor*)(((uint64_t)this_arg) & ~1);
8794 (this_arg_conv->disconnect_socket)(this_arg_conv->this_arg);
8797 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SocketDescriptor_1hash(JNIEnv *env, jclass clz, int64_t this_arg) {
8798 LDKSocketDescriptor* this_arg_conv = (LDKSocketDescriptor*)(((uint64_t)this_arg) & ~1);
8799 int64_t ret_val = (this_arg_conv->hash)(this_arg_conv->this_arg);
8803 typedef struct LDKChannelManagerPersister_JCalls {
8804 atomic_size_t refcnt;
8807 jmethodID persist_manager_meth;
8808 } LDKChannelManagerPersister_JCalls;
8809 static void LDKChannelManagerPersister_JCalls_free(void* this_arg) {
8810 LDKChannelManagerPersister_JCalls *j_calls = (LDKChannelManagerPersister_JCalls*) this_arg;
8811 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
8813 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
8814 if (get_jenv_res == JNI_EDETACHED) {
8815 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
8817 DO_ASSERT(get_jenv_res == JNI_OK);
8819 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
8820 if (get_jenv_res == JNI_EDETACHED) {
8821 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
8826 LDKCResult_NoneErrorZ persist_manager_LDKChannelManagerPersister_jcall(const void* this_arg, const LDKChannelManager * channel_manager) {
8827 LDKChannelManagerPersister_JCalls *j_calls = (LDKChannelManagerPersister_JCalls*) this_arg;
8829 jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
8830 if (get_jenv_res == JNI_EDETACHED) {
8831 DO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);
8833 DO_ASSERT(get_jenv_res == JNI_OK);
8835 LDKChannelManager channel_manager_var = *channel_manager;
8836 // Warning: we may need a move here but no clone is available for LDKChannelManager
8837 CHECK((((uint64_t)channel_manager_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8838 CHECK((((uint64_t)&channel_manager_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8839 uint64_t channel_manager_ref = (uint64_t)channel_manager_var.inner;
8840 if (channel_manager_var.is_owned) {
8841 channel_manager_ref |= 1;
8843 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
8845 LDKCResult_NoneErrorZ* ret = (LDKCResult_NoneErrorZ*)(*env)->CallLongMethod(env, obj, j_calls->persist_manager_meth, channel_manager_ref);
8846 if ((*env)->ExceptionCheck(env)) {
8847 (*env)->ExceptionDescribe(env);
8848 (*env)->FatalError(env, "A call to persist_manager in LDKChannelManagerPersister from rust threw an exception.");
8850 LDKCResult_NoneErrorZ ret_conv = *(LDKCResult_NoneErrorZ*)(((uint64_t)ret) & ~1);
8851 ret_conv = CResult_NoneErrorZ_clone((LDKCResult_NoneErrorZ*)(((uint64_t)ret) & ~1));
8852 if (get_jenv_res == JNI_EDETACHED) {
8853 DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
8857 static void* LDKChannelManagerPersister_JCalls_clone(const void* this_arg) {
8858 LDKChannelManagerPersister_JCalls *j_calls = (LDKChannelManagerPersister_JCalls*) this_arg;
8859 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
8860 return (void*) this_arg;
8862 static inline LDKChannelManagerPersister LDKChannelManagerPersister_init (JNIEnv *env, jclass clz, jobject o) {
8863 jclass c = (*env)->GetObjectClass(env, o);
8865 LDKChannelManagerPersister_JCalls *calls = MALLOC(sizeof(LDKChannelManagerPersister_JCalls), "LDKChannelManagerPersister_JCalls");
8866 atomic_init(&calls->refcnt, 1);
8867 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
8868 calls->o = (*env)->NewWeakGlobalRef(env, o);
8869 calls->persist_manager_meth = (*env)->GetMethodID(env, c, "persist_manager", "(J)J");
8870 CHECK(calls->persist_manager_meth != NULL);
8872 LDKChannelManagerPersister ret = {
8873 .this_arg = (void*) calls,
8874 .persist_manager = persist_manager_LDKChannelManagerPersister_jcall,
8875 .free = LDKChannelManagerPersister_JCalls_free,
8879 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKChannelManagerPersister_1new(JNIEnv *env, jclass clz, jobject o) {
8880 LDKChannelManagerPersister *res_ptr = MALLOC(sizeof(LDKChannelManagerPersister), "LDKChannelManagerPersister");
8881 *res_ptr = LDKChannelManagerPersister_init(env, clz, o);
8882 return (uint64_t)res_ptr;
8884 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManagerPersister_1persist_1manager(JNIEnv *env, jclass clz, int64_t this_arg, int64_t channel_manager) {
8885 LDKChannelManagerPersister* this_arg_conv = (LDKChannelManagerPersister*)(((uint64_t)this_arg) & ~1);
8886 LDKChannelManager channel_manager_conv;
8887 channel_manager_conv.inner = (void*)(channel_manager & (~1));
8888 channel_manager_conv.is_owned = false;
8889 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
8890 *ret_conv = (this_arg_conv->persist_manager)(this_arg_conv->this_arg, &channel_manager_conv);
8891 return (uint64_t)ret_conv;
8894 static jclass LDKFallback_SegWitProgram_class = NULL;
8895 static jmethodID LDKFallback_SegWitProgram_meth = NULL;
8896 static jclass LDKFallback_PubKeyHash_class = NULL;
8897 static jmethodID LDKFallback_PubKeyHash_meth = NULL;
8898 static jclass LDKFallback_ScriptHash_class = NULL;
8899 static jmethodID LDKFallback_ScriptHash_meth = NULL;
8900 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKFallback_init (JNIEnv *env, jclass clz) {
8901 LDKFallback_SegWitProgram_class =
8902 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKFallback$SegWitProgram;"));
8903 CHECK(LDKFallback_SegWitProgram_class != NULL);
8904 LDKFallback_SegWitProgram_meth = (*env)->GetMethodID(env, LDKFallback_SegWitProgram_class, "<init>", "(B[B)V");
8905 CHECK(LDKFallback_SegWitProgram_meth != NULL);
8906 LDKFallback_PubKeyHash_class =
8907 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKFallback$PubKeyHash;"));
8908 CHECK(LDKFallback_PubKeyHash_class != NULL);
8909 LDKFallback_PubKeyHash_meth = (*env)->GetMethodID(env, LDKFallback_PubKeyHash_class, "<init>", "([B)V");
8910 CHECK(LDKFallback_PubKeyHash_meth != NULL);
8911 LDKFallback_ScriptHash_class =
8912 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKFallback$ScriptHash;"));
8913 CHECK(LDKFallback_ScriptHash_class != NULL);
8914 LDKFallback_ScriptHash_meth = (*env)->GetMethodID(env, LDKFallback_ScriptHash_class, "<init>", "([B)V");
8915 CHECK(LDKFallback_ScriptHash_meth != NULL);
8917 JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKFallback_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
8918 LDKFallback *obj = (LDKFallback*)(ptr & ~1);
8920 case LDKFallback_SegWitProgram: {
8921 uint8_t version_val = obj->seg_wit_program.version._0;
8922 LDKCVec_u8Z program_var = obj->seg_wit_program.program;
8923 int8_tArray program_arr = (*env)->NewByteArray(env, program_var.datalen);
8924 (*env)->SetByteArrayRegion(env, program_arr, 0, program_var.datalen, program_var.data);
8925 return (*env)->NewObject(env, LDKFallback_SegWitProgram_class, LDKFallback_SegWitProgram_meth, version_val, program_arr);
8927 case LDKFallback_PubKeyHash: {
8928 int8_tArray pub_key_hash_arr = (*env)->NewByteArray(env, 20);
8929 (*env)->SetByteArrayRegion(env, pub_key_hash_arr, 0, 20, obj->pub_key_hash.data);
8930 return (*env)->NewObject(env, LDKFallback_PubKeyHash_class, LDKFallback_PubKeyHash_meth, pub_key_hash_arr);
8932 case LDKFallback_ScriptHash: {
8933 int8_tArray script_hash_arr = (*env)->NewByteArray(env, 20);
8934 (*env)->SetByteArrayRegion(env, script_hash_arr, 0, 20, obj->script_hash.data);
8935 return (*env)->NewObject(env, LDKFallback_ScriptHash_class, LDKFallback_ScriptHash_meth, script_hash_arr);
8940 JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings__1ldk_1get_1compiled_1version(JNIEnv *env, jclass clz) {
8941 LDKStr ret_str = _ldk_get_compiled_version();
8942 jstring ret_conv = str_ref_to_java(env, ret_str.chars, ret_str.len);
8946 JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings__1ldk_1c_1bindings_1get_1compiled_1version(JNIEnv *env, jclass clz) {
8947 LDKStr ret_str = _ldk_c_bindings_get_compiled_version();
8948 jstring ret_conv = str_ref_to_java(env, ret_str.chars, ret_str.len);
8952 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Transaction_1free(JNIEnv *env, jclass clz, int8_tArray _res) {
8953 LDKTransaction _res_ref;
8954 _res_ref.datalen = (*env)->GetArrayLength(env, _res);
8955 _res_ref.data = MALLOC(_res_ref.datalen, "LDKTransaction Bytes");
8956 (*env)->GetByteArrayRegion(env, _res, 0, _res_ref.datalen, _res_ref.data);
8957 _res_ref.data_is_owned = true;
8958 Transaction_free(_res_ref);
8961 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_TxOut_1free(JNIEnv *env, jclass clz, int64_t _res) {
8962 if ((_res & 1) != 0) return;
8963 LDKTxOut _res_conv = *(LDKTxOut*)(((uint64_t)_res) & ~1);
8965 TxOut_free(_res_conv);
8968 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_TxOut_1clone(JNIEnv *env, jclass clz, int64_t orig) {
8969 LDKTxOut* orig_conv = (LDKTxOut*)(orig & ~1);
8970 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
8971 *ret_ref = TxOut_clone(orig_conv);
8972 return (uint64_t)ret_ref;
8975 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Str_1free(JNIEnv *env, jclass clz, jstring _res) {
8976 LDKStr dummy = { .chars = NULL, .len = 0, .chars_is_owned = false };
8980 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SecretKeyErrorZ_1ok(JNIEnv *env, jclass clz, int8_tArray o) {
8982 CHECK((*env)->GetArrayLength(env, o) == 32);
8983 (*env)->GetByteArrayRegion(env, o, 0, 32, o_ref.bytes);
8984 LDKCResult_SecretKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SecretKeyErrorZ), "LDKCResult_SecretKeyErrorZ");
8985 *ret_conv = CResult_SecretKeyErrorZ_ok(o_ref);
8986 return (uint64_t)ret_conv;
8989 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SecretKeyErrorZ_1err(JNIEnv *env, jclass clz, jclass e) {
8990 LDKSecp256k1Error e_conv = LDKSecp256k1Error_from_java(env, e);
8991 LDKCResult_SecretKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SecretKeyErrorZ), "LDKCResult_SecretKeyErrorZ");
8992 *ret_conv = CResult_SecretKeyErrorZ_err(e_conv);
8993 return (uint64_t)ret_conv;
8996 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1SecretKeyErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
8997 if ((_res & 1) != 0) return;
8998 LDKCResult_SecretKeyErrorZ _res_conv = *(LDKCResult_SecretKeyErrorZ*)(((uint64_t)_res) & ~1);
9000 CResult_SecretKeyErrorZ_free(_res_conv);
9003 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PublicKeyErrorZ_1ok(JNIEnv *env, jclass clz, int8_tArray o) {
9005 CHECK((*env)->GetArrayLength(env, o) == 33);
9006 (*env)->GetByteArrayRegion(env, o, 0, 33, o_ref.compressed_form);
9007 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
9008 *ret_conv = CResult_PublicKeyErrorZ_ok(o_ref);
9009 return (uint64_t)ret_conv;
9012 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PublicKeyErrorZ_1err(JNIEnv *env, jclass clz, jclass e) {
9013 LDKSecp256k1Error e_conv = LDKSecp256k1Error_from_java(env, e);
9014 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
9015 *ret_conv = CResult_PublicKeyErrorZ_err(e_conv);
9016 return (uint64_t)ret_conv;
9019 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PublicKeyErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9020 if ((_res & 1) != 0) return;
9021 LDKCResult_PublicKeyErrorZ _res_conv = *(LDKCResult_PublicKeyErrorZ*)(((uint64_t)_res) & ~1);
9023 CResult_PublicKeyErrorZ_free(_res_conv);
9026 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PublicKeyErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9027 LDKCResult_PublicKeyErrorZ* orig_conv = (LDKCResult_PublicKeyErrorZ*)(orig & ~1);
9028 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
9029 *ret_conv = CResult_PublicKeyErrorZ_clone(orig_conv);
9030 return (uint64_t)ret_conv;
9033 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9034 LDKTxCreationKeys o_conv;
9035 o_conv.inner = (void*)(o & (~1));
9036 o_conv.is_owned = (o & 1) || (o == 0);
9037 o_conv = TxCreationKeys_clone(&o_conv);
9038 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
9039 *ret_conv = CResult_TxCreationKeysDecodeErrorZ_ok(o_conv);
9040 return (uint64_t)ret_conv;
9043 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9044 LDKDecodeError e_conv;
9045 e_conv.inner = (void*)(e & (~1));
9046 e_conv.is_owned = (e & 1) || (e == 0);
9047 e_conv = DecodeError_clone(&e_conv);
9048 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
9049 *ret_conv = CResult_TxCreationKeysDecodeErrorZ_err(e_conv);
9050 return (uint64_t)ret_conv;
9053 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9054 if ((_res & 1) != 0) return;
9055 LDKCResult_TxCreationKeysDecodeErrorZ _res_conv = *(LDKCResult_TxCreationKeysDecodeErrorZ*)(((uint64_t)_res) & ~1);
9057 CResult_TxCreationKeysDecodeErrorZ_free(_res_conv);
9060 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9061 LDKCResult_TxCreationKeysDecodeErrorZ* orig_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)(orig & ~1);
9062 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
9063 *ret_conv = CResult_TxCreationKeysDecodeErrorZ_clone(orig_conv);
9064 return (uint64_t)ret_conv;
9067 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelPublicKeysDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9068 LDKChannelPublicKeys o_conv;
9069 o_conv.inner = (void*)(o & (~1));
9070 o_conv.is_owned = (o & 1) || (o == 0);
9071 o_conv = ChannelPublicKeys_clone(&o_conv);
9072 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
9073 *ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_ok(o_conv);
9074 return (uint64_t)ret_conv;
9077 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelPublicKeysDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9078 LDKDecodeError e_conv;
9079 e_conv.inner = (void*)(e & (~1));
9080 e_conv.is_owned = (e & 1) || (e == 0);
9081 e_conv = DecodeError_clone(&e_conv);
9082 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
9083 *ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_err(e_conv);
9084 return (uint64_t)ret_conv;
9087 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelPublicKeysDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9088 if ((_res & 1) != 0) return;
9089 LDKCResult_ChannelPublicKeysDecodeErrorZ _res_conv = *(LDKCResult_ChannelPublicKeysDecodeErrorZ*)(((uint64_t)_res) & ~1);
9091 CResult_ChannelPublicKeysDecodeErrorZ_free(_res_conv);
9094 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelPublicKeysDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9095 LDKCResult_ChannelPublicKeysDecodeErrorZ* orig_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)(orig & ~1);
9096 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
9097 *ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_clone(orig_conv);
9098 return (uint64_t)ret_conv;
9101 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9102 LDKTxCreationKeys o_conv;
9103 o_conv.inner = (void*)(o & (~1));
9104 o_conv.is_owned = (o & 1) || (o == 0);
9105 o_conv = TxCreationKeys_clone(&o_conv);
9106 LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
9107 *ret_conv = CResult_TxCreationKeysErrorZ_ok(o_conv);
9108 return (uint64_t)ret_conv;
9111 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysErrorZ_1err(JNIEnv *env, jclass clz, jclass e) {
9112 LDKSecp256k1Error e_conv = LDKSecp256k1Error_from_java(env, e);
9113 LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
9114 *ret_conv = CResult_TxCreationKeysErrorZ_err(e_conv);
9115 return (uint64_t)ret_conv;
9118 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9119 if ((_res & 1) != 0) return;
9120 LDKCResult_TxCreationKeysErrorZ _res_conv = *(LDKCResult_TxCreationKeysErrorZ*)(((uint64_t)_res) & ~1);
9122 CResult_TxCreationKeysErrorZ_free(_res_conv);
9125 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9126 LDKCResult_TxCreationKeysErrorZ* orig_conv = (LDKCResult_TxCreationKeysErrorZ*)(orig & ~1);
9127 LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
9128 *ret_conv = CResult_TxCreationKeysErrorZ_clone(orig_conv);
9129 return (uint64_t)ret_conv;
9132 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1u32Z_1some(JNIEnv *env, jclass clz, int32_t o) {
9133 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
9134 *ret_copy = COption_u32Z_some(o);
9135 uint64_t ret_ref = (uint64_t)ret_copy;
9139 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1u32Z_1none(JNIEnv *env, jclass clz) {
9140 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
9141 *ret_copy = COption_u32Z_none();
9142 uint64_t ret_ref = (uint64_t)ret_copy;
9146 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_COption_1u32Z_1free(JNIEnv *env, jclass clz, int64_t _res) {
9147 if ((_res & 1) != 0) return;
9148 LDKCOption_u32Z _res_conv = *(LDKCOption_u32Z*)(((uint64_t)_res) & ~1);
9150 COption_u32Z_free(_res_conv);
9153 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1u32Z_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9154 LDKCOption_u32Z* orig_conv = (LDKCOption_u32Z*)orig;
9155 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
9156 *ret_copy = COption_u32Z_clone(orig_conv);
9157 uint64_t ret_ref = (uint64_t)ret_copy;
9161 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCOutputInCommitmentDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9162 LDKHTLCOutputInCommitment o_conv;
9163 o_conv.inner = (void*)(o & (~1));
9164 o_conv.is_owned = (o & 1) || (o == 0);
9165 o_conv = HTLCOutputInCommitment_clone(&o_conv);
9166 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
9167 *ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o_conv);
9168 return (uint64_t)ret_conv;
9171 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCOutputInCommitmentDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9172 LDKDecodeError e_conv;
9173 e_conv.inner = (void*)(e & (~1));
9174 e_conv.is_owned = (e & 1) || (e == 0);
9175 e_conv = DecodeError_clone(&e_conv);
9176 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
9177 *ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e_conv);
9178 return (uint64_t)ret_conv;
9181 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCOutputInCommitmentDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9182 if ((_res & 1) != 0) return;
9183 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ _res_conv = *(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(((uint64_t)_res) & ~1);
9185 CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res_conv);
9188 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCOutputInCommitmentDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9189 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* orig_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(orig & ~1);
9190 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
9191 *ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig_conv);
9192 return (uint64_t)ret_conv;
9195 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CounterpartyChannelTransactionParametersDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9196 LDKCounterpartyChannelTransactionParameters o_conv;
9197 o_conv.inner = (void*)(o & (~1));
9198 o_conv.is_owned = (o & 1) || (o == 0);
9199 o_conv = CounterpartyChannelTransactionParameters_clone(&o_conv);
9200 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
9201 *ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o_conv);
9202 return (uint64_t)ret_conv;
9205 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CounterpartyChannelTransactionParametersDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9206 LDKDecodeError e_conv;
9207 e_conv.inner = (void*)(e & (~1));
9208 e_conv.is_owned = (e & 1) || (e == 0);
9209 e_conv = DecodeError_clone(&e_conv);
9210 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
9211 *ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e_conv);
9212 return (uint64_t)ret_conv;
9215 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CounterpartyChannelTransactionParametersDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9216 if ((_res & 1) != 0) return;
9217 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ _res_conv = *(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(((uint64_t)_res) & ~1);
9219 CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res_conv);
9222 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CounterpartyChannelTransactionParametersDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9223 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* orig_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(orig & ~1);
9224 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
9225 *ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig_conv);
9226 return (uint64_t)ret_conv;
9229 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelTransactionParametersDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9230 LDKChannelTransactionParameters o_conv;
9231 o_conv.inner = (void*)(o & (~1));
9232 o_conv.is_owned = (o & 1) || (o == 0);
9233 o_conv = ChannelTransactionParameters_clone(&o_conv);
9234 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
9235 *ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_ok(o_conv);
9236 return (uint64_t)ret_conv;
9239 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelTransactionParametersDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9240 LDKDecodeError e_conv;
9241 e_conv.inner = (void*)(e & (~1));
9242 e_conv.is_owned = (e & 1) || (e == 0);
9243 e_conv = DecodeError_clone(&e_conv);
9244 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
9245 *ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_err(e_conv);
9246 return (uint64_t)ret_conv;
9249 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelTransactionParametersDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9250 if ((_res & 1) != 0) return;
9251 LDKCResult_ChannelTransactionParametersDecodeErrorZ _res_conv = *(LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(((uint64_t)_res) & ~1);
9253 CResult_ChannelTransactionParametersDecodeErrorZ_free(_res_conv);
9256 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelTransactionParametersDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9257 LDKCResult_ChannelTransactionParametersDecodeErrorZ* orig_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(orig & ~1);
9258 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
9259 *ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig_conv);
9260 return (uint64_t)ret_conv;
9263 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1SignatureZ_1free(JNIEnv *env, jclass clz, jobjectArray _res) {
9264 LDKCVec_SignatureZ _res_constr;
9265 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
9266 if (_res_constr.datalen > 0)
9267 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
9269 _res_constr.data = NULL;
9270 for (size_t i = 0; i < _res_constr.datalen; i++) {
9271 int8_tArray _res_conv_8 = (*env)->GetObjectArrayElement(env, _res, i);
9272 LDKSignature _res_conv_8_ref;
9273 CHECK((*env)->GetArrayLength(env, _res_conv_8) == 64);
9274 (*env)->GetByteArrayRegion(env, _res_conv_8, 0, 64, _res_conv_8_ref.compact_form);
9275 _res_constr.data[i] = _res_conv_8_ref;
9277 CVec_SignatureZ_free(_res_constr);
9280 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1HolderCommitmentTransactionDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9281 LDKHolderCommitmentTransaction o_conv;
9282 o_conv.inner = (void*)(o & (~1));
9283 o_conv.is_owned = (o & 1) || (o == 0);
9284 o_conv = HolderCommitmentTransaction_clone(&o_conv);
9285 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
9286 *ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o_conv);
9287 return (uint64_t)ret_conv;
9290 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1HolderCommitmentTransactionDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9291 LDKDecodeError e_conv;
9292 e_conv.inner = (void*)(e & (~1));
9293 e_conv.is_owned = (e & 1) || (e == 0);
9294 e_conv = DecodeError_clone(&e_conv);
9295 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
9296 *ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_err(e_conv);
9297 return (uint64_t)ret_conv;
9300 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1HolderCommitmentTransactionDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9301 if ((_res & 1) != 0) return;
9302 LDKCResult_HolderCommitmentTransactionDecodeErrorZ _res_conv = *(LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(((uint64_t)_res) & ~1);
9304 CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res_conv);
9307 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1HolderCommitmentTransactionDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9308 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(orig & ~1);
9309 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
9310 *ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig_conv);
9311 return (uint64_t)ret_conv;
9314 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1BuiltCommitmentTransactionDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9315 LDKBuiltCommitmentTransaction o_conv;
9316 o_conv.inner = (void*)(o & (~1));
9317 o_conv.is_owned = (o & 1) || (o == 0);
9318 o_conv = BuiltCommitmentTransaction_clone(&o_conv);
9319 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
9320 *ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o_conv);
9321 return (uint64_t)ret_conv;
9324 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1BuiltCommitmentTransactionDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9325 LDKDecodeError e_conv;
9326 e_conv.inner = (void*)(e & (~1));
9327 e_conv.is_owned = (e & 1) || (e == 0);
9328 e_conv = DecodeError_clone(&e_conv);
9329 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
9330 *ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e_conv);
9331 return (uint64_t)ret_conv;
9334 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1BuiltCommitmentTransactionDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9335 if ((_res & 1) != 0) return;
9336 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ _res_conv = *(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(((uint64_t)_res) & ~1);
9338 CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res_conv);
9341 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1BuiltCommitmentTransactionDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9342 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(orig & ~1);
9343 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
9344 *ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig_conv);
9345 return (uint64_t)ret_conv;
9348 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentTransactionDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9349 LDKCommitmentTransaction o_conv;
9350 o_conv.inner = (void*)(o & (~1));
9351 o_conv.is_owned = (o & 1) || (o == 0);
9352 o_conv = CommitmentTransaction_clone(&o_conv);
9353 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
9354 *ret_conv = CResult_CommitmentTransactionDecodeErrorZ_ok(o_conv);
9355 return (uint64_t)ret_conv;
9358 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentTransactionDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9359 LDKDecodeError e_conv;
9360 e_conv.inner = (void*)(e & (~1));
9361 e_conv.is_owned = (e & 1) || (e == 0);
9362 e_conv = DecodeError_clone(&e_conv);
9363 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
9364 *ret_conv = CResult_CommitmentTransactionDecodeErrorZ_err(e_conv);
9365 return (uint64_t)ret_conv;
9368 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentTransactionDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9369 if ((_res & 1) != 0) return;
9370 LDKCResult_CommitmentTransactionDecodeErrorZ _res_conv = *(LDKCResult_CommitmentTransactionDecodeErrorZ*)(((uint64_t)_res) & ~1);
9372 CResult_CommitmentTransactionDecodeErrorZ_free(_res_conv);
9375 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentTransactionDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9376 LDKCResult_CommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)(orig & ~1);
9377 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
9378 *ret_conv = CResult_CommitmentTransactionDecodeErrorZ_clone(orig_conv);
9379 return (uint64_t)ret_conv;
9382 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TrustedCommitmentTransactionNoneZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9383 LDKTrustedCommitmentTransaction o_conv;
9384 o_conv.inner = (void*)(o & (~1));
9385 o_conv.is_owned = (o & 1) || (o == 0);
9386 // Warning: we need a move here but no clone is available for LDKTrustedCommitmentTransaction
9387 LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
9388 *ret_conv = CResult_TrustedCommitmentTransactionNoneZ_ok(o_conv);
9389 return (uint64_t)ret_conv;
9392 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TrustedCommitmentTransactionNoneZ_1err(JNIEnv *env, jclass clz) {
9393 LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
9394 *ret_conv = CResult_TrustedCommitmentTransactionNoneZ_err();
9395 return (uint64_t)ret_conv;
9398 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1TrustedCommitmentTransactionNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9399 if ((_res & 1) != 0) return;
9400 LDKCResult_TrustedCommitmentTransactionNoneZ _res_conv = *(LDKCResult_TrustedCommitmentTransactionNoneZ*)(((uint64_t)_res) & ~1);
9402 CResult_TrustedCommitmentTransactionNoneZ_free(_res_conv);
9405 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1ok(JNIEnv *env, jclass clz, jobjectArray o) {
9406 LDKCVec_SignatureZ o_constr;
9407 o_constr.datalen = (*env)->GetArrayLength(env, o);
9408 if (o_constr.datalen > 0)
9409 o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
9411 o_constr.data = NULL;
9412 for (size_t i = 0; i < o_constr.datalen; i++) {
9413 int8_tArray o_conv_8 = (*env)->GetObjectArrayElement(env, o, i);
9414 LDKSignature o_conv_8_ref;
9415 CHECK((*env)->GetArrayLength(env, o_conv_8) == 64);
9416 (*env)->GetByteArrayRegion(env, o_conv_8, 0, 64, o_conv_8_ref.compact_form);
9417 o_constr.data[i] = o_conv_8_ref;
9419 LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
9420 *ret_conv = CResult_CVec_SignatureZNoneZ_ok(o_constr);
9421 return (uint64_t)ret_conv;
9424 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1err(JNIEnv *env, jclass clz) {
9425 LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
9426 *ret_conv = CResult_CVec_SignatureZNoneZ_err();
9427 return (uint64_t)ret_conv;
9430 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9431 if ((_res & 1) != 0) return;
9432 LDKCResult_CVec_SignatureZNoneZ _res_conv = *(LDKCResult_CVec_SignatureZNoneZ*)(((uint64_t)_res) & ~1);
9434 CResult_CVec_SignatureZNoneZ_free(_res_conv);
9437 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9438 LDKCResult_CVec_SignatureZNoneZ* orig_conv = (LDKCResult_CVec_SignatureZNoneZ*)(orig & ~1);
9439 LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
9440 *ret_conv = CResult_CVec_SignatureZNoneZ_clone(orig_conv);
9441 return (uint64_t)ret_conv;
9444 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneErrorZ_1ok(JNIEnv *env, jclass clz) {
9445 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
9446 *ret_conv = CResult_NoneErrorZ_ok();
9447 return (uint64_t)ret_conv;
9450 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneErrorZ_1err(JNIEnv *env, jclass clz, jclass e) {
9451 LDKIOError e_conv = LDKIOError_from_java(env, e);
9452 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
9453 *ret_conv = CResult_NoneErrorZ_err(e_conv);
9454 return (uint64_t)ret_conv;
9457 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9458 if ((_res & 1) != 0) return;
9459 LDKCResult_NoneErrorZ _res_conv = *(LDKCResult_NoneErrorZ*)(((uint64_t)_res) & ~1);
9461 CResult_NoneErrorZ_free(_res_conv);
9464 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9465 LDKCResult_NoneErrorZ* orig_conv = (LDKCResult_NoneErrorZ*)(orig & ~1);
9466 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
9467 *ret_conv = CResult_NoneErrorZ_clone(orig_conv);
9468 return (uint64_t)ret_conv;
9471 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHopDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9473 o_conv.inner = (void*)(o & (~1));
9474 o_conv.is_owned = (o & 1) || (o == 0);
9475 o_conv = RouteHop_clone(&o_conv);
9476 LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
9477 *ret_conv = CResult_RouteHopDecodeErrorZ_ok(o_conv);
9478 return (uint64_t)ret_conv;
9481 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHopDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9482 LDKDecodeError e_conv;
9483 e_conv.inner = (void*)(e & (~1));
9484 e_conv.is_owned = (e & 1) || (e == 0);
9485 e_conv = DecodeError_clone(&e_conv);
9486 LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
9487 *ret_conv = CResult_RouteHopDecodeErrorZ_err(e_conv);
9488 return (uint64_t)ret_conv;
9491 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHopDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9492 if ((_res & 1) != 0) return;
9493 LDKCResult_RouteHopDecodeErrorZ _res_conv = *(LDKCResult_RouteHopDecodeErrorZ*)(((uint64_t)_res) & ~1);
9495 CResult_RouteHopDecodeErrorZ_free(_res_conv);
9498 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHopDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9499 LDKCResult_RouteHopDecodeErrorZ* orig_conv = (LDKCResult_RouteHopDecodeErrorZ*)(orig & ~1);
9500 LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
9501 *ret_conv = CResult_RouteHopDecodeErrorZ_clone(orig_conv);
9502 return (uint64_t)ret_conv;
9505 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1RouteHopZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
9506 LDKCVec_RouteHopZ _res_constr;
9507 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
9508 if (_res_constr.datalen > 0)
9509 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
9511 _res_constr.data = NULL;
9512 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
9513 for (size_t k = 0; k < _res_constr.datalen; k++) {
9514 int64_t _res_conv_10 = _res_vals[k];
9515 LDKRouteHop _res_conv_10_conv;
9516 _res_conv_10_conv.inner = (void*)(_res_conv_10 & (~1));
9517 _res_conv_10_conv.is_owned = (_res_conv_10 & 1) || (_res_conv_10 == 0);
9518 _res_constr.data[k] = _res_conv_10_conv;
9520 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
9521 CVec_RouteHopZ_free(_res_constr);
9524 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1CVec_1RouteHopZZ_1free(JNIEnv *env, jclass clz, jobjectArray _res) {
9525 LDKCVec_CVec_RouteHopZZ _res_constr;
9526 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
9527 if (_res_constr.datalen > 0)
9528 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKCVec_RouteHopZ), "LDKCVec_CVec_RouteHopZZ Elements");
9530 _res_constr.data = NULL;
9531 for (size_t m = 0; m < _res_constr.datalen; m++) {
9532 int64_tArray _res_conv_12 = (*env)->GetObjectArrayElement(env, _res, m);
9533 LDKCVec_RouteHopZ _res_conv_12_constr;
9534 _res_conv_12_constr.datalen = (*env)->GetArrayLength(env, _res_conv_12);
9535 if (_res_conv_12_constr.datalen > 0)
9536 _res_conv_12_constr.data = MALLOC(_res_conv_12_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
9538 _res_conv_12_constr.data = NULL;
9539 int64_t* _res_conv_12_vals = (*env)->GetLongArrayElements (env, _res_conv_12, NULL);
9540 for (size_t k = 0; k < _res_conv_12_constr.datalen; k++) {
9541 int64_t _res_conv_12_conv_10 = _res_conv_12_vals[k];
9542 LDKRouteHop _res_conv_12_conv_10_conv;
9543 _res_conv_12_conv_10_conv.inner = (void*)(_res_conv_12_conv_10 & (~1));
9544 _res_conv_12_conv_10_conv.is_owned = (_res_conv_12_conv_10 & 1) || (_res_conv_12_conv_10 == 0);
9545 _res_conv_12_constr.data[k] = _res_conv_12_conv_10_conv;
9547 (*env)->ReleaseLongArrayElements(env, _res_conv_12, _res_conv_12_vals, 0);
9548 _res_constr.data[m] = _res_conv_12_constr;
9550 CVec_CVec_RouteHopZZ_free(_res_constr);
9553 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9555 o_conv.inner = (void*)(o & (~1));
9556 o_conv.is_owned = (o & 1) || (o == 0);
9557 o_conv = Route_clone(&o_conv);
9558 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
9559 *ret_conv = CResult_RouteDecodeErrorZ_ok(o_conv);
9560 return (uint64_t)ret_conv;
9563 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9564 LDKDecodeError e_conv;
9565 e_conv.inner = (void*)(e & (~1));
9566 e_conv.is_owned = (e & 1) || (e == 0);
9567 e_conv = DecodeError_clone(&e_conv);
9568 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
9569 *ret_conv = CResult_RouteDecodeErrorZ_err(e_conv);
9570 return (uint64_t)ret_conv;
9573 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RouteDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9574 if ((_res & 1) != 0) return;
9575 LDKCResult_RouteDecodeErrorZ _res_conv = *(LDKCResult_RouteDecodeErrorZ*)(((uint64_t)_res) & ~1);
9577 CResult_RouteDecodeErrorZ_free(_res_conv);
9580 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9581 LDKCResult_RouteDecodeErrorZ* orig_conv = (LDKCResult_RouteDecodeErrorZ*)(orig & ~1);
9582 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
9583 *ret_conv = CResult_RouteDecodeErrorZ_clone(orig_conv);
9584 return (uint64_t)ret_conv;
9587 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1u64Z_1some(JNIEnv *env, jclass clz, int64_t o) {
9588 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
9589 *ret_copy = COption_u64Z_some(o);
9590 uint64_t ret_ref = (uint64_t)ret_copy;
9594 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1u64Z_1none(JNIEnv *env, jclass clz) {
9595 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
9596 *ret_copy = COption_u64Z_none();
9597 uint64_t ret_ref = (uint64_t)ret_copy;
9601 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_COption_1u64Z_1free(JNIEnv *env, jclass clz, int64_t _res) {
9602 if ((_res & 1) != 0) return;
9603 LDKCOption_u64Z _res_conv = *(LDKCOption_u64Z*)(((uint64_t)_res) & ~1);
9605 COption_u64Z_free(_res_conv);
9608 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1u64Z_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9609 LDKCOption_u64Z* orig_conv = (LDKCOption_u64Z*)orig;
9610 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
9611 *ret_copy = COption_u64Z_clone(orig_conv);
9612 uint64_t ret_ref = (uint64_t)ret_copy;
9616 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1ChannelDetailsZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
9617 LDKCVec_ChannelDetailsZ _res_constr;
9618 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
9619 if (_res_constr.datalen > 0)
9620 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
9622 _res_constr.data = NULL;
9623 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
9624 for (size_t q = 0; q < _res_constr.datalen; q++) {
9625 int64_t _res_conv_16 = _res_vals[q];
9626 LDKChannelDetails _res_conv_16_conv;
9627 _res_conv_16_conv.inner = (void*)(_res_conv_16 & (~1));
9628 _res_conv_16_conv.is_owned = (_res_conv_16 & 1) || (_res_conv_16 == 0);
9629 _res_constr.data[q] = _res_conv_16_conv;
9631 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
9632 CVec_ChannelDetailsZ_free(_res_constr);
9635 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1RouteHintZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
9636 LDKCVec_RouteHintZ _res_constr;
9637 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
9638 if (_res_constr.datalen > 0)
9639 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKRouteHint), "LDKCVec_RouteHintZ Elements");
9641 _res_constr.data = NULL;
9642 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
9643 for (size_t l = 0; l < _res_constr.datalen; l++) {
9644 int64_t _res_conv_11 = _res_vals[l];
9645 LDKRouteHint _res_conv_11_conv;
9646 _res_conv_11_conv.inner = (void*)(_res_conv_11 & (~1));
9647 _res_conv_11_conv.is_owned = (_res_conv_11 & 1) || (_res_conv_11 == 0);
9648 _res_constr.data[l] = _res_conv_11_conv;
9650 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
9651 CVec_RouteHintZ_free(_res_constr);
9654 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteLightningErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9656 o_conv.inner = (void*)(o & (~1));
9657 o_conv.is_owned = (o & 1) || (o == 0);
9658 o_conv = Route_clone(&o_conv);
9659 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
9660 *ret_conv = CResult_RouteLightningErrorZ_ok(o_conv);
9661 return (uint64_t)ret_conv;
9664 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteLightningErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9665 LDKLightningError e_conv;
9666 e_conv.inner = (void*)(e & (~1));
9667 e_conv.is_owned = (e & 1) || (e == 0);
9668 e_conv = LightningError_clone(&e_conv);
9669 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
9670 *ret_conv = CResult_RouteLightningErrorZ_err(e_conv);
9671 return (uint64_t)ret_conv;
9674 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RouteLightningErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9675 if ((_res & 1) != 0) return;
9676 LDKCResult_RouteLightningErrorZ _res_conv = *(LDKCResult_RouteLightningErrorZ*)(((uint64_t)_res) & ~1);
9678 CResult_RouteLightningErrorZ_free(_res_conv);
9681 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteLightningErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9682 LDKCResult_RouteLightningErrorZ* orig_conv = (LDKCResult_RouteLightningErrorZ*)(orig & ~1);
9683 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
9684 *ret_conv = CResult_RouteLightningErrorZ_clone(orig_conv);
9685 return (uint64_t)ret_conv;
9688 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TxOutAccessErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9689 LDKTxOut o_conv = *(LDKTxOut*)(((uint64_t)o) & ~1);
9690 LDKCResult_TxOutAccessErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutAccessErrorZ), "LDKCResult_TxOutAccessErrorZ");
9691 *ret_conv = CResult_TxOutAccessErrorZ_ok(o_conv);
9692 return (uint64_t)ret_conv;
9695 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TxOutAccessErrorZ_1err(JNIEnv *env, jclass clz, jclass e) {
9696 LDKAccessError e_conv = LDKAccessError_from_java(env, e);
9697 LDKCResult_TxOutAccessErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutAccessErrorZ), "LDKCResult_TxOutAccessErrorZ");
9698 *ret_conv = CResult_TxOutAccessErrorZ_err(e_conv);
9699 return (uint64_t)ret_conv;
9702 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1TxOutAccessErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9703 if ((_res & 1) != 0) return;
9704 LDKCResult_TxOutAccessErrorZ _res_conv = *(LDKCResult_TxOutAccessErrorZ*)(((uint64_t)_res) & ~1);
9706 CResult_TxOutAccessErrorZ_free(_res_conv);
9709 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TxOutAccessErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9710 LDKCResult_TxOutAccessErrorZ* orig_conv = (LDKCResult_TxOutAccessErrorZ*)(orig & ~1);
9711 LDKCResult_TxOutAccessErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutAccessErrorZ), "LDKCResult_TxOutAccessErrorZ");
9712 *ret_conv = CResult_TxOutAccessErrorZ_clone(orig_conv);
9713 return (uint64_t)ret_conv;
9716 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1usizeTransactionZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9717 LDKC2Tuple_usizeTransactionZ* orig_conv = (LDKC2Tuple_usizeTransactionZ*)(orig & ~1);
9718 LDKC2Tuple_usizeTransactionZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
9719 *ret_ref = C2Tuple_usizeTransactionZ_clone(orig_conv);
9720 return (uint64_t)ret_ref;
9723 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1usizeTransactionZ_1new(JNIEnv *env, jclass clz, int64_t a, int8_tArray b) {
9724 LDKTransaction b_ref;
9725 b_ref.datalen = (*env)->GetArrayLength(env, b);
9726 b_ref.data = MALLOC(b_ref.datalen, "LDKTransaction Bytes");
9727 (*env)->GetByteArrayRegion(env, b, 0, b_ref.datalen, b_ref.data);
9728 b_ref.data_is_owned = true;
9729 LDKC2Tuple_usizeTransactionZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
9730 *ret_ref = C2Tuple_usizeTransactionZ_new(a, b_ref);
9731 return (uint64_t)ret_ref;
9734 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_C2Tuple_1usizeTransactionZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9735 if ((_res & 1) != 0) return;
9736 LDKC2Tuple_usizeTransactionZ _res_conv = *(LDKC2Tuple_usizeTransactionZ*)(((uint64_t)_res) & ~1);
9738 C2Tuple_usizeTransactionZ_free(_res_conv);
9741 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1C2Tuple_1usizeTransactionZZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
9742 LDKCVec_C2Tuple_usizeTransactionZZ _res_constr;
9743 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
9744 if (_res_constr.datalen > 0)
9745 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
9747 _res_constr.data = NULL;
9748 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
9749 for (size_t y = 0; y < _res_constr.datalen; y++) {
9750 int64_t _res_conv_24 = _res_vals[y];
9751 LDKC2Tuple_usizeTransactionZ _res_conv_24_conv = *(LDKC2Tuple_usizeTransactionZ*)(((uint64_t)_res_conv_24) & ~1);
9752 FREE((void*)_res_conv_24);
9753 _res_constr.data[y] = _res_conv_24_conv;
9755 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
9756 CVec_C2Tuple_usizeTransactionZZ_free(_res_constr);
9759 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1TxidZ_1free(JNIEnv *env, jclass clz, jobjectArray _res) {
9760 LDKCVec_TxidZ _res_constr;
9761 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
9762 if (_res_constr.datalen > 0)
9763 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_TxidZ Elements");
9765 _res_constr.data = NULL;
9766 for (size_t i = 0; i < _res_constr.datalen; i++) {
9767 int8_tArray _res_conv_8 = (*env)->GetObjectArrayElement(env, _res, i);
9768 LDKThirtyTwoBytes _res_conv_8_ref;
9769 CHECK((*env)->GetArrayLength(env, _res_conv_8) == 32);
9770 (*env)->GetByteArrayRegion(env, _res_conv_8, 0, 32, _res_conv_8_ref.data);
9771 _res_constr.data[i] = _res_conv_8_ref;
9773 CVec_TxidZ_free(_res_constr);
9776 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneChannelMonitorUpdateErrZ_1ok(JNIEnv *env, jclass clz) {
9777 LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
9778 *ret_conv = CResult_NoneChannelMonitorUpdateErrZ_ok();
9779 return (uint64_t)ret_conv;
9782 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneChannelMonitorUpdateErrZ_1err(JNIEnv *env, jclass clz, jclass e) {
9783 LDKChannelMonitorUpdateErr e_conv = LDKChannelMonitorUpdateErr_from_java(env, e);
9784 LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
9785 *ret_conv = CResult_NoneChannelMonitorUpdateErrZ_err(e_conv);
9786 return (uint64_t)ret_conv;
9789 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneChannelMonitorUpdateErrZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9790 if ((_res & 1) != 0) return;
9791 LDKCResult_NoneChannelMonitorUpdateErrZ _res_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)_res) & ~1);
9793 CResult_NoneChannelMonitorUpdateErrZ_free(_res_conv);
9796 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneChannelMonitorUpdateErrZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9797 LDKCResult_NoneChannelMonitorUpdateErrZ* orig_conv = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(orig & ~1);
9798 LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
9799 *ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone(orig_conv);
9800 return (uint64_t)ret_conv;
9803 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1MonitorEventZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
9804 LDKCVec_MonitorEventZ _res_constr;
9805 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
9806 if (_res_constr.datalen > 0)
9807 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKMonitorEvent), "LDKCVec_MonitorEventZ Elements");
9809 _res_constr.data = NULL;
9810 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
9811 for (size_t o = 0; o < _res_constr.datalen; o++) {
9812 int64_t _res_conv_14 = _res_vals[o];
9813 LDKMonitorEvent _res_conv_14_conv = *(LDKMonitorEvent*)(((uint64_t)_res_conv_14) & ~1);
9814 FREE((void*)_res_conv_14);
9815 _res_constr.data[o] = _res_conv_14_conv;
9817 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
9818 CVec_MonitorEventZ_free(_res_constr);
9821 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1C2Tuple_1usizeTransactionZZ_1some(JNIEnv *env, jclass clz, int64_t o) {
9822 LDKC2Tuple_usizeTransactionZ o_conv = *(LDKC2Tuple_usizeTransactionZ*)(((uint64_t)o) & ~1);
9823 LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ");
9824 *ret_copy = COption_C2Tuple_usizeTransactionZZ_some(o_conv);
9825 uint64_t ret_ref = (uint64_t)ret_copy;
9829 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1C2Tuple_1usizeTransactionZZ_1none(JNIEnv *env, jclass clz) {
9830 LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ");
9831 *ret_copy = COption_C2Tuple_usizeTransactionZZ_none();
9832 uint64_t ret_ref = (uint64_t)ret_copy;
9836 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_COption_1C2Tuple_1usizeTransactionZZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9837 if ((_res & 1) != 0) return;
9838 LDKCOption_C2Tuple_usizeTransactionZZ _res_conv = *(LDKCOption_C2Tuple_usizeTransactionZZ*)(((uint64_t)_res) & ~1);
9840 COption_C2Tuple_usizeTransactionZZ_free(_res_conv);
9843 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1C2Tuple_1usizeTransactionZZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9844 LDKCOption_C2Tuple_usizeTransactionZZ* orig_conv = (LDKCOption_C2Tuple_usizeTransactionZZ*)orig;
9845 LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ");
9846 *ret_copy = COption_C2Tuple_usizeTransactionZZ_clone(orig_conv);
9847 uint64_t ret_ref = (uint64_t)ret_copy;
9851 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1SpendableOutputDescriptorZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
9852 LDKCVec_SpendableOutputDescriptorZ _res_constr;
9853 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
9854 if (_res_constr.datalen > 0)
9855 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKSpendableOutputDescriptor), "LDKCVec_SpendableOutputDescriptorZ Elements");
9857 _res_constr.data = NULL;
9858 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
9859 for (size_t b = 0; b < _res_constr.datalen; b++) {
9860 int64_t _res_conv_27 = _res_vals[b];
9861 LDKSpendableOutputDescriptor _res_conv_27_conv = *(LDKSpendableOutputDescriptor*)(((uint64_t)_res_conv_27) & ~1);
9862 FREE((void*)_res_conv_27);
9863 _res_constr.data[b] = _res_conv_27_conv;
9865 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
9866 CVec_SpendableOutputDescriptorZ_free(_res_constr);
9869 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1MessageSendEventZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
9870 LDKCVec_MessageSendEventZ _res_constr;
9871 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
9872 if (_res_constr.datalen > 0)
9873 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKMessageSendEvent), "LDKCVec_MessageSendEventZ Elements");
9875 _res_constr.data = NULL;
9876 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
9877 for (size_t s = 0; s < _res_constr.datalen; s++) {
9878 int64_t _res_conv_18 = _res_vals[s];
9879 LDKMessageSendEvent _res_conv_18_conv = *(LDKMessageSendEvent*)(((uint64_t)_res_conv_18) & ~1);
9880 FREE((void*)_res_conv_18);
9881 _res_constr.data[s] = _res_conv_18_conv;
9883 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
9884 CVec_MessageSendEventZ_free(_res_constr);
9887 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InitFeaturesDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9888 LDKInitFeatures o_conv;
9889 o_conv.inner = (void*)(o & (~1));
9890 o_conv.is_owned = (o & 1) || (o == 0);
9891 o_conv = InitFeatures_clone(&o_conv);
9892 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
9893 *ret_conv = CResult_InitFeaturesDecodeErrorZ_ok(o_conv);
9894 return (uint64_t)ret_conv;
9897 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InitFeaturesDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9898 LDKDecodeError e_conv;
9899 e_conv.inner = (void*)(e & (~1));
9900 e_conv.is_owned = (e & 1) || (e == 0);
9901 e_conv = DecodeError_clone(&e_conv);
9902 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
9903 *ret_conv = CResult_InitFeaturesDecodeErrorZ_err(e_conv);
9904 return (uint64_t)ret_conv;
9907 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1InitFeaturesDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9908 if ((_res & 1) != 0) return;
9909 LDKCResult_InitFeaturesDecodeErrorZ _res_conv = *(LDKCResult_InitFeaturesDecodeErrorZ*)(((uint64_t)_res) & ~1);
9911 CResult_InitFeaturesDecodeErrorZ_free(_res_conv);
9914 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeFeaturesDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9915 LDKNodeFeatures o_conv;
9916 o_conv.inner = (void*)(o & (~1));
9917 o_conv.is_owned = (o & 1) || (o == 0);
9918 o_conv = NodeFeatures_clone(&o_conv);
9919 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
9920 *ret_conv = CResult_NodeFeaturesDecodeErrorZ_ok(o_conv);
9921 return (uint64_t)ret_conv;
9924 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeFeaturesDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9925 LDKDecodeError e_conv;
9926 e_conv.inner = (void*)(e & (~1));
9927 e_conv.is_owned = (e & 1) || (e == 0);
9928 e_conv = DecodeError_clone(&e_conv);
9929 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
9930 *ret_conv = CResult_NodeFeaturesDecodeErrorZ_err(e_conv);
9931 return (uint64_t)ret_conv;
9934 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NodeFeaturesDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9935 if ((_res & 1) != 0) return;
9936 LDKCResult_NodeFeaturesDecodeErrorZ _res_conv = *(LDKCResult_NodeFeaturesDecodeErrorZ*)(((uint64_t)_res) & ~1);
9938 CResult_NodeFeaturesDecodeErrorZ_free(_res_conv);
9941 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelFeaturesDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9942 LDKChannelFeatures o_conv;
9943 o_conv.inner = (void*)(o & (~1));
9944 o_conv.is_owned = (o & 1) || (o == 0);
9945 o_conv = ChannelFeatures_clone(&o_conv);
9946 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
9947 *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_ok(o_conv);
9948 return (uint64_t)ret_conv;
9951 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelFeaturesDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9952 LDKDecodeError e_conv;
9953 e_conv.inner = (void*)(e & (~1));
9954 e_conv.is_owned = (e & 1) || (e == 0);
9955 e_conv = DecodeError_clone(&e_conv);
9956 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
9957 *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_err(e_conv);
9958 return (uint64_t)ret_conv;
9961 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelFeaturesDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9962 if ((_res & 1) != 0) return;
9963 LDKCResult_ChannelFeaturesDecodeErrorZ _res_conv = *(LDKCResult_ChannelFeaturesDecodeErrorZ*)(((uint64_t)_res) & ~1);
9965 CResult_ChannelFeaturesDecodeErrorZ_free(_res_conv);
9968 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceFeaturesDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9969 LDKInvoiceFeatures o_conv;
9970 o_conv.inner = (void*)(o & (~1));
9971 o_conv.is_owned = (o & 1) || (o == 0);
9972 o_conv = InvoiceFeatures_clone(&o_conv);
9973 LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
9974 *ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_ok(o_conv);
9975 return (uint64_t)ret_conv;
9978 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceFeaturesDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9979 LDKDecodeError e_conv;
9980 e_conv.inner = (void*)(e & (~1));
9981 e_conv.is_owned = (e & 1) || (e == 0);
9982 e_conv = DecodeError_clone(&e_conv);
9983 LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
9984 *ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_err(e_conv);
9985 return (uint64_t)ret_conv;
9988 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceFeaturesDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9989 if ((_res & 1) != 0) return;
9990 LDKCResult_InvoiceFeaturesDecodeErrorZ _res_conv = *(LDKCResult_InvoiceFeaturesDecodeErrorZ*)(((uint64_t)_res) & ~1);
9992 CResult_InvoiceFeaturesDecodeErrorZ_free(_res_conv);
9995 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1DelayedPaymentOutputDescriptorDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9996 LDKDelayedPaymentOutputDescriptor o_conv;
9997 o_conv.inner = (void*)(o & (~1));
9998 o_conv.is_owned = (o & 1) || (o == 0);
9999 o_conv = DelayedPaymentOutputDescriptor_clone(&o_conv);
10000 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
10001 *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o_conv);
10002 return (uint64_t)ret_conv;
10005 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1DelayedPaymentOutputDescriptorDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
10006 LDKDecodeError e_conv;
10007 e_conv.inner = (void*)(e & (~1));
10008 e_conv.is_owned = (e & 1) || (e == 0);
10009 e_conv = DecodeError_clone(&e_conv);
10010 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
10011 *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e_conv);
10012 return (uint64_t)ret_conv;
10015 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1DelayedPaymentOutputDescriptorDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
10016 if ((_res & 1) != 0) return;
10017 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res_conv = *(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(((uint64_t)_res) & ~1);
10019 CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res_conv);
10022 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1DelayedPaymentOutputDescriptorDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10023 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(orig & ~1);
10024 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
10025 *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig_conv);
10026 return (uint64_t)ret_conv;
10029 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1StaticPaymentOutputDescriptorDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
10030 LDKStaticPaymentOutputDescriptor o_conv;
10031 o_conv.inner = (void*)(o & (~1));
10032 o_conv.is_owned = (o & 1) || (o == 0);
10033 o_conv = StaticPaymentOutputDescriptor_clone(&o_conv);
10034 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
10035 *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o_conv);
10036 return (uint64_t)ret_conv;
10039 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1StaticPaymentOutputDescriptorDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
10040 LDKDecodeError e_conv;
10041 e_conv.inner = (void*)(e & (~1));
10042 e_conv.is_owned = (e & 1) || (e == 0);
10043 e_conv = DecodeError_clone(&e_conv);
10044 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
10045 *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e_conv);
10046 return (uint64_t)ret_conv;
10049 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1StaticPaymentOutputDescriptorDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
10050 if ((_res & 1) != 0) return;
10051 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res_conv = *(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(((uint64_t)_res) & ~1);
10053 CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res_conv);
10056 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1StaticPaymentOutputDescriptorDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10057 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(orig & ~1);
10058 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
10059 *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig_conv);
10060 return (uint64_t)ret_conv;
10063 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SpendableOutputDescriptorDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
10064 LDKSpendableOutputDescriptor o_conv = *(LDKSpendableOutputDescriptor*)(((uint64_t)o) & ~1);
10065 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
10066 *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o_conv);
10067 return (uint64_t)ret_conv;
10070 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SpendableOutputDescriptorDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
10071 LDKDecodeError e_conv;
10072 e_conv.inner = (void*)(e & (~1));
10073 e_conv.is_owned = (e & 1) || (e == 0);
10074 e_conv = DecodeError_clone(&e_conv);
10075 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
10076 *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_err(e_conv);
10077 return (uint64_t)ret_conv;
10080 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1SpendableOutputDescriptorDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
10081 if ((_res & 1) != 0) return;
10082 LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res_conv = *(LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(((uint64_t)_res) & ~1);
10084 CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res_conv);
10087 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SpendableOutputDescriptorDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10088 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(orig & ~1);
10089 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
10090 *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig_conv);
10091 return (uint64_t)ret_conv;
10094 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1SignatureCVec_1SignatureZZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10095 LDKC2Tuple_SignatureCVec_SignatureZZ* orig_conv = (LDKC2Tuple_SignatureCVec_SignatureZZ*)(orig & ~1);
10096 LDKC2Tuple_SignatureCVec_SignatureZZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
10097 *ret_ref = C2Tuple_SignatureCVec_SignatureZZ_clone(orig_conv);
10098 return (uint64_t)ret_ref;
10101 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1SignatureCVec_1SignatureZZ_1new(JNIEnv *env, jclass clz, int8_tArray a, jobjectArray b) {
10102 LDKSignature a_ref;
10103 CHECK((*env)->GetArrayLength(env, a) == 64);
10104 (*env)->GetByteArrayRegion(env, a, 0, 64, a_ref.compact_form);
10105 LDKCVec_SignatureZ b_constr;
10106 b_constr.datalen = (*env)->GetArrayLength(env, b);
10107 if (b_constr.datalen > 0)
10108 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
10110 b_constr.data = NULL;
10111 for (size_t i = 0; i < b_constr.datalen; i++) {
10112 int8_tArray b_conv_8 = (*env)->GetObjectArrayElement(env, b, i);
10113 LDKSignature b_conv_8_ref;
10114 CHECK((*env)->GetArrayLength(env, b_conv_8) == 64);
10115 (*env)->GetByteArrayRegion(env, b_conv_8, 0, 64, b_conv_8_ref.compact_form);
10116 b_constr.data[i] = b_conv_8_ref;
10118 LDKC2Tuple_SignatureCVec_SignatureZZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
10119 *ret_ref = C2Tuple_SignatureCVec_SignatureZZ_new(a_ref, b_constr);
10120 return (uint64_t)ret_ref;
10123 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_C2Tuple_1SignatureCVec_1SignatureZZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
10124 if ((_res & 1) != 0) return;
10125 LDKC2Tuple_SignatureCVec_SignatureZZ _res_conv = *(LDKC2Tuple_SignatureCVec_SignatureZZ*)(((uint64_t)_res) & ~1);
10127 C2Tuple_SignatureCVec_SignatureZZ_free(_res_conv);
10130 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1SignatureCVec_1SignatureZZNoneZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
10131 LDKC2Tuple_SignatureCVec_SignatureZZ o_conv = *(LDKC2Tuple_SignatureCVec_SignatureZZ*)(((uint64_t)o) & ~1);
10132 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
10133 *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o_conv);
10134 return (uint64_t)ret_conv;
10137 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1SignatureCVec_1SignatureZZNoneZ_1err(JNIEnv *env, jclass clz) {
10138 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
10139 *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err();
10140 return (uint64_t)ret_conv;
10143 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1SignatureCVec_1SignatureZZNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
10144 if ((_res & 1) != 0) return;
10145 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ _res_conv = *(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(((uint64_t)_res) & ~1);
10147 CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res_conv);
10150 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1SignatureCVec_1SignatureZZNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10151 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* orig_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(orig & ~1);
10152 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
10153 *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig_conv);
10154 return (uint64_t)ret_conv;
10157 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SignatureNoneZ_1ok(JNIEnv *env, jclass clz, int8_tArray o) {
10158 LDKSignature o_ref;
10159 CHECK((*env)->GetArrayLength(env, o) == 64);
10160 (*env)->GetByteArrayRegion(env, o, 0, 64, o_ref.compact_form);
10161 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
10162 *ret_conv = CResult_SignatureNoneZ_ok(o_ref);
10163 return (uint64_t)ret_conv;
10166 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SignatureNoneZ_1err(JNIEnv *env, jclass clz) {
10167 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
10168 *ret_conv = CResult_SignatureNoneZ_err();
10169 return (uint64_t)ret_conv;
10172 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1SignatureNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
10173 if ((_res & 1) != 0) return;
10174 LDKCResult_SignatureNoneZ _res_conv = *(LDKCResult_SignatureNoneZ*)(((uint64_t)_res) & ~1);
10176 CResult_SignatureNoneZ_free(_res_conv);
10179 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SignatureNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10180 LDKCResult_SignatureNoneZ* orig_conv = (LDKCResult_SignatureNoneZ*)(orig & ~1);
10181 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
10182 *ret_conv = CResult_SignatureNoneZ_clone(orig_conv);
10183 return (uint64_t)ret_conv;
10186 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SignDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
10187 LDKSign o_conv = *(LDKSign*)(((uint64_t)o) & ~1);
10188 if (o_conv.free == LDKSign_JCalls_free) {
10189 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
10190 LDKSign_JCalls_clone(o_conv.this_arg);
10192 LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
10193 *ret_conv = CResult_SignDecodeErrorZ_ok(o_conv);
10194 return (uint64_t)ret_conv;
10197 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SignDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
10198 LDKDecodeError e_conv;
10199 e_conv.inner = (void*)(e & (~1));
10200 e_conv.is_owned = (e & 1) || (e == 0);
10201 e_conv = DecodeError_clone(&e_conv);
10202 LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
10203 *ret_conv = CResult_SignDecodeErrorZ_err(e_conv);
10204 return (uint64_t)ret_conv;
10207 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1SignDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
10208 if ((_res & 1) != 0) return;
10209 LDKCResult_SignDecodeErrorZ _res_conv = *(LDKCResult_SignDecodeErrorZ*)(((uint64_t)_res) & ~1);
10211 CResult_SignDecodeErrorZ_free(_res_conv);
10214 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SignDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10215 LDKCResult_SignDecodeErrorZ* orig_conv = (LDKCResult_SignDecodeErrorZ*)(orig & ~1);
10216 LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
10217 *ret_conv = CResult_SignDecodeErrorZ_clone(orig_conv);
10218 return (uint64_t)ret_conv;
10221 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1u8Z_1free(JNIEnv *env, jclass clz, int8_tArray _res) {
10222 LDKCVec_u8Z _res_ref;
10223 _res_ref.datalen = (*env)->GetArrayLength(env, _res);
10224 _res_ref.data = MALLOC(_res_ref.datalen, "LDKCVec_u8Z Bytes");
10225 (*env)->GetByteArrayRegion(env, _res, 0, _res_ref.datalen, _res_ref.data);
10226 CVec_u8Z_free(_res_ref);
10229 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RecoverableSignatureNoneZ_1ok(JNIEnv *env, jclass clz, int8_tArray arg) {
10230 LDKRecoverableSignature arg_ref;
10231 CHECK((*env)->GetArrayLength(env, arg) == 68);
10232 (*env)->GetByteArrayRegion(env, arg, 0, 68, arg_ref.serialized_form);
10233 LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
10234 *ret_conv = CResult_RecoverableSignatureNoneZ_ok(arg_ref);
10235 return (uint64_t)ret_conv;
10238 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RecoverableSignatureNoneZ_1err(JNIEnv *env, jclass clz) {
10239 LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
10240 *ret_conv = CResult_RecoverableSignatureNoneZ_err();
10241 return (uint64_t)ret_conv;
10244 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RecoverableSignatureNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
10245 if ((_res & 1) != 0) return;
10246 LDKCResult_RecoverableSignatureNoneZ _res_conv = *(LDKCResult_RecoverableSignatureNoneZ*)(((uint64_t)_res) & ~1);
10248 CResult_RecoverableSignatureNoneZ_free(_res_conv);
10251 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RecoverableSignatureNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10252 LDKCResult_RecoverableSignatureNoneZ* orig_conv = (LDKCResult_RecoverableSignatureNoneZ*)(orig & ~1);
10253 LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
10254 *ret_conv = CResult_RecoverableSignatureNoneZ_clone(orig_conv);
10255 return (uint64_t)ret_conv;
10258 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1CVec_1u8ZZ_1free(JNIEnv *env, jclass clz, jobjectArray _res) {
10259 LDKCVec_CVec_u8ZZ _res_constr;
10260 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
10261 if (_res_constr.datalen > 0)
10262 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKCVec_u8Z), "LDKCVec_CVec_u8ZZ Elements");
10264 _res_constr.data = NULL;
10265 for (size_t i = 0; i < _res_constr.datalen; i++) {
10266 int8_tArray _res_conv_8 = (*env)->GetObjectArrayElement(env, _res, i);
10267 LDKCVec_u8Z _res_conv_8_ref;
10268 _res_conv_8_ref.datalen = (*env)->GetArrayLength(env, _res_conv_8);
10269 _res_conv_8_ref.data = MALLOC(_res_conv_8_ref.datalen, "LDKCVec_u8Z Bytes");
10270 (*env)->GetByteArrayRegion(env, _res_conv_8, 0, _res_conv_8_ref.datalen, _res_conv_8_ref.data);
10271 _res_constr.data[i] = _res_conv_8_ref;
10273 CVec_CVec_u8ZZ_free(_res_constr);
10276 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1CVec_1u8ZZNoneZ_1ok(JNIEnv *env, jclass clz, jobjectArray o) {
10277 LDKCVec_CVec_u8ZZ o_constr;
10278 o_constr.datalen = (*env)->GetArrayLength(env, o);
10279 if (o_constr.datalen > 0)
10280 o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKCVec_u8Z), "LDKCVec_CVec_u8ZZ Elements");
10282 o_constr.data = NULL;
10283 for (size_t i = 0; i < o_constr.datalen; i++) {
10284 int8_tArray o_conv_8 = (*env)->GetObjectArrayElement(env, o, i);
10285 LDKCVec_u8Z o_conv_8_ref;
10286 o_conv_8_ref.datalen = (*env)->GetArrayLength(env, o_conv_8);
10287 o_conv_8_ref.data = MALLOC(o_conv_8_ref.datalen, "LDKCVec_u8Z Bytes");
10288 (*env)->GetByteArrayRegion(env, o_conv_8, 0, o_conv_8_ref.datalen, o_conv_8_ref.data);
10289 o_constr.data[i] = o_conv_8_ref;
10291 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
10292 *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_ok(o_constr);
10293 return (uint64_t)ret_conv;
10296 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1CVec_1u8ZZNoneZ_1err(JNIEnv *env, jclass clz) {
10297 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
10298 *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_err();
10299 return (uint64_t)ret_conv;
10302 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1CVec_1u8ZZNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
10303 if ((_res & 1) != 0) return;
10304 LDKCResult_CVec_CVec_u8ZZNoneZ _res_conv = *(LDKCResult_CVec_CVec_u8ZZNoneZ*)(((uint64_t)_res) & ~1);
10306 CResult_CVec_CVec_u8ZZNoneZ_free(_res_conv);
10309 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1CVec_1u8ZZNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10310 LDKCResult_CVec_CVec_u8ZZNoneZ* orig_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)(orig & ~1);
10311 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
10312 *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_clone(orig_conv);
10313 return (uint64_t)ret_conv;
10316 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InMemorySignerDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
10317 LDKInMemorySigner o_conv;
10318 o_conv.inner = (void*)(o & (~1));
10319 o_conv.is_owned = (o & 1) || (o == 0);
10320 o_conv = InMemorySigner_clone(&o_conv);
10321 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
10322 *ret_conv = CResult_InMemorySignerDecodeErrorZ_ok(o_conv);
10323 return (uint64_t)ret_conv;
10326 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InMemorySignerDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
10327 LDKDecodeError e_conv;
10328 e_conv.inner = (void*)(e & (~1));
10329 e_conv.is_owned = (e & 1) || (e == 0);
10330 e_conv = DecodeError_clone(&e_conv);
10331 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
10332 *ret_conv = CResult_InMemorySignerDecodeErrorZ_err(e_conv);
10333 return (uint64_t)ret_conv;
10336 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1InMemorySignerDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
10337 if ((_res & 1) != 0) return;
10338 LDKCResult_InMemorySignerDecodeErrorZ _res_conv = *(LDKCResult_InMemorySignerDecodeErrorZ*)(((uint64_t)_res) & ~1);
10340 CResult_InMemorySignerDecodeErrorZ_free(_res_conv);
10343 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InMemorySignerDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10344 LDKCResult_InMemorySignerDecodeErrorZ* orig_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)(orig & ~1);
10345 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
10346 *ret_conv = CResult_InMemorySignerDecodeErrorZ_clone(orig_conv);
10347 return (uint64_t)ret_conv;
10350 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1TxOutZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
10351 LDKCVec_TxOutZ _res_constr;
10352 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
10353 if (_res_constr.datalen > 0)
10354 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKTxOut), "LDKCVec_TxOutZ Elements");
10356 _res_constr.data = NULL;
10357 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
10358 for (size_t h = 0; h < _res_constr.datalen; h++) {
10359 int64_t _res_conv_7 = _res_vals[h];
10360 LDKTxOut _res_conv_7_conv = *(LDKTxOut*)(((uint64_t)_res_conv_7) & ~1);
10361 FREE((void*)_res_conv_7);
10362 _res_constr.data[h] = _res_conv_7_conv;
10364 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
10365 CVec_TxOutZ_free(_res_constr);
10368 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TransactionNoneZ_1ok(JNIEnv *env, jclass clz, int8_tArray o) {
10369 LDKTransaction o_ref;
10370 o_ref.datalen = (*env)->GetArrayLength(env, o);
10371 o_ref.data = MALLOC(o_ref.datalen, "LDKTransaction Bytes");
10372 (*env)->GetByteArrayRegion(env, o, 0, o_ref.datalen, o_ref.data);
10373 o_ref.data_is_owned = true;
10374 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
10375 *ret_conv = CResult_TransactionNoneZ_ok(o_ref);
10376 return (uint64_t)ret_conv;
10379 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TransactionNoneZ_1err(JNIEnv *env, jclass clz) {
10380 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
10381 *ret_conv = CResult_TransactionNoneZ_err();
10382 return (uint64_t)ret_conv;
10385 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1TransactionNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
10386 if ((_res & 1) != 0) return;
10387 LDKCResult_TransactionNoneZ _res_conv = *(LDKCResult_TransactionNoneZ*)(((uint64_t)_res) & ~1);
10389 CResult_TransactionNoneZ_free(_res_conv);
10392 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TransactionNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10393 LDKCResult_TransactionNoneZ* orig_conv = (LDKCResult_TransactionNoneZ*)(orig & ~1);
10394 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
10395 *ret_conv = CResult_TransactionNoneZ_clone(orig_conv);
10396 return (uint64_t)ret_conv;
10399 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1BlockHashChannelMonitorZ_1new(JNIEnv *env, jclass clz, int8_tArray a, int64_t b) {
10400 LDKThirtyTwoBytes a_ref;
10401 CHECK((*env)->GetArrayLength(env, a) == 32);
10402 (*env)->GetByteArrayRegion(env, a, 0, 32, a_ref.data);
10403 LDKChannelMonitor b_conv;
10404 b_conv.inner = (void*)(b & (~1));
10405 b_conv.is_owned = (b & 1) || (b == 0);
10406 b_conv = ChannelMonitor_clone(&b_conv);
10407 LDKC2Tuple_BlockHashChannelMonitorZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
10408 *ret_ref = C2Tuple_BlockHashChannelMonitorZ_new(a_ref, b_conv);
10409 return (uint64_t)ret_ref;
10412 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_C2Tuple_1BlockHashChannelMonitorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
10413 if ((_res & 1) != 0) return;
10414 LDKC2Tuple_BlockHashChannelMonitorZ _res_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(((uint64_t)_res) & ~1);
10416 C2Tuple_BlockHashChannelMonitorZ_free(_res_conv);
10419 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1C2Tuple_1BlockHashChannelMonitorZZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
10420 LDKCVec_C2Tuple_BlockHashChannelMonitorZZ _res_constr;
10421 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
10422 if (_res_constr.datalen > 0)
10423 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKCVec_C2Tuple_BlockHashChannelMonitorZZ Elements");
10425 _res_constr.data = NULL;
10426 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
10427 for (size_t i = 0; i < _res_constr.datalen; i++) {
10428 int64_t _res_conv_34 = _res_vals[i];
10429 LDKC2Tuple_BlockHashChannelMonitorZ _res_conv_34_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(((uint64_t)_res_conv_34) & ~1);
10430 FREE((void*)_res_conv_34);
10431 _res_constr.data[i] = _res_conv_34_conv;
10433 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
10434 CVec_C2Tuple_BlockHashChannelMonitorZZ_free(_res_constr);
10437 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1C2Tuple_1BlockHashChannelMonitorZZErrorZ_1ok(JNIEnv *env, jclass clz, int64_tArray o) {
10438 LDKCVec_C2Tuple_BlockHashChannelMonitorZZ o_constr;
10439 o_constr.datalen = (*env)->GetArrayLength(env, o);
10440 if (o_constr.datalen > 0)
10441 o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKCVec_C2Tuple_BlockHashChannelMonitorZZ Elements");
10443 o_constr.data = NULL;
10444 int64_t* o_vals = (*env)->GetLongArrayElements (env, o, NULL);
10445 for (size_t i = 0; i < o_constr.datalen; i++) {
10446 int64_t o_conv_34 = o_vals[i];
10447 LDKC2Tuple_BlockHashChannelMonitorZ o_conv_34_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(((uint64_t)o_conv_34) & ~1);
10448 // Warning: we may need a move here but no clone is available for LDKC2Tuple_BlockHashChannelMonitorZ
10449 o_constr.data[i] = o_conv_34_conv;
10451 (*env)->ReleaseLongArrayElements(env, o, o_vals, 0);
10452 LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ), "LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ");
10453 *ret_conv = CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_ok(o_constr);
10454 return (uint64_t)ret_conv;
10457 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1C2Tuple_1BlockHashChannelMonitorZZErrorZ_1err(JNIEnv *env, jclass clz, jclass e) {
10458 LDKIOError e_conv = LDKIOError_from_java(env, e);
10459 LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ), "LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ");
10460 *ret_conv = CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_err(e_conv);
10461 return (uint64_t)ret_conv;
10464 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1C2Tuple_1BlockHashChannelMonitorZZErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
10465 if ((_res & 1) != 0) return;
10466 LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ _res_conv = *(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)(((uint64_t)_res) & ~1);
10468 CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(_res_conv);
10471 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1u16Z_1some(JNIEnv *env, jclass clz, int16_t o) {
10472 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
10473 *ret_copy = COption_u16Z_some(o);
10474 uint64_t ret_ref = (uint64_t)ret_copy;
10478 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1u16Z_1none(JNIEnv *env, jclass clz) {
10479 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
10480 *ret_copy = COption_u16Z_none();
10481 uint64_t ret_ref = (uint64_t)ret_copy;
10485 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_COption_1u16Z_1free(JNIEnv *env, jclass clz, int64_t _res) {
10486 if ((_res & 1) != 0) return;
10487 LDKCOption_u16Z _res_conv = *(LDKCOption_u16Z*)(((uint64_t)_res) & ~1);
10489 COption_u16Z_free(_res_conv);
10492 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1u16Z_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10493 LDKCOption_u16Z* orig_conv = (LDKCOption_u16Z*)orig;
10494 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
10495 *ret_copy = COption_u16Z_clone(orig_conv);
10496 uint64_t ret_ref = (uint64_t)ret_copy;
10500 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneAPIErrorZ_1ok(JNIEnv *env, jclass clz) {
10501 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
10502 *ret_conv = CResult_NoneAPIErrorZ_ok();
10503 return (uint64_t)ret_conv;
10506 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneAPIErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
10507 LDKAPIError e_conv = *(LDKAPIError*)(((uint64_t)e) & ~1);
10508 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
10509 *ret_conv = CResult_NoneAPIErrorZ_err(e_conv);
10510 return (uint64_t)ret_conv;
10513 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneAPIErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
10514 if ((_res & 1) != 0) return;
10515 LDKCResult_NoneAPIErrorZ _res_conv = *(LDKCResult_NoneAPIErrorZ*)(((uint64_t)_res) & ~1);
10517 CResult_NoneAPIErrorZ_free(_res_conv);
10520 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneAPIErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10521 LDKCResult_NoneAPIErrorZ* orig_conv = (LDKCResult_NoneAPIErrorZ*)(orig & ~1);
10522 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
10523 *ret_conv = CResult_NoneAPIErrorZ_clone(orig_conv);
10524 return (uint64_t)ret_conv;
10527 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1CResult_1NoneAPIErrorZZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
10528 LDKCVec_CResult_NoneAPIErrorZZ _res_constr;
10529 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
10530 if (_res_constr.datalen > 0)
10531 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKCResult_NoneAPIErrorZ), "LDKCVec_CResult_NoneAPIErrorZZ Elements");
10533 _res_constr.data = NULL;
10534 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
10535 for (size_t w = 0; w < _res_constr.datalen; w++) {
10536 int64_t _res_conv_22 = _res_vals[w];
10537 LDKCResult_NoneAPIErrorZ _res_conv_22_conv = *(LDKCResult_NoneAPIErrorZ*)(((uint64_t)_res_conv_22) & ~1);
10538 FREE((void*)_res_conv_22);
10539 _res_constr.data[w] = _res_conv_22_conv;
10541 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
10542 CVec_CResult_NoneAPIErrorZZ_free(_res_constr);
10545 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1APIErrorZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
10546 LDKCVec_APIErrorZ _res_constr;
10547 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
10548 if (_res_constr.datalen > 0)
10549 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKAPIError), "LDKCVec_APIErrorZ Elements");
10551 _res_constr.data = NULL;
10552 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
10553 for (size_t k = 0; k < _res_constr.datalen; k++) {
10554 int64_t _res_conv_10 = _res_vals[k];
10555 LDKAPIError _res_conv_10_conv = *(LDKAPIError*)(((uint64_t)_res_conv_10) & ~1);
10556 FREE((void*)_res_conv_10);
10557 _res_constr.data[k] = _res_conv_10_conv;
10559 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
10560 CVec_APIErrorZ_free(_res_constr);
10563 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NonePaymentSendFailureZ_1ok(JNIEnv *env, jclass clz) {
10564 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
10565 *ret_conv = CResult_NonePaymentSendFailureZ_ok();
10566 return (uint64_t)ret_conv;
10569 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NonePaymentSendFailureZ_1err(JNIEnv *env, jclass clz, int64_t e) {
10570 LDKPaymentSendFailure e_conv = *(LDKPaymentSendFailure*)(((uint64_t)e) & ~1);
10571 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
10572 *ret_conv = CResult_NonePaymentSendFailureZ_err(e_conv);
10573 return (uint64_t)ret_conv;
10576 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NonePaymentSendFailureZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
10577 if ((_res & 1) != 0) return;
10578 LDKCResult_NonePaymentSendFailureZ _res_conv = *(LDKCResult_NonePaymentSendFailureZ*)(((uint64_t)_res) & ~1);
10580 CResult_NonePaymentSendFailureZ_free(_res_conv);
10583 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NonePaymentSendFailureZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10584 LDKCResult_NonePaymentSendFailureZ* orig_conv = (LDKCResult_NonePaymentSendFailureZ*)(orig & ~1);
10585 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
10586 *ret_conv = CResult_NonePaymentSendFailureZ_clone(orig_conv);
10587 return (uint64_t)ret_conv;
10590 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1NetAddressZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
10591 LDKCVec_NetAddressZ _res_constr;
10592 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
10593 if (_res_constr.datalen > 0)
10594 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
10596 _res_constr.data = NULL;
10597 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
10598 for (size_t m = 0; m < _res_constr.datalen; m++) {
10599 int64_t _res_conv_12 = _res_vals[m];
10600 LDKNetAddress _res_conv_12_conv = *(LDKNetAddress*)(((uint64_t)_res_conv_12) & ~1);
10601 FREE((void*)_res_conv_12);
10602 _res_constr.data[m] = _res_conv_12_conv;
10604 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
10605 CVec_NetAddressZ_free(_res_constr);
10608 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1PaymentHashPaymentSecretZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10609 LDKC2Tuple_PaymentHashPaymentSecretZ* orig_conv = (LDKC2Tuple_PaymentHashPaymentSecretZ*)(orig & ~1);
10610 LDKC2Tuple_PaymentHashPaymentSecretZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
10611 *ret_ref = C2Tuple_PaymentHashPaymentSecretZ_clone(orig_conv);
10612 return (uint64_t)ret_ref;
10615 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1PaymentHashPaymentSecretZ_1new(JNIEnv *env, jclass clz, int8_tArray a, int8_tArray b) {
10616 LDKThirtyTwoBytes a_ref;
10617 CHECK((*env)->GetArrayLength(env, a) == 32);
10618 (*env)->GetByteArrayRegion(env, a, 0, 32, a_ref.data);
10619 LDKThirtyTwoBytes b_ref;
10620 CHECK((*env)->GetArrayLength(env, b) == 32);
10621 (*env)->GetByteArrayRegion(env, b, 0, 32, b_ref.data);
10622 LDKC2Tuple_PaymentHashPaymentSecretZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
10623 *ret_ref = C2Tuple_PaymentHashPaymentSecretZ_new(a_ref, b_ref);
10624 return (uint64_t)ret_ref;
10627 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_C2Tuple_1PaymentHashPaymentSecretZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
10628 if ((_res & 1) != 0) return;
10629 LDKC2Tuple_PaymentHashPaymentSecretZ _res_conv = *(LDKC2Tuple_PaymentHashPaymentSecretZ*)(((uint64_t)_res) & ~1);
10631 C2Tuple_PaymentHashPaymentSecretZ_free(_res_conv);
10634 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentSecretAPIErrorZ_1ok(JNIEnv *env, jclass clz, int8_tArray o) {
10635 LDKThirtyTwoBytes o_ref;
10636 CHECK((*env)->GetArrayLength(env, o) == 32);
10637 (*env)->GetByteArrayRegion(env, o, 0, 32, o_ref.data);
10638 LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
10639 *ret_conv = CResult_PaymentSecretAPIErrorZ_ok(o_ref);
10640 return (uint64_t)ret_conv;
10643 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentSecretAPIErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
10644 LDKAPIError e_conv = *(LDKAPIError*)(((uint64_t)e) & ~1);
10645 LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
10646 *ret_conv = CResult_PaymentSecretAPIErrorZ_err(e_conv);
10647 return (uint64_t)ret_conv;
10650 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentSecretAPIErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
10651 if ((_res & 1) != 0) return;
10652 LDKCResult_PaymentSecretAPIErrorZ _res_conv = *(LDKCResult_PaymentSecretAPIErrorZ*)(((uint64_t)_res) & ~1);
10654 CResult_PaymentSecretAPIErrorZ_free(_res_conv);
10657 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentSecretAPIErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10658 LDKCResult_PaymentSecretAPIErrorZ* orig_conv = (LDKCResult_PaymentSecretAPIErrorZ*)(orig & ~1);
10659 LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
10660 *ret_conv = CResult_PaymentSecretAPIErrorZ_clone(orig_conv);
10661 return (uint64_t)ret_conv;
10664 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1ChannelMonitorZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
10665 LDKCVec_ChannelMonitorZ _res_constr;
10666 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
10667 if (_res_constr.datalen > 0)
10668 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKChannelMonitor), "LDKCVec_ChannelMonitorZ Elements");
10670 _res_constr.data = NULL;
10671 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
10672 for (size_t q = 0; q < _res_constr.datalen; q++) {
10673 int64_t _res_conv_16 = _res_vals[q];
10674 LDKChannelMonitor _res_conv_16_conv;
10675 _res_conv_16_conv.inner = (void*)(_res_conv_16 & (~1));
10676 _res_conv_16_conv.is_owned = (_res_conv_16 & 1) || (_res_conv_16 == 0);
10677 _res_constr.data[q] = _res_conv_16_conv;
10679 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
10680 CVec_ChannelMonitorZ_free(_res_constr);
10683 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1BlockHashChannelManagerZ_1new(JNIEnv *env, jclass clz, int8_tArray a, int64_t b) {
10684 LDKThirtyTwoBytes a_ref;
10685 CHECK((*env)->GetArrayLength(env, a) == 32);
10686 (*env)->GetByteArrayRegion(env, a, 0, 32, a_ref.data);
10687 LDKChannelManager b_conv;
10688 b_conv.inner = (void*)(b & (~1));
10689 b_conv.is_owned = (b & 1) || (b == 0);
10690 // Warning: we need a move here but no clone is available for LDKChannelManager
10691 LDKC2Tuple_BlockHashChannelManagerZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelManagerZ), "LDKC2Tuple_BlockHashChannelManagerZ");
10692 *ret_ref = C2Tuple_BlockHashChannelManagerZ_new(a_ref, b_conv);
10693 return (uint64_t)ret_ref;
10696 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_C2Tuple_1BlockHashChannelManagerZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
10697 if ((_res & 1) != 0) return;
10698 LDKC2Tuple_BlockHashChannelManagerZ _res_conv = *(LDKC2Tuple_BlockHashChannelManagerZ*)(((uint64_t)_res) & ~1);
10700 C2Tuple_BlockHashChannelManagerZ_free(_res_conv);
10703 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1BlockHashChannelManagerZDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
10704 LDKC2Tuple_BlockHashChannelManagerZ o_conv = *(LDKC2Tuple_BlockHashChannelManagerZ*)(((uint64_t)o) & ~1);
10705 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ");
10706 *ret_conv = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o_conv);
10707 return (uint64_t)ret_conv;
10710 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1BlockHashChannelManagerZDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
10711 LDKDecodeError e_conv;
10712 e_conv.inner = (void*)(e & (~1));
10713 e_conv.is_owned = (e & 1) || (e == 0);
10714 e_conv = DecodeError_clone(&e_conv);
10715 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ");
10716 *ret_conv = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e_conv);
10717 return (uint64_t)ret_conv;
10720 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1BlockHashChannelManagerZDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
10721 if ((_res & 1) != 0) return;
10722 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res_conv = *(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)(((uint64_t)_res) & ~1);
10724 CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res_conv);
10727 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelConfigDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
10728 LDKChannelConfig o_conv;
10729 o_conv.inner = (void*)(o & (~1));
10730 o_conv.is_owned = (o & 1) || (o == 0);
10731 o_conv = ChannelConfig_clone(&o_conv);
10732 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
10733 *ret_conv = CResult_ChannelConfigDecodeErrorZ_ok(o_conv);
10734 return (uint64_t)ret_conv;
10737 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelConfigDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
10738 LDKDecodeError e_conv;
10739 e_conv.inner = (void*)(e & (~1));
10740 e_conv.is_owned = (e & 1) || (e == 0);
10741 e_conv = DecodeError_clone(&e_conv);
10742 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
10743 *ret_conv = CResult_ChannelConfigDecodeErrorZ_err(e_conv);
10744 return (uint64_t)ret_conv;
10747 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelConfigDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
10748 if ((_res & 1) != 0) return;
10749 LDKCResult_ChannelConfigDecodeErrorZ _res_conv = *(LDKCResult_ChannelConfigDecodeErrorZ*)(((uint64_t)_res) & ~1);
10751 CResult_ChannelConfigDecodeErrorZ_free(_res_conv);
10754 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelConfigDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10755 LDKCResult_ChannelConfigDecodeErrorZ* orig_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)(orig & ~1);
10756 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
10757 *ret_conv = CResult_ChannelConfigDecodeErrorZ_clone(orig_conv);
10758 return (uint64_t)ret_conv;
10761 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1OutPointDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
10762 LDKOutPoint o_conv;
10763 o_conv.inner = (void*)(o & (~1));
10764 o_conv.is_owned = (o & 1) || (o == 0);
10765 o_conv = OutPoint_clone(&o_conv);
10766 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
10767 *ret_conv = CResult_OutPointDecodeErrorZ_ok(o_conv);
10768 return (uint64_t)ret_conv;
10771 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1OutPointDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
10772 LDKDecodeError e_conv;
10773 e_conv.inner = (void*)(e & (~1));
10774 e_conv.is_owned = (e & 1) || (e == 0);
10775 e_conv = DecodeError_clone(&e_conv);
10776 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
10777 *ret_conv = CResult_OutPointDecodeErrorZ_err(e_conv);
10778 return (uint64_t)ret_conv;
10781 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1OutPointDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
10782 if ((_res & 1) != 0) return;
10783 LDKCResult_OutPointDecodeErrorZ _res_conv = *(LDKCResult_OutPointDecodeErrorZ*)(((uint64_t)_res) & ~1);
10785 CResult_OutPointDecodeErrorZ_free(_res_conv);
10788 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1OutPointDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10789 LDKCResult_OutPointDecodeErrorZ* orig_conv = (LDKCResult_OutPointDecodeErrorZ*)(orig & ~1);
10790 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
10791 *ret_conv = CResult_OutPointDecodeErrorZ_clone(orig_conv);
10792 return (uint64_t)ret_conv;
10795 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SiPrefixNoneZ_1ok(JNIEnv *env, jclass clz, jclass o) {
10796 LDKSiPrefix o_conv = LDKSiPrefix_from_java(env, o);
10797 LDKCResult_SiPrefixNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixNoneZ), "LDKCResult_SiPrefixNoneZ");
10798 *ret_conv = CResult_SiPrefixNoneZ_ok(o_conv);
10799 return (uint64_t)ret_conv;
10802 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SiPrefixNoneZ_1err(JNIEnv *env, jclass clz) {
10803 LDKCResult_SiPrefixNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixNoneZ), "LDKCResult_SiPrefixNoneZ");
10804 *ret_conv = CResult_SiPrefixNoneZ_err();
10805 return (uint64_t)ret_conv;
10808 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1SiPrefixNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
10809 if ((_res & 1) != 0) return;
10810 LDKCResult_SiPrefixNoneZ _res_conv = *(LDKCResult_SiPrefixNoneZ*)(((uint64_t)_res) & ~1);
10812 CResult_SiPrefixNoneZ_free(_res_conv);
10815 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SiPrefixNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10816 LDKCResult_SiPrefixNoneZ* orig_conv = (LDKCResult_SiPrefixNoneZ*)(orig & ~1);
10817 LDKCResult_SiPrefixNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixNoneZ), "LDKCResult_SiPrefixNoneZ");
10818 *ret_conv = CResult_SiPrefixNoneZ_clone(orig_conv);
10819 return (uint64_t)ret_conv;
10822 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceNoneZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
10824 o_conv.inner = (void*)(o & (~1));
10825 o_conv.is_owned = (o & 1) || (o == 0);
10826 o_conv = Invoice_clone(&o_conv);
10827 LDKCResult_InvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceNoneZ), "LDKCResult_InvoiceNoneZ");
10828 *ret_conv = CResult_InvoiceNoneZ_ok(o_conv);
10829 return (uint64_t)ret_conv;
10832 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceNoneZ_1err(JNIEnv *env, jclass clz) {
10833 LDKCResult_InvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceNoneZ), "LDKCResult_InvoiceNoneZ");
10834 *ret_conv = CResult_InvoiceNoneZ_err();
10835 return (uint64_t)ret_conv;
10838 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
10839 if ((_res & 1) != 0) return;
10840 LDKCResult_InvoiceNoneZ _res_conv = *(LDKCResult_InvoiceNoneZ*)(((uint64_t)_res) & ~1);
10842 CResult_InvoiceNoneZ_free(_res_conv);
10845 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10846 LDKCResult_InvoiceNoneZ* orig_conv = (LDKCResult_InvoiceNoneZ*)(orig & ~1);
10847 LDKCResult_InvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceNoneZ), "LDKCResult_InvoiceNoneZ");
10848 *ret_conv = CResult_InvoiceNoneZ_clone(orig_conv);
10849 return (uint64_t)ret_conv;
10852 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SignedRawInvoiceNoneZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
10853 LDKSignedRawInvoice o_conv;
10854 o_conv.inner = (void*)(o & (~1));
10855 o_conv.is_owned = (o & 1) || (o == 0);
10856 o_conv = SignedRawInvoice_clone(&o_conv);
10857 LDKCResult_SignedRawInvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceNoneZ), "LDKCResult_SignedRawInvoiceNoneZ");
10858 *ret_conv = CResult_SignedRawInvoiceNoneZ_ok(o_conv);
10859 return (uint64_t)ret_conv;
10862 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SignedRawInvoiceNoneZ_1err(JNIEnv *env, jclass clz) {
10863 LDKCResult_SignedRawInvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceNoneZ), "LDKCResult_SignedRawInvoiceNoneZ");
10864 *ret_conv = CResult_SignedRawInvoiceNoneZ_err();
10865 return (uint64_t)ret_conv;
10868 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1SignedRawInvoiceNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
10869 if ((_res & 1) != 0) return;
10870 LDKCResult_SignedRawInvoiceNoneZ _res_conv = *(LDKCResult_SignedRawInvoiceNoneZ*)(((uint64_t)_res) & ~1);
10872 CResult_SignedRawInvoiceNoneZ_free(_res_conv);
10875 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SignedRawInvoiceNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10876 LDKCResult_SignedRawInvoiceNoneZ* orig_conv = (LDKCResult_SignedRawInvoiceNoneZ*)(orig & ~1);
10877 LDKCResult_SignedRawInvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceNoneZ), "LDKCResult_SignedRawInvoiceNoneZ");
10878 *ret_conv = CResult_SignedRawInvoiceNoneZ_clone(orig_conv);
10879 return (uint64_t)ret_conv;
10882 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C3Tuple_1RawInvoice_1u832InvoiceSignatureZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10883 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* orig_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(orig & ~1);
10884 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_ref = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
10885 *ret_ref = C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig_conv);
10886 return (uint64_t)ret_ref;
10889 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C3Tuple_1RawInvoice_1u832InvoiceSignatureZ_1new(JNIEnv *env, jclass clz, int64_t a, int8_tArray b, int64_t c) {
10890 LDKRawInvoice a_conv;
10891 a_conv.inner = (void*)(a & (~1));
10892 a_conv.is_owned = (a & 1) || (a == 0);
10893 a_conv = RawInvoice_clone(&a_conv);
10894 LDKThirtyTwoBytes b_ref;
10895 CHECK((*env)->GetArrayLength(env, b) == 32);
10896 (*env)->GetByteArrayRegion(env, b, 0, 32, b_ref.data);
10897 LDKInvoiceSignature c_conv;
10898 c_conv.inner = (void*)(c & (~1));
10899 c_conv.is_owned = (c & 1) || (c == 0);
10900 c_conv = InvoiceSignature_clone(&c_conv);
10901 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_ref = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
10902 *ret_ref = C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a_conv, b_ref, c_conv);
10903 return (uint64_t)ret_ref;
10906 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_C3Tuple_1RawInvoice_1u832InvoiceSignatureZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
10907 if ((_res & 1) != 0) return;
10908 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ _res_conv = *(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(((uint64_t)_res) & ~1);
10910 C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res_conv);
10913 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PayeePubKeyErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
10914 LDKPayeePubKey o_conv;
10915 o_conv.inner = (void*)(o & (~1));
10916 o_conv.is_owned = (o & 1) || (o == 0);
10917 o_conv = PayeePubKey_clone(&o_conv);
10918 LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
10919 *ret_conv = CResult_PayeePubKeyErrorZ_ok(o_conv);
10920 return (uint64_t)ret_conv;
10923 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PayeePubKeyErrorZ_1err(JNIEnv *env, jclass clz, jclass e) {
10924 LDKSecp256k1Error e_conv = LDKSecp256k1Error_from_java(env, e);
10925 LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
10926 *ret_conv = CResult_PayeePubKeyErrorZ_err(e_conv);
10927 return (uint64_t)ret_conv;
10930 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PayeePubKeyErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
10931 if ((_res & 1) != 0) return;
10932 LDKCResult_PayeePubKeyErrorZ _res_conv = *(LDKCResult_PayeePubKeyErrorZ*)(((uint64_t)_res) & ~1);
10934 CResult_PayeePubKeyErrorZ_free(_res_conv);
10937 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PayeePubKeyErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10938 LDKCResult_PayeePubKeyErrorZ* orig_conv = (LDKCResult_PayeePubKeyErrorZ*)(orig & ~1);
10939 LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
10940 *ret_conv = CResult_PayeePubKeyErrorZ_clone(orig_conv);
10941 return (uint64_t)ret_conv;
10944 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1PrivateRouteZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
10945 LDKCVec_PrivateRouteZ _res_constr;
10946 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
10947 if (_res_constr.datalen > 0)
10948 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKPrivateRoute), "LDKCVec_PrivateRouteZ Elements");
10950 _res_constr.data = NULL;
10951 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
10952 for (size_t o = 0; o < _res_constr.datalen; o++) {
10953 int64_t _res_conv_14 = _res_vals[o];
10954 LDKPrivateRoute _res_conv_14_conv;
10955 _res_conv_14_conv.inner = (void*)(_res_conv_14 & (~1));
10956 _res_conv_14_conv.is_owned = (_res_conv_14 & 1) || (_res_conv_14 == 0);
10957 _res_constr.data[o] = _res_conv_14_conv;
10959 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
10960 CVec_PrivateRouteZ_free(_res_constr);
10963 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PositiveTimestampCreationErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
10964 LDKPositiveTimestamp o_conv;
10965 o_conv.inner = (void*)(o & (~1));
10966 o_conv.is_owned = (o & 1) || (o == 0);
10967 o_conv = PositiveTimestamp_clone(&o_conv);
10968 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
10969 *ret_conv = CResult_PositiveTimestampCreationErrorZ_ok(o_conv);
10970 return (uint64_t)ret_conv;
10973 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PositiveTimestampCreationErrorZ_1err(JNIEnv *env, jclass clz, jclass e) {
10974 LDKCreationError e_conv = LDKCreationError_from_java(env, e);
10975 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
10976 *ret_conv = CResult_PositiveTimestampCreationErrorZ_err(e_conv);
10977 return (uint64_t)ret_conv;
10980 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PositiveTimestampCreationErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
10981 if ((_res & 1) != 0) return;
10982 LDKCResult_PositiveTimestampCreationErrorZ _res_conv = *(LDKCResult_PositiveTimestampCreationErrorZ*)(((uint64_t)_res) & ~1);
10984 CResult_PositiveTimestampCreationErrorZ_free(_res_conv);
10987 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PositiveTimestampCreationErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10988 LDKCResult_PositiveTimestampCreationErrorZ* orig_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)(orig & ~1);
10989 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
10990 *ret_conv = CResult_PositiveTimestampCreationErrorZ_clone(orig_conv);
10991 return (uint64_t)ret_conv;
10994 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneSemanticErrorZ_1ok(JNIEnv *env, jclass clz) {
10995 LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
10996 *ret_conv = CResult_NoneSemanticErrorZ_ok();
10997 return (uint64_t)ret_conv;
11000 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneSemanticErrorZ_1err(JNIEnv *env, jclass clz, jclass e) {
11001 LDKSemanticError e_conv = LDKSemanticError_from_java(env, e);
11002 LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
11003 *ret_conv = CResult_NoneSemanticErrorZ_err(e_conv);
11004 return (uint64_t)ret_conv;
11007 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneSemanticErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
11008 if ((_res & 1) != 0) return;
11009 LDKCResult_NoneSemanticErrorZ _res_conv = *(LDKCResult_NoneSemanticErrorZ*)(((uint64_t)_res) & ~1);
11011 CResult_NoneSemanticErrorZ_free(_res_conv);
11014 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneSemanticErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
11015 LDKCResult_NoneSemanticErrorZ* orig_conv = (LDKCResult_NoneSemanticErrorZ*)(orig & ~1);
11016 LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
11017 *ret_conv = CResult_NoneSemanticErrorZ_clone(orig_conv);
11018 return (uint64_t)ret_conv;
11021 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceSemanticErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
11023 o_conv.inner = (void*)(o & (~1));
11024 o_conv.is_owned = (o & 1) || (o == 0);
11025 o_conv = Invoice_clone(&o_conv);
11026 LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
11027 *ret_conv = CResult_InvoiceSemanticErrorZ_ok(o_conv);
11028 return (uint64_t)ret_conv;
11031 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceSemanticErrorZ_1err(JNIEnv *env, jclass clz, jclass e) {
11032 LDKSemanticError e_conv = LDKSemanticError_from_java(env, e);
11033 LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
11034 *ret_conv = CResult_InvoiceSemanticErrorZ_err(e_conv);
11035 return (uint64_t)ret_conv;
11038 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceSemanticErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
11039 if ((_res & 1) != 0) return;
11040 LDKCResult_InvoiceSemanticErrorZ _res_conv = *(LDKCResult_InvoiceSemanticErrorZ*)(((uint64_t)_res) & ~1);
11042 CResult_InvoiceSemanticErrorZ_free(_res_conv);
11045 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceSemanticErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
11046 LDKCResult_InvoiceSemanticErrorZ* orig_conv = (LDKCResult_InvoiceSemanticErrorZ*)(orig & ~1);
11047 LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
11048 *ret_conv = CResult_InvoiceSemanticErrorZ_clone(orig_conv);
11049 return (uint64_t)ret_conv;
11052 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1DescriptionCreationErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
11053 LDKDescription o_conv;
11054 o_conv.inner = (void*)(o & (~1));
11055 o_conv.is_owned = (o & 1) || (o == 0);
11056 o_conv = Description_clone(&o_conv);
11057 LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
11058 *ret_conv = CResult_DescriptionCreationErrorZ_ok(o_conv);
11059 return (uint64_t)ret_conv;
11062 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1DescriptionCreationErrorZ_1err(JNIEnv *env, jclass clz, jclass e) {
11063 LDKCreationError e_conv = LDKCreationError_from_java(env, e);
11064 LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
11065 *ret_conv = CResult_DescriptionCreationErrorZ_err(e_conv);
11066 return (uint64_t)ret_conv;
11069 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1DescriptionCreationErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
11070 if ((_res & 1) != 0) return;
11071 LDKCResult_DescriptionCreationErrorZ _res_conv = *(LDKCResult_DescriptionCreationErrorZ*)(((uint64_t)_res) & ~1);
11073 CResult_DescriptionCreationErrorZ_free(_res_conv);
11076 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1DescriptionCreationErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
11077 LDKCResult_DescriptionCreationErrorZ* orig_conv = (LDKCResult_DescriptionCreationErrorZ*)(orig & ~1);
11078 LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
11079 *ret_conv = CResult_DescriptionCreationErrorZ_clone(orig_conv);
11080 return (uint64_t)ret_conv;
11083 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ExpiryTimeCreationErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
11084 LDKExpiryTime o_conv;
11085 o_conv.inner = (void*)(o & (~1));
11086 o_conv.is_owned = (o & 1) || (o == 0);
11087 o_conv = ExpiryTime_clone(&o_conv);
11088 LDKCResult_ExpiryTimeCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ExpiryTimeCreationErrorZ), "LDKCResult_ExpiryTimeCreationErrorZ");
11089 *ret_conv = CResult_ExpiryTimeCreationErrorZ_ok(o_conv);
11090 return (uint64_t)ret_conv;
11093 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ExpiryTimeCreationErrorZ_1err(JNIEnv *env, jclass clz, jclass e) {
11094 LDKCreationError e_conv = LDKCreationError_from_java(env, e);
11095 LDKCResult_ExpiryTimeCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ExpiryTimeCreationErrorZ), "LDKCResult_ExpiryTimeCreationErrorZ");
11096 *ret_conv = CResult_ExpiryTimeCreationErrorZ_err(e_conv);
11097 return (uint64_t)ret_conv;
11100 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ExpiryTimeCreationErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
11101 if ((_res & 1) != 0) return;
11102 LDKCResult_ExpiryTimeCreationErrorZ _res_conv = *(LDKCResult_ExpiryTimeCreationErrorZ*)(((uint64_t)_res) & ~1);
11104 CResult_ExpiryTimeCreationErrorZ_free(_res_conv);
11107 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ExpiryTimeCreationErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
11108 LDKCResult_ExpiryTimeCreationErrorZ* orig_conv = (LDKCResult_ExpiryTimeCreationErrorZ*)(orig & ~1);
11109 LDKCResult_ExpiryTimeCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ExpiryTimeCreationErrorZ), "LDKCResult_ExpiryTimeCreationErrorZ");
11110 *ret_conv = CResult_ExpiryTimeCreationErrorZ_clone(orig_conv);
11111 return (uint64_t)ret_conv;
11114 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PrivateRouteCreationErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
11115 LDKPrivateRoute o_conv;
11116 o_conv.inner = (void*)(o & (~1));
11117 o_conv.is_owned = (o & 1) || (o == 0);
11118 o_conv = PrivateRoute_clone(&o_conv);
11119 LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
11120 *ret_conv = CResult_PrivateRouteCreationErrorZ_ok(o_conv);
11121 return (uint64_t)ret_conv;
11124 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PrivateRouteCreationErrorZ_1err(JNIEnv *env, jclass clz, jclass e) {
11125 LDKCreationError e_conv = LDKCreationError_from_java(env, e);
11126 LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
11127 *ret_conv = CResult_PrivateRouteCreationErrorZ_err(e_conv);
11128 return (uint64_t)ret_conv;
11131 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PrivateRouteCreationErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
11132 if ((_res & 1) != 0) return;
11133 LDKCResult_PrivateRouteCreationErrorZ _res_conv = *(LDKCResult_PrivateRouteCreationErrorZ*)(((uint64_t)_res) & ~1);
11135 CResult_PrivateRouteCreationErrorZ_free(_res_conv);
11138 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PrivateRouteCreationErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
11139 LDKCResult_PrivateRouteCreationErrorZ* orig_conv = (LDKCResult_PrivateRouteCreationErrorZ*)(orig & ~1);
11140 LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
11141 *ret_conv = CResult_PrivateRouteCreationErrorZ_clone(orig_conv);
11142 return (uint64_t)ret_conv;
11145 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1StringErrorZ_1ok(JNIEnv *env, jclass clz, jstring o) {
11146 LDKStr o_conv = java_to_owned_str(env, o);
11147 LDKCResult_StringErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StringErrorZ), "LDKCResult_StringErrorZ");
11148 *ret_conv = CResult_StringErrorZ_ok(o_conv);
11149 return (uint64_t)ret_conv;
11152 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1StringErrorZ_1err(JNIEnv *env, jclass clz, jclass e) {
11153 LDKSecp256k1Error e_conv = LDKSecp256k1Error_from_java(env, e);
11154 LDKCResult_StringErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StringErrorZ), "LDKCResult_StringErrorZ");
11155 *ret_conv = CResult_StringErrorZ_err(e_conv);
11156 return (uint64_t)ret_conv;
11159 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1StringErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
11160 if ((_res & 1) != 0) return;
11161 LDKCResult_StringErrorZ _res_conv = *(LDKCResult_StringErrorZ*)(((uint64_t)_res) & ~1);
11163 CResult_StringErrorZ_free(_res_conv);
11166 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelMonitorUpdateDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
11167 LDKChannelMonitorUpdate o_conv;
11168 o_conv.inner = (void*)(o & (~1));
11169 o_conv.is_owned = (o & 1) || (o == 0);
11170 o_conv = ChannelMonitorUpdate_clone(&o_conv);
11171 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
11172 *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o_conv);
11173 return (uint64_t)ret_conv;
11176 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelMonitorUpdateDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
11177 LDKDecodeError e_conv;
11178 e_conv.inner = (void*)(e & (~1));
11179 e_conv.is_owned = (e & 1) || (e == 0);
11180 e_conv = DecodeError_clone(&e_conv);
11181 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
11182 *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_err(e_conv);
11183 return (uint64_t)ret_conv;
11186 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelMonitorUpdateDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
11187 if ((_res & 1) != 0) return;
11188 LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res_conv = *(LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(((uint64_t)_res) & ~1);
11190 CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res_conv);
11193 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelMonitorUpdateDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
11194 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* orig_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(orig & ~1);
11195 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
11196 *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig_conv);
11197 return (uint64_t)ret_conv;
11200 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCUpdateDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
11201 LDKHTLCUpdate o_conv;
11202 o_conv.inner = (void*)(o & (~1));
11203 o_conv.is_owned = (o & 1) || (o == 0);
11204 o_conv = HTLCUpdate_clone(&o_conv);
11205 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
11206 *ret_conv = CResult_HTLCUpdateDecodeErrorZ_ok(o_conv);
11207 return (uint64_t)ret_conv;
11210 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCUpdateDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
11211 LDKDecodeError e_conv;
11212 e_conv.inner = (void*)(e & (~1));
11213 e_conv.is_owned = (e & 1) || (e == 0);
11214 e_conv = DecodeError_clone(&e_conv);
11215 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
11216 *ret_conv = CResult_HTLCUpdateDecodeErrorZ_err(e_conv);
11217 return (uint64_t)ret_conv;
11220 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCUpdateDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
11221 if ((_res & 1) != 0) return;
11222 LDKCResult_HTLCUpdateDecodeErrorZ _res_conv = *(LDKCResult_HTLCUpdateDecodeErrorZ*)(((uint64_t)_res) & ~1);
11224 CResult_HTLCUpdateDecodeErrorZ_free(_res_conv);
11227 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCUpdateDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
11228 LDKCResult_HTLCUpdateDecodeErrorZ* orig_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)(orig & ~1);
11229 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
11230 *ret_conv = CResult_HTLCUpdateDecodeErrorZ_clone(orig_conv);
11231 return (uint64_t)ret_conv;
11234 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneMonitorUpdateErrorZ_1ok(JNIEnv *env, jclass clz) {
11235 LDKCResult_NoneMonitorUpdateErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneMonitorUpdateErrorZ), "LDKCResult_NoneMonitorUpdateErrorZ");
11236 *ret_conv = CResult_NoneMonitorUpdateErrorZ_ok();
11237 return (uint64_t)ret_conv;
11240 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneMonitorUpdateErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
11241 LDKMonitorUpdateError e_conv;
11242 e_conv.inner = (void*)(e & (~1));
11243 e_conv.is_owned = (e & 1) || (e == 0);
11244 e_conv = MonitorUpdateError_clone(&e_conv);
11245 LDKCResult_NoneMonitorUpdateErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneMonitorUpdateErrorZ), "LDKCResult_NoneMonitorUpdateErrorZ");
11246 *ret_conv = CResult_NoneMonitorUpdateErrorZ_err(e_conv);
11247 return (uint64_t)ret_conv;
11250 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneMonitorUpdateErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
11251 if ((_res & 1) != 0) return;
11252 LDKCResult_NoneMonitorUpdateErrorZ _res_conv = *(LDKCResult_NoneMonitorUpdateErrorZ*)(((uint64_t)_res) & ~1);
11254 CResult_NoneMonitorUpdateErrorZ_free(_res_conv);
11257 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneMonitorUpdateErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
11258 LDKCResult_NoneMonitorUpdateErrorZ* orig_conv = (LDKCResult_NoneMonitorUpdateErrorZ*)(orig & ~1);
11259 LDKCResult_NoneMonitorUpdateErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneMonitorUpdateErrorZ), "LDKCResult_NoneMonitorUpdateErrorZ");
11260 *ret_conv = CResult_NoneMonitorUpdateErrorZ_clone(orig_conv);
11261 return (uint64_t)ret_conv;
11264 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1OutPointScriptZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
11265 LDKC2Tuple_OutPointScriptZ* orig_conv = (LDKC2Tuple_OutPointScriptZ*)(orig & ~1);
11266 LDKC2Tuple_OutPointScriptZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
11267 *ret_ref = C2Tuple_OutPointScriptZ_clone(orig_conv);
11268 return (uint64_t)ret_ref;
11271 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1OutPointScriptZ_1new(JNIEnv *env, jclass clz, int64_t a, int8_tArray b) {
11272 LDKOutPoint a_conv;
11273 a_conv.inner = (void*)(a & (~1));
11274 a_conv.is_owned = (a & 1) || (a == 0);
11275 a_conv = OutPoint_clone(&a_conv);
11277 b_ref.datalen = (*env)->GetArrayLength(env, b);
11278 b_ref.data = MALLOC(b_ref.datalen, "LDKCVec_u8Z Bytes");
11279 (*env)->GetByteArrayRegion(env, b, 0, b_ref.datalen, b_ref.data);
11280 LDKC2Tuple_OutPointScriptZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
11281 *ret_ref = C2Tuple_OutPointScriptZ_new(a_conv, b_ref);
11282 return (uint64_t)ret_ref;
11285 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_C2Tuple_1OutPointScriptZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
11286 if ((_res & 1) != 0) return;
11287 LDKC2Tuple_OutPointScriptZ _res_conv = *(LDKC2Tuple_OutPointScriptZ*)(((uint64_t)_res) & ~1);
11289 C2Tuple_OutPointScriptZ_free(_res_conv);
11292 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1u32ScriptZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
11293 LDKC2Tuple_u32ScriptZ* orig_conv = (LDKC2Tuple_u32ScriptZ*)(orig & ~1);
11294 LDKC2Tuple_u32ScriptZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
11295 *ret_ref = C2Tuple_u32ScriptZ_clone(orig_conv);
11296 return (uint64_t)ret_ref;
11299 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1u32ScriptZ_1new(JNIEnv *env, jclass clz, int32_t a, int8_tArray b) {
11301 b_ref.datalen = (*env)->GetArrayLength(env, b);
11302 b_ref.data = MALLOC(b_ref.datalen, "LDKCVec_u8Z Bytes");
11303 (*env)->GetByteArrayRegion(env, b, 0, b_ref.datalen, b_ref.data);
11304 LDKC2Tuple_u32ScriptZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
11305 *ret_ref = C2Tuple_u32ScriptZ_new(a, b_ref);
11306 return (uint64_t)ret_ref;
11309 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_C2Tuple_1u32ScriptZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
11310 if ((_res & 1) != 0) return;
11311 LDKC2Tuple_u32ScriptZ _res_conv = *(LDKC2Tuple_u32ScriptZ*)(((uint64_t)_res) & ~1);
11313 C2Tuple_u32ScriptZ_free(_res_conv);
11316 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1C2Tuple_1u32ScriptZZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
11317 LDKCVec_C2Tuple_u32ScriptZZ _res_constr;
11318 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
11319 if (_res_constr.datalen > 0)
11320 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_u32ScriptZ), "LDKCVec_C2Tuple_u32ScriptZZ Elements");
11322 _res_constr.data = NULL;
11323 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
11324 for (size_t b = 0; b < _res_constr.datalen; b++) {
11325 int64_t _res_conv_27 = _res_vals[b];
11326 LDKC2Tuple_u32ScriptZ _res_conv_27_conv = *(LDKC2Tuple_u32ScriptZ*)(((uint64_t)_res_conv_27) & ~1);
11327 FREE((void*)_res_conv_27);
11328 _res_constr.data[b] = _res_conv_27_conv;
11330 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
11331 CVec_C2Tuple_u32ScriptZZ_free(_res_constr);
11334 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1TxidCVec_1C2Tuple_1u32ScriptZZZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
11335 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* orig_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(orig & ~1);
11336 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
11337 *ret_ref = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig_conv);
11338 return (uint64_t)ret_ref;
11341 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1TxidCVec_1C2Tuple_1u32ScriptZZZ_1new(JNIEnv *env, jclass clz, int8_tArray a, int64_tArray b) {
11342 LDKThirtyTwoBytes a_ref;
11343 CHECK((*env)->GetArrayLength(env, a) == 32);
11344 (*env)->GetByteArrayRegion(env, a, 0, 32, a_ref.data);
11345 LDKCVec_C2Tuple_u32ScriptZZ b_constr;
11346 b_constr.datalen = (*env)->GetArrayLength(env, b);
11347 if (b_constr.datalen > 0)
11348 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKC2Tuple_u32ScriptZ), "LDKCVec_C2Tuple_u32ScriptZZ Elements");
11350 b_constr.data = NULL;
11351 int64_t* b_vals = (*env)->GetLongArrayElements (env, b, NULL);
11352 for (size_t b = 0; b < b_constr.datalen; b++) {
11353 int64_t b_conv_27 = b_vals[b];
11354 LDKC2Tuple_u32ScriptZ b_conv_27_conv = *(LDKC2Tuple_u32ScriptZ*)(((uint64_t)b_conv_27) & ~1);
11355 b_conv_27_conv = C2Tuple_u32ScriptZ_clone((LDKC2Tuple_u32ScriptZ*)(((uint64_t)b_conv_27) & ~1));
11356 b_constr.data[b] = b_conv_27_conv;
11358 (*env)->ReleaseLongArrayElements(env, b, b_vals, 0);
11359 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
11360 *ret_ref = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a_ref, b_constr);
11361 return (uint64_t)ret_ref;
11364 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_C2Tuple_1TxidCVec_1C2Tuple_1u32ScriptZZZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
11365 if ((_res & 1) != 0) return;
11366 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(((uint64_t)_res) & ~1);
11368 C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res_conv);
11371 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1C2Tuple_1TxidCVec_1C2Tuple_1u32ScriptZZZZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
11372 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ _res_constr;
11373 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
11374 if (_res_constr.datalen > 0)
11375 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ Elements");
11377 _res_constr.data = NULL;
11378 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
11379 for (size_t v = 0; v < _res_constr.datalen; v++) {
11380 int64_t _res_conv_47 = _res_vals[v];
11381 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res_conv_47_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(((uint64_t)_res_conv_47) & ~1);
11382 FREE((void*)_res_conv_47);
11383 _res_constr.data[v] = _res_conv_47_conv;
11385 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
11386 CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res_constr);
11389 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1EventZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
11390 LDKCVec_EventZ _res_constr;
11391 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
11392 if (_res_constr.datalen > 0)
11393 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKEvent), "LDKCVec_EventZ Elements");
11395 _res_constr.data = NULL;
11396 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
11397 for (size_t h = 0; h < _res_constr.datalen; h++) {
11398 int64_t _res_conv_7 = _res_vals[h];
11399 LDKEvent _res_conv_7_conv = *(LDKEvent*)(((uint64_t)_res_conv_7) & ~1);
11400 FREE((void*)_res_conv_7);
11401 _res_constr.data[h] = _res_conv_7_conv;
11403 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
11404 CVec_EventZ_free(_res_constr);
11407 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1TransactionZ_1free(JNIEnv *env, jclass clz, jobjectArray _res) {
11408 LDKCVec_TransactionZ _res_constr;
11409 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
11410 if (_res_constr.datalen > 0)
11411 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKTransaction), "LDKCVec_TransactionZ Elements");
11413 _res_constr.data = NULL;
11414 for (size_t i = 0; i < _res_constr.datalen; i++) {
11415 int8_tArray _res_conv_8 = (*env)->GetObjectArrayElement(env, _res, i);
11416 LDKTransaction _res_conv_8_ref;
11417 _res_conv_8_ref.datalen = (*env)->GetArrayLength(env, _res_conv_8);
11418 _res_conv_8_ref.data = MALLOC(_res_conv_8_ref.datalen, "LDKTransaction Bytes");
11419 (*env)->GetByteArrayRegion(env, _res_conv_8, 0, _res_conv_8_ref.datalen, _res_conv_8_ref.data);
11420 _res_conv_8_ref.data_is_owned = true;
11421 _res_constr.data[i] = _res_conv_8_ref;
11423 CVec_TransactionZ_free(_res_constr);
11426 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1u32TxOutZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
11427 LDKC2Tuple_u32TxOutZ* orig_conv = (LDKC2Tuple_u32TxOutZ*)(orig & ~1);
11428 LDKC2Tuple_u32TxOutZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
11429 *ret_ref = C2Tuple_u32TxOutZ_clone(orig_conv);
11430 return (uint64_t)ret_ref;
11433 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1u32TxOutZ_1new(JNIEnv *env, jclass clz, int32_t a, int64_t b) {
11434 LDKTxOut b_conv = *(LDKTxOut*)(((uint64_t)b) & ~1);
11435 LDKC2Tuple_u32TxOutZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
11436 *ret_ref = C2Tuple_u32TxOutZ_new(a, b_conv);
11437 return (uint64_t)ret_ref;
11440 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_C2Tuple_1u32TxOutZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
11441 if ((_res & 1) != 0) return;
11442 LDKC2Tuple_u32TxOutZ _res_conv = *(LDKC2Tuple_u32TxOutZ*)(((uint64_t)_res) & ~1);
11444 C2Tuple_u32TxOutZ_free(_res_conv);
11447 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1C2Tuple_1u32TxOutZZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
11448 LDKCVec_C2Tuple_u32TxOutZZ _res_constr;
11449 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
11450 if (_res_constr.datalen > 0)
11451 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_u32TxOutZ), "LDKCVec_C2Tuple_u32TxOutZZ Elements");
11453 _res_constr.data = NULL;
11454 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
11455 for (size_t a = 0; a < _res_constr.datalen; a++) {
11456 int64_t _res_conv_26 = _res_vals[a];
11457 LDKC2Tuple_u32TxOutZ _res_conv_26_conv = *(LDKC2Tuple_u32TxOutZ*)(((uint64_t)_res_conv_26) & ~1);
11458 FREE((void*)_res_conv_26);
11459 _res_constr.data[a] = _res_conv_26_conv;
11461 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
11462 CVec_C2Tuple_u32TxOutZZ_free(_res_constr);
11465 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1TxidCVec_1C2Tuple_1u32TxOutZZZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
11466 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* orig_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(orig & ~1);
11467 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
11468 *ret_ref = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig_conv);
11469 return (uint64_t)ret_ref;
11472 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1TxidCVec_1C2Tuple_1u32TxOutZZZ_1new(JNIEnv *env, jclass clz, int8_tArray a, int64_tArray b) {
11473 LDKThirtyTwoBytes a_ref;
11474 CHECK((*env)->GetArrayLength(env, a) == 32);
11475 (*env)->GetByteArrayRegion(env, a, 0, 32, a_ref.data);
11476 LDKCVec_C2Tuple_u32TxOutZZ b_constr;
11477 b_constr.datalen = (*env)->GetArrayLength(env, b);
11478 if (b_constr.datalen > 0)
11479 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKC2Tuple_u32TxOutZ), "LDKCVec_C2Tuple_u32TxOutZZ Elements");
11481 b_constr.data = NULL;
11482 int64_t* b_vals = (*env)->GetLongArrayElements (env, b, NULL);
11483 for (size_t a = 0; a < b_constr.datalen; a++) {
11484 int64_t b_conv_26 = b_vals[a];
11485 LDKC2Tuple_u32TxOutZ b_conv_26_conv = *(LDKC2Tuple_u32TxOutZ*)(((uint64_t)b_conv_26) & ~1);
11486 b_conv_26_conv = C2Tuple_u32TxOutZ_clone((LDKC2Tuple_u32TxOutZ*)(((uint64_t)b_conv_26) & ~1));
11487 b_constr.data[a] = b_conv_26_conv;
11489 (*env)->ReleaseLongArrayElements(env, b, b_vals, 0);
11490 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
11491 *ret_ref = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a_ref, b_constr);
11492 return (uint64_t)ret_ref;
11495 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_C2Tuple_1TxidCVec_1C2Tuple_1u32TxOutZZZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
11496 if ((_res & 1) != 0) return;
11497 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(((uint64_t)_res) & ~1);
11499 C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res_conv);
11502 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1C2Tuple_1TxidCVec_1C2Tuple_1u32TxOutZZZZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
11503 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ _res_constr;
11504 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
11505 if (_res_constr.datalen > 0)
11506 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ Elements");
11508 _res_constr.data = NULL;
11509 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
11510 for (size_t u = 0; u < _res_constr.datalen; u++) {
11511 int64_t _res_conv_46 = _res_vals[u];
11512 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res_conv_46_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(((uint64_t)_res_conv_46) & ~1);
11513 FREE((void*)_res_conv_46);
11514 _res_constr.data[u] = _res_conv_46_conv;
11516 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
11517 CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res_constr);
11520 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1BlockHashChannelMonitorZDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
11521 LDKC2Tuple_BlockHashChannelMonitorZ o_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(((uint64_t)o) & ~1);
11522 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
11523 *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o_conv);
11524 return (uint64_t)ret_conv;
11527 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1BlockHashChannelMonitorZDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
11528 LDKDecodeError e_conv;
11529 e_conv.inner = (void*)(e & (~1));
11530 e_conv.is_owned = (e & 1) || (e == 0);
11531 e_conv = DecodeError_clone(&e_conv);
11532 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
11533 *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e_conv);
11534 return (uint64_t)ret_conv;
11537 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1BlockHashChannelMonitorZDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
11538 if ((_res & 1) != 0) return;
11539 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ _res_conv = *(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(((uint64_t)_res) & ~1);
11541 CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res_conv);
11544 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1ok(JNIEnv *env, jclass clz, jboolean o) {
11545 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
11546 *ret_conv = CResult_boolLightningErrorZ_ok(o);
11547 return (uint64_t)ret_conv;
11550 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
11551 LDKLightningError e_conv;
11552 e_conv.inner = (void*)(e & (~1));
11553 e_conv.is_owned = (e & 1) || (e == 0);
11554 e_conv = LightningError_clone(&e_conv);
11555 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
11556 *ret_conv = CResult_boolLightningErrorZ_err(e_conv);
11557 return (uint64_t)ret_conv;
11560 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
11561 if ((_res & 1) != 0) return;
11562 LDKCResult_boolLightningErrorZ _res_conv = *(LDKCResult_boolLightningErrorZ*)(((uint64_t)_res) & ~1);
11564 CResult_boolLightningErrorZ_free(_res_conv);
11567 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
11568 LDKCResult_boolLightningErrorZ* orig_conv = (LDKCResult_boolLightningErrorZ*)(orig & ~1);
11569 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
11570 *ret_conv = CResult_boolLightningErrorZ_clone(orig_conv);
11571 return (uint64_t)ret_conv;
11574 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
11575 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* orig_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(orig & ~1);
11576 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_ref = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
11577 *ret_ref = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig_conv);
11578 return (uint64_t)ret_ref;
11581 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1new(JNIEnv *env, jclass clz, int64_t a, int64_t b, int64_t c) {
11582 LDKChannelAnnouncement a_conv;
11583 a_conv.inner = (void*)(a & (~1));
11584 a_conv.is_owned = (a & 1) || (a == 0);
11585 a_conv = ChannelAnnouncement_clone(&a_conv);
11586 LDKChannelUpdate b_conv;
11587 b_conv.inner = (void*)(b & (~1));
11588 b_conv.is_owned = (b & 1) || (b == 0);
11589 b_conv = ChannelUpdate_clone(&b_conv);
11590 LDKChannelUpdate c_conv;
11591 c_conv.inner = (void*)(c & (~1));
11592 c_conv.is_owned = (c & 1) || (c == 0);
11593 c_conv = ChannelUpdate_clone(&c_conv);
11594 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_ref = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
11595 *ret_ref = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a_conv, b_conv, c_conv);
11596 return (uint64_t)ret_ref;
11599 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
11600 if ((_res & 1) != 0) return;
11601 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)_res) & ~1);
11603 C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res_conv);
11606 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
11607 LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res_constr;
11608 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
11609 if (_res_constr.datalen > 0)
11610 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ Elements");
11612 _res_constr.data = NULL;
11613 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
11614 for (size_t l = 0; l < _res_constr.datalen; l++) {
11615 int64_t _res_conv_63 = _res_vals[l];
11616 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res_conv_63_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)_res_conv_63) & ~1);
11617 FREE((void*)_res_conv_63);
11618 _res_constr.data[l] = _res_conv_63_conv;
11620 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
11621 CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res_constr);
11624 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1NodeAnnouncementZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
11625 LDKCVec_NodeAnnouncementZ _res_constr;
11626 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
11627 if (_res_constr.datalen > 0)
11628 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKNodeAnnouncement), "LDKCVec_NodeAnnouncementZ Elements");
11630 _res_constr.data = NULL;
11631 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
11632 for (size_t s = 0; s < _res_constr.datalen; s++) {
11633 int64_t _res_conv_18 = _res_vals[s];
11634 LDKNodeAnnouncement _res_conv_18_conv;
11635 _res_conv_18_conv.inner = (void*)(_res_conv_18 & (~1));
11636 _res_conv_18_conv.is_owned = (_res_conv_18 & 1) || (_res_conv_18 == 0);
11637 _res_constr.data[s] = _res_conv_18_conv;
11639 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
11640 CVec_NodeAnnouncementZ_free(_res_constr);
11643 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1ok(JNIEnv *env, jclass clz) {
11644 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
11645 *ret_conv = CResult_NoneLightningErrorZ_ok();
11646 return (uint64_t)ret_conv;
11649 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
11650 LDKLightningError e_conv;
11651 e_conv.inner = (void*)(e & (~1));
11652 e_conv.is_owned = (e & 1) || (e == 0);
11653 e_conv = LightningError_clone(&e_conv);
11654 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
11655 *ret_conv = CResult_NoneLightningErrorZ_err(e_conv);
11656 return (uint64_t)ret_conv;
11659 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
11660 if ((_res & 1) != 0) return;
11661 LDKCResult_NoneLightningErrorZ _res_conv = *(LDKCResult_NoneLightningErrorZ*)(((uint64_t)_res) & ~1);
11663 CResult_NoneLightningErrorZ_free(_res_conv);
11666 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
11667 LDKCResult_NoneLightningErrorZ* orig_conv = (LDKCResult_NoneLightningErrorZ*)(orig & ~1);
11668 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
11669 *ret_conv = CResult_NoneLightningErrorZ_clone(orig_conv);
11670 return (uint64_t)ret_conv;
11673 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1PublicKeyZ_1free(JNIEnv *env, jclass clz, jobjectArray _res) {
11674 LDKCVec_PublicKeyZ _res_constr;
11675 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
11676 if (_res_constr.datalen > 0)
11677 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKPublicKey), "LDKCVec_PublicKeyZ Elements");
11679 _res_constr.data = NULL;
11680 for (size_t i = 0; i < _res_constr.datalen; i++) {
11681 int8_tArray _res_conv_8 = (*env)->GetObjectArrayElement(env, _res, i);
11682 LDKPublicKey _res_conv_8_ref;
11683 CHECK((*env)->GetArrayLength(env, _res_conv_8) == 33);
11684 (*env)->GetByteArrayRegion(env, _res_conv_8, 0, 33, _res_conv_8_ref.compressed_form);
11685 _res_constr.data[i] = _res_conv_8_ref;
11687 CVec_PublicKeyZ_free(_res_constr);
11690 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1u8ZPeerHandleErrorZ_1ok(JNIEnv *env, jclass clz, int8_tArray o) {
11692 o_ref.datalen = (*env)->GetArrayLength(env, o);
11693 o_ref.data = MALLOC(o_ref.datalen, "LDKCVec_u8Z Bytes");
11694 (*env)->GetByteArrayRegion(env, o, 0, o_ref.datalen, o_ref.data);
11695 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
11696 *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_ok(o_ref);
11697 return (uint64_t)ret_conv;
11700 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1u8ZPeerHandleErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
11701 LDKPeerHandleError e_conv;
11702 e_conv.inner = (void*)(e & (~1));
11703 e_conv.is_owned = (e & 1) || (e == 0);
11704 e_conv = PeerHandleError_clone(&e_conv);
11705 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
11706 *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_err(e_conv);
11707 return (uint64_t)ret_conv;
11710 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1u8ZPeerHandleErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
11711 if ((_res & 1) != 0) return;
11712 LDKCResult_CVec_u8ZPeerHandleErrorZ _res_conv = *(LDKCResult_CVec_u8ZPeerHandleErrorZ*)(((uint64_t)_res) & ~1);
11714 CResult_CVec_u8ZPeerHandleErrorZ_free(_res_conv);
11717 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1u8ZPeerHandleErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
11718 LDKCResult_CVec_u8ZPeerHandleErrorZ* orig_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(orig & ~1);
11719 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
11720 *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_clone(orig_conv);
11721 return (uint64_t)ret_conv;
11724 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NonePeerHandleErrorZ_1ok(JNIEnv *env, jclass clz) {
11725 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
11726 *ret_conv = CResult_NonePeerHandleErrorZ_ok();
11727 return (uint64_t)ret_conv;
11730 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NonePeerHandleErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
11731 LDKPeerHandleError e_conv;
11732 e_conv.inner = (void*)(e & (~1));
11733 e_conv.is_owned = (e & 1) || (e == 0);
11734 e_conv = PeerHandleError_clone(&e_conv);
11735 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
11736 *ret_conv = CResult_NonePeerHandleErrorZ_err(e_conv);
11737 return (uint64_t)ret_conv;
11740 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NonePeerHandleErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
11741 if ((_res & 1) != 0) return;
11742 LDKCResult_NonePeerHandleErrorZ _res_conv = *(LDKCResult_NonePeerHandleErrorZ*)(((uint64_t)_res) & ~1);
11744 CResult_NonePeerHandleErrorZ_free(_res_conv);
11747 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NonePeerHandleErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
11748 LDKCResult_NonePeerHandleErrorZ* orig_conv = (LDKCResult_NonePeerHandleErrorZ*)(orig & ~1);
11749 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
11750 *ret_conv = CResult_NonePeerHandleErrorZ_clone(orig_conv);
11751 return (uint64_t)ret_conv;
11754 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1boolPeerHandleErrorZ_1ok(JNIEnv *env, jclass clz, jboolean o) {
11755 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
11756 *ret_conv = CResult_boolPeerHandleErrorZ_ok(o);
11757 return (uint64_t)ret_conv;
11760 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1boolPeerHandleErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
11761 LDKPeerHandleError e_conv;
11762 e_conv.inner = (void*)(e & (~1));
11763 e_conv.is_owned = (e & 1) || (e == 0);
11764 e_conv = PeerHandleError_clone(&e_conv);
11765 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
11766 *ret_conv = CResult_boolPeerHandleErrorZ_err(e_conv);
11767 return (uint64_t)ret_conv;
11770 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1boolPeerHandleErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
11771 if ((_res & 1) != 0) return;
11772 LDKCResult_boolPeerHandleErrorZ _res_conv = *(LDKCResult_boolPeerHandleErrorZ*)(((uint64_t)_res) & ~1);
11774 CResult_boolPeerHandleErrorZ_free(_res_conv);
11777 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1boolPeerHandleErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
11778 LDKCResult_boolPeerHandleErrorZ* orig_conv = (LDKCResult_boolPeerHandleErrorZ*)(orig & ~1);
11779 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
11780 *ret_conv = CResult_boolPeerHandleErrorZ_clone(orig_conv);
11781 return (uint64_t)ret_conv;
11784 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1DirectionalChannelInfoDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
11785 LDKDirectionalChannelInfo o_conv;
11786 o_conv.inner = (void*)(o & (~1));
11787 o_conv.is_owned = (o & 1) || (o == 0);
11788 o_conv = DirectionalChannelInfo_clone(&o_conv);
11789 LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ");
11790 *ret_conv = CResult_DirectionalChannelInfoDecodeErrorZ_ok(o_conv);
11791 return (uint64_t)ret_conv;
11794 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1DirectionalChannelInfoDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
11795 LDKDecodeError e_conv;
11796 e_conv.inner = (void*)(e & (~1));
11797 e_conv.is_owned = (e & 1) || (e == 0);
11798 e_conv = DecodeError_clone(&e_conv);
11799 LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ");
11800 *ret_conv = CResult_DirectionalChannelInfoDecodeErrorZ_err(e_conv);
11801 return (uint64_t)ret_conv;
11804 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1DirectionalChannelInfoDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
11805 if ((_res & 1) != 0) return;
11806 LDKCResult_DirectionalChannelInfoDecodeErrorZ _res_conv = *(LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(((uint64_t)_res) & ~1);
11808 CResult_DirectionalChannelInfoDecodeErrorZ_free(_res_conv);
11811 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1DirectionalChannelInfoDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
11812 LDKCResult_DirectionalChannelInfoDecodeErrorZ* orig_conv = (LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(orig & ~1);
11813 LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ");
11814 *ret_conv = CResult_DirectionalChannelInfoDecodeErrorZ_clone(orig_conv);
11815 return (uint64_t)ret_conv;
11818 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelInfoDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
11819 LDKChannelInfo o_conv;
11820 o_conv.inner = (void*)(o & (~1));
11821 o_conv.is_owned = (o & 1) || (o == 0);
11822 o_conv = ChannelInfo_clone(&o_conv);
11823 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
11824 *ret_conv = CResult_ChannelInfoDecodeErrorZ_ok(o_conv);
11825 return (uint64_t)ret_conv;
11828 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelInfoDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
11829 LDKDecodeError e_conv;
11830 e_conv.inner = (void*)(e & (~1));
11831 e_conv.is_owned = (e & 1) || (e == 0);
11832 e_conv = DecodeError_clone(&e_conv);
11833 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
11834 *ret_conv = CResult_ChannelInfoDecodeErrorZ_err(e_conv);
11835 return (uint64_t)ret_conv;
11838 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelInfoDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
11839 if ((_res & 1) != 0) return;
11840 LDKCResult_ChannelInfoDecodeErrorZ _res_conv = *(LDKCResult_ChannelInfoDecodeErrorZ*)(((uint64_t)_res) & ~1);
11842 CResult_ChannelInfoDecodeErrorZ_free(_res_conv);
11845 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelInfoDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
11846 LDKCResult_ChannelInfoDecodeErrorZ* orig_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)(orig & ~1);
11847 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
11848 *ret_conv = CResult_ChannelInfoDecodeErrorZ_clone(orig_conv);
11849 return (uint64_t)ret_conv;
11852 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RoutingFeesDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
11853 LDKRoutingFees o_conv;
11854 o_conv.inner = (void*)(o & (~1));
11855 o_conv.is_owned = (o & 1) || (o == 0);
11856 o_conv = RoutingFees_clone(&o_conv);
11857 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
11858 *ret_conv = CResult_RoutingFeesDecodeErrorZ_ok(o_conv);
11859 return (uint64_t)ret_conv;
11862 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RoutingFeesDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
11863 LDKDecodeError e_conv;
11864 e_conv.inner = (void*)(e & (~1));
11865 e_conv.is_owned = (e & 1) || (e == 0);
11866 e_conv = DecodeError_clone(&e_conv);
11867 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
11868 *ret_conv = CResult_RoutingFeesDecodeErrorZ_err(e_conv);
11869 return (uint64_t)ret_conv;
11872 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RoutingFeesDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
11873 if ((_res & 1) != 0) return;
11874 LDKCResult_RoutingFeesDecodeErrorZ _res_conv = *(LDKCResult_RoutingFeesDecodeErrorZ*)(((uint64_t)_res) & ~1);
11876 CResult_RoutingFeesDecodeErrorZ_free(_res_conv);
11879 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RoutingFeesDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
11880 LDKCResult_RoutingFeesDecodeErrorZ* orig_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)(orig & ~1);
11881 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
11882 *ret_conv = CResult_RoutingFeesDecodeErrorZ_clone(orig_conv);
11883 return (uint64_t)ret_conv;
11886 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementInfoDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
11887 LDKNodeAnnouncementInfo o_conv;
11888 o_conv.inner = (void*)(o & (~1));
11889 o_conv.is_owned = (o & 1) || (o == 0);
11890 o_conv = NodeAnnouncementInfo_clone(&o_conv);
11891 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
11892 *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o_conv);
11893 return (uint64_t)ret_conv;
11896 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementInfoDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
11897 LDKDecodeError e_conv;
11898 e_conv.inner = (void*)(e & (~1));
11899 e_conv.is_owned = (e & 1) || (e == 0);
11900 e_conv = DecodeError_clone(&e_conv);
11901 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
11902 *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_err(e_conv);
11903 return (uint64_t)ret_conv;
11906 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementInfoDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
11907 if ((_res & 1) != 0) return;
11908 LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res_conv = *(LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(((uint64_t)_res) & ~1);
11910 CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res_conv);
11913 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementInfoDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
11914 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* orig_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(orig & ~1);
11915 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
11916 *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig_conv);
11917 return (uint64_t)ret_conv;
11920 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1u64Z_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
11921 LDKCVec_u64Z _res_constr;
11922 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
11923 if (_res_constr.datalen > 0)
11924 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
11926 _res_constr.data = NULL;
11927 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
11928 for (size_t g = 0; g < _res_constr.datalen; g++) {
11929 int64_t _res_conv_6 = _res_vals[g];
11930 _res_constr.data[g] = _res_conv_6;
11932 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
11933 CVec_u64Z_free(_res_constr);
11936 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeInfoDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
11937 LDKNodeInfo o_conv;
11938 o_conv.inner = (void*)(o & (~1));
11939 o_conv.is_owned = (o & 1) || (o == 0);
11940 o_conv = NodeInfo_clone(&o_conv);
11941 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
11942 *ret_conv = CResult_NodeInfoDecodeErrorZ_ok(o_conv);
11943 return (uint64_t)ret_conv;
11946 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeInfoDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
11947 LDKDecodeError e_conv;
11948 e_conv.inner = (void*)(e & (~1));
11949 e_conv.is_owned = (e & 1) || (e == 0);
11950 e_conv = DecodeError_clone(&e_conv);
11951 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
11952 *ret_conv = CResult_NodeInfoDecodeErrorZ_err(e_conv);
11953 return (uint64_t)ret_conv;
11956 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NodeInfoDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
11957 if ((_res & 1) != 0) return;
11958 LDKCResult_NodeInfoDecodeErrorZ _res_conv = *(LDKCResult_NodeInfoDecodeErrorZ*)(((uint64_t)_res) & ~1);
11960 CResult_NodeInfoDecodeErrorZ_free(_res_conv);
11963 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeInfoDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
11964 LDKCResult_NodeInfoDecodeErrorZ* orig_conv = (LDKCResult_NodeInfoDecodeErrorZ*)(orig & ~1);
11965 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
11966 *ret_conv = CResult_NodeInfoDecodeErrorZ_clone(orig_conv);
11967 return (uint64_t)ret_conv;
11970 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NetworkGraphDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
11971 LDKNetworkGraph o_conv;
11972 o_conv.inner = (void*)(o & (~1));
11973 o_conv.is_owned = (o & 1) || (o == 0);
11974 o_conv = NetworkGraph_clone(&o_conv);
11975 LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
11976 *ret_conv = CResult_NetworkGraphDecodeErrorZ_ok(o_conv);
11977 return (uint64_t)ret_conv;
11980 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NetworkGraphDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
11981 LDKDecodeError e_conv;
11982 e_conv.inner = (void*)(e & (~1));
11983 e_conv.is_owned = (e & 1) || (e == 0);
11984 e_conv = DecodeError_clone(&e_conv);
11985 LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
11986 *ret_conv = CResult_NetworkGraphDecodeErrorZ_err(e_conv);
11987 return (uint64_t)ret_conv;
11990 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NetworkGraphDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
11991 if ((_res & 1) != 0) return;
11992 LDKCResult_NetworkGraphDecodeErrorZ _res_conv = *(LDKCResult_NetworkGraphDecodeErrorZ*)(((uint64_t)_res) & ~1);
11994 CResult_NetworkGraphDecodeErrorZ_free(_res_conv);
11997 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NetworkGraphDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
11998 LDKCResult_NetworkGraphDecodeErrorZ* orig_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)(orig & ~1);
11999 LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
12000 *ret_conv = CResult_NetworkGraphDecodeErrorZ_clone(orig_conv);
12001 return (uint64_t)ret_conv;
12004 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NetAddressu8Z_1ok(JNIEnv *env, jclass clz, int64_t o) {
12005 LDKNetAddress o_conv = *(LDKNetAddress*)(((uint64_t)o) & ~1);
12006 LDKCResult_NetAddressu8Z* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressu8Z), "LDKCResult_NetAddressu8Z");
12007 *ret_conv = CResult_NetAddressu8Z_ok(o_conv);
12008 return (uint64_t)ret_conv;
12011 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NetAddressu8Z_1err(JNIEnv *env, jclass clz, int8_t e) {
12012 LDKCResult_NetAddressu8Z* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressu8Z), "LDKCResult_NetAddressu8Z");
12013 *ret_conv = CResult_NetAddressu8Z_err(e);
12014 return (uint64_t)ret_conv;
12017 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NetAddressu8Z_1free(JNIEnv *env, jclass clz, int64_t _res) {
12018 if ((_res & 1) != 0) return;
12019 LDKCResult_NetAddressu8Z _res_conv = *(LDKCResult_NetAddressu8Z*)(((uint64_t)_res) & ~1);
12021 CResult_NetAddressu8Z_free(_res_conv);
12024 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NetAddressu8Z_1clone(JNIEnv *env, jclass clz, int64_t orig) {
12025 LDKCResult_NetAddressu8Z* orig_conv = (LDKCResult_NetAddressu8Z*)(orig & ~1);
12026 LDKCResult_NetAddressu8Z* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressu8Z), "LDKCResult_NetAddressu8Z");
12027 *ret_conv = CResult_NetAddressu8Z_clone(orig_conv);
12028 return (uint64_t)ret_conv;
12031 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CResult_1NetAddressu8ZDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
12032 LDKCResult_NetAddressu8Z o_conv = *(LDKCResult_NetAddressu8Z*)(((uint64_t)o) & ~1);
12033 LDKCResult_CResult_NetAddressu8ZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CResult_NetAddressu8ZDecodeErrorZ), "LDKCResult_CResult_NetAddressu8ZDecodeErrorZ");
12034 *ret_conv = CResult_CResult_NetAddressu8ZDecodeErrorZ_ok(o_conv);
12035 return (uint64_t)ret_conv;
12038 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CResult_1NetAddressu8ZDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
12039 LDKDecodeError e_conv;
12040 e_conv.inner = (void*)(e & (~1));
12041 e_conv.is_owned = (e & 1) || (e == 0);
12042 e_conv = DecodeError_clone(&e_conv);
12043 LDKCResult_CResult_NetAddressu8ZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CResult_NetAddressu8ZDecodeErrorZ), "LDKCResult_CResult_NetAddressu8ZDecodeErrorZ");
12044 *ret_conv = CResult_CResult_NetAddressu8ZDecodeErrorZ_err(e_conv);
12045 return (uint64_t)ret_conv;
12048 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CResult_1NetAddressu8ZDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
12049 if ((_res & 1) != 0) return;
12050 LDKCResult_CResult_NetAddressu8ZDecodeErrorZ _res_conv = *(LDKCResult_CResult_NetAddressu8ZDecodeErrorZ*)(((uint64_t)_res) & ~1);
12052 CResult_CResult_NetAddressu8ZDecodeErrorZ_free(_res_conv);
12055 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CResult_1NetAddressu8ZDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
12056 LDKCResult_CResult_NetAddressu8ZDecodeErrorZ* orig_conv = (LDKCResult_CResult_NetAddressu8ZDecodeErrorZ*)(orig & ~1);
12057 LDKCResult_CResult_NetAddressu8ZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CResult_NetAddressu8ZDecodeErrorZ), "LDKCResult_CResult_NetAddressu8ZDecodeErrorZ");
12058 *ret_conv = CResult_CResult_NetAddressu8ZDecodeErrorZ_clone(orig_conv);
12059 return (uint64_t)ret_conv;
12062 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NetAddressDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
12063 LDKNetAddress o_conv = *(LDKNetAddress*)(((uint64_t)o) & ~1);
12064 LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
12065 *ret_conv = CResult_NetAddressDecodeErrorZ_ok(o_conv);
12066 return (uint64_t)ret_conv;
12069 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NetAddressDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
12070 LDKDecodeError e_conv;
12071 e_conv.inner = (void*)(e & (~1));
12072 e_conv.is_owned = (e & 1) || (e == 0);
12073 e_conv = DecodeError_clone(&e_conv);
12074 LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
12075 *ret_conv = CResult_NetAddressDecodeErrorZ_err(e_conv);
12076 return (uint64_t)ret_conv;
12079 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NetAddressDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
12080 if ((_res & 1) != 0) return;
12081 LDKCResult_NetAddressDecodeErrorZ _res_conv = *(LDKCResult_NetAddressDecodeErrorZ*)(((uint64_t)_res) & ~1);
12083 CResult_NetAddressDecodeErrorZ_free(_res_conv);
12086 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NetAddressDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
12087 LDKCResult_NetAddressDecodeErrorZ* orig_conv = (LDKCResult_NetAddressDecodeErrorZ*)(orig & ~1);
12088 LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
12089 *ret_conv = CResult_NetAddressDecodeErrorZ_clone(orig_conv);
12090 return (uint64_t)ret_conv;
12093 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1UpdateAddHTLCZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
12094 LDKCVec_UpdateAddHTLCZ _res_constr;
12095 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
12096 if (_res_constr.datalen > 0)
12097 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateAddHTLC), "LDKCVec_UpdateAddHTLCZ Elements");
12099 _res_constr.data = NULL;
12100 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
12101 for (size_t p = 0; p < _res_constr.datalen; p++) {
12102 int64_t _res_conv_15 = _res_vals[p];
12103 LDKUpdateAddHTLC _res_conv_15_conv;
12104 _res_conv_15_conv.inner = (void*)(_res_conv_15 & (~1));
12105 _res_conv_15_conv.is_owned = (_res_conv_15 & 1) || (_res_conv_15 == 0);
12106 _res_constr.data[p] = _res_conv_15_conv;
12108 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
12109 CVec_UpdateAddHTLCZ_free(_res_constr);
12112 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1UpdateFulfillHTLCZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
12113 LDKCVec_UpdateFulfillHTLCZ _res_constr;
12114 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
12115 if (_res_constr.datalen > 0)
12116 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateFulfillHTLC), "LDKCVec_UpdateFulfillHTLCZ Elements");
12118 _res_constr.data = NULL;
12119 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
12120 for (size_t t = 0; t < _res_constr.datalen; t++) {
12121 int64_t _res_conv_19 = _res_vals[t];
12122 LDKUpdateFulfillHTLC _res_conv_19_conv;
12123 _res_conv_19_conv.inner = (void*)(_res_conv_19 & (~1));
12124 _res_conv_19_conv.is_owned = (_res_conv_19 & 1) || (_res_conv_19 == 0);
12125 _res_constr.data[t] = _res_conv_19_conv;
12127 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
12128 CVec_UpdateFulfillHTLCZ_free(_res_constr);
12131 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1UpdateFailHTLCZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
12132 LDKCVec_UpdateFailHTLCZ _res_constr;
12133 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
12134 if (_res_constr.datalen > 0)
12135 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateFailHTLC), "LDKCVec_UpdateFailHTLCZ Elements");
12137 _res_constr.data = NULL;
12138 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
12139 for (size_t q = 0; q < _res_constr.datalen; q++) {
12140 int64_t _res_conv_16 = _res_vals[q];
12141 LDKUpdateFailHTLC _res_conv_16_conv;
12142 _res_conv_16_conv.inner = (void*)(_res_conv_16 & (~1));
12143 _res_conv_16_conv.is_owned = (_res_conv_16 & 1) || (_res_conv_16 == 0);
12144 _res_constr.data[q] = _res_conv_16_conv;
12146 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
12147 CVec_UpdateFailHTLCZ_free(_res_constr);
12150 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1UpdateFailMalformedHTLCZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
12151 LDKCVec_UpdateFailMalformedHTLCZ _res_constr;
12152 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
12153 if (_res_constr.datalen > 0)
12154 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateFailMalformedHTLC), "LDKCVec_UpdateFailMalformedHTLCZ Elements");
12156 _res_constr.data = NULL;
12157 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
12158 for (size_t z = 0; z < _res_constr.datalen; z++) {
12159 int64_t _res_conv_25 = _res_vals[z];
12160 LDKUpdateFailMalformedHTLC _res_conv_25_conv;
12161 _res_conv_25_conv.inner = (void*)(_res_conv_25 & (~1));
12162 _res_conv_25_conv.is_owned = (_res_conv_25 & 1) || (_res_conv_25 == 0);
12163 _res_constr.data[z] = _res_conv_25_conv;
12165 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
12166 CVec_UpdateFailMalformedHTLCZ_free(_res_constr);
12169 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1AcceptChannelDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
12170 LDKAcceptChannel o_conv;
12171 o_conv.inner = (void*)(o & (~1));
12172 o_conv.is_owned = (o & 1) || (o == 0);
12173 o_conv = AcceptChannel_clone(&o_conv);
12174 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
12175 *ret_conv = CResult_AcceptChannelDecodeErrorZ_ok(o_conv);
12176 return (uint64_t)ret_conv;
12179 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1AcceptChannelDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
12180 LDKDecodeError e_conv;
12181 e_conv.inner = (void*)(e & (~1));
12182 e_conv.is_owned = (e & 1) || (e == 0);
12183 e_conv = DecodeError_clone(&e_conv);
12184 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
12185 *ret_conv = CResult_AcceptChannelDecodeErrorZ_err(e_conv);
12186 return (uint64_t)ret_conv;
12189 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1AcceptChannelDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
12190 if ((_res & 1) != 0) return;
12191 LDKCResult_AcceptChannelDecodeErrorZ _res_conv = *(LDKCResult_AcceptChannelDecodeErrorZ*)(((uint64_t)_res) & ~1);
12193 CResult_AcceptChannelDecodeErrorZ_free(_res_conv);
12196 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1AcceptChannelDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
12197 LDKCResult_AcceptChannelDecodeErrorZ* orig_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)(orig & ~1);
12198 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
12199 *ret_conv = CResult_AcceptChannelDecodeErrorZ_clone(orig_conv);
12200 return (uint64_t)ret_conv;
12203 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1AnnouncementSignaturesDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
12204 LDKAnnouncementSignatures o_conv;
12205 o_conv.inner = (void*)(o & (~1));
12206 o_conv.is_owned = (o & 1) || (o == 0);
12207 o_conv = AnnouncementSignatures_clone(&o_conv);
12208 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
12209 *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_ok(o_conv);
12210 return (uint64_t)ret_conv;
12213 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1AnnouncementSignaturesDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
12214 LDKDecodeError e_conv;
12215 e_conv.inner = (void*)(e & (~1));
12216 e_conv.is_owned = (e & 1) || (e == 0);
12217 e_conv = DecodeError_clone(&e_conv);
12218 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
12219 *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_err(e_conv);
12220 return (uint64_t)ret_conv;
12223 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1AnnouncementSignaturesDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
12224 if ((_res & 1) != 0) return;
12225 LDKCResult_AnnouncementSignaturesDecodeErrorZ _res_conv = *(LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(((uint64_t)_res) & ~1);
12227 CResult_AnnouncementSignaturesDecodeErrorZ_free(_res_conv);
12230 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1AnnouncementSignaturesDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
12231 LDKCResult_AnnouncementSignaturesDecodeErrorZ* orig_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(orig & ~1);
12232 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
12233 *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig_conv);
12234 return (uint64_t)ret_conv;
12237 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelReestablishDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
12238 LDKChannelReestablish o_conv;
12239 o_conv.inner = (void*)(o & (~1));
12240 o_conv.is_owned = (o & 1) || (o == 0);
12241 o_conv = ChannelReestablish_clone(&o_conv);
12242 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
12243 *ret_conv = CResult_ChannelReestablishDecodeErrorZ_ok(o_conv);
12244 return (uint64_t)ret_conv;
12247 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelReestablishDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
12248 LDKDecodeError e_conv;
12249 e_conv.inner = (void*)(e & (~1));
12250 e_conv.is_owned = (e & 1) || (e == 0);
12251 e_conv = DecodeError_clone(&e_conv);
12252 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
12253 *ret_conv = CResult_ChannelReestablishDecodeErrorZ_err(e_conv);
12254 return (uint64_t)ret_conv;
12257 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelReestablishDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
12258 if ((_res & 1) != 0) return;
12259 LDKCResult_ChannelReestablishDecodeErrorZ _res_conv = *(LDKCResult_ChannelReestablishDecodeErrorZ*)(((uint64_t)_res) & ~1);
12261 CResult_ChannelReestablishDecodeErrorZ_free(_res_conv);
12264 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelReestablishDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
12265 LDKCResult_ChannelReestablishDecodeErrorZ* orig_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)(orig & ~1);
12266 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
12267 *ret_conv = CResult_ChannelReestablishDecodeErrorZ_clone(orig_conv);
12268 return (uint64_t)ret_conv;
12271 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ClosingSignedDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
12272 LDKClosingSigned o_conv;
12273 o_conv.inner = (void*)(o & (~1));
12274 o_conv.is_owned = (o & 1) || (o == 0);
12275 o_conv = ClosingSigned_clone(&o_conv);
12276 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
12277 *ret_conv = CResult_ClosingSignedDecodeErrorZ_ok(o_conv);
12278 return (uint64_t)ret_conv;
12281 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ClosingSignedDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
12282 LDKDecodeError e_conv;
12283 e_conv.inner = (void*)(e & (~1));
12284 e_conv.is_owned = (e & 1) || (e == 0);
12285 e_conv = DecodeError_clone(&e_conv);
12286 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
12287 *ret_conv = CResult_ClosingSignedDecodeErrorZ_err(e_conv);
12288 return (uint64_t)ret_conv;
12291 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ClosingSignedDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
12292 if ((_res & 1) != 0) return;
12293 LDKCResult_ClosingSignedDecodeErrorZ _res_conv = *(LDKCResult_ClosingSignedDecodeErrorZ*)(((uint64_t)_res) & ~1);
12295 CResult_ClosingSignedDecodeErrorZ_free(_res_conv);
12298 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ClosingSignedDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
12299 LDKCResult_ClosingSignedDecodeErrorZ* orig_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)(orig & ~1);
12300 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
12301 *ret_conv = CResult_ClosingSignedDecodeErrorZ_clone(orig_conv);
12302 return (uint64_t)ret_conv;
12305 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentSignedDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
12306 LDKCommitmentSigned o_conv;
12307 o_conv.inner = (void*)(o & (~1));
12308 o_conv.is_owned = (o & 1) || (o == 0);
12309 o_conv = CommitmentSigned_clone(&o_conv);
12310 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
12311 *ret_conv = CResult_CommitmentSignedDecodeErrorZ_ok(o_conv);
12312 return (uint64_t)ret_conv;
12315 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentSignedDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
12316 LDKDecodeError e_conv;
12317 e_conv.inner = (void*)(e & (~1));
12318 e_conv.is_owned = (e & 1) || (e == 0);
12319 e_conv = DecodeError_clone(&e_conv);
12320 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
12321 *ret_conv = CResult_CommitmentSignedDecodeErrorZ_err(e_conv);
12322 return (uint64_t)ret_conv;
12325 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentSignedDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
12326 if ((_res & 1) != 0) return;
12327 LDKCResult_CommitmentSignedDecodeErrorZ _res_conv = *(LDKCResult_CommitmentSignedDecodeErrorZ*)(((uint64_t)_res) & ~1);
12329 CResult_CommitmentSignedDecodeErrorZ_free(_res_conv);
12332 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentSignedDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
12333 LDKCResult_CommitmentSignedDecodeErrorZ* orig_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)(orig & ~1);
12334 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
12335 *ret_conv = CResult_CommitmentSignedDecodeErrorZ_clone(orig_conv);
12336 return (uint64_t)ret_conv;
12339 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1FundingCreatedDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
12340 LDKFundingCreated o_conv;
12341 o_conv.inner = (void*)(o & (~1));
12342 o_conv.is_owned = (o & 1) || (o == 0);
12343 o_conv = FundingCreated_clone(&o_conv);
12344 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
12345 *ret_conv = CResult_FundingCreatedDecodeErrorZ_ok(o_conv);
12346 return (uint64_t)ret_conv;
12349 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1FundingCreatedDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
12350 LDKDecodeError e_conv;
12351 e_conv.inner = (void*)(e & (~1));
12352 e_conv.is_owned = (e & 1) || (e == 0);
12353 e_conv = DecodeError_clone(&e_conv);
12354 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
12355 *ret_conv = CResult_FundingCreatedDecodeErrorZ_err(e_conv);
12356 return (uint64_t)ret_conv;
12359 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1FundingCreatedDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
12360 if ((_res & 1) != 0) return;
12361 LDKCResult_FundingCreatedDecodeErrorZ _res_conv = *(LDKCResult_FundingCreatedDecodeErrorZ*)(((uint64_t)_res) & ~1);
12363 CResult_FundingCreatedDecodeErrorZ_free(_res_conv);
12366 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1FundingCreatedDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
12367 LDKCResult_FundingCreatedDecodeErrorZ* orig_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)(orig & ~1);
12368 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
12369 *ret_conv = CResult_FundingCreatedDecodeErrorZ_clone(orig_conv);
12370 return (uint64_t)ret_conv;
12373 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1FundingSignedDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
12374 LDKFundingSigned o_conv;
12375 o_conv.inner = (void*)(o & (~1));
12376 o_conv.is_owned = (o & 1) || (o == 0);
12377 o_conv = FundingSigned_clone(&o_conv);
12378 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
12379 *ret_conv = CResult_FundingSignedDecodeErrorZ_ok(o_conv);
12380 return (uint64_t)ret_conv;
12383 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1FundingSignedDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
12384 LDKDecodeError e_conv;
12385 e_conv.inner = (void*)(e & (~1));
12386 e_conv.is_owned = (e & 1) || (e == 0);
12387 e_conv = DecodeError_clone(&e_conv);
12388 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
12389 *ret_conv = CResult_FundingSignedDecodeErrorZ_err(e_conv);
12390 return (uint64_t)ret_conv;
12393 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1FundingSignedDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
12394 if ((_res & 1) != 0) return;
12395 LDKCResult_FundingSignedDecodeErrorZ _res_conv = *(LDKCResult_FundingSignedDecodeErrorZ*)(((uint64_t)_res) & ~1);
12397 CResult_FundingSignedDecodeErrorZ_free(_res_conv);
12400 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1FundingSignedDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
12401 LDKCResult_FundingSignedDecodeErrorZ* orig_conv = (LDKCResult_FundingSignedDecodeErrorZ*)(orig & ~1);
12402 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
12403 *ret_conv = CResult_FundingSignedDecodeErrorZ_clone(orig_conv);
12404 return (uint64_t)ret_conv;
12407 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1FundingLockedDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
12408 LDKFundingLocked o_conv;
12409 o_conv.inner = (void*)(o & (~1));
12410 o_conv.is_owned = (o & 1) || (o == 0);
12411 o_conv = FundingLocked_clone(&o_conv);
12412 LDKCResult_FundingLockedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingLockedDecodeErrorZ), "LDKCResult_FundingLockedDecodeErrorZ");
12413 *ret_conv = CResult_FundingLockedDecodeErrorZ_ok(o_conv);
12414 return (uint64_t)ret_conv;
12417 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1FundingLockedDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
12418 LDKDecodeError e_conv;
12419 e_conv.inner = (void*)(e & (~1));
12420 e_conv.is_owned = (e & 1) || (e == 0);
12421 e_conv = DecodeError_clone(&e_conv);
12422 LDKCResult_FundingLockedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingLockedDecodeErrorZ), "LDKCResult_FundingLockedDecodeErrorZ");
12423 *ret_conv = CResult_FundingLockedDecodeErrorZ_err(e_conv);
12424 return (uint64_t)ret_conv;
12427 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1FundingLockedDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
12428 if ((_res & 1) != 0) return;
12429 LDKCResult_FundingLockedDecodeErrorZ _res_conv = *(LDKCResult_FundingLockedDecodeErrorZ*)(((uint64_t)_res) & ~1);
12431 CResult_FundingLockedDecodeErrorZ_free(_res_conv);
12434 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1FundingLockedDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
12435 LDKCResult_FundingLockedDecodeErrorZ* orig_conv = (LDKCResult_FundingLockedDecodeErrorZ*)(orig & ~1);
12436 LDKCResult_FundingLockedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingLockedDecodeErrorZ), "LDKCResult_FundingLockedDecodeErrorZ");
12437 *ret_conv = CResult_FundingLockedDecodeErrorZ_clone(orig_conv);
12438 return (uint64_t)ret_conv;
12441 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InitDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
12443 o_conv.inner = (void*)(o & (~1));
12444 o_conv.is_owned = (o & 1) || (o == 0);
12445 o_conv = Init_clone(&o_conv);
12446 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
12447 *ret_conv = CResult_InitDecodeErrorZ_ok(o_conv);
12448 return (uint64_t)ret_conv;
12451 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InitDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
12452 LDKDecodeError e_conv;
12453 e_conv.inner = (void*)(e & (~1));
12454 e_conv.is_owned = (e & 1) || (e == 0);
12455 e_conv = DecodeError_clone(&e_conv);
12456 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
12457 *ret_conv = CResult_InitDecodeErrorZ_err(e_conv);
12458 return (uint64_t)ret_conv;
12461 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1InitDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
12462 if ((_res & 1) != 0) return;
12463 LDKCResult_InitDecodeErrorZ _res_conv = *(LDKCResult_InitDecodeErrorZ*)(((uint64_t)_res) & ~1);
12465 CResult_InitDecodeErrorZ_free(_res_conv);
12468 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InitDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
12469 LDKCResult_InitDecodeErrorZ* orig_conv = (LDKCResult_InitDecodeErrorZ*)(orig & ~1);
12470 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
12471 *ret_conv = CResult_InitDecodeErrorZ_clone(orig_conv);
12472 return (uint64_t)ret_conv;
12475 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1OpenChannelDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
12476 LDKOpenChannel o_conv;
12477 o_conv.inner = (void*)(o & (~1));
12478 o_conv.is_owned = (o & 1) || (o == 0);
12479 o_conv = OpenChannel_clone(&o_conv);
12480 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
12481 *ret_conv = CResult_OpenChannelDecodeErrorZ_ok(o_conv);
12482 return (uint64_t)ret_conv;
12485 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1OpenChannelDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
12486 LDKDecodeError e_conv;
12487 e_conv.inner = (void*)(e & (~1));
12488 e_conv.is_owned = (e & 1) || (e == 0);
12489 e_conv = DecodeError_clone(&e_conv);
12490 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
12491 *ret_conv = CResult_OpenChannelDecodeErrorZ_err(e_conv);
12492 return (uint64_t)ret_conv;
12495 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1OpenChannelDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
12496 if ((_res & 1) != 0) return;
12497 LDKCResult_OpenChannelDecodeErrorZ _res_conv = *(LDKCResult_OpenChannelDecodeErrorZ*)(((uint64_t)_res) & ~1);
12499 CResult_OpenChannelDecodeErrorZ_free(_res_conv);
12502 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1OpenChannelDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
12503 LDKCResult_OpenChannelDecodeErrorZ* orig_conv = (LDKCResult_OpenChannelDecodeErrorZ*)(orig & ~1);
12504 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
12505 *ret_conv = CResult_OpenChannelDecodeErrorZ_clone(orig_conv);
12506 return (uint64_t)ret_conv;
12509 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RevokeAndACKDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
12510 LDKRevokeAndACK o_conv;
12511 o_conv.inner = (void*)(o & (~1));
12512 o_conv.is_owned = (o & 1) || (o == 0);
12513 o_conv = RevokeAndACK_clone(&o_conv);
12514 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
12515 *ret_conv = CResult_RevokeAndACKDecodeErrorZ_ok(o_conv);
12516 return (uint64_t)ret_conv;
12519 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RevokeAndACKDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
12520 LDKDecodeError e_conv;
12521 e_conv.inner = (void*)(e & (~1));
12522 e_conv.is_owned = (e & 1) || (e == 0);
12523 e_conv = DecodeError_clone(&e_conv);
12524 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
12525 *ret_conv = CResult_RevokeAndACKDecodeErrorZ_err(e_conv);
12526 return (uint64_t)ret_conv;
12529 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RevokeAndACKDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
12530 if ((_res & 1) != 0) return;
12531 LDKCResult_RevokeAndACKDecodeErrorZ _res_conv = *(LDKCResult_RevokeAndACKDecodeErrorZ*)(((uint64_t)_res) & ~1);
12533 CResult_RevokeAndACKDecodeErrorZ_free(_res_conv);
12536 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RevokeAndACKDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
12537 LDKCResult_RevokeAndACKDecodeErrorZ* orig_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)(orig & ~1);
12538 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
12539 *ret_conv = CResult_RevokeAndACKDecodeErrorZ_clone(orig_conv);
12540 return (uint64_t)ret_conv;
12543 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
12544 LDKShutdown o_conv;
12545 o_conv.inner = (void*)(o & (~1));
12546 o_conv.is_owned = (o & 1) || (o == 0);
12547 o_conv = Shutdown_clone(&o_conv);
12548 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
12549 *ret_conv = CResult_ShutdownDecodeErrorZ_ok(o_conv);
12550 return (uint64_t)ret_conv;
12553 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
12554 LDKDecodeError e_conv;
12555 e_conv.inner = (void*)(e & (~1));
12556 e_conv.is_owned = (e & 1) || (e == 0);
12557 e_conv = DecodeError_clone(&e_conv);
12558 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
12559 *ret_conv = CResult_ShutdownDecodeErrorZ_err(e_conv);
12560 return (uint64_t)ret_conv;
12563 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
12564 if ((_res & 1) != 0) return;
12565 LDKCResult_ShutdownDecodeErrorZ _res_conv = *(LDKCResult_ShutdownDecodeErrorZ*)(((uint64_t)_res) & ~1);
12567 CResult_ShutdownDecodeErrorZ_free(_res_conv);
12570 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
12571 LDKCResult_ShutdownDecodeErrorZ* orig_conv = (LDKCResult_ShutdownDecodeErrorZ*)(orig & ~1);
12572 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
12573 *ret_conv = CResult_ShutdownDecodeErrorZ_clone(orig_conv);
12574 return (uint64_t)ret_conv;
12577 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailHTLCDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
12578 LDKUpdateFailHTLC o_conv;
12579 o_conv.inner = (void*)(o & (~1));
12580 o_conv.is_owned = (o & 1) || (o == 0);
12581 o_conv = UpdateFailHTLC_clone(&o_conv);
12582 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
12583 *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_ok(o_conv);
12584 return (uint64_t)ret_conv;
12587 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailHTLCDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
12588 LDKDecodeError e_conv;
12589 e_conv.inner = (void*)(e & (~1));
12590 e_conv.is_owned = (e & 1) || (e == 0);
12591 e_conv = DecodeError_clone(&e_conv);
12592 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
12593 *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_err(e_conv);
12594 return (uint64_t)ret_conv;
12597 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailHTLCDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
12598 if ((_res & 1) != 0) return;
12599 LDKCResult_UpdateFailHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateFailHTLCDecodeErrorZ*)(((uint64_t)_res) & ~1);
12601 CResult_UpdateFailHTLCDecodeErrorZ_free(_res_conv);
12604 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailHTLCDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
12605 LDKCResult_UpdateFailHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)(orig & ~1);
12606 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
12607 *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_clone(orig_conv);
12608 return (uint64_t)ret_conv;
12611 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailMalformedHTLCDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
12612 LDKUpdateFailMalformedHTLC o_conv;
12613 o_conv.inner = (void*)(o & (~1));
12614 o_conv.is_owned = (o & 1) || (o == 0);
12615 o_conv = UpdateFailMalformedHTLC_clone(&o_conv);
12616 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
12617 *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o_conv);
12618 return (uint64_t)ret_conv;
12621 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailMalformedHTLCDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
12622 LDKDecodeError e_conv;
12623 e_conv.inner = (void*)(e & (~1));
12624 e_conv.is_owned = (e & 1) || (e == 0);
12625 e_conv = DecodeError_clone(&e_conv);
12626 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
12627 *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e_conv);
12628 return (uint64_t)ret_conv;
12631 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailMalformedHTLCDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
12632 if ((_res & 1) != 0) return;
12633 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(((uint64_t)_res) & ~1);
12635 CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res_conv);
12638 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailMalformedHTLCDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
12639 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(orig & ~1);
12640 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
12641 *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig_conv);
12642 return (uint64_t)ret_conv;
12645 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFeeDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
12646 LDKUpdateFee o_conv;
12647 o_conv.inner = (void*)(o & (~1));
12648 o_conv.is_owned = (o & 1) || (o == 0);
12649 o_conv = UpdateFee_clone(&o_conv);
12650 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
12651 *ret_conv = CResult_UpdateFeeDecodeErrorZ_ok(o_conv);
12652 return (uint64_t)ret_conv;
12655 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFeeDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
12656 LDKDecodeError e_conv;
12657 e_conv.inner = (void*)(e & (~1));
12658 e_conv.is_owned = (e & 1) || (e == 0);
12659 e_conv = DecodeError_clone(&e_conv);
12660 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
12661 *ret_conv = CResult_UpdateFeeDecodeErrorZ_err(e_conv);
12662 return (uint64_t)ret_conv;
12665 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFeeDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
12666 if ((_res & 1) != 0) return;
12667 LDKCResult_UpdateFeeDecodeErrorZ _res_conv = *(LDKCResult_UpdateFeeDecodeErrorZ*)(((uint64_t)_res) & ~1);
12669 CResult_UpdateFeeDecodeErrorZ_free(_res_conv);
12672 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFeeDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
12673 LDKCResult_UpdateFeeDecodeErrorZ* orig_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)(orig & ~1);
12674 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
12675 *ret_conv = CResult_UpdateFeeDecodeErrorZ_clone(orig_conv);
12676 return (uint64_t)ret_conv;
12679 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFulfillHTLCDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
12680 LDKUpdateFulfillHTLC o_conv;
12681 o_conv.inner = (void*)(o & (~1));
12682 o_conv.is_owned = (o & 1) || (o == 0);
12683 o_conv = UpdateFulfillHTLC_clone(&o_conv);
12684 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
12685 *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o_conv);
12686 return (uint64_t)ret_conv;
12689 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFulfillHTLCDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
12690 LDKDecodeError e_conv;
12691 e_conv.inner = (void*)(e & (~1));
12692 e_conv.is_owned = (e & 1) || (e == 0);
12693 e_conv = DecodeError_clone(&e_conv);
12694 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
12695 *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_err(e_conv);
12696 return (uint64_t)ret_conv;
12699 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFulfillHTLCDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
12700 if ((_res & 1) != 0) return;
12701 LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(((uint64_t)_res) & ~1);
12703 CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res_conv);
12706 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFulfillHTLCDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
12707 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(orig & ~1);
12708 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
12709 *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig_conv);
12710 return (uint64_t)ret_conv;
12713 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateAddHTLCDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
12714 LDKUpdateAddHTLC o_conv;
12715 o_conv.inner = (void*)(o & (~1));
12716 o_conv.is_owned = (o & 1) || (o == 0);
12717 o_conv = UpdateAddHTLC_clone(&o_conv);
12718 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
12719 *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_ok(o_conv);
12720 return (uint64_t)ret_conv;
12723 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateAddHTLCDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
12724 LDKDecodeError e_conv;
12725 e_conv.inner = (void*)(e & (~1));
12726 e_conv.is_owned = (e & 1) || (e == 0);
12727 e_conv = DecodeError_clone(&e_conv);
12728 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
12729 *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_err(e_conv);
12730 return (uint64_t)ret_conv;
12733 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateAddHTLCDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
12734 if ((_res & 1) != 0) return;
12735 LDKCResult_UpdateAddHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateAddHTLCDecodeErrorZ*)(((uint64_t)_res) & ~1);
12737 CResult_UpdateAddHTLCDecodeErrorZ_free(_res_conv);
12740 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateAddHTLCDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
12741 LDKCResult_UpdateAddHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)(orig & ~1);
12742 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
12743 *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_clone(orig_conv);
12744 return (uint64_t)ret_conv;
12747 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PingDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
12749 o_conv.inner = (void*)(o & (~1));
12750 o_conv.is_owned = (o & 1) || (o == 0);
12751 o_conv = Ping_clone(&o_conv);
12752 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
12753 *ret_conv = CResult_PingDecodeErrorZ_ok(o_conv);
12754 return (uint64_t)ret_conv;
12757 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PingDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
12758 LDKDecodeError e_conv;
12759 e_conv.inner = (void*)(e & (~1));
12760 e_conv.is_owned = (e & 1) || (e == 0);
12761 e_conv = DecodeError_clone(&e_conv);
12762 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
12763 *ret_conv = CResult_PingDecodeErrorZ_err(e_conv);
12764 return (uint64_t)ret_conv;
12767 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PingDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
12768 if ((_res & 1) != 0) return;
12769 LDKCResult_PingDecodeErrorZ _res_conv = *(LDKCResult_PingDecodeErrorZ*)(((uint64_t)_res) & ~1);
12771 CResult_PingDecodeErrorZ_free(_res_conv);
12774 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PingDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
12775 LDKCResult_PingDecodeErrorZ* orig_conv = (LDKCResult_PingDecodeErrorZ*)(orig & ~1);
12776 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
12777 *ret_conv = CResult_PingDecodeErrorZ_clone(orig_conv);
12778 return (uint64_t)ret_conv;
12781 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PongDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
12783 o_conv.inner = (void*)(o & (~1));
12784 o_conv.is_owned = (o & 1) || (o == 0);
12785 o_conv = Pong_clone(&o_conv);
12786 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
12787 *ret_conv = CResult_PongDecodeErrorZ_ok(o_conv);
12788 return (uint64_t)ret_conv;
12791 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PongDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
12792 LDKDecodeError e_conv;
12793 e_conv.inner = (void*)(e & (~1));
12794 e_conv.is_owned = (e & 1) || (e == 0);
12795 e_conv = DecodeError_clone(&e_conv);
12796 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
12797 *ret_conv = CResult_PongDecodeErrorZ_err(e_conv);
12798 return (uint64_t)ret_conv;
12801 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PongDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
12802 if ((_res & 1) != 0) return;
12803 LDKCResult_PongDecodeErrorZ _res_conv = *(LDKCResult_PongDecodeErrorZ*)(((uint64_t)_res) & ~1);
12805 CResult_PongDecodeErrorZ_free(_res_conv);
12808 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PongDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
12809 LDKCResult_PongDecodeErrorZ* orig_conv = (LDKCResult_PongDecodeErrorZ*)(orig & ~1);
12810 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
12811 *ret_conv = CResult_PongDecodeErrorZ_clone(orig_conv);
12812 return (uint64_t)ret_conv;
12815 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelAnnouncementDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
12816 LDKUnsignedChannelAnnouncement o_conv;
12817 o_conv.inner = (void*)(o & (~1));
12818 o_conv.is_owned = (o & 1) || (o == 0);
12819 o_conv = UnsignedChannelAnnouncement_clone(&o_conv);
12820 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
12821 *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o_conv);
12822 return (uint64_t)ret_conv;
12825 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelAnnouncementDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
12826 LDKDecodeError e_conv;
12827 e_conv.inner = (void*)(e & (~1));
12828 e_conv.is_owned = (e & 1) || (e == 0);
12829 e_conv = DecodeError_clone(&e_conv);
12830 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
12831 *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e_conv);
12832 return (uint64_t)ret_conv;
12835 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelAnnouncementDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
12836 if ((_res & 1) != 0) return;
12837 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(((uint64_t)_res) & ~1);
12839 CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res_conv);
12842 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelAnnouncementDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
12843 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(orig & ~1);
12844 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
12845 *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig_conv);
12846 return (uint64_t)ret_conv;
12849 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelAnnouncementDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
12850 LDKChannelAnnouncement o_conv;
12851 o_conv.inner = (void*)(o & (~1));
12852 o_conv.is_owned = (o & 1) || (o == 0);
12853 o_conv = ChannelAnnouncement_clone(&o_conv);
12854 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
12855 *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_ok(o_conv);
12856 return (uint64_t)ret_conv;
12859 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelAnnouncementDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
12860 LDKDecodeError e_conv;
12861 e_conv.inner = (void*)(e & (~1));
12862 e_conv.is_owned = (e & 1) || (e == 0);
12863 e_conv = DecodeError_clone(&e_conv);
12864 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
12865 *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_err(e_conv);
12866 return (uint64_t)ret_conv;
12869 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelAnnouncementDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
12870 if ((_res & 1) != 0) return;
12871 LDKCResult_ChannelAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_ChannelAnnouncementDecodeErrorZ*)(((uint64_t)_res) & ~1);
12873 CResult_ChannelAnnouncementDecodeErrorZ_free(_res_conv);
12876 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelAnnouncementDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
12877 LDKCResult_ChannelAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)(orig & ~1);
12878 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
12879 *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_clone(orig_conv);
12880 return (uint64_t)ret_conv;
12883 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelUpdateDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
12884 LDKUnsignedChannelUpdate o_conv;
12885 o_conv.inner = (void*)(o & (~1));
12886 o_conv.is_owned = (o & 1) || (o == 0);
12887 o_conv = UnsignedChannelUpdate_clone(&o_conv);
12888 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
12889 *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o_conv);
12890 return (uint64_t)ret_conv;
12893 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelUpdateDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
12894 LDKDecodeError e_conv;
12895 e_conv.inner = (void*)(e & (~1));
12896 e_conv.is_owned = (e & 1) || (e == 0);
12897 e_conv = DecodeError_clone(&e_conv);
12898 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
12899 *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_err(e_conv);
12900 return (uint64_t)ret_conv;
12903 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelUpdateDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
12904 if ((_res & 1) != 0) return;
12905 LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res_conv = *(LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(((uint64_t)_res) & ~1);
12907 CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res_conv);
12910 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelUpdateDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
12911 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* orig_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(orig & ~1);
12912 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
12913 *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig_conv);
12914 return (uint64_t)ret_conv;
12917 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelUpdateDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
12918 LDKChannelUpdate o_conv;
12919 o_conv.inner = (void*)(o & (~1));
12920 o_conv.is_owned = (o & 1) || (o == 0);
12921 o_conv = ChannelUpdate_clone(&o_conv);
12922 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
12923 *ret_conv = CResult_ChannelUpdateDecodeErrorZ_ok(o_conv);
12924 return (uint64_t)ret_conv;
12927 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelUpdateDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
12928 LDKDecodeError e_conv;
12929 e_conv.inner = (void*)(e & (~1));
12930 e_conv.is_owned = (e & 1) || (e == 0);
12931 e_conv = DecodeError_clone(&e_conv);
12932 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
12933 *ret_conv = CResult_ChannelUpdateDecodeErrorZ_err(e_conv);
12934 return (uint64_t)ret_conv;
12937 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelUpdateDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
12938 if ((_res & 1) != 0) return;
12939 LDKCResult_ChannelUpdateDecodeErrorZ _res_conv = *(LDKCResult_ChannelUpdateDecodeErrorZ*)(((uint64_t)_res) & ~1);
12941 CResult_ChannelUpdateDecodeErrorZ_free(_res_conv);
12944 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelUpdateDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
12945 LDKCResult_ChannelUpdateDecodeErrorZ* orig_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)(orig & ~1);
12946 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
12947 *ret_conv = CResult_ChannelUpdateDecodeErrorZ_clone(orig_conv);
12948 return (uint64_t)ret_conv;
12951 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ErrorMessageDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
12952 LDKErrorMessage o_conv;
12953 o_conv.inner = (void*)(o & (~1));
12954 o_conv.is_owned = (o & 1) || (o == 0);
12955 o_conv = ErrorMessage_clone(&o_conv);
12956 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
12957 *ret_conv = CResult_ErrorMessageDecodeErrorZ_ok(o_conv);
12958 return (uint64_t)ret_conv;
12961 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ErrorMessageDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
12962 LDKDecodeError e_conv;
12963 e_conv.inner = (void*)(e & (~1));
12964 e_conv.is_owned = (e & 1) || (e == 0);
12965 e_conv = DecodeError_clone(&e_conv);
12966 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
12967 *ret_conv = CResult_ErrorMessageDecodeErrorZ_err(e_conv);
12968 return (uint64_t)ret_conv;
12971 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ErrorMessageDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
12972 if ((_res & 1) != 0) return;
12973 LDKCResult_ErrorMessageDecodeErrorZ _res_conv = *(LDKCResult_ErrorMessageDecodeErrorZ*)(((uint64_t)_res) & ~1);
12975 CResult_ErrorMessageDecodeErrorZ_free(_res_conv);
12978 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ErrorMessageDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
12979 LDKCResult_ErrorMessageDecodeErrorZ* orig_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)(orig & ~1);
12980 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
12981 *ret_conv = CResult_ErrorMessageDecodeErrorZ_clone(orig_conv);
12982 return (uint64_t)ret_conv;
12985 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedNodeAnnouncementDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
12986 LDKUnsignedNodeAnnouncement o_conv;
12987 o_conv.inner = (void*)(o & (~1));
12988 o_conv.is_owned = (o & 1) || (o == 0);
12989 o_conv = UnsignedNodeAnnouncement_clone(&o_conv);
12990 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
12991 *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o_conv);
12992 return (uint64_t)ret_conv;
12995 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedNodeAnnouncementDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
12996 LDKDecodeError e_conv;
12997 e_conv.inner = (void*)(e & (~1));
12998 e_conv.is_owned = (e & 1) || (e == 0);
12999 e_conv = DecodeError_clone(&e_conv);
13000 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
13001 *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e_conv);
13002 return (uint64_t)ret_conv;
13005 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedNodeAnnouncementDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
13006 if ((_res & 1) != 0) return;
13007 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(((uint64_t)_res) & ~1);
13009 CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res_conv);
13012 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedNodeAnnouncementDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
13013 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(orig & ~1);
13014 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
13015 *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig_conv);
13016 return (uint64_t)ret_conv;
13019 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
13020 LDKNodeAnnouncement o_conv;
13021 o_conv.inner = (void*)(o & (~1));
13022 o_conv.is_owned = (o & 1) || (o == 0);
13023 o_conv = NodeAnnouncement_clone(&o_conv);
13024 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
13025 *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_ok(o_conv);
13026 return (uint64_t)ret_conv;
13029 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
13030 LDKDecodeError e_conv;
13031 e_conv.inner = (void*)(e & (~1));
13032 e_conv.is_owned = (e & 1) || (e == 0);
13033 e_conv = DecodeError_clone(&e_conv);
13034 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
13035 *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_err(e_conv);
13036 return (uint64_t)ret_conv;
13039 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
13040 if ((_res & 1) != 0) return;
13041 LDKCResult_NodeAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_NodeAnnouncementDecodeErrorZ*)(((uint64_t)_res) & ~1);
13043 CResult_NodeAnnouncementDecodeErrorZ_free(_res_conv);
13046 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
13047 LDKCResult_NodeAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)(orig & ~1);
13048 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
13049 *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_clone(orig_conv);
13050 return (uint64_t)ret_conv;
13053 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1QueryShortChannelIdsDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
13054 LDKQueryShortChannelIds o_conv;
13055 o_conv.inner = (void*)(o & (~1));
13056 o_conv.is_owned = (o & 1) || (o == 0);
13057 o_conv = QueryShortChannelIds_clone(&o_conv);
13058 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
13059 *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_ok(o_conv);
13060 return (uint64_t)ret_conv;
13063 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1QueryShortChannelIdsDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
13064 LDKDecodeError e_conv;
13065 e_conv.inner = (void*)(e & (~1));
13066 e_conv.is_owned = (e & 1) || (e == 0);
13067 e_conv = DecodeError_clone(&e_conv);
13068 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
13069 *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_err(e_conv);
13070 return (uint64_t)ret_conv;
13073 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1QueryShortChannelIdsDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
13074 if ((_res & 1) != 0) return;
13075 LDKCResult_QueryShortChannelIdsDecodeErrorZ _res_conv = *(LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(((uint64_t)_res) & ~1);
13077 CResult_QueryShortChannelIdsDecodeErrorZ_free(_res_conv);
13080 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1QueryShortChannelIdsDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
13081 LDKCResult_QueryShortChannelIdsDecodeErrorZ* orig_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(orig & ~1);
13082 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
13083 *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig_conv);
13084 return (uint64_t)ret_conv;
13087 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyShortChannelIdsEndDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
13088 LDKReplyShortChannelIdsEnd o_conv;
13089 o_conv.inner = (void*)(o & (~1));
13090 o_conv.is_owned = (o & 1) || (o == 0);
13091 o_conv = ReplyShortChannelIdsEnd_clone(&o_conv);
13092 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
13093 *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o_conv);
13094 return (uint64_t)ret_conv;
13097 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyShortChannelIdsEndDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
13098 LDKDecodeError e_conv;
13099 e_conv.inner = (void*)(e & (~1));
13100 e_conv.is_owned = (e & 1) || (e == 0);
13101 e_conv = DecodeError_clone(&e_conv);
13102 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
13103 *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e_conv);
13104 return (uint64_t)ret_conv;
13107 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyShortChannelIdsEndDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
13108 if ((_res & 1) != 0) return;
13109 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res_conv = *(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(((uint64_t)_res) & ~1);
13111 CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res_conv);
13114 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyShortChannelIdsEndDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
13115 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* orig_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(orig & ~1);
13116 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
13117 *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig_conv);
13118 return (uint64_t)ret_conv;
13121 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1QueryChannelRangeDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
13122 LDKQueryChannelRange o_conv;
13123 o_conv.inner = (void*)(o & (~1));
13124 o_conv.is_owned = (o & 1) || (o == 0);
13125 o_conv = QueryChannelRange_clone(&o_conv);
13126 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
13127 *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_ok(o_conv);
13128 return (uint64_t)ret_conv;
13131 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1QueryChannelRangeDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
13132 LDKDecodeError e_conv;
13133 e_conv.inner = (void*)(e & (~1));
13134 e_conv.is_owned = (e & 1) || (e == 0);
13135 e_conv = DecodeError_clone(&e_conv);
13136 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
13137 *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_err(e_conv);
13138 return (uint64_t)ret_conv;
13141 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1QueryChannelRangeDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
13142 if ((_res & 1) != 0) return;
13143 LDKCResult_QueryChannelRangeDecodeErrorZ _res_conv = *(LDKCResult_QueryChannelRangeDecodeErrorZ*)(((uint64_t)_res) & ~1);
13145 CResult_QueryChannelRangeDecodeErrorZ_free(_res_conv);
13148 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1QueryChannelRangeDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
13149 LDKCResult_QueryChannelRangeDecodeErrorZ* orig_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)(orig & ~1);
13150 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
13151 *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_clone(orig_conv);
13152 return (uint64_t)ret_conv;
13155 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyChannelRangeDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
13156 LDKReplyChannelRange o_conv;
13157 o_conv.inner = (void*)(o & (~1));
13158 o_conv.is_owned = (o & 1) || (o == 0);
13159 o_conv = ReplyChannelRange_clone(&o_conv);
13160 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
13161 *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_ok(o_conv);
13162 return (uint64_t)ret_conv;
13165 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyChannelRangeDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
13166 LDKDecodeError e_conv;
13167 e_conv.inner = (void*)(e & (~1));
13168 e_conv.is_owned = (e & 1) || (e == 0);
13169 e_conv = DecodeError_clone(&e_conv);
13170 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
13171 *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_err(e_conv);
13172 return (uint64_t)ret_conv;
13175 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyChannelRangeDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
13176 if ((_res & 1) != 0) return;
13177 LDKCResult_ReplyChannelRangeDecodeErrorZ _res_conv = *(LDKCResult_ReplyChannelRangeDecodeErrorZ*)(((uint64_t)_res) & ~1);
13179 CResult_ReplyChannelRangeDecodeErrorZ_free(_res_conv);
13182 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyChannelRangeDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
13183 LDKCResult_ReplyChannelRangeDecodeErrorZ* orig_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)(orig & ~1);
13184 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
13185 *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_clone(orig_conv);
13186 return (uint64_t)ret_conv;
13189 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1GossipTimestampFilterDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
13190 LDKGossipTimestampFilter o_conv;
13191 o_conv.inner = (void*)(o & (~1));
13192 o_conv.is_owned = (o & 1) || (o == 0);
13193 o_conv = GossipTimestampFilter_clone(&o_conv);
13194 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
13195 *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_ok(o_conv);
13196 return (uint64_t)ret_conv;
13199 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1GossipTimestampFilterDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
13200 LDKDecodeError e_conv;
13201 e_conv.inner = (void*)(e & (~1));
13202 e_conv.is_owned = (e & 1) || (e == 0);
13203 e_conv = DecodeError_clone(&e_conv);
13204 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
13205 *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_err(e_conv);
13206 return (uint64_t)ret_conv;
13209 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1GossipTimestampFilterDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
13210 if ((_res & 1) != 0) return;
13211 LDKCResult_GossipTimestampFilterDecodeErrorZ _res_conv = *(LDKCResult_GossipTimestampFilterDecodeErrorZ*)(((uint64_t)_res) & ~1);
13213 CResult_GossipTimestampFilterDecodeErrorZ_free(_res_conv);
13216 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1GossipTimestampFilterDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
13217 LDKCResult_GossipTimestampFilterDecodeErrorZ* orig_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)(orig & ~1);
13218 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
13219 *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_clone(orig_conv);
13220 return (uint64_t)ret_conv;
13223 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceSignOrCreationErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
13225 o_conv.inner = (void*)(o & (~1));
13226 o_conv.is_owned = (o & 1) || (o == 0);
13227 o_conv = Invoice_clone(&o_conv);
13228 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
13229 *ret_conv = CResult_InvoiceSignOrCreationErrorZ_ok(o_conv);
13230 return (uint64_t)ret_conv;
13233 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceSignOrCreationErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
13234 LDKSignOrCreationError e_conv = *(LDKSignOrCreationError*)(((uint64_t)e) & ~1);
13235 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
13236 *ret_conv = CResult_InvoiceSignOrCreationErrorZ_err(e_conv);
13237 return (uint64_t)ret_conv;
13240 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceSignOrCreationErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
13241 if ((_res & 1) != 0) return;
13242 LDKCResult_InvoiceSignOrCreationErrorZ _res_conv = *(LDKCResult_InvoiceSignOrCreationErrorZ*)(((uint64_t)_res) & ~1);
13244 CResult_InvoiceSignOrCreationErrorZ_free(_res_conv);
13247 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceSignOrCreationErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
13248 LDKCResult_InvoiceSignOrCreationErrorZ* orig_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)(orig & ~1);
13249 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
13250 *ret_conv = CResult_InvoiceSignOrCreationErrorZ_clone(orig_conv);
13251 return (uint64_t)ret_conv;
13254 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Event_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
13255 if ((this_ptr & 1) != 0) return;
13256 LDKEvent this_ptr_conv = *(LDKEvent*)(((uint64_t)this_ptr) & ~1);
13257 FREE((void*)this_ptr);
13258 Event_free(this_ptr_conv);
13261 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Event_1clone(JNIEnv *env, jclass clz, int64_t orig) {
13262 LDKEvent* orig_conv = (LDKEvent*)orig;
13263 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
13264 *ret_copy = Event_clone(orig_conv);
13265 uint64_t ret_ref = (uint64_t)ret_copy;
13269 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_Event_1write(JNIEnv *env, jclass clz, int64_t obj) {
13270 LDKEvent* obj_conv = (LDKEvent*)obj;
13271 LDKCVec_u8Z ret_var = Event_write(obj_conv);
13272 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
13273 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
13274 CVec_u8Z_free(ret_var);
13278 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_MessageSendEvent_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
13279 if ((this_ptr & 1) != 0) return;
13280 LDKMessageSendEvent this_ptr_conv = *(LDKMessageSendEvent*)(((uint64_t)this_ptr) & ~1);
13281 FREE((void*)this_ptr);
13282 MessageSendEvent_free(this_ptr_conv);
13285 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MessageSendEvent_1clone(JNIEnv *env, jclass clz, int64_t orig) {
13286 LDKMessageSendEvent* orig_conv = (LDKMessageSendEvent*)orig;
13287 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
13288 *ret_copy = MessageSendEvent_clone(orig_conv);
13289 uint64_t ret_ref = (uint64_t)ret_copy;
13293 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_MessageSendEventsProvider_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
13294 if ((this_ptr & 1) != 0) return;
13295 LDKMessageSendEventsProvider this_ptr_conv = *(LDKMessageSendEventsProvider*)(((uint64_t)this_ptr) & ~1);
13296 FREE((void*)this_ptr);
13297 MessageSendEventsProvider_free(this_ptr_conv);
13300 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_EventsProvider_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
13301 if ((this_ptr & 1) != 0) return;
13302 LDKEventsProvider this_ptr_conv = *(LDKEventsProvider*)(((uint64_t)this_ptr) & ~1);
13303 FREE((void*)this_ptr);
13304 EventsProvider_free(this_ptr_conv);
13307 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_EventHandler_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
13308 if ((this_ptr & 1) != 0) return;
13309 LDKEventHandler this_ptr_conv = *(LDKEventHandler*)(((uint64_t)this_ptr) & ~1);
13310 FREE((void*)this_ptr);
13311 EventHandler_free(this_ptr_conv);
13314 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_APIError_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
13315 if ((this_ptr & 1) != 0) return;
13316 LDKAPIError this_ptr_conv = *(LDKAPIError*)(((uint64_t)this_ptr) & ~1);
13317 FREE((void*)this_ptr);
13318 APIError_free(this_ptr_conv);
13321 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_APIError_1clone(JNIEnv *env, jclass clz, int64_t orig) {
13322 LDKAPIError* orig_conv = (LDKAPIError*)orig;
13323 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
13324 *ret_copy = APIError_clone(orig_conv);
13325 uint64_t ret_ref = (uint64_t)ret_copy;
13329 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_sign(JNIEnv *env, jclass clz, int8_tArray msg, int8_tArray sk) {
13330 LDKu8slice msg_ref;
13331 msg_ref.datalen = (*env)->GetArrayLength(env, msg);
13332 msg_ref.data = (*env)->GetByteArrayElements (env, msg, NULL);
13333 unsigned char sk_arr[32];
13334 CHECK((*env)->GetArrayLength(env, sk) == 32);
13335 (*env)->GetByteArrayRegion(env, sk, 0, 32, sk_arr);
13336 unsigned char (*sk_ref)[32] = &sk_arr;
13337 LDKCResult_StringErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StringErrorZ), "LDKCResult_StringErrorZ");
13338 *ret_conv = sign(msg_ref, sk_ref);
13339 (*env)->ReleaseByteArrayElements(env, msg, (int8_t*)msg_ref.data, 0);
13340 return (uint64_t)ret_conv;
13343 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_recover_1pk(JNIEnv *env, jclass clz, int8_tArray msg, jstring sig) {
13344 LDKu8slice msg_ref;
13345 msg_ref.datalen = (*env)->GetArrayLength(env, msg);
13346 msg_ref.data = (*env)->GetByteArrayElements (env, msg, NULL);
13347 LDKStr sig_conv = java_to_owned_str(env, sig);
13348 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
13349 *ret_conv = recover_pk(msg_ref, sig_conv);
13350 (*env)->ReleaseByteArrayElements(env, msg, (int8_t*)msg_ref.data, 0);
13351 return (uint64_t)ret_conv;
13354 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_verify(JNIEnv *env, jclass clz, int8_tArray msg, jstring sig, int8_tArray pk) {
13355 LDKu8slice msg_ref;
13356 msg_ref.datalen = (*env)->GetArrayLength(env, msg);
13357 msg_ref.data = (*env)->GetByteArrayElements (env, msg, NULL);
13358 LDKStr sig_conv = java_to_owned_str(env, sig);
13359 LDKPublicKey pk_ref;
13360 CHECK((*env)->GetArrayLength(env, pk) == 33);
13361 (*env)->GetByteArrayRegion(env, pk, 0, 33, pk_ref.compressed_form);
13362 jboolean ret_val = verify(msg_ref, sig_conv, pk_ref);
13363 (*env)->ReleaseByteArrayElements(env, msg, (int8_t*)msg_ref.data, 0);
13367 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_Level_1clone(JNIEnv *env, jclass clz, int64_t orig) {
13368 LDKLevel* orig_conv = (LDKLevel*)(orig & ~1);
13369 jclass ret_conv = LDKLevel_to_java(env, Level_clone(orig_conv));
13373 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_Level_1eq(JNIEnv *env, jclass clz, int64_t a, int64_t b) {
13374 LDKLevel* a_conv = (LDKLevel*)(a & ~1);
13375 LDKLevel* b_conv = (LDKLevel*)(b & ~1);
13376 jboolean ret_val = Level_eq(a_conv, b_conv);
13380 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Level_1hash(JNIEnv *env, jclass clz, int64_t o) {
13381 LDKLevel* o_conv = (LDKLevel*)(o & ~1);
13382 int64_t ret_val = Level_hash(o_conv);
13386 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_Level_1max(JNIEnv *env, jclass clz) {
13387 jclass ret_conv = LDKLevel_to_java(env, Level_max());
13391 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Logger_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
13392 if ((this_ptr & 1) != 0) return;
13393 LDKLogger this_ptr_conv = *(LDKLogger*)(((uint64_t)this_ptr) & ~1);
13394 FREE((void*)this_ptr);
13395 Logger_free(this_ptr_conv);
13398 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeConfig_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
13399 LDKChannelHandshakeConfig this_obj_conv;
13400 this_obj_conv.inner = (void*)(this_obj & (~1));
13401 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
13402 ChannelHandshakeConfig_free(this_obj_conv);
13405 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeConfig_1get_1minimum_1depth(JNIEnv *env, jclass clz, int64_t this_ptr) {
13406 LDKChannelHandshakeConfig this_ptr_conv;
13407 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13408 this_ptr_conv.is_owned = false;
13409 int32_t ret_val = ChannelHandshakeConfig_get_minimum_depth(&this_ptr_conv);
13413 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeConfig_1set_1minimum_1depth(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
13414 LDKChannelHandshakeConfig this_ptr_conv;
13415 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13416 this_ptr_conv.is_owned = false;
13417 ChannelHandshakeConfig_set_minimum_depth(&this_ptr_conv, val);
13420 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeConfig_1get_1our_1to_1self_1delay(JNIEnv *env, jclass clz, int64_t this_ptr) {
13421 LDKChannelHandshakeConfig this_ptr_conv;
13422 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13423 this_ptr_conv.is_owned = false;
13424 int16_t ret_val = ChannelHandshakeConfig_get_our_to_self_delay(&this_ptr_conv);
13428 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeConfig_1set_1our_1to_1self_1delay(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
13429 LDKChannelHandshakeConfig this_ptr_conv;
13430 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13431 this_ptr_conv.is_owned = false;
13432 ChannelHandshakeConfig_set_our_to_self_delay(&this_ptr_conv, val);
13435 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeConfig_1get_1our_1htlc_1minimum_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
13436 LDKChannelHandshakeConfig this_ptr_conv;
13437 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13438 this_ptr_conv.is_owned = false;
13439 int64_t ret_val = ChannelHandshakeConfig_get_our_htlc_minimum_msat(&this_ptr_conv);
13443 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeConfig_1set_1our_1htlc_1minimum_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
13444 LDKChannelHandshakeConfig this_ptr_conv;
13445 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13446 this_ptr_conv.is_owned = false;
13447 ChannelHandshakeConfig_set_our_htlc_minimum_msat(&this_ptr_conv, val);
13450 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeConfig_1new(JNIEnv *env, jclass clz, int32_t minimum_depth_arg, int16_t our_to_self_delay_arg, int64_t our_htlc_minimum_msat_arg) {
13451 LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_new(minimum_depth_arg, our_to_self_delay_arg, our_htlc_minimum_msat_arg);
13452 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13453 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13454 uint64_t ret_ref = (uint64_t)ret_var.inner;
13455 if (ret_var.is_owned) {
13461 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeConfig_1clone(JNIEnv *env, jclass clz, int64_t orig) {
13462 LDKChannelHandshakeConfig orig_conv;
13463 orig_conv.inner = (void*)(orig & (~1));
13464 orig_conv.is_owned = false;
13465 LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_clone(&orig_conv);
13466 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13467 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13468 uint64_t ret_ref = (uint64_t)ret_var.inner;
13469 if (ret_var.is_owned) {
13475 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeConfig_1default(JNIEnv *env, jclass clz) {
13476 LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_default();
13477 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13478 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13479 uint64_t ret_ref = (uint64_t)ret_var.inner;
13480 if (ret_var.is_owned) {
13486 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
13487 LDKChannelHandshakeLimits this_obj_conv;
13488 this_obj_conv.inner = (void*)(this_obj & (~1));
13489 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
13490 ChannelHandshakeLimits_free(this_obj_conv);
13493 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1get_1min_1funding_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr) {
13494 LDKChannelHandshakeLimits this_ptr_conv;
13495 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13496 this_ptr_conv.is_owned = false;
13497 int64_t ret_val = ChannelHandshakeLimits_get_min_funding_satoshis(&this_ptr_conv);
13501 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1set_1min_1funding_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
13502 LDKChannelHandshakeLimits this_ptr_conv;
13503 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13504 this_ptr_conv.is_owned = false;
13505 ChannelHandshakeLimits_set_min_funding_satoshis(&this_ptr_conv, val);
13508 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1get_1max_1htlc_1minimum_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
13509 LDKChannelHandshakeLimits this_ptr_conv;
13510 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13511 this_ptr_conv.is_owned = false;
13512 int64_t ret_val = ChannelHandshakeLimits_get_max_htlc_minimum_msat(&this_ptr_conv);
13516 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1set_1max_1htlc_1minimum_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
13517 LDKChannelHandshakeLimits this_ptr_conv;
13518 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13519 this_ptr_conv.is_owned = false;
13520 ChannelHandshakeLimits_set_max_htlc_minimum_msat(&this_ptr_conv, val);
13523 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1get_1min_1max_1htlc_1value_1in_1flight_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
13524 LDKChannelHandshakeLimits this_ptr_conv;
13525 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13526 this_ptr_conv.is_owned = false;
13527 int64_t ret_val = ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(&this_ptr_conv);
13531 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1set_1min_1max_1htlc_1value_1in_1flight_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
13532 LDKChannelHandshakeLimits this_ptr_conv;
13533 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13534 this_ptr_conv.is_owned = false;
13535 ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
13538 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1get_1max_1channel_1reserve_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr) {
13539 LDKChannelHandshakeLimits this_ptr_conv;
13540 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13541 this_ptr_conv.is_owned = false;
13542 int64_t ret_val = ChannelHandshakeLimits_get_max_channel_reserve_satoshis(&this_ptr_conv);
13546 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1set_1max_1channel_1reserve_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
13547 LDKChannelHandshakeLimits this_ptr_conv;
13548 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13549 this_ptr_conv.is_owned = false;
13550 ChannelHandshakeLimits_set_max_channel_reserve_satoshis(&this_ptr_conv, val);
13553 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1get_1min_1max_1accepted_1htlcs(JNIEnv *env, jclass clz, int64_t this_ptr) {
13554 LDKChannelHandshakeLimits this_ptr_conv;
13555 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13556 this_ptr_conv.is_owned = false;
13557 int16_t ret_val = ChannelHandshakeLimits_get_min_max_accepted_htlcs(&this_ptr_conv);
13561 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1set_1min_1max_1accepted_1htlcs(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
13562 LDKChannelHandshakeLimits this_ptr_conv;
13563 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13564 this_ptr_conv.is_owned = false;
13565 ChannelHandshakeLimits_set_min_max_accepted_htlcs(&this_ptr_conv, val);
13568 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1get_1max_1minimum_1depth(JNIEnv *env, jclass clz, int64_t this_ptr) {
13569 LDKChannelHandshakeLimits this_ptr_conv;
13570 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13571 this_ptr_conv.is_owned = false;
13572 int32_t ret_val = ChannelHandshakeLimits_get_max_minimum_depth(&this_ptr_conv);
13576 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1set_1max_1minimum_1depth(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
13577 LDKChannelHandshakeLimits this_ptr_conv;
13578 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13579 this_ptr_conv.is_owned = false;
13580 ChannelHandshakeLimits_set_max_minimum_depth(&this_ptr_conv, val);
13583 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1get_1force_1announced_1channel_1preference(JNIEnv *env, jclass clz, int64_t this_ptr) {
13584 LDKChannelHandshakeLimits this_ptr_conv;
13585 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13586 this_ptr_conv.is_owned = false;
13587 jboolean ret_val = ChannelHandshakeLimits_get_force_announced_channel_preference(&this_ptr_conv);
13591 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1set_1force_1announced_1channel_1preference(JNIEnv *env, jclass clz, int64_t this_ptr, jboolean val) {
13592 LDKChannelHandshakeLimits this_ptr_conv;
13593 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13594 this_ptr_conv.is_owned = false;
13595 ChannelHandshakeLimits_set_force_announced_channel_preference(&this_ptr_conv, val);
13598 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1get_1their_1to_1self_1delay(JNIEnv *env, jclass clz, int64_t this_ptr) {
13599 LDKChannelHandshakeLimits this_ptr_conv;
13600 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13601 this_ptr_conv.is_owned = false;
13602 int16_t ret_val = ChannelHandshakeLimits_get_their_to_self_delay(&this_ptr_conv);
13606 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1set_1their_1to_1self_1delay(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
13607 LDKChannelHandshakeLimits this_ptr_conv;
13608 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13609 this_ptr_conv.is_owned = false;
13610 ChannelHandshakeLimits_set_their_to_self_delay(&this_ptr_conv, val);
13613 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1new(JNIEnv *env, jclass clz, 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) {
13614 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);
13615 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13616 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13617 uint64_t ret_ref = (uint64_t)ret_var.inner;
13618 if (ret_var.is_owned) {
13624 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1clone(JNIEnv *env, jclass clz, int64_t orig) {
13625 LDKChannelHandshakeLimits orig_conv;
13626 orig_conv.inner = (void*)(orig & (~1));
13627 orig_conv.is_owned = false;
13628 LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_clone(&orig_conv);
13629 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13630 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13631 uint64_t ret_ref = (uint64_t)ret_var.inner;
13632 if (ret_var.is_owned) {
13638 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1default(JNIEnv *env, jclass clz) {
13639 LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_default();
13640 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13641 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13642 uint64_t ret_ref = (uint64_t)ret_var.inner;
13643 if (ret_var.is_owned) {
13649 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
13650 LDKChannelConfig this_obj_conv;
13651 this_obj_conv.inner = (void*)(this_obj & (~1));
13652 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
13653 ChannelConfig_free(this_obj_conv);
13656 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1get_1forwarding_1fee_1proportional_1millionths(JNIEnv *env, jclass clz, int64_t this_ptr) {
13657 LDKChannelConfig this_ptr_conv;
13658 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13659 this_ptr_conv.is_owned = false;
13660 int32_t ret_val = ChannelConfig_get_forwarding_fee_proportional_millionths(&this_ptr_conv);
13664 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1set_1forwarding_1fee_1proportional_1millionths(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
13665 LDKChannelConfig this_ptr_conv;
13666 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13667 this_ptr_conv.is_owned = false;
13668 ChannelConfig_set_forwarding_fee_proportional_millionths(&this_ptr_conv, val);
13671 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1get_1forwarding_1fee_1base_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
13672 LDKChannelConfig this_ptr_conv;
13673 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13674 this_ptr_conv.is_owned = false;
13675 int32_t ret_val = ChannelConfig_get_forwarding_fee_base_msat(&this_ptr_conv);
13679 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1set_1forwarding_1fee_1base_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
13680 LDKChannelConfig this_ptr_conv;
13681 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13682 this_ptr_conv.is_owned = false;
13683 ChannelConfig_set_forwarding_fee_base_msat(&this_ptr_conv, val);
13686 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1get_1cltv_1expiry_1delta(JNIEnv *env, jclass clz, int64_t this_ptr) {
13687 LDKChannelConfig this_ptr_conv;
13688 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13689 this_ptr_conv.is_owned = false;
13690 int16_t ret_val = ChannelConfig_get_cltv_expiry_delta(&this_ptr_conv);
13694 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1set_1cltv_1expiry_1delta(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
13695 LDKChannelConfig this_ptr_conv;
13696 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13697 this_ptr_conv.is_owned = false;
13698 ChannelConfig_set_cltv_expiry_delta(&this_ptr_conv, val);
13701 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1get_1announced_1channel(JNIEnv *env, jclass clz, int64_t this_ptr) {
13702 LDKChannelConfig this_ptr_conv;
13703 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13704 this_ptr_conv.is_owned = false;
13705 jboolean ret_val = ChannelConfig_get_announced_channel(&this_ptr_conv);
13709 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1set_1announced_1channel(JNIEnv *env, jclass clz, int64_t this_ptr, jboolean val) {
13710 LDKChannelConfig this_ptr_conv;
13711 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13712 this_ptr_conv.is_owned = false;
13713 ChannelConfig_set_announced_channel(&this_ptr_conv, val);
13716 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1get_1commit_1upfront_1shutdown_1pubkey(JNIEnv *env, jclass clz, int64_t this_ptr) {
13717 LDKChannelConfig this_ptr_conv;
13718 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13719 this_ptr_conv.is_owned = false;
13720 jboolean ret_val = ChannelConfig_get_commit_upfront_shutdown_pubkey(&this_ptr_conv);
13724 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1set_1commit_1upfront_1shutdown_1pubkey(JNIEnv *env, jclass clz, int64_t this_ptr, jboolean val) {
13725 LDKChannelConfig this_ptr_conv;
13726 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13727 this_ptr_conv.is_owned = false;
13728 ChannelConfig_set_commit_upfront_shutdown_pubkey(&this_ptr_conv, val);
13731 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1new(JNIEnv *env, jclass clz, int32_t forwarding_fee_proportional_millionths_arg, int32_t forwarding_fee_base_msat_arg, int16_t cltv_expiry_delta_arg, jboolean announced_channel_arg, jboolean commit_upfront_shutdown_pubkey_arg) {
13732 LDKChannelConfig ret_var = ChannelConfig_new(forwarding_fee_proportional_millionths_arg, forwarding_fee_base_msat_arg, cltv_expiry_delta_arg, announced_channel_arg, commit_upfront_shutdown_pubkey_arg);
13733 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13734 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13735 uint64_t ret_ref = (uint64_t)ret_var.inner;
13736 if (ret_var.is_owned) {
13742 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1clone(JNIEnv *env, jclass clz, int64_t orig) {
13743 LDKChannelConfig orig_conv;
13744 orig_conv.inner = (void*)(orig & (~1));
13745 orig_conv.is_owned = false;
13746 LDKChannelConfig ret_var = ChannelConfig_clone(&orig_conv);
13747 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13748 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13749 uint64_t ret_ref = (uint64_t)ret_var.inner;
13750 if (ret_var.is_owned) {
13756 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1default(JNIEnv *env, jclass clz) {
13757 LDKChannelConfig ret_var = ChannelConfig_default();
13758 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13759 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13760 uint64_t ret_ref = (uint64_t)ret_var.inner;
13761 if (ret_var.is_owned) {
13767 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1write(JNIEnv *env, jclass clz, int64_t obj) {
13768 LDKChannelConfig obj_conv;
13769 obj_conv.inner = (void*)(obj & (~1));
13770 obj_conv.is_owned = false;
13771 LDKCVec_u8Z ret_var = ChannelConfig_write(&obj_conv);
13772 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
13773 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
13774 CVec_u8Z_free(ret_var);
13778 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
13779 LDKu8slice ser_ref;
13780 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
13781 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
13782 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
13783 *ret_conv = ChannelConfig_read(ser_ref);
13784 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
13785 return (uint64_t)ret_conv;
13788 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UserConfig_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
13789 LDKUserConfig this_obj_conv;
13790 this_obj_conv.inner = (void*)(this_obj & (~1));
13791 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
13792 UserConfig_free(this_obj_conv);
13795 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UserConfig_1get_1own_1channel_1config(JNIEnv *env, jclass clz, int64_t this_ptr) {
13796 LDKUserConfig this_ptr_conv;
13797 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13798 this_ptr_conv.is_owned = false;
13799 LDKChannelHandshakeConfig ret_var = UserConfig_get_own_channel_config(&this_ptr_conv);
13800 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13801 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13802 uint64_t ret_ref = (uint64_t)ret_var.inner;
13803 if (ret_var.is_owned) {
13809 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UserConfig_1set_1own_1channel_1config(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
13810 LDKUserConfig this_ptr_conv;
13811 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13812 this_ptr_conv.is_owned = false;
13813 LDKChannelHandshakeConfig val_conv;
13814 val_conv.inner = (void*)(val & (~1));
13815 val_conv.is_owned = (val & 1) || (val == 0);
13816 val_conv = ChannelHandshakeConfig_clone(&val_conv);
13817 UserConfig_set_own_channel_config(&this_ptr_conv, val_conv);
13820 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UserConfig_1get_1peer_1channel_1config_1limits(JNIEnv *env, jclass clz, int64_t this_ptr) {
13821 LDKUserConfig this_ptr_conv;
13822 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13823 this_ptr_conv.is_owned = false;
13824 LDKChannelHandshakeLimits ret_var = UserConfig_get_peer_channel_config_limits(&this_ptr_conv);
13825 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13826 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13827 uint64_t ret_ref = (uint64_t)ret_var.inner;
13828 if (ret_var.is_owned) {
13834 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UserConfig_1set_1peer_1channel_1config_1limits(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
13835 LDKUserConfig this_ptr_conv;
13836 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13837 this_ptr_conv.is_owned = false;
13838 LDKChannelHandshakeLimits val_conv;
13839 val_conv.inner = (void*)(val & (~1));
13840 val_conv.is_owned = (val & 1) || (val == 0);
13841 val_conv = ChannelHandshakeLimits_clone(&val_conv);
13842 UserConfig_set_peer_channel_config_limits(&this_ptr_conv, val_conv);
13845 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UserConfig_1get_1channel_1options(JNIEnv *env, jclass clz, int64_t this_ptr) {
13846 LDKUserConfig this_ptr_conv;
13847 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13848 this_ptr_conv.is_owned = false;
13849 LDKChannelConfig ret_var = UserConfig_get_channel_options(&this_ptr_conv);
13850 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13851 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13852 uint64_t ret_ref = (uint64_t)ret_var.inner;
13853 if (ret_var.is_owned) {
13859 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UserConfig_1set_1channel_1options(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
13860 LDKUserConfig this_ptr_conv;
13861 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13862 this_ptr_conv.is_owned = false;
13863 LDKChannelConfig val_conv;
13864 val_conv.inner = (void*)(val & (~1));
13865 val_conv.is_owned = (val & 1) || (val == 0);
13866 val_conv = ChannelConfig_clone(&val_conv);
13867 UserConfig_set_channel_options(&this_ptr_conv, val_conv);
13870 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_UserConfig_1get_1accept_1forwards_1to_1priv_1channels(JNIEnv *env, jclass clz, int64_t this_ptr) {
13871 LDKUserConfig this_ptr_conv;
13872 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13873 this_ptr_conv.is_owned = false;
13874 jboolean ret_val = UserConfig_get_accept_forwards_to_priv_channels(&this_ptr_conv);
13878 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UserConfig_1set_1accept_1forwards_1to_1priv_1channels(JNIEnv *env, jclass clz, int64_t this_ptr, jboolean val) {
13879 LDKUserConfig this_ptr_conv;
13880 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13881 this_ptr_conv.is_owned = false;
13882 UserConfig_set_accept_forwards_to_priv_channels(&this_ptr_conv, val);
13885 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UserConfig_1new(JNIEnv *env, jclass clz, int64_t own_channel_config_arg, int64_t peer_channel_config_limits_arg, int64_t channel_options_arg, jboolean accept_forwards_to_priv_channels_arg) {
13886 LDKChannelHandshakeConfig own_channel_config_arg_conv;
13887 own_channel_config_arg_conv.inner = (void*)(own_channel_config_arg & (~1));
13888 own_channel_config_arg_conv.is_owned = (own_channel_config_arg & 1) || (own_channel_config_arg == 0);
13889 own_channel_config_arg_conv = ChannelHandshakeConfig_clone(&own_channel_config_arg_conv);
13890 LDKChannelHandshakeLimits peer_channel_config_limits_arg_conv;
13891 peer_channel_config_limits_arg_conv.inner = (void*)(peer_channel_config_limits_arg & (~1));
13892 peer_channel_config_limits_arg_conv.is_owned = (peer_channel_config_limits_arg & 1) || (peer_channel_config_limits_arg == 0);
13893 peer_channel_config_limits_arg_conv = ChannelHandshakeLimits_clone(&peer_channel_config_limits_arg_conv);
13894 LDKChannelConfig channel_options_arg_conv;
13895 channel_options_arg_conv.inner = (void*)(channel_options_arg & (~1));
13896 channel_options_arg_conv.is_owned = (channel_options_arg & 1) || (channel_options_arg == 0);
13897 channel_options_arg_conv = ChannelConfig_clone(&channel_options_arg_conv);
13898 LDKUserConfig ret_var = UserConfig_new(own_channel_config_arg_conv, peer_channel_config_limits_arg_conv, channel_options_arg_conv, accept_forwards_to_priv_channels_arg);
13899 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13900 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13901 uint64_t ret_ref = (uint64_t)ret_var.inner;
13902 if (ret_var.is_owned) {
13908 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UserConfig_1clone(JNIEnv *env, jclass clz, int64_t orig) {
13909 LDKUserConfig orig_conv;
13910 orig_conv.inner = (void*)(orig & (~1));
13911 orig_conv.is_owned = false;
13912 LDKUserConfig ret_var = UserConfig_clone(&orig_conv);
13913 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13914 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13915 uint64_t ret_ref = (uint64_t)ret_var.inner;
13916 if (ret_var.is_owned) {
13922 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UserConfig_1default(JNIEnv *env, jclass clz) {
13923 LDKUserConfig ret_var = UserConfig_default();
13924 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13925 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13926 uint64_t ret_ref = (uint64_t)ret_var.inner;
13927 if (ret_var.is_owned) {
13933 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_BestBlock_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
13934 LDKBestBlock this_obj_conv;
13935 this_obj_conv.inner = (void*)(this_obj & (~1));
13936 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
13937 BestBlock_free(this_obj_conv);
13940 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_BestBlock_1clone(JNIEnv *env, jclass clz, int64_t orig) {
13941 LDKBestBlock orig_conv;
13942 orig_conv.inner = (void*)(orig & (~1));
13943 orig_conv.is_owned = false;
13944 LDKBestBlock ret_var = BestBlock_clone(&orig_conv);
13945 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13946 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13947 uint64_t ret_ref = (uint64_t)ret_var.inner;
13948 if (ret_var.is_owned) {
13954 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_BestBlock_1from_1genesis(JNIEnv *env, jclass clz, jclass network) {
13955 LDKNetwork network_conv = LDKNetwork_from_java(env, network);
13956 LDKBestBlock ret_var = BestBlock_from_genesis(network_conv);
13957 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13958 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13959 uint64_t ret_ref = (uint64_t)ret_var.inner;
13960 if (ret_var.is_owned) {
13966 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_BestBlock_1new(JNIEnv *env, jclass clz, int8_tArray block_hash, int32_t height) {
13967 LDKThirtyTwoBytes block_hash_ref;
13968 CHECK((*env)->GetArrayLength(env, block_hash) == 32);
13969 (*env)->GetByteArrayRegion(env, block_hash, 0, 32, block_hash_ref.data);
13970 LDKBestBlock ret_var = BestBlock_new(block_hash_ref, height);
13971 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13972 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13973 uint64_t ret_ref = (uint64_t)ret_var.inner;
13974 if (ret_var.is_owned) {
13980 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_BestBlock_1block_1hash(JNIEnv *env, jclass clz, int64_t this_arg) {
13981 LDKBestBlock this_arg_conv;
13982 this_arg_conv.inner = (void*)(this_arg & (~1));
13983 this_arg_conv.is_owned = false;
13984 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
13985 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, BestBlock_block_hash(&this_arg_conv).data);
13989 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_BestBlock_1height(JNIEnv *env, jclass clz, int64_t this_arg) {
13990 LDKBestBlock this_arg_conv;
13991 this_arg_conv.inner = (void*)(this_arg & (~1));
13992 this_arg_conv.is_owned = false;
13993 int32_t ret_val = BestBlock_height(&this_arg_conv);
13997 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_AccessError_1clone(JNIEnv *env, jclass clz, int64_t orig) {
13998 LDKAccessError* orig_conv = (LDKAccessError*)(orig & ~1);
13999 jclass ret_conv = LDKAccessError_to_java(env, AccessError_clone(orig_conv));
14003 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Access_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
14004 if ((this_ptr & 1) != 0) return;
14005 LDKAccess this_ptr_conv = *(LDKAccess*)(((uint64_t)this_ptr) & ~1);
14006 FREE((void*)this_ptr);
14007 Access_free(this_ptr_conv);
14010 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Listen_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
14011 if ((this_ptr & 1) != 0) return;
14012 LDKListen this_ptr_conv = *(LDKListen*)(((uint64_t)this_ptr) & ~1);
14013 FREE((void*)this_ptr);
14014 Listen_free(this_ptr_conv);
14017 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Confirm_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
14018 if ((this_ptr & 1) != 0) return;
14019 LDKConfirm this_ptr_conv = *(LDKConfirm*)(((uint64_t)this_ptr) & ~1);
14020 FREE((void*)this_ptr);
14021 Confirm_free(this_ptr_conv);
14024 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Watch_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
14025 if ((this_ptr & 1) != 0) return;
14026 LDKWatch this_ptr_conv = *(LDKWatch*)(((uint64_t)this_ptr) & ~1);
14027 FREE((void*)this_ptr);
14028 Watch_free(this_ptr_conv);
14031 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Filter_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
14032 if ((this_ptr & 1) != 0) return;
14033 LDKFilter this_ptr_conv = *(LDKFilter*)(((uint64_t)this_ptr) & ~1);
14034 FREE((void*)this_ptr);
14035 Filter_free(this_ptr_conv);
14038 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_WatchedOutput_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
14039 LDKWatchedOutput this_obj_conv;
14040 this_obj_conv.inner = (void*)(this_obj & (~1));
14041 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
14042 WatchedOutput_free(this_obj_conv);
14045 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_WatchedOutput_1get_1block_1hash(JNIEnv *env, jclass clz, int64_t this_ptr) {
14046 LDKWatchedOutput this_ptr_conv;
14047 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14048 this_ptr_conv.is_owned = false;
14049 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
14050 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, WatchedOutput_get_block_hash(&this_ptr_conv).data);
14054 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_WatchedOutput_1set_1block_1hash(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
14055 LDKWatchedOutput this_ptr_conv;
14056 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14057 this_ptr_conv.is_owned = false;
14058 LDKThirtyTwoBytes val_ref;
14059 CHECK((*env)->GetArrayLength(env, val) == 32);
14060 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
14061 WatchedOutput_set_block_hash(&this_ptr_conv, val_ref);
14064 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_WatchedOutput_1get_1outpoint(JNIEnv *env, jclass clz, int64_t this_ptr) {
14065 LDKWatchedOutput this_ptr_conv;
14066 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14067 this_ptr_conv.is_owned = false;
14068 LDKOutPoint ret_var = WatchedOutput_get_outpoint(&this_ptr_conv);
14069 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14070 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14071 uint64_t ret_ref = (uint64_t)ret_var.inner;
14072 if (ret_var.is_owned) {
14078 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_WatchedOutput_1set_1outpoint(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
14079 LDKWatchedOutput this_ptr_conv;
14080 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14081 this_ptr_conv.is_owned = false;
14082 LDKOutPoint val_conv;
14083 val_conv.inner = (void*)(val & (~1));
14084 val_conv.is_owned = (val & 1) || (val == 0);
14085 val_conv = OutPoint_clone(&val_conv);
14086 WatchedOutput_set_outpoint(&this_ptr_conv, val_conv);
14089 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_WatchedOutput_1get_1script_1pubkey(JNIEnv *env, jclass clz, int64_t this_ptr) {
14090 LDKWatchedOutput this_ptr_conv;
14091 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14092 this_ptr_conv.is_owned = false;
14093 LDKu8slice ret_var = WatchedOutput_get_script_pubkey(&this_ptr_conv);
14094 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
14095 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
14099 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_WatchedOutput_1set_1script_1pubkey(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
14100 LDKWatchedOutput this_ptr_conv;
14101 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14102 this_ptr_conv.is_owned = false;
14103 LDKCVec_u8Z val_ref;
14104 val_ref.datalen = (*env)->GetArrayLength(env, val);
14105 val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
14106 (*env)->GetByteArrayRegion(env, val, 0, val_ref.datalen, val_ref.data);
14107 WatchedOutput_set_script_pubkey(&this_ptr_conv, val_ref);
14110 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_WatchedOutput_1new(JNIEnv *env, jclass clz, int8_tArray block_hash_arg, int64_t outpoint_arg, int8_tArray script_pubkey_arg) {
14111 LDKThirtyTwoBytes block_hash_arg_ref;
14112 CHECK((*env)->GetArrayLength(env, block_hash_arg) == 32);
14113 (*env)->GetByteArrayRegion(env, block_hash_arg, 0, 32, block_hash_arg_ref.data);
14114 LDKOutPoint outpoint_arg_conv;
14115 outpoint_arg_conv.inner = (void*)(outpoint_arg & (~1));
14116 outpoint_arg_conv.is_owned = (outpoint_arg & 1) || (outpoint_arg == 0);
14117 outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
14118 LDKCVec_u8Z script_pubkey_arg_ref;
14119 script_pubkey_arg_ref.datalen = (*env)->GetArrayLength(env, script_pubkey_arg);
14120 script_pubkey_arg_ref.data = MALLOC(script_pubkey_arg_ref.datalen, "LDKCVec_u8Z Bytes");
14121 (*env)->GetByteArrayRegion(env, script_pubkey_arg, 0, script_pubkey_arg_ref.datalen, script_pubkey_arg_ref.data);
14122 LDKWatchedOutput ret_var = WatchedOutput_new(block_hash_arg_ref, outpoint_arg_conv, script_pubkey_arg_ref);
14123 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14124 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14125 uint64_t ret_ref = (uint64_t)ret_var.inner;
14126 if (ret_var.is_owned) {
14132 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_WatchedOutput_1clone(JNIEnv *env, jclass clz, int64_t orig) {
14133 LDKWatchedOutput orig_conv;
14134 orig_conv.inner = (void*)(orig & (~1));
14135 orig_conv.is_owned = false;
14136 LDKWatchedOutput ret_var = WatchedOutput_clone(&orig_conv);
14137 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14138 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14139 uint64_t ret_ref = (uint64_t)ret_var.inner;
14140 if (ret_var.is_owned) {
14146 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_WatchedOutput_1hash(JNIEnv *env, jclass clz, int64_t o) {
14147 LDKWatchedOutput o_conv;
14148 o_conv.inner = (void*)(o & (~1));
14149 o_conv.is_owned = false;
14150 int64_t ret_val = WatchedOutput_hash(&o_conv);
14154 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_BroadcasterInterface_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
14155 if ((this_ptr & 1) != 0) return;
14156 LDKBroadcasterInterface this_ptr_conv = *(LDKBroadcasterInterface*)(((uint64_t)this_ptr) & ~1);
14157 FREE((void*)this_ptr);
14158 BroadcasterInterface_free(this_ptr_conv);
14161 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_ConfirmationTarget_1clone(JNIEnv *env, jclass clz, int64_t orig) {
14162 LDKConfirmationTarget* orig_conv = (LDKConfirmationTarget*)(orig & ~1);
14163 jclass ret_conv = LDKConfirmationTarget_to_java(env, ConfirmationTarget_clone(orig_conv));
14167 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_FeeEstimator_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
14168 if ((this_ptr & 1) != 0) return;
14169 LDKFeeEstimator this_ptr_conv = *(LDKFeeEstimator*)(((uint64_t)this_ptr) & ~1);
14170 FREE((void*)this_ptr);
14171 FeeEstimator_free(this_ptr_conv);
14174 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChainMonitor_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
14175 LDKChainMonitor this_obj_conv;
14176 this_obj_conv.inner = (void*)(this_obj & (~1));
14177 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
14178 ChainMonitor_free(this_obj_conv);
14181 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChainMonitor_1new(JNIEnv *env, jclass clz, int64_t chain_source, int64_t broadcaster, int64_t logger, int64_t feeest, int64_t persister) {
14182 LDKFilter *chain_source_conv_ptr = NULL;
14183 if (chain_source != 0) {
14184 LDKFilter chain_source_conv;
14185 chain_source_conv = *(LDKFilter*)(((uint64_t)chain_source) & ~1);
14186 if (chain_source_conv.free == LDKFilter_JCalls_free) {
14187 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
14188 LDKFilter_JCalls_clone(chain_source_conv.this_arg);
14190 chain_source_conv_ptr = MALLOC(sizeof(LDKFilter), "LDKFilter");
14191 *chain_source_conv_ptr = chain_source_conv;
14193 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(((uint64_t)broadcaster) & ~1);
14194 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
14195 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
14196 LDKBroadcasterInterface_JCalls_clone(broadcaster_conv.this_arg);
14198 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
14199 if (logger_conv.free == LDKLogger_JCalls_free) {
14200 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
14201 LDKLogger_JCalls_clone(logger_conv.this_arg);
14203 LDKFeeEstimator feeest_conv = *(LDKFeeEstimator*)(((uint64_t)feeest) & ~1);
14204 if (feeest_conv.free == LDKFeeEstimator_JCalls_free) {
14205 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
14206 LDKFeeEstimator_JCalls_clone(feeest_conv.this_arg);
14208 LDKPersist persister_conv = *(LDKPersist*)(((uint64_t)persister) & ~1);
14209 if (persister_conv.free == LDKPersist_JCalls_free) {
14210 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
14211 LDKPersist_JCalls_clone(persister_conv.this_arg);
14213 LDKChainMonitor ret_var = ChainMonitor_new(chain_source_conv_ptr, broadcaster_conv, logger_conv, feeest_conv, persister_conv);
14214 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14215 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14216 uint64_t ret_ref = (uint64_t)ret_var.inner;
14217 if (ret_var.is_owned) {
14223 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChainMonitor_1as_1Listen(JNIEnv *env, jclass clz, int64_t this_arg) {
14224 LDKChainMonitor this_arg_conv;
14225 this_arg_conv.inner = (void*)(this_arg & (~1));
14226 this_arg_conv.is_owned = false;
14227 LDKListen* ret = MALLOC(sizeof(LDKListen), "LDKListen");
14228 *ret = ChainMonitor_as_Listen(&this_arg_conv);
14229 return (uint64_t)ret;
14232 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChainMonitor_1as_1Confirm(JNIEnv *env, jclass clz, int64_t this_arg) {
14233 LDKChainMonitor this_arg_conv;
14234 this_arg_conv.inner = (void*)(this_arg & (~1));
14235 this_arg_conv.is_owned = false;
14236 LDKConfirm* ret = MALLOC(sizeof(LDKConfirm), "LDKConfirm");
14237 *ret = ChainMonitor_as_Confirm(&this_arg_conv);
14238 return (uint64_t)ret;
14241 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChainMonitor_1as_1Watch(JNIEnv *env, jclass clz, int64_t this_arg) {
14242 LDKChainMonitor this_arg_conv;
14243 this_arg_conv.inner = (void*)(this_arg & (~1));
14244 this_arg_conv.is_owned = false;
14245 LDKWatch* ret = MALLOC(sizeof(LDKWatch), "LDKWatch");
14246 *ret = ChainMonitor_as_Watch(&this_arg_conv);
14247 return (uint64_t)ret;
14250 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChainMonitor_1as_1EventsProvider(JNIEnv *env, jclass clz, int64_t this_arg) {
14251 LDKChainMonitor this_arg_conv;
14252 this_arg_conv.inner = (void*)(this_arg & (~1));
14253 this_arg_conv.is_owned = false;
14254 LDKEventsProvider* ret = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider");
14255 *ret = ChainMonitor_as_EventsProvider(&this_arg_conv);
14256 return (uint64_t)ret;
14259 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMonitorUpdate_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
14260 LDKChannelMonitorUpdate this_obj_conv;
14261 this_obj_conv.inner = (void*)(this_obj & (~1));
14262 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
14263 ChannelMonitorUpdate_free(this_obj_conv);
14266 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelMonitorUpdate_1get_1update_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
14267 LDKChannelMonitorUpdate this_ptr_conv;
14268 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14269 this_ptr_conv.is_owned = false;
14270 int64_t ret_val = ChannelMonitorUpdate_get_update_id(&this_ptr_conv);
14274 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMonitorUpdate_1set_1update_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
14275 LDKChannelMonitorUpdate this_ptr_conv;
14276 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14277 this_ptr_conv.is_owned = false;
14278 ChannelMonitorUpdate_set_update_id(&this_ptr_conv, val);
14281 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelMonitorUpdate_1clone(JNIEnv *env, jclass clz, int64_t orig) {
14282 LDKChannelMonitorUpdate orig_conv;
14283 orig_conv.inner = (void*)(orig & (~1));
14284 orig_conv.is_owned = false;
14285 LDKChannelMonitorUpdate ret_var = ChannelMonitorUpdate_clone(&orig_conv);
14286 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14287 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14288 uint64_t ret_ref = (uint64_t)ret_var.inner;
14289 if (ret_var.is_owned) {
14295 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelMonitorUpdate_1write(JNIEnv *env, jclass clz, int64_t obj) {
14296 LDKChannelMonitorUpdate obj_conv;
14297 obj_conv.inner = (void*)(obj & (~1));
14298 obj_conv.is_owned = false;
14299 LDKCVec_u8Z ret_var = ChannelMonitorUpdate_write(&obj_conv);
14300 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
14301 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
14302 CVec_u8Z_free(ret_var);
14306 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelMonitorUpdate_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
14307 LDKu8slice ser_ref;
14308 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
14309 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
14310 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
14311 *ret_conv = ChannelMonitorUpdate_read(ser_ref);
14312 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
14313 return (uint64_t)ret_conv;
14316 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_ChannelMonitorUpdateErr_1clone(JNIEnv *env, jclass clz, int64_t orig) {
14317 LDKChannelMonitorUpdateErr* orig_conv = (LDKChannelMonitorUpdateErr*)(orig & ~1);
14318 jclass ret_conv = LDKChannelMonitorUpdateErr_to_java(env, ChannelMonitorUpdateErr_clone(orig_conv));
14322 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_MonitorUpdateError_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
14323 LDKMonitorUpdateError this_obj_conv;
14324 this_obj_conv.inner = (void*)(this_obj & (~1));
14325 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
14326 MonitorUpdateError_free(this_obj_conv);
14329 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MonitorUpdateError_1clone(JNIEnv *env, jclass clz, int64_t orig) {
14330 LDKMonitorUpdateError orig_conv;
14331 orig_conv.inner = (void*)(orig & (~1));
14332 orig_conv.is_owned = false;
14333 LDKMonitorUpdateError ret_var = MonitorUpdateError_clone(&orig_conv);
14334 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14335 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14336 uint64_t ret_ref = (uint64_t)ret_var.inner;
14337 if (ret_var.is_owned) {
14343 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_MonitorEvent_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
14344 if ((this_ptr & 1) != 0) return;
14345 LDKMonitorEvent this_ptr_conv = *(LDKMonitorEvent*)(((uint64_t)this_ptr) & ~1);
14346 FREE((void*)this_ptr);
14347 MonitorEvent_free(this_ptr_conv);
14350 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MonitorEvent_1clone(JNIEnv *env, jclass clz, int64_t orig) {
14351 LDKMonitorEvent* orig_conv = (LDKMonitorEvent*)orig;
14352 LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
14353 *ret_copy = MonitorEvent_clone(orig_conv);
14354 uint64_t ret_ref = (uint64_t)ret_copy;
14358 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_HTLCUpdate_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
14359 LDKHTLCUpdate this_obj_conv;
14360 this_obj_conv.inner = (void*)(this_obj & (~1));
14361 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
14362 HTLCUpdate_free(this_obj_conv);
14365 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_HTLCUpdate_1clone(JNIEnv *env, jclass clz, int64_t orig) {
14366 LDKHTLCUpdate orig_conv;
14367 orig_conv.inner = (void*)(orig & (~1));
14368 orig_conv.is_owned = false;
14369 LDKHTLCUpdate ret_var = HTLCUpdate_clone(&orig_conv);
14370 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14371 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14372 uint64_t ret_ref = (uint64_t)ret_var.inner;
14373 if (ret_var.is_owned) {
14379 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_HTLCUpdate_1write(JNIEnv *env, jclass clz, int64_t obj) {
14380 LDKHTLCUpdate obj_conv;
14381 obj_conv.inner = (void*)(obj & (~1));
14382 obj_conv.is_owned = false;
14383 LDKCVec_u8Z ret_var = HTLCUpdate_write(&obj_conv);
14384 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
14385 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
14386 CVec_u8Z_free(ret_var);
14390 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_HTLCUpdate_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
14391 LDKu8slice ser_ref;
14392 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
14393 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
14394 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
14395 *ret_conv = HTLCUpdate_read(ser_ref);
14396 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
14397 return (uint64_t)ret_conv;
14400 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMonitor_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
14401 LDKChannelMonitor this_obj_conv;
14402 this_obj_conv.inner = (void*)(this_obj & (~1));
14403 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
14404 ChannelMonitor_free(this_obj_conv);
14407 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelMonitor_1clone(JNIEnv *env, jclass clz, int64_t orig) {
14408 LDKChannelMonitor orig_conv;
14409 orig_conv.inner = (void*)(orig & (~1));
14410 orig_conv.is_owned = false;
14411 LDKChannelMonitor ret_var = ChannelMonitor_clone(&orig_conv);
14412 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14413 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14414 uint64_t ret_ref = (uint64_t)ret_var.inner;
14415 if (ret_var.is_owned) {
14421 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelMonitor_1write(JNIEnv *env, jclass clz, int64_t obj) {
14422 LDKChannelMonitor obj_conv;
14423 obj_conv.inner = (void*)(obj & (~1));
14424 obj_conv.is_owned = false;
14425 LDKCVec_u8Z ret_var = ChannelMonitor_write(&obj_conv);
14426 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
14427 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
14428 CVec_u8Z_free(ret_var);
14432 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelMonitor_1update_1monitor(JNIEnv *env, jclass clz, int64_t this_arg, int64_t updates, int64_t broadcaster, int64_t fee_estimator, int64_t logger) {
14433 LDKChannelMonitor this_arg_conv;
14434 this_arg_conv.inner = (void*)(this_arg & (~1));
14435 this_arg_conv.is_owned = false;
14436 LDKChannelMonitorUpdate updates_conv;
14437 updates_conv.inner = (void*)(updates & (~1));
14438 updates_conv.is_owned = false;
14439 LDKBroadcasterInterface* broadcaster_conv = (LDKBroadcasterInterface*)(((uint64_t)broadcaster) & ~1);
14440 LDKFeeEstimator* fee_estimator_conv = (LDKFeeEstimator*)(((uint64_t)fee_estimator) & ~1);
14441 LDKLogger* logger_conv = (LDKLogger*)(((uint64_t)logger) & ~1);
14442 LDKCResult_NoneMonitorUpdateErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneMonitorUpdateErrorZ), "LDKCResult_NoneMonitorUpdateErrorZ");
14443 *ret_conv = ChannelMonitor_update_monitor(&this_arg_conv, &updates_conv, broadcaster_conv, fee_estimator_conv, logger_conv);
14444 return (uint64_t)ret_conv;
14447 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelMonitor_1get_1latest_1update_1id(JNIEnv *env, jclass clz, int64_t this_arg) {
14448 LDKChannelMonitor this_arg_conv;
14449 this_arg_conv.inner = (void*)(this_arg & (~1));
14450 this_arg_conv.is_owned = false;
14451 int64_t ret_val = ChannelMonitor_get_latest_update_id(&this_arg_conv);
14455 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelMonitor_1get_1funding_1txo(JNIEnv *env, jclass clz, int64_t this_arg) {
14456 LDKChannelMonitor this_arg_conv;
14457 this_arg_conv.inner = (void*)(this_arg & (~1));
14458 this_arg_conv.is_owned = false;
14459 LDKC2Tuple_OutPointScriptZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
14460 *ret_ref = ChannelMonitor_get_funding_txo(&this_arg_conv);
14461 return (uint64_t)ret_ref;
14464 JNIEXPORT int64_tArray JNICALL Java_org_ldk_impl_bindings_ChannelMonitor_1get_1outputs_1to_1watch(JNIEnv *env, jclass clz, int64_t this_arg) {
14465 LDKChannelMonitor this_arg_conv;
14466 this_arg_conv.inner = (void*)(this_arg & (~1));
14467 this_arg_conv.is_owned = false;
14468 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ret_var = ChannelMonitor_get_outputs_to_watch(&this_arg_conv);
14469 int64_tArray ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
14470 int64_t *ret_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, ret_arr, NULL);
14471 for (size_t v = 0; v < ret_var.datalen; v++) {
14472 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv_47_ref = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
14473 *ret_conv_47_ref = ret_var.data[v];
14474 ret_arr_ptr[v] = (uint64_t)ret_conv_47_ref;
14476 (*env)->ReleasePrimitiveArrayCritical(env, ret_arr, ret_arr_ptr, 0);
14477 FREE(ret_var.data);
14481 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMonitor_1load_1outputs_1to_1watch(JNIEnv *env, jclass clz, int64_t this_arg, int64_t filter) {
14482 LDKChannelMonitor this_arg_conv;
14483 this_arg_conv.inner = (void*)(this_arg & (~1));
14484 this_arg_conv.is_owned = false;
14485 LDKFilter* filter_conv = (LDKFilter*)(((uint64_t)filter) & ~1);
14486 ChannelMonitor_load_outputs_to_watch(&this_arg_conv, filter_conv);
14489 JNIEXPORT int64_tArray JNICALL Java_org_ldk_impl_bindings_ChannelMonitor_1get_1and_1clear_1pending_1monitor_1events(JNIEnv *env, jclass clz, int64_t this_arg) {
14490 LDKChannelMonitor this_arg_conv;
14491 this_arg_conv.inner = (void*)(this_arg & (~1));
14492 this_arg_conv.is_owned = false;
14493 LDKCVec_MonitorEventZ ret_var = ChannelMonitor_get_and_clear_pending_monitor_events(&this_arg_conv);
14494 int64_tArray ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
14495 int64_t *ret_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, ret_arr, NULL);
14496 for (size_t o = 0; o < ret_var.datalen; o++) {
14497 LDKMonitorEvent *ret_conv_14_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
14498 *ret_conv_14_copy = MonitorEvent_clone(&ret_var.data[o]);
14499 uint64_t ret_conv_14_ref = (uint64_t)ret_conv_14_copy;
14500 ret_arr_ptr[o] = ret_conv_14_ref;
14502 (*env)->ReleasePrimitiveArrayCritical(env, ret_arr, ret_arr_ptr, 0);
14503 FREE(ret_var.data);
14507 JNIEXPORT int64_tArray JNICALL Java_org_ldk_impl_bindings_ChannelMonitor_1get_1and_1clear_1pending_1events(JNIEnv *env, jclass clz, int64_t this_arg) {
14508 LDKChannelMonitor this_arg_conv;
14509 this_arg_conv.inner = (void*)(this_arg & (~1));
14510 this_arg_conv.is_owned = false;
14511 LDKCVec_EventZ ret_var = ChannelMonitor_get_and_clear_pending_events(&this_arg_conv);
14512 int64_tArray ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
14513 int64_t *ret_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, ret_arr, NULL);
14514 for (size_t h = 0; h < ret_var.datalen; h++) {
14515 LDKEvent *ret_conv_7_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
14516 *ret_conv_7_copy = Event_clone(&ret_var.data[h]);
14517 uint64_t ret_conv_7_ref = (uint64_t)ret_conv_7_copy;
14518 ret_arr_ptr[h] = ret_conv_7_ref;
14520 (*env)->ReleasePrimitiveArrayCritical(env, ret_arr, ret_arr_ptr, 0);
14521 FREE(ret_var.data);
14525 JNIEXPORT jobjectArray JNICALL Java_org_ldk_impl_bindings_ChannelMonitor_1get_1latest_1holder_1commitment_1txn(JNIEnv *env, jclass clz, int64_t this_arg, int64_t logger) {
14526 LDKChannelMonitor this_arg_conv;
14527 this_arg_conv.inner = (void*)(this_arg & (~1));
14528 this_arg_conv.is_owned = false;
14529 LDKLogger* logger_conv = (LDKLogger*)(((uint64_t)logger) & ~1);
14530 LDKCVec_TransactionZ ret_var = ChannelMonitor_get_latest_holder_commitment_txn(&this_arg_conv, logger_conv);
14531 jobjectArray ret_arr = (*env)->NewObjectArray(env, ret_var.datalen, arr_of_B_clz, NULL);
14533 for (size_t i = 0; i < ret_var.datalen; i++) {
14534 LDKTransaction ret_conv_8_var = ret_var.data[i];
14535 int8_tArray ret_conv_8_arr = (*env)->NewByteArray(env, ret_conv_8_var.datalen);
14536 (*env)->SetByteArrayRegion(env, ret_conv_8_arr, 0, ret_conv_8_var.datalen, ret_conv_8_var.data);
14537 Transaction_free(ret_conv_8_var);
14538 (*env)->SetObjectArrayElement(env, ret_arr, i, ret_conv_8_arr);
14540 FREE(ret_var.data);
14544 JNIEXPORT int64_tArray JNICALL Java_org_ldk_impl_bindings_ChannelMonitor_1block_1connected(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray header, int64_tArray txdata, int32_t height, int64_t broadcaster, int64_t fee_estimator, int64_t logger) {
14545 LDKChannelMonitor this_arg_conv;
14546 this_arg_conv.inner = (void*)(this_arg & (~1));
14547 this_arg_conv.is_owned = false;
14548 unsigned char header_arr[80];
14549 CHECK((*env)->GetArrayLength(env, header) == 80);
14550 (*env)->GetByteArrayRegion(env, header, 0, 80, header_arr);
14551 unsigned char (*header_ref)[80] = &header_arr;
14552 LDKCVec_C2Tuple_usizeTransactionZZ txdata_constr;
14553 txdata_constr.datalen = (*env)->GetArrayLength(env, txdata);
14554 if (txdata_constr.datalen > 0)
14555 txdata_constr.data = MALLOC(txdata_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
14557 txdata_constr.data = NULL;
14558 int64_t* txdata_vals = (*env)->GetLongArrayElements (env, txdata, NULL);
14559 for (size_t y = 0; y < txdata_constr.datalen; y++) {
14560 int64_t txdata_conv_24 = txdata_vals[y];
14561 LDKC2Tuple_usizeTransactionZ txdata_conv_24_conv = *(LDKC2Tuple_usizeTransactionZ*)(((uint64_t)txdata_conv_24) & ~1);
14562 txdata_conv_24_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)(((uint64_t)txdata_conv_24) & ~1));
14563 txdata_constr.data[y] = txdata_conv_24_conv;
14565 (*env)->ReleaseLongArrayElements(env, txdata, txdata_vals, 0);
14566 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(((uint64_t)broadcaster) & ~1);
14567 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
14568 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
14569 LDKBroadcasterInterface_JCalls_clone(broadcaster_conv.this_arg);
14571 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(((uint64_t)fee_estimator) & ~1);
14572 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
14573 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
14574 LDKFeeEstimator_JCalls_clone(fee_estimator_conv.this_arg);
14576 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
14577 if (logger_conv.free == LDKLogger_JCalls_free) {
14578 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
14579 LDKLogger_JCalls_clone(logger_conv.this_arg);
14581 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ret_var = ChannelMonitor_block_connected(&this_arg_conv, header_ref, txdata_constr, height, broadcaster_conv, fee_estimator_conv, logger_conv);
14582 int64_tArray ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
14583 int64_t *ret_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, ret_arr, NULL);
14584 for (size_t u = 0; u < ret_var.datalen; u++) {
14585 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv_46_ref = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
14586 *ret_conv_46_ref = ret_var.data[u];
14587 ret_arr_ptr[u] = (uint64_t)ret_conv_46_ref;
14589 (*env)->ReleasePrimitiveArrayCritical(env, ret_arr, ret_arr_ptr, 0);
14590 FREE(ret_var.data);
14594 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMonitor_1block_1disconnected(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray header, int32_t height, int64_t broadcaster, int64_t fee_estimator, int64_t logger) {
14595 LDKChannelMonitor this_arg_conv;
14596 this_arg_conv.inner = (void*)(this_arg & (~1));
14597 this_arg_conv.is_owned = false;
14598 unsigned char header_arr[80];
14599 CHECK((*env)->GetArrayLength(env, header) == 80);
14600 (*env)->GetByteArrayRegion(env, header, 0, 80, header_arr);
14601 unsigned char (*header_ref)[80] = &header_arr;
14602 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(((uint64_t)broadcaster) & ~1);
14603 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
14604 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
14605 LDKBroadcasterInterface_JCalls_clone(broadcaster_conv.this_arg);
14607 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(((uint64_t)fee_estimator) & ~1);
14608 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
14609 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
14610 LDKFeeEstimator_JCalls_clone(fee_estimator_conv.this_arg);
14612 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
14613 if (logger_conv.free == LDKLogger_JCalls_free) {
14614 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
14615 LDKLogger_JCalls_clone(logger_conv.this_arg);
14617 ChannelMonitor_block_disconnected(&this_arg_conv, header_ref, height, broadcaster_conv, fee_estimator_conv, logger_conv);
14620 JNIEXPORT int64_tArray JNICALL Java_org_ldk_impl_bindings_ChannelMonitor_1transactions_1confirmed(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray header, int64_tArray txdata, int32_t height, int64_t broadcaster, int64_t fee_estimator, int64_t logger) {
14621 LDKChannelMonitor this_arg_conv;
14622 this_arg_conv.inner = (void*)(this_arg & (~1));
14623 this_arg_conv.is_owned = false;
14624 unsigned char header_arr[80];
14625 CHECK((*env)->GetArrayLength(env, header) == 80);
14626 (*env)->GetByteArrayRegion(env, header, 0, 80, header_arr);
14627 unsigned char (*header_ref)[80] = &header_arr;
14628 LDKCVec_C2Tuple_usizeTransactionZZ txdata_constr;
14629 txdata_constr.datalen = (*env)->GetArrayLength(env, txdata);
14630 if (txdata_constr.datalen > 0)
14631 txdata_constr.data = MALLOC(txdata_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
14633 txdata_constr.data = NULL;
14634 int64_t* txdata_vals = (*env)->GetLongArrayElements (env, txdata, NULL);
14635 for (size_t y = 0; y < txdata_constr.datalen; y++) {
14636 int64_t txdata_conv_24 = txdata_vals[y];
14637 LDKC2Tuple_usizeTransactionZ txdata_conv_24_conv = *(LDKC2Tuple_usizeTransactionZ*)(((uint64_t)txdata_conv_24) & ~1);
14638 txdata_conv_24_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)(((uint64_t)txdata_conv_24) & ~1));
14639 txdata_constr.data[y] = txdata_conv_24_conv;
14641 (*env)->ReleaseLongArrayElements(env, txdata, txdata_vals, 0);
14642 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(((uint64_t)broadcaster) & ~1);
14643 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
14644 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
14645 LDKBroadcasterInterface_JCalls_clone(broadcaster_conv.this_arg);
14647 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(((uint64_t)fee_estimator) & ~1);
14648 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
14649 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
14650 LDKFeeEstimator_JCalls_clone(fee_estimator_conv.this_arg);
14652 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
14653 if (logger_conv.free == LDKLogger_JCalls_free) {
14654 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
14655 LDKLogger_JCalls_clone(logger_conv.this_arg);
14657 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ret_var = ChannelMonitor_transactions_confirmed(&this_arg_conv, header_ref, txdata_constr, height, broadcaster_conv, fee_estimator_conv, logger_conv);
14658 int64_tArray ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
14659 int64_t *ret_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, ret_arr, NULL);
14660 for (size_t u = 0; u < ret_var.datalen; u++) {
14661 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv_46_ref = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
14662 *ret_conv_46_ref = ret_var.data[u];
14663 ret_arr_ptr[u] = (uint64_t)ret_conv_46_ref;
14665 (*env)->ReleasePrimitiveArrayCritical(env, ret_arr, ret_arr_ptr, 0);
14666 FREE(ret_var.data);
14670 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMonitor_1transaction_1unconfirmed(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray txid, int64_t broadcaster, int64_t fee_estimator, int64_t logger) {
14671 LDKChannelMonitor this_arg_conv;
14672 this_arg_conv.inner = (void*)(this_arg & (~1));
14673 this_arg_conv.is_owned = false;
14674 unsigned char txid_arr[32];
14675 CHECK((*env)->GetArrayLength(env, txid) == 32);
14676 (*env)->GetByteArrayRegion(env, txid, 0, 32, txid_arr);
14677 unsigned char (*txid_ref)[32] = &txid_arr;
14678 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(((uint64_t)broadcaster) & ~1);
14679 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
14680 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
14681 LDKBroadcasterInterface_JCalls_clone(broadcaster_conv.this_arg);
14683 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(((uint64_t)fee_estimator) & ~1);
14684 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
14685 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
14686 LDKFeeEstimator_JCalls_clone(fee_estimator_conv.this_arg);
14688 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
14689 if (logger_conv.free == LDKLogger_JCalls_free) {
14690 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
14691 LDKLogger_JCalls_clone(logger_conv.this_arg);
14693 ChannelMonitor_transaction_unconfirmed(&this_arg_conv, txid_ref, broadcaster_conv, fee_estimator_conv, logger_conv);
14696 JNIEXPORT int64_tArray JNICALL Java_org_ldk_impl_bindings_ChannelMonitor_1best_1block_1updated(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray header, int32_t height, int64_t broadcaster, int64_t fee_estimator, int64_t logger) {
14697 LDKChannelMonitor this_arg_conv;
14698 this_arg_conv.inner = (void*)(this_arg & (~1));
14699 this_arg_conv.is_owned = false;
14700 unsigned char header_arr[80];
14701 CHECK((*env)->GetArrayLength(env, header) == 80);
14702 (*env)->GetByteArrayRegion(env, header, 0, 80, header_arr);
14703 unsigned char (*header_ref)[80] = &header_arr;
14704 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(((uint64_t)broadcaster) & ~1);
14705 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
14706 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
14707 LDKBroadcasterInterface_JCalls_clone(broadcaster_conv.this_arg);
14709 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(((uint64_t)fee_estimator) & ~1);
14710 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
14711 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
14712 LDKFeeEstimator_JCalls_clone(fee_estimator_conv.this_arg);
14714 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
14715 if (logger_conv.free == LDKLogger_JCalls_free) {
14716 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
14717 LDKLogger_JCalls_clone(logger_conv.this_arg);
14719 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ret_var = ChannelMonitor_best_block_updated(&this_arg_conv, header_ref, height, broadcaster_conv, fee_estimator_conv, logger_conv);
14720 int64_tArray ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
14721 int64_t *ret_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, ret_arr, NULL);
14722 for (size_t u = 0; u < ret_var.datalen; u++) {
14723 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv_46_ref = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
14724 *ret_conv_46_ref = ret_var.data[u];
14725 ret_arr_ptr[u] = (uint64_t)ret_conv_46_ref;
14727 (*env)->ReleasePrimitiveArrayCritical(env, ret_arr, ret_arr_ptr, 0);
14728 FREE(ret_var.data);
14732 JNIEXPORT jobjectArray JNICALL Java_org_ldk_impl_bindings_ChannelMonitor_1get_1relevant_1txids(JNIEnv *env, jclass clz, int64_t this_arg) {
14733 LDKChannelMonitor this_arg_conv;
14734 this_arg_conv.inner = (void*)(this_arg & (~1));
14735 this_arg_conv.is_owned = false;
14736 LDKCVec_TxidZ ret_var = ChannelMonitor_get_relevant_txids(&this_arg_conv);
14737 jobjectArray ret_arr = (*env)->NewObjectArray(env, ret_var.datalen, arr_of_B_clz, NULL);
14739 for (size_t i = 0; i < ret_var.datalen; i++) {
14740 int8_tArray ret_conv_8_arr = (*env)->NewByteArray(env, 32);
14741 (*env)->SetByteArrayRegion(env, ret_conv_8_arr, 0, 32, ret_var.data[i].data);
14742 (*env)->SetObjectArrayElement(env, ret_arr, i, ret_conv_8_arr);
14744 FREE(ret_var.data);
14748 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelMonitor_1current_1best_1block(JNIEnv *env, jclass clz, int64_t this_arg) {
14749 LDKChannelMonitor this_arg_conv;
14750 this_arg_conv.inner = (void*)(this_arg & (~1));
14751 this_arg_conv.is_owned = false;
14752 LDKBestBlock ret_var = ChannelMonitor_current_best_block(&this_arg_conv);
14753 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14754 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14755 uint64_t ret_ref = (uint64_t)ret_var.inner;
14756 if (ret_var.is_owned) {
14762 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Persist_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
14763 if ((this_ptr & 1) != 0) return;
14764 LDKPersist this_ptr_conv = *(LDKPersist*)(((uint64_t)this_ptr) & ~1);
14765 FREE((void*)this_ptr);
14766 Persist_free(this_ptr_conv);
14769 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1BlockHashChannelMonitorZ_1read(JNIEnv *env, jclass clz, int8_tArray ser, int64_t arg) {
14770 LDKu8slice ser_ref;
14771 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
14772 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
14773 LDKKeysInterface* arg_conv = (LDKKeysInterface*)(((uint64_t)arg) & ~1);
14774 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
14775 *ret_conv = C2Tuple_BlockHashChannelMonitorZ_read(ser_ref, arg_conv);
14776 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
14777 return (uint64_t)ret_conv;
14780 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OutPoint_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
14781 LDKOutPoint this_obj_conv;
14782 this_obj_conv.inner = (void*)(this_obj & (~1));
14783 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
14784 OutPoint_free(this_obj_conv);
14787 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_OutPoint_1get_1txid(JNIEnv *env, jclass clz, int64_t this_ptr) {
14788 LDKOutPoint this_ptr_conv;
14789 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14790 this_ptr_conv.is_owned = false;
14791 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
14792 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *OutPoint_get_txid(&this_ptr_conv));
14796 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OutPoint_1set_1txid(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
14797 LDKOutPoint this_ptr_conv;
14798 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14799 this_ptr_conv.is_owned = false;
14800 LDKThirtyTwoBytes val_ref;
14801 CHECK((*env)->GetArrayLength(env, val) == 32);
14802 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
14803 OutPoint_set_txid(&this_ptr_conv, val_ref);
14806 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_OutPoint_1get_1index(JNIEnv *env, jclass clz, int64_t this_ptr) {
14807 LDKOutPoint this_ptr_conv;
14808 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14809 this_ptr_conv.is_owned = false;
14810 int16_t ret_val = OutPoint_get_index(&this_ptr_conv);
14814 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OutPoint_1set_1index(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
14815 LDKOutPoint this_ptr_conv;
14816 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14817 this_ptr_conv.is_owned = false;
14818 OutPoint_set_index(&this_ptr_conv, val);
14821 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OutPoint_1new(JNIEnv *env, jclass clz, int8_tArray txid_arg, int16_t index_arg) {
14822 LDKThirtyTwoBytes txid_arg_ref;
14823 CHECK((*env)->GetArrayLength(env, txid_arg) == 32);
14824 (*env)->GetByteArrayRegion(env, txid_arg, 0, 32, txid_arg_ref.data);
14825 LDKOutPoint ret_var = OutPoint_new(txid_arg_ref, index_arg);
14826 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14827 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14828 uint64_t ret_ref = (uint64_t)ret_var.inner;
14829 if (ret_var.is_owned) {
14835 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OutPoint_1clone(JNIEnv *env, jclass clz, int64_t orig) {
14836 LDKOutPoint orig_conv;
14837 orig_conv.inner = (void*)(orig & (~1));
14838 orig_conv.is_owned = false;
14839 LDKOutPoint ret_var = OutPoint_clone(&orig_conv);
14840 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14841 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14842 uint64_t ret_ref = (uint64_t)ret_var.inner;
14843 if (ret_var.is_owned) {
14849 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_OutPoint_1eq(JNIEnv *env, jclass clz, int64_t a, int64_t b) {
14850 LDKOutPoint a_conv;
14851 a_conv.inner = (void*)(a & (~1));
14852 a_conv.is_owned = false;
14853 LDKOutPoint b_conv;
14854 b_conv.inner = (void*)(b & (~1));
14855 b_conv.is_owned = false;
14856 jboolean ret_val = OutPoint_eq(&a_conv, &b_conv);
14860 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OutPoint_1hash(JNIEnv *env, jclass clz, int64_t o) {
14861 LDKOutPoint o_conv;
14862 o_conv.inner = (void*)(o & (~1));
14863 o_conv.is_owned = false;
14864 int64_t ret_val = OutPoint_hash(&o_conv);
14868 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_OutPoint_1to_1channel_1id(JNIEnv *env, jclass clz, int64_t this_arg) {
14869 LDKOutPoint this_arg_conv;
14870 this_arg_conv.inner = (void*)(this_arg & (~1));
14871 this_arg_conv.is_owned = false;
14872 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
14873 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, OutPoint_to_channel_id(&this_arg_conv).data);
14877 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_OutPoint_1write(JNIEnv *env, jclass clz, int64_t obj) {
14878 LDKOutPoint obj_conv;
14879 obj_conv.inner = (void*)(obj & (~1));
14880 obj_conv.is_owned = false;
14881 LDKCVec_u8Z ret_var = OutPoint_write(&obj_conv);
14882 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
14883 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
14884 CVec_u8Z_free(ret_var);
14888 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OutPoint_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
14889 LDKu8slice ser_ref;
14890 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
14891 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
14892 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
14893 *ret_conv = OutPoint_read(ser_ref);
14894 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
14895 return (uint64_t)ret_conv;
14898 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
14899 LDKDelayedPaymentOutputDescriptor this_obj_conv;
14900 this_obj_conv.inner = (void*)(this_obj & (~1));
14901 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
14902 DelayedPaymentOutputDescriptor_free(this_obj_conv);
14905 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1get_1outpoint(JNIEnv *env, jclass clz, int64_t this_ptr) {
14906 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
14907 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14908 this_ptr_conv.is_owned = false;
14909 LDKOutPoint ret_var = DelayedPaymentOutputDescriptor_get_outpoint(&this_ptr_conv);
14910 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14911 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14912 uint64_t ret_ref = (uint64_t)ret_var.inner;
14913 if (ret_var.is_owned) {
14919 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1set_1outpoint(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
14920 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
14921 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14922 this_ptr_conv.is_owned = false;
14923 LDKOutPoint val_conv;
14924 val_conv.inner = (void*)(val & (~1));
14925 val_conv.is_owned = (val & 1) || (val == 0);
14926 val_conv = OutPoint_clone(&val_conv);
14927 DelayedPaymentOutputDescriptor_set_outpoint(&this_ptr_conv, val_conv);
14930 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1get_1per_1commitment_1point(JNIEnv *env, jclass clz, int64_t this_ptr) {
14931 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
14932 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14933 this_ptr_conv.is_owned = false;
14934 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
14935 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, DelayedPaymentOutputDescriptor_get_per_commitment_point(&this_ptr_conv).compressed_form);
14939 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1set_1per_1commitment_1point(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
14940 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
14941 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14942 this_ptr_conv.is_owned = false;
14943 LDKPublicKey val_ref;
14944 CHECK((*env)->GetArrayLength(env, val) == 33);
14945 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
14946 DelayedPaymentOutputDescriptor_set_per_commitment_point(&this_ptr_conv, val_ref);
14949 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1get_1to_1self_1delay(JNIEnv *env, jclass clz, int64_t this_ptr) {
14950 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
14951 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14952 this_ptr_conv.is_owned = false;
14953 int16_t ret_val = DelayedPaymentOutputDescriptor_get_to_self_delay(&this_ptr_conv);
14957 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1set_1to_1self_1delay(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
14958 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
14959 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14960 this_ptr_conv.is_owned = false;
14961 DelayedPaymentOutputDescriptor_set_to_self_delay(&this_ptr_conv, val);
14964 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1set_1output(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
14965 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
14966 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14967 this_ptr_conv.is_owned = false;
14968 LDKTxOut val_conv = *(LDKTxOut*)(((uint64_t)val) & ~1);
14969 DelayedPaymentOutputDescriptor_set_output(&this_ptr_conv, val_conv);
14972 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1get_1revocation_1pubkey(JNIEnv *env, jclass clz, int64_t this_ptr) {
14973 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
14974 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14975 this_ptr_conv.is_owned = false;
14976 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
14977 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, DelayedPaymentOutputDescriptor_get_revocation_pubkey(&this_ptr_conv).compressed_form);
14981 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1set_1revocation_1pubkey(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
14982 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
14983 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14984 this_ptr_conv.is_owned = false;
14985 LDKPublicKey val_ref;
14986 CHECK((*env)->GetArrayLength(env, val) == 33);
14987 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
14988 DelayedPaymentOutputDescriptor_set_revocation_pubkey(&this_ptr_conv, val_ref);
14991 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1get_1channel_1keys_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
14992 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
14993 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14994 this_ptr_conv.is_owned = false;
14995 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
14996 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *DelayedPaymentOutputDescriptor_get_channel_keys_id(&this_ptr_conv));
15000 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1set_1channel_1keys_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
15001 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
15002 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15003 this_ptr_conv.is_owned = false;
15004 LDKThirtyTwoBytes val_ref;
15005 CHECK((*env)->GetArrayLength(env, val) == 32);
15006 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
15007 DelayedPaymentOutputDescriptor_set_channel_keys_id(&this_ptr_conv, val_ref);
15010 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1get_1channel_1value_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr) {
15011 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
15012 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15013 this_ptr_conv.is_owned = false;
15014 int64_t ret_val = DelayedPaymentOutputDescriptor_get_channel_value_satoshis(&this_ptr_conv);
15018 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1set_1channel_1value_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
15019 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
15020 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15021 this_ptr_conv.is_owned = false;
15022 DelayedPaymentOutputDescriptor_set_channel_value_satoshis(&this_ptr_conv, val);
15025 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1new(JNIEnv *env, jclass clz, int64_t outpoint_arg, int8_tArray per_commitment_point_arg, int16_t to_self_delay_arg, int64_t output_arg, int8_tArray revocation_pubkey_arg, int8_tArray channel_keys_id_arg, int64_t channel_value_satoshis_arg) {
15026 LDKOutPoint outpoint_arg_conv;
15027 outpoint_arg_conv.inner = (void*)(outpoint_arg & (~1));
15028 outpoint_arg_conv.is_owned = (outpoint_arg & 1) || (outpoint_arg == 0);
15029 outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
15030 LDKPublicKey per_commitment_point_arg_ref;
15031 CHECK((*env)->GetArrayLength(env, per_commitment_point_arg) == 33);
15032 (*env)->GetByteArrayRegion(env, per_commitment_point_arg, 0, 33, per_commitment_point_arg_ref.compressed_form);
15033 LDKTxOut output_arg_conv = *(LDKTxOut*)(((uint64_t)output_arg) & ~1);
15034 LDKPublicKey revocation_pubkey_arg_ref;
15035 CHECK((*env)->GetArrayLength(env, revocation_pubkey_arg) == 33);
15036 (*env)->GetByteArrayRegion(env, revocation_pubkey_arg, 0, 33, revocation_pubkey_arg_ref.compressed_form);
15037 LDKThirtyTwoBytes channel_keys_id_arg_ref;
15038 CHECK((*env)->GetArrayLength(env, channel_keys_id_arg) == 32);
15039 (*env)->GetByteArrayRegion(env, channel_keys_id_arg, 0, 32, channel_keys_id_arg_ref.data);
15040 LDKDelayedPaymentOutputDescriptor ret_var = DelayedPaymentOutputDescriptor_new(outpoint_arg_conv, per_commitment_point_arg_ref, to_self_delay_arg, output_arg_conv, revocation_pubkey_arg_ref, channel_keys_id_arg_ref, channel_value_satoshis_arg);
15041 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15042 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15043 uint64_t ret_ref = (uint64_t)ret_var.inner;
15044 if (ret_var.is_owned) {
15050 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1clone(JNIEnv *env, jclass clz, int64_t orig) {
15051 LDKDelayedPaymentOutputDescriptor orig_conv;
15052 orig_conv.inner = (void*)(orig & (~1));
15053 orig_conv.is_owned = false;
15054 LDKDelayedPaymentOutputDescriptor ret_var = DelayedPaymentOutputDescriptor_clone(&orig_conv);
15055 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15056 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15057 uint64_t ret_ref = (uint64_t)ret_var.inner;
15058 if (ret_var.is_owned) {
15064 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1write(JNIEnv *env, jclass clz, int64_t obj) {
15065 LDKDelayedPaymentOutputDescriptor obj_conv;
15066 obj_conv.inner = (void*)(obj & (~1));
15067 obj_conv.is_owned = false;
15068 LDKCVec_u8Z ret_var = DelayedPaymentOutputDescriptor_write(&obj_conv);
15069 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
15070 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
15071 CVec_u8Z_free(ret_var);
15075 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
15076 LDKu8slice ser_ref;
15077 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
15078 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
15079 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
15080 *ret_conv = DelayedPaymentOutputDescriptor_read(ser_ref);
15081 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
15082 return (uint64_t)ret_conv;
15085 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_StaticPaymentOutputDescriptor_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
15086 LDKStaticPaymentOutputDescriptor this_obj_conv;
15087 this_obj_conv.inner = (void*)(this_obj & (~1));
15088 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
15089 StaticPaymentOutputDescriptor_free(this_obj_conv);
15092 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_StaticPaymentOutputDescriptor_1get_1outpoint(JNIEnv *env, jclass clz, int64_t this_ptr) {
15093 LDKStaticPaymentOutputDescriptor this_ptr_conv;
15094 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15095 this_ptr_conv.is_owned = false;
15096 LDKOutPoint ret_var = StaticPaymentOutputDescriptor_get_outpoint(&this_ptr_conv);
15097 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15098 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15099 uint64_t ret_ref = (uint64_t)ret_var.inner;
15100 if (ret_var.is_owned) {
15106 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_StaticPaymentOutputDescriptor_1set_1outpoint(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
15107 LDKStaticPaymentOutputDescriptor this_ptr_conv;
15108 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15109 this_ptr_conv.is_owned = false;
15110 LDKOutPoint val_conv;
15111 val_conv.inner = (void*)(val & (~1));
15112 val_conv.is_owned = (val & 1) || (val == 0);
15113 val_conv = OutPoint_clone(&val_conv);
15114 StaticPaymentOutputDescriptor_set_outpoint(&this_ptr_conv, val_conv);
15117 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_StaticPaymentOutputDescriptor_1set_1output(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
15118 LDKStaticPaymentOutputDescriptor this_ptr_conv;
15119 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15120 this_ptr_conv.is_owned = false;
15121 LDKTxOut val_conv = *(LDKTxOut*)(((uint64_t)val) & ~1);
15122 StaticPaymentOutputDescriptor_set_output(&this_ptr_conv, val_conv);
15125 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_StaticPaymentOutputDescriptor_1get_1channel_1keys_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
15126 LDKStaticPaymentOutputDescriptor this_ptr_conv;
15127 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15128 this_ptr_conv.is_owned = false;
15129 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
15130 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *StaticPaymentOutputDescriptor_get_channel_keys_id(&this_ptr_conv));
15134 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_StaticPaymentOutputDescriptor_1set_1channel_1keys_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
15135 LDKStaticPaymentOutputDescriptor this_ptr_conv;
15136 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15137 this_ptr_conv.is_owned = false;
15138 LDKThirtyTwoBytes val_ref;
15139 CHECK((*env)->GetArrayLength(env, val) == 32);
15140 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
15141 StaticPaymentOutputDescriptor_set_channel_keys_id(&this_ptr_conv, val_ref);
15144 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_StaticPaymentOutputDescriptor_1get_1channel_1value_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr) {
15145 LDKStaticPaymentOutputDescriptor this_ptr_conv;
15146 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15147 this_ptr_conv.is_owned = false;
15148 int64_t ret_val = StaticPaymentOutputDescriptor_get_channel_value_satoshis(&this_ptr_conv);
15152 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_StaticPaymentOutputDescriptor_1set_1channel_1value_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
15153 LDKStaticPaymentOutputDescriptor this_ptr_conv;
15154 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15155 this_ptr_conv.is_owned = false;
15156 StaticPaymentOutputDescriptor_set_channel_value_satoshis(&this_ptr_conv, val);
15159 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_StaticPaymentOutputDescriptor_1new(JNIEnv *env, jclass clz, int64_t outpoint_arg, int64_t output_arg, int8_tArray channel_keys_id_arg, int64_t channel_value_satoshis_arg) {
15160 LDKOutPoint outpoint_arg_conv;
15161 outpoint_arg_conv.inner = (void*)(outpoint_arg & (~1));
15162 outpoint_arg_conv.is_owned = (outpoint_arg & 1) || (outpoint_arg == 0);
15163 outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
15164 LDKTxOut output_arg_conv = *(LDKTxOut*)(((uint64_t)output_arg) & ~1);
15165 LDKThirtyTwoBytes channel_keys_id_arg_ref;
15166 CHECK((*env)->GetArrayLength(env, channel_keys_id_arg) == 32);
15167 (*env)->GetByteArrayRegion(env, channel_keys_id_arg, 0, 32, channel_keys_id_arg_ref.data);
15168 LDKStaticPaymentOutputDescriptor ret_var = StaticPaymentOutputDescriptor_new(outpoint_arg_conv, output_arg_conv, channel_keys_id_arg_ref, channel_value_satoshis_arg);
15169 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15170 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15171 uint64_t ret_ref = (uint64_t)ret_var.inner;
15172 if (ret_var.is_owned) {
15178 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_StaticPaymentOutputDescriptor_1clone(JNIEnv *env, jclass clz, int64_t orig) {
15179 LDKStaticPaymentOutputDescriptor orig_conv;
15180 orig_conv.inner = (void*)(orig & (~1));
15181 orig_conv.is_owned = false;
15182 LDKStaticPaymentOutputDescriptor ret_var = StaticPaymentOutputDescriptor_clone(&orig_conv);
15183 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15184 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15185 uint64_t ret_ref = (uint64_t)ret_var.inner;
15186 if (ret_var.is_owned) {
15192 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_StaticPaymentOutputDescriptor_1write(JNIEnv *env, jclass clz, int64_t obj) {
15193 LDKStaticPaymentOutputDescriptor obj_conv;
15194 obj_conv.inner = (void*)(obj & (~1));
15195 obj_conv.is_owned = false;
15196 LDKCVec_u8Z ret_var = StaticPaymentOutputDescriptor_write(&obj_conv);
15197 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
15198 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
15199 CVec_u8Z_free(ret_var);
15203 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_StaticPaymentOutputDescriptor_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
15204 LDKu8slice ser_ref;
15205 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
15206 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
15207 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
15208 *ret_conv = StaticPaymentOutputDescriptor_read(ser_ref);
15209 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
15210 return (uint64_t)ret_conv;
15213 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_SpendableOutputDescriptor_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
15214 if ((this_ptr & 1) != 0) return;
15215 LDKSpendableOutputDescriptor this_ptr_conv = *(LDKSpendableOutputDescriptor*)(((uint64_t)this_ptr) & ~1);
15216 FREE((void*)this_ptr);
15217 SpendableOutputDescriptor_free(this_ptr_conv);
15220 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SpendableOutputDescriptor_1clone(JNIEnv *env, jclass clz, int64_t orig) {
15221 LDKSpendableOutputDescriptor* orig_conv = (LDKSpendableOutputDescriptor*)orig;
15222 LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
15223 *ret_copy = SpendableOutputDescriptor_clone(orig_conv);
15224 uint64_t ret_ref = (uint64_t)ret_copy;
15228 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_SpendableOutputDescriptor_1write(JNIEnv *env, jclass clz, int64_t obj) {
15229 LDKSpendableOutputDescriptor* obj_conv = (LDKSpendableOutputDescriptor*)obj;
15230 LDKCVec_u8Z ret_var = SpendableOutputDescriptor_write(obj_conv);
15231 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
15232 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
15233 CVec_u8Z_free(ret_var);
15237 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SpendableOutputDescriptor_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
15238 LDKu8slice ser_ref;
15239 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
15240 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
15241 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
15242 *ret_conv = SpendableOutputDescriptor_read(ser_ref);
15243 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
15244 return (uint64_t)ret_conv;
15247 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_BaseSign_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
15248 if ((this_ptr & 1) != 0) return;
15249 LDKBaseSign this_ptr_conv = *(LDKBaseSign*)(((uint64_t)this_ptr) & ~1);
15250 FREE((void*)this_ptr);
15251 BaseSign_free(this_ptr_conv);
15254 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Sign_1clone(JNIEnv *env, jclass clz, int64_t orig) {
15255 LDKSign* orig_conv = (LDKSign*)(((uint64_t)orig) & ~1);
15256 LDKSign* ret = MALLOC(sizeof(LDKSign), "LDKSign");
15257 *ret = Sign_clone(orig_conv);
15258 return (uint64_t)ret;
15261 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Sign_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
15262 if ((this_ptr & 1) != 0) return;
15263 LDKSign this_ptr_conv = *(LDKSign*)(((uint64_t)this_ptr) & ~1);
15264 FREE((void*)this_ptr);
15265 Sign_free(this_ptr_conv);
15268 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_KeysInterface_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
15269 if ((this_ptr & 1) != 0) return;
15270 LDKKeysInterface this_ptr_conv = *(LDKKeysInterface*)(((uint64_t)this_ptr) & ~1);
15271 FREE((void*)this_ptr);
15272 KeysInterface_free(this_ptr_conv);
15275 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
15276 LDKInMemorySigner this_obj_conv;
15277 this_obj_conv.inner = (void*)(this_obj & (~1));
15278 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
15279 InMemorySigner_free(this_obj_conv);
15282 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1get_1funding_1key(JNIEnv *env, jclass clz, int64_t this_ptr) {
15283 LDKInMemorySigner this_ptr_conv;
15284 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15285 this_ptr_conv.is_owned = false;
15286 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
15287 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *InMemorySigner_get_funding_key(&this_ptr_conv));
15291 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1set_1funding_1key(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
15292 LDKInMemorySigner this_ptr_conv;
15293 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15294 this_ptr_conv.is_owned = false;
15295 LDKSecretKey val_ref;
15296 CHECK((*env)->GetArrayLength(env, val) == 32);
15297 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.bytes);
15298 InMemorySigner_set_funding_key(&this_ptr_conv, val_ref);
15301 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1get_1revocation_1base_1key(JNIEnv *env, jclass clz, int64_t this_ptr) {
15302 LDKInMemorySigner this_ptr_conv;
15303 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15304 this_ptr_conv.is_owned = false;
15305 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
15306 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *InMemorySigner_get_revocation_base_key(&this_ptr_conv));
15310 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1set_1revocation_1base_1key(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
15311 LDKInMemorySigner this_ptr_conv;
15312 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15313 this_ptr_conv.is_owned = false;
15314 LDKSecretKey val_ref;
15315 CHECK((*env)->GetArrayLength(env, val) == 32);
15316 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.bytes);
15317 InMemorySigner_set_revocation_base_key(&this_ptr_conv, val_ref);
15320 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1get_1payment_1key(JNIEnv *env, jclass clz, int64_t this_ptr) {
15321 LDKInMemorySigner this_ptr_conv;
15322 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15323 this_ptr_conv.is_owned = false;
15324 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
15325 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *InMemorySigner_get_payment_key(&this_ptr_conv));
15329 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1set_1payment_1key(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
15330 LDKInMemorySigner this_ptr_conv;
15331 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15332 this_ptr_conv.is_owned = false;
15333 LDKSecretKey val_ref;
15334 CHECK((*env)->GetArrayLength(env, val) == 32);
15335 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.bytes);
15336 InMemorySigner_set_payment_key(&this_ptr_conv, val_ref);
15339 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1get_1delayed_1payment_1base_1key(JNIEnv *env, jclass clz, int64_t this_ptr) {
15340 LDKInMemorySigner this_ptr_conv;
15341 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15342 this_ptr_conv.is_owned = false;
15343 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
15344 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *InMemorySigner_get_delayed_payment_base_key(&this_ptr_conv));
15348 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1set_1delayed_1payment_1base_1key(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
15349 LDKInMemorySigner this_ptr_conv;
15350 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15351 this_ptr_conv.is_owned = false;
15352 LDKSecretKey val_ref;
15353 CHECK((*env)->GetArrayLength(env, val) == 32);
15354 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.bytes);
15355 InMemorySigner_set_delayed_payment_base_key(&this_ptr_conv, val_ref);
15358 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1get_1htlc_1base_1key(JNIEnv *env, jclass clz, int64_t this_ptr) {
15359 LDKInMemorySigner this_ptr_conv;
15360 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15361 this_ptr_conv.is_owned = false;
15362 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
15363 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *InMemorySigner_get_htlc_base_key(&this_ptr_conv));
15367 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1set_1htlc_1base_1key(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
15368 LDKInMemorySigner this_ptr_conv;
15369 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15370 this_ptr_conv.is_owned = false;
15371 LDKSecretKey val_ref;
15372 CHECK((*env)->GetArrayLength(env, val) == 32);
15373 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.bytes);
15374 InMemorySigner_set_htlc_base_key(&this_ptr_conv, val_ref);
15377 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1get_1commitment_1seed(JNIEnv *env, jclass clz, int64_t this_ptr) {
15378 LDKInMemorySigner this_ptr_conv;
15379 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15380 this_ptr_conv.is_owned = false;
15381 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
15382 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *InMemorySigner_get_commitment_seed(&this_ptr_conv));
15386 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1set_1commitment_1seed(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
15387 LDKInMemorySigner this_ptr_conv;
15388 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15389 this_ptr_conv.is_owned = false;
15390 LDKThirtyTwoBytes val_ref;
15391 CHECK((*env)->GetArrayLength(env, val) == 32);
15392 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
15393 InMemorySigner_set_commitment_seed(&this_ptr_conv, val_ref);
15396 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1clone(JNIEnv *env, jclass clz, int64_t orig) {
15397 LDKInMemorySigner orig_conv;
15398 orig_conv.inner = (void*)(orig & (~1));
15399 orig_conv.is_owned = false;
15400 LDKInMemorySigner ret_var = InMemorySigner_clone(&orig_conv);
15401 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15402 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15403 uint64_t ret_ref = (uint64_t)ret_var.inner;
15404 if (ret_var.is_owned) {
15410 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1new(JNIEnv *env, jclass clz, int8_tArray funding_key, int8_tArray revocation_base_key, int8_tArray payment_key, int8_tArray delayed_payment_base_key, int8_tArray htlc_base_key, int8_tArray commitment_seed, int64_t channel_value_satoshis, int8_tArray channel_keys_id) {
15411 LDKSecretKey funding_key_ref;
15412 CHECK((*env)->GetArrayLength(env, funding_key) == 32);
15413 (*env)->GetByteArrayRegion(env, funding_key, 0, 32, funding_key_ref.bytes);
15414 LDKSecretKey revocation_base_key_ref;
15415 CHECK((*env)->GetArrayLength(env, revocation_base_key) == 32);
15416 (*env)->GetByteArrayRegion(env, revocation_base_key, 0, 32, revocation_base_key_ref.bytes);
15417 LDKSecretKey payment_key_ref;
15418 CHECK((*env)->GetArrayLength(env, payment_key) == 32);
15419 (*env)->GetByteArrayRegion(env, payment_key, 0, 32, payment_key_ref.bytes);
15420 LDKSecretKey delayed_payment_base_key_ref;
15421 CHECK((*env)->GetArrayLength(env, delayed_payment_base_key) == 32);
15422 (*env)->GetByteArrayRegion(env, delayed_payment_base_key, 0, 32, delayed_payment_base_key_ref.bytes);
15423 LDKSecretKey htlc_base_key_ref;
15424 CHECK((*env)->GetArrayLength(env, htlc_base_key) == 32);
15425 (*env)->GetByteArrayRegion(env, htlc_base_key, 0, 32, htlc_base_key_ref.bytes);
15426 LDKThirtyTwoBytes commitment_seed_ref;
15427 CHECK((*env)->GetArrayLength(env, commitment_seed) == 32);
15428 (*env)->GetByteArrayRegion(env, commitment_seed, 0, 32, commitment_seed_ref.data);
15429 LDKThirtyTwoBytes channel_keys_id_ref;
15430 CHECK((*env)->GetArrayLength(env, channel_keys_id) == 32);
15431 (*env)->GetByteArrayRegion(env, channel_keys_id, 0, 32, channel_keys_id_ref.data);
15432 LDKInMemorySigner ret_var = InMemorySigner_new(funding_key_ref, revocation_base_key_ref, payment_key_ref, delayed_payment_base_key_ref, htlc_base_key_ref, commitment_seed_ref, channel_value_satoshis, channel_keys_id_ref);
15433 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15434 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15435 uint64_t ret_ref = (uint64_t)ret_var.inner;
15436 if (ret_var.is_owned) {
15442 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1counterparty_1pubkeys(JNIEnv *env, jclass clz, int64_t this_arg) {
15443 LDKInMemorySigner this_arg_conv;
15444 this_arg_conv.inner = (void*)(this_arg & (~1));
15445 this_arg_conv.is_owned = false;
15446 LDKChannelPublicKeys ret_var = InMemorySigner_counterparty_pubkeys(&this_arg_conv);
15447 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15448 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15449 uint64_t ret_ref = (uint64_t)ret_var.inner;
15450 if (ret_var.is_owned) {
15456 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1counterparty_1selected_1contest_1delay(JNIEnv *env, jclass clz, int64_t this_arg) {
15457 LDKInMemorySigner this_arg_conv;
15458 this_arg_conv.inner = (void*)(this_arg & (~1));
15459 this_arg_conv.is_owned = false;
15460 int16_t ret_val = InMemorySigner_counterparty_selected_contest_delay(&this_arg_conv);
15464 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1holder_1selected_1contest_1delay(JNIEnv *env, jclass clz, int64_t this_arg) {
15465 LDKInMemorySigner this_arg_conv;
15466 this_arg_conv.inner = (void*)(this_arg & (~1));
15467 this_arg_conv.is_owned = false;
15468 int16_t ret_val = InMemorySigner_holder_selected_contest_delay(&this_arg_conv);
15472 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1is_1outbound(JNIEnv *env, jclass clz, int64_t this_arg) {
15473 LDKInMemorySigner this_arg_conv;
15474 this_arg_conv.inner = (void*)(this_arg & (~1));
15475 this_arg_conv.is_owned = false;
15476 jboolean ret_val = InMemorySigner_is_outbound(&this_arg_conv);
15480 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1funding_1outpoint(JNIEnv *env, jclass clz, int64_t this_arg) {
15481 LDKInMemorySigner this_arg_conv;
15482 this_arg_conv.inner = (void*)(this_arg & (~1));
15483 this_arg_conv.is_owned = false;
15484 LDKOutPoint ret_var = InMemorySigner_funding_outpoint(&this_arg_conv);
15485 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15486 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15487 uint64_t ret_ref = (uint64_t)ret_var.inner;
15488 if (ret_var.is_owned) {
15494 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1get_1channel_1parameters(JNIEnv *env, jclass clz, int64_t this_arg) {
15495 LDKInMemorySigner this_arg_conv;
15496 this_arg_conv.inner = (void*)(this_arg & (~1));
15497 this_arg_conv.is_owned = false;
15498 LDKChannelTransactionParameters ret_var = InMemorySigner_get_channel_parameters(&this_arg_conv);
15499 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15500 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15501 uint64_t ret_ref = (uint64_t)ret_var.inner;
15502 if (ret_var.is_owned) {
15508 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1sign_1counterparty_1payment_1input(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray spend_tx, int64_t input_idx, int64_t descriptor) {
15509 LDKInMemorySigner this_arg_conv;
15510 this_arg_conv.inner = (void*)(this_arg & (~1));
15511 this_arg_conv.is_owned = false;
15512 LDKTransaction spend_tx_ref;
15513 spend_tx_ref.datalen = (*env)->GetArrayLength(env, spend_tx);
15514 spend_tx_ref.data = MALLOC(spend_tx_ref.datalen, "LDKTransaction Bytes");
15515 (*env)->GetByteArrayRegion(env, spend_tx, 0, spend_tx_ref.datalen, spend_tx_ref.data);
15516 spend_tx_ref.data_is_owned = true;
15517 LDKStaticPaymentOutputDescriptor descriptor_conv;
15518 descriptor_conv.inner = (void*)(descriptor & (~1));
15519 descriptor_conv.is_owned = false;
15520 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
15521 *ret_conv = InMemorySigner_sign_counterparty_payment_input(&this_arg_conv, spend_tx_ref, input_idx, &descriptor_conv);
15522 return (uint64_t)ret_conv;
15525 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1sign_1dynamic_1p2wsh_1input(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray spend_tx, int64_t input_idx, int64_t descriptor) {
15526 LDKInMemorySigner this_arg_conv;
15527 this_arg_conv.inner = (void*)(this_arg & (~1));
15528 this_arg_conv.is_owned = false;
15529 LDKTransaction spend_tx_ref;
15530 spend_tx_ref.datalen = (*env)->GetArrayLength(env, spend_tx);
15531 spend_tx_ref.data = MALLOC(spend_tx_ref.datalen, "LDKTransaction Bytes");
15532 (*env)->GetByteArrayRegion(env, spend_tx, 0, spend_tx_ref.datalen, spend_tx_ref.data);
15533 spend_tx_ref.data_is_owned = true;
15534 LDKDelayedPaymentOutputDescriptor descriptor_conv;
15535 descriptor_conv.inner = (void*)(descriptor & (~1));
15536 descriptor_conv.is_owned = false;
15537 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
15538 *ret_conv = InMemorySigner_sign_dynamic_p2wsh_input(&this_arg_conv, spend_tx_ref, input_idx, &descriptor_conv);
15539 return (uint64_t)ret_conv;
15542 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1as_1BaseSign(JNIEnv *env, jclass clz, int64_t this_arg) {
15543 LDKInMemorySigner this_arg_conv;
15544 this_arg_conv.inner = (void*)(this_arg & (~1));
15545 this_arg_conv.is_owned = false;
15546 LDKBaseSign* ret = MALLOC(sizeof(LDKBaseSign), "LDKBaseSign");
15547 *ret = InMemorySigner_as_BaseSign(&this_arg_conv);
15548 return (uint64_t)ret;
15551 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1as_1Sign(JNIEnv *env, jclass clz, int64_t this_arg) {
15552 LDKInMemorySigner this_arg_conv;
15553 this_arg_conv.inner = (void*)(this_arg & (~1));
15554 this_arg_conv.is_owned = false;
15555 LDKSign* ret = MALLOC(sizeof(LDKSign), "LDKSign");
15556 *ret = InMemorySigner_as_Sign(&this_arg_conv);
15557 return (uint64_t)ret;
15560 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1write(JNIEnv *env, jclass clz, int64_t obj) {
15561 LDKInMemorySigner obj_conv;
15562 obj_conv.inner = (void*)(obj & (~1));
15563 obj_conv.is_owned = false;
15564 LDKCVec_u8Z ret_var = InMemorySigner_write(&obj_conv);
15565 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
15566 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
15567 CVec_u8Z_free(ret_var);
15571 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
15572 LDKu8slice ser_ref;
15573 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
15574 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
15575 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
15576 *ret_conv = InMemorySigner_read(ser_ref);
15577 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
15578 return (uint64_t)ret_conv;
15581 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_KeysManager_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
15582 LDKKeysManager this_obj_conv;
15583 this_obj_conv.inner = (void*)(this_obj & (~1));
15584 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
15585 KeysManager_free(this_obj_conv);
15588 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_KeysManager_1new(JNIEnv *env, jclass clz, int8_tArray seed, int64_t starting_time_secs, int32_t starting_time_nanos) {
15589 unsigned char seed_arr[32];
15590 CHECK((*env)->GetArrayLength(env, seed) == 32);
15591 (*env)->GetByteArrayRegion(env, seed, 0, 32, seed_arr);
15592 unsigned char (*seed_ref)[32] = &seed_arr;
15593 LDKKeysManager ret_var = KeysManager_new(seed_ref, starting_time_secs, starting_time_nanos);
15594 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15595 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15596 uint64_t ret_ref = (uint64_t)ret_var.inner;
15597 if (ret_var.is_owned) {
15603 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_KeysManager_1derive_1channel_1keys(JNIEnv *env, jclass clz, int64_t this_arg, int64_t channel_value_satoshis, int8_tArray params) {
15604 LDKKeysManager this_arg_conv;
15605 this_arg_conv.inner = (void*)(this_arg & (~1));
15606 this_arg_conv.is_owned = false;
15607 unsigned char params_arr[32];
15608 CHECK((*env)->GetArrayLength(env, params) == 32);
15609 (*env)->GetByteArrayRegion(env, params, 0, 32, params_arr);
15610 unsigned char (*params_ref)[32] = ¶ms_arr;
15611 LDKInMemorySigner ret_var = KeysManager_derive_channel_keys(&this_arg_conv, channel_value_satoshis, params_ref);
15612 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15613 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15614 uint64_t ret_ref = (uint64_t)ret_var.inner;
15615 if (ret_var.is_owned) {
15621 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_KeysManager_1spend_1spendable_1outputs(JNIEnv *env, jclass clz, int64_t this_arg, int64_tArray descriptors, int64_tArray outputs, int8_tArray change_destination_script, int32_t feerate_sat_per_1000_weight) {
15622 LDKKeysManager this_arg_conv;
15623 this_arg_conv.inner = (void*)(this_arg & (~1));
15624 this_arg_conv.is_owned = false;
15625 LDKCVec_SpendableOutputDescriptorZ descriptors_constr;
15626 descriptors_constr.datalen = (*env)->GetArrayLength(env, descriptors);
15627 if (descriptors_constr.datalen > 0)
15628 descriptors_constr.data = MALLOC(descriptors_constr.datalen * sizeof(LDKSpendableOutputDescriptor), "LDKCVec_SpendableOutputDescriptorZ Elements");
15630 descriptors_constr.data = NULL;
15631 int64_t* descriptors_vals = (*env)->GetLongArrayElements (env, descriptors, NULL);
15632 for (size_t b = 0; b < descriptors_constr.datalen; b++) {
15633 int64_t descriptors_conv_27 = descriptors_vals[b];
15634 LDKSpendableOutputDescriptor descriptors_conv_27_conv = *(LDKSpendableOutputDescriptor*)(((uint64_t)descriptors_conv_27) & ~1);
15635 descriptors_conv_27_conv = SpendableOutputDescriptor_clone((LDKSpendableOutputDescriptor*)(((uint64_t)descriptors_conv_27) & ~1));
15636 descriptors_constr.data[b] = descriptors_conv_27_conv;
15638 (*env)->ReleaseLongArrayElements(env, descriptors, descriptors_vals, 0);
15639 LDKCVec_TxOutZ outputs_constr;
15640 outputs_constr.datalen = (*env)->GetArrayLength(env, outputs);
15641 if (outputs_constr.datalen > 0)
15642 outputs_constr.data = MALLOC(outputs_constr.datalen * sizeof(LDKTxOut), "LDKCVec_TxOutZ Elements");
15644 outputs_constr.data = NULL;
15645 int64_t* outputs_vals = (*env)->GetLongArrayElements (env, outputs, NULL);
15646 for (size_t h = 0; h < outputs_constr.datalen; h++) {
15647 int64_t outputs_conv_7 = outputs_vals[h];
15648 LDKTxOut outputs_conv_7_conv = *(LDKTxOut*)(((uint64_t)outputs_conv_7) & ~1);
15649 outputs_conv_7_conv = TxOut_clone((LDKTxOut*)(((uint64_t)outputs_conv_7) & ~1));
15650 outputs_constr.data[h] = outputs_conv_7_conv;
15652 (*env)->ReleaseLongArrayElements(env, outputs, outputs_vals, 0);
15653 LDKCVec_u8Z change_destination_script_ref;
15654 change_destination_script_ref.datalen = (*env)->GetArrayLength(env, change_destination_script);
15655 change_destination_script_ref.data = MALLOC(change_destination_script_ref.datalen, "LDKCVec_u8Z Bytes");
15656 (*env)->GetByteArrayRegion(env, change_destination_script, 0, change_destination_script_ref.datalen, change_destination_script_ref.data);
15657 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
15658 *ret_conv = KeysManager_spend_spendable_outputs(&this_arg_conv, descriptors_constr, outputs_constr, change_destination_script_ref, feerate_sat_per_1000_weight);
15659 return (uint64_t)ret_conv;
15662 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_KeysManager_1as_1KeysInterface(JNIEnv *env, jclass clz, int64_t this_arg) {
15663 LDKKeysManager this_arg_conv;
15664 this_arg_conv.inner = (void*)(this_arg & (~1));
15665 this_arg_conv.is_owned = false;
15666 LDKKeysInterface* ret = MALLOC(sizeof(LDKKeysInterface), "LDKKeysInterface");
15667 *ret = KeysManager_as_KeysInterface(&this_arg_conv);
15668 return (uint64_t)ret;
15671 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelManager_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
15672 LDKChannelManager this_obj_conv;
15673 this_obj_conv.inner = (void*)(this_obj & (~1));
15674 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
15675 ChannelManager_free(this_obj_conv);
15678 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChainParameters_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
15679 LDKChainParameters this_obj_conv;
15680 this_obj_conv.inner = (void*)(this_obj & (~1));
15681 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
15682 ChainParameters_free(this_obj_conv);
15685 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_ChainParameters_1get_1network(JNIEnv *env, jclass clz, int64_t this_ptr) {
15686 LDKChainParameters this_ptr_conv;
15687 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15688 this_ptr_conv.is_owned = false;
15689 jclass ret_conv = LDKNetwork_to_java(env, ChainParameters_get_network(&this_ptr_conv));
15693 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChainParameters_1set_1network(JNIEnv *env, jclass clz, int64_t this_ptr, jclass val) {
15694 LDKChainParameters this_ptr_conv;
15695 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15696 this_ptr_conv.is_owned = false;
15697 LDKNetwork val_conv = LDKNetwork_from_java(env, val);
15698 ChainParameters_set_network(&this_ptr_conv, val_conv);
15701 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChainParameters_1get_1best_1block(JNIEnv *env, jclass clz, int64_t this_ptr) {
15702 LDKChainParameters this_ptr_conv;
15703 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15704 this_ptr_conv.is_owned = false;
15705 LDKBestBlock ret_var = ChainParameters_get_best_block(&this_ptr_conv);
15706 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15707 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15708 uint64_t ret_ref = (uint64_t)ret_var.inner;
15709 if (ret_var.is_owned) {
15715 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChainParameters_1set_1best_1block(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
15716 LDKChainParameters this_ptr_conv;
15717 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15718 this_ptr_conv.is_owned = false;
15719 LDKBestBlock val_conv;
15720 val_conv.inner = (void*)(val & (~1));
15721 val_conv.is_owned = (val & 1) || (val == 0);
15722 val_conv = BestBlock_clone(&val_conv);
15723 ChainParameters_set_best_block(&this_ptr_conv, val_conv);
15726 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChainParameters_1new(JNIEnv *env, jclass clz, jclass network_arg, int64_t best_block_arg) {
15727 LDKNetwork network_arg_conv = LDKNetwork_from_java(env, network_arg);
15728 LDKBestBlock best_block_arg_conv;
15729 best_block_arg_conv.inner = (void*)(best_block_arg & (~1));
15730 best_block_arg_conv.is_owned = (best_block_arg & 1) || (best_block_arg == 0);
15731 best_block_arg_conv = BestBlock_clone(&best_block_arg_conv);
15732 LDKChainParameters ret_var = ChainParameters_new(network_arg_conv, best_block_arg_conv);
15733 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15734 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15735 uint64_t ret_ref = (uint64_t)ret_var.inner;
15736 if (ret_var.is_owned) {
15742 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChainParameters_1clone(JNIEnv *env, jclass clz, int64_t orig) {
15743 LDKChainParameters orig_conv;
15744 orig_conv.inner = (void*)(orig & (~1));
15745 orig_conv.is_owned = false;
15746 LDKChainParameters ret_var = ChainParameters_clone(&orig_conv);
15747 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15748 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15749 uint64_t ret_ref = (uint64_t)ret_var.inner;
15750 if (ret_var.is_owned) {
15756 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelCounterparty_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
15757 LDKChannelCounterparty this_obj_conv;
15758 this_obj_conv.inner = (void*)(this_obj & (~1));
15759 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
15760 ChannelCounterparty_free(this_obj_conv);
15763 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelCounterparty_1get_1node_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
15764 LDKChannelCounterparty this_ptr_conv;
15765 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15766 this_ptr_conv.is_owned = false;
15767 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
15768 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ChannelCounterparty_get_node_id(&this_ptr_conv).compressed_form);
15772 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelCounterparty_1set_1node_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
15773 LDKChannelCounterparty this_ptr_conv;
15774 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15775 this_ptr_conv.is_owned = false;
15776 LDKPublicKey val_ref;
15777 CHECK((*env)->GetArrayLength(env, val) == 33);
15778 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
15779 ChannelCounterparty_set_node_id(&this_ptr_conv, val_ref);
15782 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelCounterparty_1get_1features(JNIEnv *env, jclass clz, int64_t this_ptr) {
15783 LDKChannelCounterparty this_ptr_conv;
15784 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15785 this_ptr_conv.is_owned = false;
15786 LDKInitFeatures ret_var = ChannelCounterparty_get_features(&this_ptr_conv);
15787 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15788 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15789 uint64_t ret_ref = (uint64_t)ret_var.inner;
15790 if (ret_var.is_owned) {
15796 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelCounterparty_1set_1features(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
15797 LDKChannelCounterparty this_ptr_conv;
15798 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15799 this_ptr_conv.is_owned = false;
15800 LDKInitFeatures val_conv;
15801 val_conv.inner = (void*)(val & (~1));
15802 val_conv.is_owned = (val & 1) || (val == 0);
15803 val_conv = InitFeatures_clone(&val_conv);
15804 ChannelCounterparty_set_features(&this_ptr_conv, val_conv);
15807 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelCounterparty_1get_1unspendable_1punishment_1reserve(JNIEnv *env, jclass clz, int64_t this_ptr) {
15808 LDKChannelCounterparty this_ptr_conv;
15809 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15810 this_ptr_conv.is_owned = false;
15811 int64_t ret_val = ChannelCounterparty_get_unspendable_punishment_reserve(&this_ptr_conv);
15815 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelCounterparty_1set_1unspendable_1punishment_1reserve(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
15816 LDKChannelCounterparty this_ptr_conv;
15817 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15818 this_ptr_conv.is_owned = false;
15819 ChannelCounterparty_set_unspendable_punishment_reserve(&this_ptr_conv, val);
15822 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelCounterparty_1clone(JNIEnv *env, jclass clz, int64_t orig) {
15823 LDKChannelCounterparty orig_conv;
15824 orig_conv.inner = (void*)(orig & (~1));
15825 orig_conv.is_owned = false;
15826 LDKChannelCounterparty ret_var = ChannelCounterparty_clone(&orig_conv);
15827 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15828 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15829 uint64_t ret_ref = (uint64_t)ret_var.inner;
15830 if (ret_var.is_owned) {
15836 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
15837 LDKChannelDetails this_obj_conv;
15838 this_obj_conv.inner = (void*)(this_obj & (~1));
15839 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
15840 ChannelDetails_free(this_obj_conv);
15843 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1get_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
15844 LDKChannelDetails this_ptr_conv;
15845 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15846 this_ptr_conv.is_owned = false;
15847 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
15848 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *ChannelDetails_get_channel_id(&this_ptr_conv));
15852 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1set_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
15853 LDKChannelDetails this_ptr_conv;
15854 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15855 this_ptr_conv.is_owned = false;
15856 LDKThirtyTwoBytes val_ref;
15857 CHECK((*env)->GetArrayLength(env, val) == 32);
15858 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
15859 ChannelDetails_set_channel_id(&this_ptr_conv, val_ref);
15862 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1get_1counterparty(JNIEnv *env, jclass clz, int64_t this_ptr) {
15863 LDKChannelDetails this_ptr_conv;
15864 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15865 this_ptr_conv.is_owned = false;
15866 LDKChannelCounterparty ret_var = ChannelDetails_get_counterparty(&this_ptr_conv);
15867 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15868 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15869 uint64_t ret_ref = (uint64_t)ret_var.inner;
15870 if (ret_var.is_owned) {
15876 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1set_1counterparty(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
15877 LDKChannelDetails this_ptr_conv;
15878 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15879 this_ptr_conv.is_owned = false;
15880 LDKChannelCounterparty val_conv;
15881 val_conv.inner = (void*)(val & (~1));
15882 val_conv.is_owned = (val & 1) || (val == 0);
15883 val_conv = ChannelCounterparty_clone(&val_conv);
15884 ChannelDetails_set_counterparty(&this_ptr_conv, val_conv);
15887 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1get_1funding_1txo(JNIEnv *env, jclass clz, int64_t this_ptr) {
15888 LDKChannelDetails this_ptr_conv;
15889 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15890 this_ptr_conv.is_owned = false;
15891 LDKOutPoint ret_var = ChannelDetails_get_funding_txo(&this_ptr_conv);
15892 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15893 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15894 uint64_t ret_ref = (uint64_t)ret_var.inner;
15895 if (ret_var.is_owned) {
15901 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1set_1funding_1txo(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
15902 LDKChannelDetails this_ptr_conv;
15903 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15904 this_ptr_conv.is_owned = false;
15905 LDKOutPoint val_conv;
15906 val_conv.inner = (void*)(val & (~1));
15907 val_conv.is_owned = (val & 1) || (val == 0);
15908 val_conv = OutPoint_clone(&val_conv);
15909 ChannelDetails_set_funding_txo(&this_ptr_conv, val_conv);
15912 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1get_1short_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
15913 LDKChannelDetails this_ptr_conv;
15914 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15915 this_ptr_conv.is_owned = false;
15916 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
15917 *ret_copy = ChannelDetails_get_short_channel_id(&this_ptr_conv);
15918 uint64_t ret_ref = (uint64_t)ret_copy;
15922 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1set_1short_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
15923 LDKChannelDetails this_ptr_conv;
15924 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15925 this_ptr_conv.is_owned = false;
15926 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(((uint64_t)val) & ~1);
15927 ChannelDetails_set_short_channel_id(&this_ptr_conv, val_conv);
15930 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1get_1channel_1value_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr) {
15931 LDKChannelDetails this_ptr_conv;
15932 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15933 this_ptr_conv.is_owned = false;
15934 int64_t ret_val = ChannelDetails_get_channel_value_satoshis(&this_ptr_conv);
15938 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1set_1channel_1value_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
15939 LDKChannelDetails this_ptr_conv;
15940 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15941 this_ptr_conv.is_owned = false;
15942 ChannelDetails_set_channel_value_satoshis(&this_ptr_conv, val);
15945 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1get_1unspendable_1punishment_1reserve(JNIEnv *env, jclass clz, int64_t this_ptr) {
15946 LDKChannelDetails this_ptr_conv;
15947 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15948 this_ptr_conv.is_owned = false;
15949 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
15950 *ret_copy = ChannelDetails_get_unspendable_punishment_reserve(&this_ptr_conv);
15951 uint64_t ret_ref = (uint64_t)ret_copy;
15955 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1set_1unspendable_1punishment_1reserve(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
15956 LDKChannelDetails this_ptr_conv;
15957 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15958 this_ptr_conv.is_owned = false;
15959 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(((uint64_t)val) & ~1);
15960 ChannelDetails_set_unspendable_punishment_reserve(&this_ptr_conv, val_conv);
15963 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1get_1user_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
15964 LDKChannelDetails this_ptr_conv;
15965 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15966 this_ptr_conv.is_owned = false;
15967 int64_t ret_val = ChannelDetails_get_user_id(&this_ptr_conv);
15971 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1set_1user_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
15972 LDKChannelDetails this_ptr_conv;
15973 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15974 this_ptr_conv.is_owned = false;
15975 ChannelDetails_set_user_id(&this_ptr_conv, val);
15978 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1get_1outbound_1capacity_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
15979 LDKChannelDetails this_ptr_conv;
15980 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15981 this_ptr_conv.is_owned = false;
15982 int64_t ret_val = ChannelDetails_get_outbound_capacity_msat(&this_ptr_conv);
15986 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1set_1outbound_1capacity_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
15987 LDKChannelDetails this_ptr_conv;
15988 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15989 this_ptr_conv.is_owned = false;
15990 ChannelDetails_set_outbound_capacity_msat(&this_ptr_conv, val);
15993 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1get_1inbound_1capacity_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
15994 LDKChannelDetails this_ptr_conv;
15995 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15996 this_ptr_conv.is_owned = false;
15997 int64_t ret_val = ChannelDetails_get_inbound_capacity_msat(&this_ptr_conv);
16001 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1set_1inbound_1capacity_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
16002 LDKChannelDetails this_ptr_conv;
16003 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16004 this_ptr_conv.is_owned = false;
16005 ChannelDetails_set_inbound_capacity_msat(&this_ptr_conv, val);
16008 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1get_1confirmations_1required(JNIEnv *env, jclass clz, int64_t this_ptr) {
16009 LDKChannelDetails this_ptr_conv;
16010 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16011 this_ptr_conv.is_owned = false;
16012 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
16013 *ret_copy = ChannelDetails_get_confirmations_required(&this_ptr_conv);
16014 uint64_t ret_ref = (uint64_t)ret_copy;
16018 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1set_1confirmations_1required(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
16019 LDKChannelDetails this_ptr_conv;
16020 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16021 this_ptr_conv.is_owned = false;
16022 LDKCOption_u32Z val_conv = *(LDKCOption_u32Z*)(((uint64_t)val) & ~1);
16023 ChannelDetails_set_confirmations_required(&this_ptr_conv, val_conv);
16026 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1get_1force_1close_1spend_1delay(JNIEnv *env, jclass clz, int64_t this_ptr) {
16027 LDKChannelDetails this_ptr_conv;
16028 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16029 this_ptr_conv.is_owned = false;
16030 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
16031 *ret_copy = ChannelDetails_get_force_close_spend_delay(&this_ptr_conv);
16032 uint64_t ret_ref = (uint64_t)ret_copy;
16036 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1set_1force_1close_1spend_1delay(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
16037 LDKChannelDetails this_ptr_conv;
16038 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16039 this_ptr_conv.is_owned = false;
16040 LDKCOption_u16Z val_conv = *(LDKCOption_u16Z*)(((uint64_t)val) & ~1);
16041 ChannelDetails_set_force_close_spend_delay(&this_ptr_conv, val_conv);
16044 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1get_1is_1outbound(JNIEnv *env, jclass clz, int64_t this_ptr) {
16045 LDKChannelDetails this_ptr_conv;
16046 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16047 this_ptr_conv.is_owned = false;
16048 jboolean ret_val = ChannelDetails_get_is_outbound(&this_ptr_conv);
16052 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1set_1is_1outbound(JNIEnv *env, jclass clz, int64_t this_ptr, jboolean val) {
16053 LDKChannelDetails this_ptr_conv;
16054 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16055 this_ptr_conv.is_owned = false;
16056 ChannelDetails_set_is_outbound(&this_ptr_conv, val);
16059 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1get_1is_1funding_1locked(JNIEnv *env, jclass clz, int64_t this_ptr) {
16060 LDKChannelDetails this_ptr_conv;
16061 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16062 this_ptr_conv.is_owned = false;
16063 jboolean ret_val = ChannelDetails_get_is_funding_locked(&this_ptr_conv);
16067 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1set_1is_1funding_1locked(JNIEnv *env, jclass clz, int64_t this_ptr, jboolean val) {
16068 LDKChannelDetails this_ptr_conv;
16069 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16070 this_ptr_conv.is_owned = false;
16071 ChannelDetails_set_is_funding_locked(&this_ptr_conv, val);
16074 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1get_1is_1usable(JNIEnv *env, jclass clz, int64_t this_ptr) {
16075 LDKChannelDetails this_ptr_conv;
16076 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16077 this_ptr_conv.is_owned = false;
16078 jboolean ret_val = ChannelDetails_get_is_usable(&this_ptr_conv);
16082 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1set_1is_1usable(JNIEnv *env, jclass clz, int64_t this_ptr, jboolean val) {
16083 LDKChannelDetails this_ptr_conv;
16084 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16085 this_ptr_conv.is_owned = false;
16086 ChannelDetails_set_is_usable(&this_ptr_conv, val);
16089 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1get_1is_1public(JNIEnv *env, jclass clz, int64_t this_ptr) {
16090 LDKChannelDetails this_ptr_conv;
16091 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16092 this_ptr_conv.is_owned = false;
16093 jboolean ret_val = ChannelDetails_get_is_public(&this_ptr_conv);
16097 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1set_1is_1public(JNIEnv *env, jclass clz, int64_t this_ptr, jboolean val) {
16098 LDKChannelDetails this_ptr_conv;
16099 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16100 this_ptr_conv.is_owned = false;
16101 ChannelDetails_set_is_public(&this_ptr_conv, val);
16104 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1new(JNIEnv *env, jclass clz, int8_tArray channel_id_arg, int64_t counterparty_arg, int64_t funding_txo_arg, int64_t short_channel_id_arg, int64_t channel_value_satoshis_arg, int64_t unspendable_punishment_reserve_arg, int64_t user_id_arg, int64_t outbound_capacity_msat_arg, int64_t inbound_capacity_msat_arg, int64_t confirmations_required_arg, int64_t force_close_spend_delay_arg, jboolean is_outbound_arg, jboolean is_funding_locked_arg, jboolean is_usable_arg, jboolean is_public_arg) {
16105 LDKThirtyTwoBytes channel_id_arg_ref;
16106 CHECK((*env)->GetArrayLength(env, channel_id_arg) == 32);
16107 (*env)->GetByteArrayRegion(env, channel_id_arg, 0, 32, channel_id_arg_ref.data);
16108 LDKChannelCounterparty counterparty_arg_conv;
16109 counterparty_arg_conv.inner = (void*)(counterparty_arg & (~1));
16110 counterparty_arg_conv.is_owned = (counterparty_arg & 1) || (counterparty_arg == 0);
16111 counterparty_arg_conv = ChannelCounterparty_clone(&counterparty_arg_conv);
16112 LDKOutPoint funding_txo_arg_conv;
16113 funding_txo_arg_conv.inner = (void*)(funding_txo_arg & (~1));
16114 funding_txo_arg_conv.is_owned = (funding_txo_arg & 1) || (funding_txo_arg == 0);
16115 funding_txo_arg_conv = OutPoint_clone(&funding_txo_arg_conv);
16116 LDKCOption_u64Z short_channel_id_arg_conv = *(LDKCOption_u64Z*)(((uint64_t)short_channel_id_arg) & ~1);
16117 LDKCOption_u64Z unspendable_punishment_reserve_arg_conv = *(LDKCOption_u64Z*)(((uint64_t)unspendable_punishment_reserve_arg) & ~1);
16118 LDKCOption_u32Z confirmations_required_arg_conv = *(LDKCOption_u32Z*)(((uint64_t)confirmations_required_arg) & ~1);
16119 LDKCOption_u16Z force_close_spend_delay_arg_conv = *(LDKCOption_u16Z*)(((uint64_t)force_close_spend_delay_arg) & ~1);
16120 LDKChannelDetails ret_var = ChannelDetails_new(channel_id_arg_ref, counterparty_arg_conv, funding_txo_arg_conv, short_channel_id_arg_conv, channel_value_satoshis_arg, unspendable_punishment_reserve_arg_conv, user_id_arg, outbound_capacity_msat_arg, inbound_capacity_msat_arg, confirmations_required_arg_conv, force_close_spend_delay_arg_conv, is_outbound_arg, is_funding_locked_arg, is_usable_arg, is_public_arg);
16121 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16122 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16123 uint64_t ret_ref = (uint64_t)ret_var.inner;
16124 if (ret_var.is_owned) {
16130 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1clone(JNIEnv *env, jclass clz, int64_t orig) {
16131 LDKChannelDetails orig_conv;
16132 orig_conv.inner = (void*)(orig & (~1));
16133 orig_conv.is_owned = false;
16134 LDKChannelDetails ret_var = ChannelDetails_clone(&orig_conv);
16135 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16136 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16137 uint64_t ret_ref = (uint64_t)ret_var.inner;
16138 if (ret_var.is_owned) {
16144 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_PaymentSendFailure_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
16145 if ((this_ptr & 1) != 0) return;
16146 LDKPaymentSendFailure this_ptr_conv = *(LDKPaymentSendFailure*)(((uint64_t)this_ptr) & ~1);
16147 FREE((void*)this_ptr);
16148 PaymentSendFailure_free(this_ptr_conv);
16151 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PaymentSendFailure_1clone(JNIEnv *env, jclass clz, int64_t orig) {
16152 LDKPaymentSendFailure* orig_conv = (LDKPaymentSendFailure*)orig;
16153 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
16154 *ret_copy = PaymentSendFailure_clone(orig_conv);
16155 uint64_t ret_ref = (uint64_t)ret_copy;
16159 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManager_1new(JNIEnv *env, jclass clz, int64_t fee_est, int64_t chain_monitor, int64_t tx_broadcaster, int64_t logger, int64_t keys_manager, int64_t config, int64_t params) {
16160 LDKFeeEstimator fee_est_conv = *(LDKFeeEstimator*)(((uint64_t)fee_est) & ~1);
16161 if (fee_est_conv.free == LDKFeeEstimator_JCalls_free) {
16162 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
16163 LDKFeeEstimator_JCalls_clone(fee_est_conv.this_arg);
16165 LDKWatch chain_monitor_conv = *(LDKWatch*)(((uint64_t)chain_monitor) & ~1);
16166 if (chain_monitor_conv.free == LDKWatch_JCalls_free) {
16167 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
16168 LDKWatch_JCalls_clone(chain_monitor_conv.this_arg);
16170 LDKBroadcasterInterface tx_broadcaster_conv = *(LDKBroadcasterInterface*)(((uint64_t)tx_broadcaster) & ~1);
16171 if (tx_broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
16172 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
16173 LDKBroadcasterInterface_JCalls_clone(tx_broadcaster_conv.this_arg);
16175 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
16176 if (logger_conv.free == LDKLogger_JCalls_free) {
16177 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
16178 LDKLogger_JCalls_clone(logger_conv.this_arg);
16180 LDKKeysInterface keys_manager_conv = *(LDKKeysInterface*)(((uint64_t)keys_manager) & ~1);
16181 if (keys_manager_conv.free == LDKKeysInterface_JCalls_free) {
16182 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
16183 LDKKeysInterface_JCalls_clone(keys_manager_conv.this_arg);
16185 LDKUserConfig config_conv;
16186 config_conv.inner = (void*)(config & (~1));
16187 config_conv.is_owned = (config & 1) || (config == 0);
16188 config_conv = UserConfig_clone(&config_conv);
16189 LDKChainParameters params_conv;
16190 params_conv.inner = (void*)(params & (~1));
16191 params_conv.is_owned = (params & 1) || (params == 0);
16192 params_conv = ChainParameters_clone(¶ms_conv);
16193 LDKChannelManager ret_var = ChannelManager_new(fee_est_conv, chain_monitor_conv, tx_broadcaster_conv, logger_conv, keys_manager_conv, config_conv, params_conv);
16194 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16195 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16196 uint64_t ret_ref = (uint64_t)ret_var.inner;
16197 if (ret_var.is_owned) {
16203 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManager_1get_1current_1default_1configuration(JNIEnv *env, jclass clz, int64_t this_arg) {
16204 LDKChannelManager this_arg_conv;
16205 this_arg_conv.inner = (void*)(this_arg & (~1));
16206 this_arg_conv.is_owned = false;
16207 LDKUserConfig ret_var = ChannelManager_get_current_default_configuration(&this_arg_conv);
16208 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16209 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16210 uint64_t ret_ref = (uint64_t)ret_var.inner;
16211 if (ret_var.is_owned) {
16217 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManager_1create_1channel(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_network_key, int64_t channel_value_satoshis, int64_t push_msat, int64_t user_id, int64_t override_config) {
16218 LDKChannelManager this_arg_conv;
16219 this_arg_conv.inner = (void*)(this_arg & (~1));
16220 this_arg_conv.is_owned = false;
16221 LDKPublicKey their_network_key_ref;
16222 CHECK((*env)->GetArrayLength(env, their_network_key) == 33);
16223 (*env)->GetByteArrayRegion(env, their_network_key, 0, 33, their_network_key_ref.compressed_form);
16224 LDKUserConfig override_config_conv;
16225 override_config_conv.inner = (void*)(override_config & (~1));
16226 override_config_conv.is_owned = (override_config & 1) || (override_config == 0);
16227 override_config_conv = UserConfig_clone(&override_config_conv);
16228 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
16229 *ret_conv = ChannelManager_create_channel(&this_arg_conv, their_network_key_ref, channel_value_satoshis, push_msat, user_id, override_config_conv);
16230 return (uint64_t)ret_conv;
16233 JNIEXPORT int64_tArray JNICALL Java_org_ldk_impl_bindings_ChannelManager_1list_1channels(JNIEnv *env, jclass clz, int64_t this_arg) {
16234 LDKChannelManager this_arg_conv;
16235 this_arg_conv.inner = (void*)(this_arg & (~1));
16236 this_arg_conv.is_owned = false;
16237 LDKCVec_ChannelDetailsZ ret_var = ChannelManager_list_channels(&this_arg_conv);
16238 int64_tArray ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
16239 int64_t *ret_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, ret_arr, NULL);
16240 for (size_t q = 0; q < ret_var.datalen; q++) {
16241 LDKChannelDetails ret_conv_16_var = ret_var.data[q];
16242 CHECK((((uint64_t)ret_conv_16_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16243 CHECK((((uint64_t)&ret_conv_16_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16244 uint64_t ret_conv_16_ref = (uint64_t)ret_conv_16_var.inner;
16245 if (ret_conv_16_var.is_owned) {
16246 ret_conv_16_ref |= 1;
16248 ret_arr_ptr[q] = ret_conv_16_ref;
16250 (*env)->ReleasePrimitiveArrayCritical(env, ret_arr, ret_arr_ptr, 0);
16251 FREE(ret_var.data);
16255 JNIEXPORT int64_tArray JNICALL Java_org_ldk_impl_bindings_ChannelManager_1list_1usable_1channels(JNIEnv *env, jclass clz, int64_t this_arg) {
16256 LDKChannelManager this_arg_conv;
16257 this_arg_conv.inner = (void*)(this_arg & (~1));
16258 this_arg_conv.is_owned = false;
16259 LDKCVec_ChannelDetailsZ ret_var = ChannelManager_list_usable_channels(&this_arg_conv);
16260 int64_tArray ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
16261 int64_t *ret_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, ret_arr, NULL);
16262 for (size_t q = 0; q < ret_var.datalen; q++) {
16263 LDKChannelDetails ret_conv_16_var = ret_var.data[q];
16264 CHECK((((uint64_t)ret_conv_16_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16265 CHECK((((uint64_t)&ret_conv_16_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16266 uint64_t ret_conv_16_ref = (uint64_t)ret_conv_16_var.inner;
16267 if (ret_conv_16_var.is_owned) {
16268 ret_conv_16_ref |= 1;
16270 ret_arr_ptr[q] = ret_conv_16_ref;
16272 (*env)->ReleasePrimitiveArrayCritical(env, ret_arr, ret_arr_ptr, 0);
16273 FREE(ret_var.data);
16277 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManager_1close_1channel(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray channel_id) {
16278 LDKChannelManager this_arg_conv;
16279 this_arg_conv.inner = (void*)(this_arg & (~1));
16280 this_arg_conv.is_owned = false;
16281 unsigned char channel_id_arr[32];
16282 CHECK((*env)->GetArrayLength(env, channel_id) == 32);
16283 (*env)->GetByteArrayRegion(env, channel_id, 0, 32, channel_id_arr);
16284 unsigned char (*channel_id_ref)[32] = &channel_id_arr;
16285 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
16286 *ret_conv = ChannelManager_close_channel(&this_arg_conv, channel_id_ref);
16287 return (uint64_t)ret_conv;
16290 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManager_1force_1close_1channel(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray channel_id) {
16291 LDKChannelManager this_arg_conv;
16292 this_arg_conv.inner = (void*)(this_arg & (~1));
16293 this_arg_conv.is_owned = false;
16294 unsigned char channel_id_arr[32];
16295 CHECK((*env)->GetArrayLength(env, channel_id) == 32);
16296 (*env)->GetByteArrayRegion(env, channel_id, 0, 32, channel_id_arr);
16297 unsigned char (*channel_id_ref)[32] = &channel_id_arr;
16298 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
16299 *ret_conv = ChannelManager_force_close_channel(&this_arg_conv, channel_id_ref);
16300 return (uint64_t)ret_conv;
16303 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelManager_1force_1close_1all_1channels(JNIEnv *env, jclass clz, int64_t this_arg) {
16304 LDKChannelManager this_arg_conv;
16305 this_arg_conv.inner = (void*)(this_arg & (~1));
16306 this_arg_conv.is_owned = false;
16307 ChannelManager_force_close_all_channels(&this_arg_conv);
16310 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManager_1send_1payment(JNIEnv *env, jclass clz, int64_t this_arg, int64_t route, int8_tArray payment_hash, int8_tArray payment_secret) {
16311 LDKChannelManager this_arg_conv;
16312 this_arg_conv.inner = (void*)(this_arg & (~1));
16313 this_arg_conv.is_owned = false;
16314 LDKRoute route_conv;
16315 route_conv.inner = (void*)(route & (~1));
16316 route_conv.is_owned = false;
16317 LDKThirtyTwoBytes payment_hash_ref;
16318 CHECK((*env)->GetArrayLength(env, payment_hash) == 32);
16319 (*env)->GetByteArrayRegion(env, payment_hash, 0, 32, payment_hash_ref.data);
16320 LDKThirtyTwoBytes payment_secret_ref;
16321 CHECK((*env)->GetArrayLength(env, payment_secret) == 32);
16322 (*env)->GetByteArrayRegion(env, payment_secret, 0, 32, payment_secret_ref.data);
16323 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
16324 *ret_conv = ChannelManager_send_payment(&this_arg_conv, &route_conv, payment_hash_ref, payment_secret_ref);
16325 return (uint64_t)ret_conv;
16328 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManager_1funding_1transaction_1generated(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray temporary_channel_id, int8_tArray funding_transaction) {
16329 LDKChannelManager this_arg_conv;
16330 this_arg_conv.inner = (void*)(this_arg & (~1));
16331 this_arg_conv.is_owned = false;
16332 unsigned char temporary_channel_id_arr[32];
16333 CHECK((*env)->GetArrayLength(env, temporary_channel_id) == 32);
16334 (*env)->GetByteArrayRegion(env, temporary_channel_id, 0, 32, temporary_channel_id_arr);
16335 unsigned char (*temporary_channel_id_ref)[32] = &temporary_channel_id_arr;
16336 LDKTransaction funding_transaction_ref;
16337 funding_transaction_ref.datalen = (*env)->GetArrayLength(env, funding_transaction);
16338 funding_transaction_ref.data = MALLOC(funding_transaction_ref.datalen, "LDKTransaction Bytes");
16339 (*env)->GetByteArrayRegion(env, funding_transaction, 0, funding_transaction_ref.datalen, funding_transaction_ref.data);
16340 funding_transaction_ref.data_is_owned = true;
16341 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
16342 *ret_conv = ChannelManager_funding_transaction_generated(&this_arg_conv, temporary_channel_id_ref, funding_transaction_ref);
16343 return (uint64_t)ret_conv;
16346 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelManager_1broadcast_1node_1announcement(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray rgb, int8_tArray alias, int64_tArray addresses) {
16347 LDKChannelManager this_arg_conv;
16348 this_arg_conv.inner = (void*)(this_arg & (~1));
16349 this_arg_conv.is_owned = false;
16350 LDKThreeBytes rgb_ref;
16351 CHECK((*env)->GetArrayLength(env, rgb) == 3);
16352 (*env)->GetByteArrayRegion(env, rgb, 0, 3, rgb_ref.data);
16353 LDKThirtyTwoBytes alias_ref;
16354 CHECK((*env)->GetArrayLength(env, alias) == 32);
16355 (*env)->GetByteArrayRegion(env, alias, 0, 32, alias_ref.data);
16356 LDKCVec_NetAddressZ addresses_constr;
16357 addresses_constr.datalen = (*env)->GetArrayLength(env, addresses);
16358 if (addresses_constr.datalen > 0)
16359 addresses_constr.data = MALLOC(addresses_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
16361 addresses_constr.data = NULL;
16362 int64_t* addresses_vals = (*env)->GetLongArrayElements (env, addresses, NULL);
16363 for (size_t m = 0; m < addresses_constr.datalen; m++) {
16364 int64_t addresses_conv_12 = addresses_vals[m];
16365 LDKNetAddress addresses_conv_12_conv = *(LDKNetAddress*)(((uint64_t)addresses_conv_12) & ~1);
16366 addresses_constr.data[m] = addresses_conv_12_conv;
16368 (*env)->ReleaseLongArrayElements(env, addresses, addresses_vals, 0);
16369 ChannelManager_broadcast_node_announcement(&this_arg_conv, rgb_ref, alias_ref, addresses_constr);
16372 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelManager_1process_1pending_1htlc_1forwards(JNIEnv *env, jclass clz, int64_t this_arg) {
16373 LDKChannelManager this_arg_conv;
16374 this_arg_conv.inner = (void*)(this_arg & (~1));
16375 this_arg_conv.is_owned = false;
16376 ChannelManager_process_pending_htlc_forwards(&this_arg_conv);
16379 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelManager_1timer_1tick_1occurred(JNIEnv *env, jclass clz, int64_t this_arg) {
16380 LDKChannelManager this_arg_conv;
16381 this_arg_conv.inner = (void*)(this_arg & (~1));
16382 this_arg_conv.is_owned = false;
16383 ChannelManager_timer_tick_occurred(&this_arg_conv);
16386 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_ChannelManager_1fail_1htlc_1backwards(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray payment_hash) {
16387 LDKChannelManager this_arg_conv;
16388 this_arg_conv.inner = (void*)(this_arg & (~1));
16389 this_arg_conv.is_owned = false;
16390 unsigned char payment_hash_arr[32];
16391 CHECK((*env)->GetArrayLength(env, payment_hash) == 32);
16392 (*env)->GetByteArrayRegion(env, payment_hash, 0, 32, payment_hash_arr);
16393 unsigned char (*payment_hash_ref)[32] = &payment_hash_arr;
16394 jboolean ret_val = ChannelManager_fail_htlc_backwards(&this_arg_conv, payment_hash_ref);
16398 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_ChannelManager_1claim_1funds(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray payment_preimage) {
16399 LDKChannelManager this_arg_conv;
16400 this_arg_conv.inner = (void*)(this_arg & (~1));
16401 this_arg_conv.is_owned = false;
16402 LDKThirtyTwoBytes payment_preimage_ref;
16403 CHECK((*env)->GetArrayLength(env, payment_preimage) == 32);
16404 (*env)->GetByteArrayRegion(env, payment_preimage, 0, 32, payment_preimage_ref.data);
16405 jboolean ret_val = ChannelManager_claim_funds(&this_arg_conv, payment_preimage_ref);
16409 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelManager_1get_1our_1node_1id(JNIEnv *env, jclass clz, int64_t this_arg) {
16410 LDKChannelManager this_arg_conv;
16411 this_arg_conv.inner = (void*)(this_arg & (~1));
16412 this_arg_conv.is_owned = false;
16413 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
16414 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ChannelManager_get_our_node_id(&this_arg_conv).compressed_form);
16418 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelManager_1channel_1monitor_1updated(JNIEnv *env, jclass clz, int64_t this_arg, int64_t funding_txo, int64_t highest_applied_update_id) {
16419 LDKChannelManager this_arg_conv;
16420 this_arg_conv.inner = (void*)(this_arg & (~1));
16421 this_arg_conv.is_owned = false;
16422 LDKOutPoint funding_txo_conv;
16423 funding_txo_conv.inner = (void*)(funding_txo & (~1));
16424 funding_txo_conv.is_owned = false;
16425 ChannelManager_channel_monitor_updated(&this_arg_conv, &funding_txo_conv, highest_applied_update_id);
16428 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManager_1create_1inbound_1payment(JNIEnv *env, jclass clz, int64_t this_arg, int64_t min_value_msat, int32_t invoice_expiry_delta_secs, int64_t user_payment_id) {
16429 LDKChannelManager this_arg_conv;
16430 this_arg_conv.inner = (void*)(this_arg & (~1));
16431 this_arg_conv.is_owned = false;
16432 LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(((uint64_t)min_value_msat) & ~1);
16433 LDKC2Tuple_PaymentHashPaymentSecretZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
16434 *ret_ref = ChannelManager_create_inbound_payment(&this_arg_conv, min_value_msat_conv, invoice_expiry_delta_secs, user_payment_id);
16435 return (uint64_t)ret_ref;
16438 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManager_1create_1inbound_1payment_1for_1hash(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray payment_hash, int64_t min_value_msat, int32_t invoice_expiry_delta_secs, int64_t user_payment_id) {
16439 LDKChannelManager this_arg_conv;
16440 this_arg_conv.inner = (void*)(this_arg & (~1));
16441 this_arg_conv.is_owned = false;
16442 LDKThirtyTwoBytes payment_hash_ref;
16443 CHECK((*env)->GetArrayLength(env, payment_hash) == 32);
16444 (*env)->GetByteArrayRegion(env, payment_hash, 0, 32, payment_hash_ref.data);
16445 LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(((uint64_t)min_value_msat) & ~1);
16446 LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
16447 *ret_conv = ChannelManager_create_inbound_payment_for_hash(&this_arg_conv, payment_hash_ref, min_value_msat_conv, invoice_expiry_delta_secs, user_payment_id);
16448 return (uint64_t)ret_conv;
16451 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManager_1as_1MessageSendEventsProvider(JNIEnv *env, jclass clz, int64_t this_arg) {
16452 LDKChannelManager this_arg_conv;
16453 this_arg_conv.inner = (void*)(this_arg & (~1));
16454 this_arg_conv.is_owned = false;
16455 LDKMessageSendEventsProvider* ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
16456 *ret = ChannelManager_as_MessageSendEventsProvider(&this_arg_conv);
16457 return (uint64_t)ret;
16460 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManager_1as_1EventsProvider(JNIEnv *env, jclass clz, int64_t this_arg) {
16461 LDKChannelManager this_arg_conv;
16462 this_arg_conv.inner = (void*)(this_arg & (~1));
16463 this_arg_conv.is_owned = false;
16464 LDKEventsProvider* ret = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider");
16465 *ret = ChannelManager_as_EventsProvider(&this_arg_conv);
16466 return (uint64_t)ret;
16469 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManager_1as_1Listen(JNIEnv *env, jclass clz, int64_t this_arg) {
16470 LDKChannelManager this_arg_conv;
16471 this_arg_conv.inner = (void*)(this_arg & (~1));
16472 this_arg_conv.is_owned = false;
16473 LDKListen* ret = MALLOC(sizeof(LDKListen), "LDKListen");
16474 *ret = ChannelManager_as_Listen(&this_arg_conv);
16475 return (uint64_t)ret;
16478 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManager_1as_1Confirm(JNIEnv *env, jclass clz, int64_t this_arg) {
16479 LDKChannelManager this_arg_conv;
16480 this_arg_conv.inner = (void*)(this_arg & (~1));
16481 this_arg_conv.is_owned = false;
16482 LDKConfirm* ret = MALLOC(sizeof(LDKConfirm), "LDKConfirm");
16483 *ret = ChannelManager_as_Confirm(&this_arg_conv);
16484 return (uint64_t)ret;
16487 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_ChannelManager_1await_1persistable_1update_1timeout(JNIEnv *env, jclass clz, int64_t this_arg, int64_t max_wait) {
16488 LDKChannelManager this_arg_conv;
16489 this_arg_conv.inner = (void*)(this_arg & (~1));
16490 this_arg_conv.is_owned = false;
16491 jboolean ret_val = ChannelManager_await_persistable_update_timeout(&this_arg_conv, max_wait);
16495 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelManager_1await_1persistable_1update(JNIEnv *env, jclass clz, int64_t this_arg) {
16496 LDKChannelManager this_arg_conv;
16497 this_arg_conv.inner = (void*)(this_arg & (~1));
16498 this_arg_conv.is_owned = false;
16499 ChannelManager_await_persistable_update(&this_arg_conv);
16502 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManager_1current_1best_1block(JNIEnv *env, jclass clz, int64_t this_arg) {
16503 LDKChannelManager this_arg_conv;
16504 this_arg_conv.inner = (void*)(this_arg & (~1));
16505 this_arg_conv.is_owned = false;
16506 LDKBestBlock ret_var = ChannelManager_current_best_block(&this_arg_conv);
16507 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16508 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16509 uint64_t ret_ref = (uint64_t)ret_var.inner;
16510 if (ret_var.is_owned) {
16516 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManager_1as_1ChannelMessageHandler(JNIEnv *env, jclass clz, int64_t this_arg) {
16517 LDKChannelManager this_arg_conv;
16518 this_arg_conv.inner = (void*)(this_arg & (~1));
16519 this_arg_conv.is_owned = false;
16520 LDKChannelMessageHandler* ret = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
16521 *ret = ChannelManager_as_ChannelMessageHandler(&this_arg_conv);
16522 return (uint64_t)ret;
16525 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelManager_1write(JNIEnv *env, jclass clz, int64_t obj) {
16526 LDKChannelManager obj_conv;
16527 obj_conv.inner = (void*)(obj & (~1));
16528 obj_conv.is_owned = false;
16529 LDKCVec_u8Z ret_var = ChannelManager_write(&obj_conv);
16530 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
16531 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
16532 CVec_u8Z_free(ret_var);
16536 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelManagerReadArgs_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
16537 LDKChannelManagerReadArgs this_obj_conv;
16538 this_obj_conv.inner = (void*)(this_obj & (~1));
16539 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
16540 ChannelManagerReadArgs_free(this_obj_conv);
16543 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManagerReadArgs_1get_1keys_1manager(JNIEnv *env, jclass clz, int64_t this_ptr) {
16544 LDKChannelManagerReadArgs this_ptr_conv;
16545 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16546 this_ptr_conv.is_owned = false;
16547 uint64_t ret_ret = (uint64_t)ChannelManagerReadArgs_get_keys_manager(&this_ptr_conv);
16551 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelManagerReadArgs_1set_1keys_1manager(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
16552 LDKChannelManagerReadArgs this_ptr_conv;
16553 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16554 this_ptr_conv.is_owned = false;
16555 LDKKeysInterface val_conv = *(LDKKeysInterface*)(((uint64_t)val) & ~1);
16556 if (val_conv.free == LDKKeysInterface_JCalls_free) {
16557 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
16558 LDKKeysInterface_JCalls_clone(val_conv.this_arg);
16560 ChannelManagerReadArgs_set_keys_manager(&this_ptr_conv, val_conv);
16563 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManagerReadArgs_1get_1fee_1estimator(JNIEnv *env, jclass clz, int64_t this_ptr) {
16564 LDKChannelManagerReadArgs this_ptr_conv;
16565 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16566 this_ptr_conv.is_owned = false;
16567 uint64_t ret_ret = (uint64_t)ChannelManagerReadArgs_get_fee_estimator(&this_ptr_conv);
16571 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelManagerReadArgs_1set_1fee_1estimator(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
16572 LDKChannelManagerReadArgs this_ptr_conv;
16573 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16574 this_ptr_conv.is_owned = false;
16575 LDKFeeEstimator val_conv = *(LDKFeeEstimator*)(((uint64_t)val) & ~1);
16576 if (val_conv.free == LDKFeeEstimator_JCalls_free) {
16577 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
16578 LDKFeeEstimator_JCalls_clone(val_conv.this_arg);
16580 ChannelManagerReadArgs_set_fee_estimator(&this_ptr_conv, val_conv);
16583 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManagerReadArgs_1get_1chain_1monitor(JNIEnv *env, jclass clz, int64_t this_ptr) {
16584 LDKChannelManagerReadArgs this_ptr_conv;
16585 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16586 this_ptr_conv.is_owned = false;
16587 uint64_t ret_ret = (uint64_t)ChannelManagerReadArgs_get_chain_monitor(&this_ptr_conv);
16591 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelManagerReadArgs_1set_1chain_1monitor(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
16592 LDKChannelManagerReadArgs this_ptr_conv;
16593 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16594 this_ptr_conv.is_owned = false;
16595 LDKWatch val_conv = *(LDKWatch*)(((uint64_t)val) & ~1);
16596 if (val_conv.free == LDKWatch_JCalls_free) {
16597 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
16598 LDKWatch_JCalls_clone(val_conv.this_arg);
16600 ChannelManagerReadArgs_set_chain_monitor(&this_ptr_conv, val_conv);
16603 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManagerReadArgs_1get_1tx_1broadcaster(JNIEnv *env, jclass clz, int64_t this_ptr) {
16604 LDKChannelManagerReadArgs this_ptr_conv;
16605 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16606 this_ptr_conv.is_owned = false;
16607 uint64_t ret_ret = (uint64_t)ChannelManagerReadArgs_get_tx_broadcaster(&this_ptr_conv);
16611 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelManagerReadArgs_1set_1tx_1broadcaster(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
16612 LDKChannelManagerReadArgs this_ptr_conv;
16613 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16614 this_ptr_conv.is_owned = false;
16615 LDKBroadcasterInterface val_conv = *(LDKBroadcasterInterface*)(((uint64_t)val) & ~1);
16616 if (val_conv.free == LDKBroadcasterInterface_JCalls_free) {
16617 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
16618 LDKBroadcasterInterface_JCalls_clone(val_conv.this_arg);
16620 ChannelManagerReadArgs_set_tx_broadcaster(&this_ptr_conv, val_conv);
16623 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManagerReadArgs_1get_1logger(JNIEnv *env, jclass clz, int64_t this_ptr) {
16624 LDKChannelManagerReadArgs this_ptr_conv;
16625 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16626 this_ptr_conv.is_owned = false;
16627 uint64_t ret_ret = (uint64_t)ChannelManagerReadArgs_get_logger(&this_ptr_conv);
16631 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelManagerReadArgs_1set_1logger(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
16632 LDKChannelManagerReadArgs this_ptr_conv;
16633 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16634 this_ptr_conv.is_owned = false;
16635 LDKLogger val_conv = *(LDKLogger*)(((uint64_t)val) & ~1);
16636 if (val_conv.free == LDKLogger_JCalls_free) {
16637 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
16638 LDKLogger_JCalls_clone(val_conv.this_arg);
16640 ChannelManagerReadArgs_set_logger(&this_ptr_conv, val_conv);
16643 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManagerReadArgs_1get_1default_1config(JNIEnv *env, jclass clz, int64_t this_ptr) {
16644 LDKChannelManagerReadArgs this_ptr_conv;
16645 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16646 this_ptr_conv.is_owned = false;
16647 LDKUserConfig ret_var = ChannelManagerReadArgs_get_default_config(&this_ptr_conv);
16648 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16649 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16650 uint64_t ret_ref = (uint64_t)ret_var.inner;
16651 if (ret_var.is_owned) {
16657 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelManagerReadArgs_1set_1default_1config(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
16658 LDKChannelManagerReadArgs this_ptr_conv;
16659 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16660 this_ptr_conv.is_owned = false;
16661 LDKUserConfig val_conv;
16662 val_conv.inner = (void*)(val & (~1));
16663 val_conv.is_owned = (val & 1) || (val == 0);
16664 val_conv = UserConfig_clone(&val_conv);
16665 ChannelManagerReadArgs_set_default_config(&this_ptr_conv, val_conv);
16668 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManagerReadArgs_1new(JNIEnv *env, jclass clz, int64_t keys_manager, int64_t fee_estimator, int64_t chain_monitor, int64_t tx_broadcaster, int64_t logger, int64_t default_config, int64_tArray channel_monitors) {
16669 LDKKeysInterface keys_manager_conv = *(LDKKeysInterface*)(((uint64_t)keys_manager) & ~1);
16670 if (keys_manager_conv.free == LDKKeysInterface_JCalls_free) {
16671 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
16672 LDKKeysInterface_JCalls_clone(keys_manager_conv.this_arg);
16674 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(((uint64_t)fee_estimator) & ~1);
16675 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
16676 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
16677 LDKFeeEstimator_JCalls_clone(fee_estimator_conv.this_arg);
16679 LDKWatch chain_monitor_conv = *(LDKWatch*)(((uint64_t)chain_monitor) & ~1);
16680 if (chain_monitor_conv.free == LDKWatch_JCalls_free) {
16681 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
16682 LDKWatch_JCalls_clone(chain_monitor_conv.this_arg);
16684 LDKBroadcasterInterface tx_broadcaster_conv = *(LDKBroadcasterInterface*)(((uint64_t)tx_broadcaster) & ~1);
16685 if (tx_broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
16686 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
16687 LDKBroadcasterInterface_JCalls_clone(tx_broadcaster_conv.this_arg);
16689 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
16690 if (logger_conv.free == LDKLogger_JCalls_free) {
16691 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
16692 LDKLogger_JCalls_clone(logger_conv.this_arg);
16694 LDKUserConfig default_config_conv;
16695 default_config_conv.inner = (void*)(default_config & (~1));
16696 default_config_conv.is_owned = (default_config & 1) || (default_config == 0);
16697 default_config_conv = UserConfig_clone(&default_config_conv);
16698 LDKCVec_ChannelMonitorZ channel_monitors_constr;
16699 channel_monitors_constr.datalen = (*env)->GetArrayLength(env, channel_monitors);
16700 if (channel_monitors_constr.datalen > 0)
16701 channel_monitors_constr.data = MALLOC(channel_monitors_constr.datalen * sizeof(LDKChannelMonitor), "LDKCVec_ChannelMonitorZ Elements");
16703 channel_monitors_constr.data = NULL;
16704 int64_t* channel_monitors_vals = (*env)->GetLongArrayElements (env, channel_monitors, NULL);
16705 for (size_t q = 0; q < channel_monitors_constr.datalen; q++) {
16706 int64_t channel_monitors_conv_16 = channel_monitors_vals[q];
16707 LDKChannelMonitor channel_monitors_conv_16_conv;
16708 channel_monitors_conv_16_conv.inner = (void*)(channel_monitors_conv_16 & (~1));
16709 channel_monitors_conv_16_conv.is_owned = (channel_monitors_conv_16 & 1) || (channel_monitors_conv_16 == 0);
16710 channel_monitors_constr.data[q] = channel_monitors_conv_16_conv;
16712 (*env)->ReleaseLongArrayElements(env, channel_monitors, channel_monitors_vals, 0);
16713 LDKChannelManagerReadArgs ret_var = ChannelManagerReadArgs_new(keys_manager_conv, fee_estimator_conv, chain_monitor_conv, tx_broadcaster_conv, logger_conv, default_config_conv, channel_monitors_constr);
16714 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16715 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16716 uint64_t ret_ref = (uint64_t)ret_var.inner;
16717 if (ret_var.is_owned) {
16723 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1BlockHashChannelManagerZ_1read(JNIEnv *env, jclass clz, int8_tArray ser, int64_t arg) {
16724 LDKu8slice ser_ref;
16725 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
16726 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
16727 LDKChannelManagerReadArgs arg_conv;
16728 arg_conv.inner = (void*)(arg & (~1));
16729 arg_conv.is_owned = (arg & 1) || (arg == 0);
16730 // Warning: we need a move here but no clone is available for LDKChannelManagerReadArgs
16731 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ");
16732 *ret_conv = C2Tuple_BlockHashChannelManagerZ_read(ser_ref, arg_conv);
16733 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
16734 return (uint64_t)ret_conv;
16737 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DecodeError_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
16738 LDKDecodeError this_obj_conv;
16739 this_obj_conv.inner = (void*)(this_obj & (~1));
16740 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
16741 DecodeError_free(this_obj_conv);
16744 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DecodeError_1clone(JNIEnv *env, jclass clz, int64_t orig) {
16745 LDKDecodeError orig_conv;
16746 orig_conv.inner = (void*)(orig & (~1));
16747 orig_conv.is_owned = false;
16748 LDKDecodeError ret_var = DecodeError_clone(&orig_conv);
16749 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16750 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16751 uint64_t ret_ref = (uint64_t)ret_var.inner;
16752 if (ret_var.is_owned) {
16758 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Init_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
16759 LDKInit this_obj_conv;
16760 this_obj_conv.inner = (void*)(this_obj & (~1));
16761 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
16762 Init_free(this_obj_conv);
16765 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Init_1get_1features(JNIEnv *env, jclass clz, int64_t this_ptr) {
16766 LDKInit this_ptr_conv;
16767 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16768 this_ptr_conv.is_owned = false;
16769 LDKInitFeatures ret_var = Init_get_features(&this_ptr_conv);
16770 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16771 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16772 uint64_t ret_ref = (uint64_t)ret_var.inner;
16773 if (ret_var.is_owned) {
16779 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Init_1set_1features(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
16780 LDKInit this_ptr_conv;
16781 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16782 this_ptr_conv.is_owned = false;
16783 LDKInitFeatures val_conv;
16784 val_conv.inner = (void*)(val & (~1));
16785 val_conv.is_owned = (val & 1) || (val == 0);
16786 val_conv = InitFeatures_clone(&val_conv);
16787 Init_set_features(&this_ptr_conv, val_conv);
16790 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Init_1new(JNIEnv *env, jclass clz, int64_t features_arg) {
16791 LDKInitFeatures features_arg_conv;
16792 features_arg_conv.inner = (void*)(features_arg & (~1));
16793 features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0);
16794 features_arg_conv = InitFeatures_clone(&features_arg_conv);
16795 LDKInit ret_var = Init_new(features_arg_conv);
16796 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16797 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16798 uint64_t ret_ref = (uint64_t)ret_var.inner;
16799 if (ret_var.is_owned) {
16805 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Init_1clone(JNIEnv *env, jclass clz, int64_t orig) {
16807 orig_conv.inner = (void*)(orig & (~1));
16808 orig_conv.is_owned = false;
16809 LDKInit ret_var = Init_clone(&orig_conv);
16810 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16811 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16812 uint64_t ret_ref = (uint64_t)ret_var.inner;
16813 if (ret_var.is_owned) {
16819 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ErrorMessage_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
16820 LDKErrorMessage this_obj_conv;
16821 this_obj_conv.inner = (void*)(this_obj & (~1));
16822 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
16823 ErrorMessage_free(this_obj_conv);
16826 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ErrorMessage_1get_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
16827 LDKErrorMessage this_ptr_conv;
16828 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16829 this_ptr_conv.is_owned = false;
16830 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
16831 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *ErrorMessage_get_channel_id(&this_ptr_conv));
16835 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ErrorMessage_1set_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
16836 LDKErrorMessage this_ptr_conv;
16837 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16838 this_ptr_conv.is_owned = false;
16839 LDKThirtyTwoBytes val_ref;
16840 CHECK((*env)->GetArrayLength(env, val) == 32);
16841 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
16842 ErrorMessage_set_channel_id(&this_ptr_conv, val_ref);
16845 JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_ErrorMessage_1get_1data(JNIEnv *env, jclass clz, int64_t this_ptr) {
16846 LDKErrorMessage this_ptr_conv;
16847 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16848 this_ptr_conv.is_owned = false;
16849 LDKStr ret_str = ErrorMessage_get_data(&this_ptr_conv);
16850 jstring ret_conv = str_ref_to_java(env, ret_str.chars, ret_str.len);
16854 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ErrorMessage_1set_1data(JNIEnv *env, jclass clz, int64_t this_ptr, jstring val) {
16855 LDKErrorMessage this_ptr_conv;
16856 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16857 this_ptr_conv.is_owned = false;
16858 LDKStr val_conv = java_to_owned_str(env, val);
16859 ErrorMessage_set_data(&this_ptr_conv, val_conv);
16862 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ErrorMessage_1new(JNIEnv *env, jclass clz, int8_tArray channel_id_arg, jstring data_arg) {
16863 LDKThirtyTwoBytes channel_id_arg_ref;
16864 CHECK((*env)->GetArrayLength(env, channel_id_arg) == 32);
16865 (*env)->GetByteArrayRegion(env, channel_id_arg, 0, 32, channel_id_arg_ref.data);
16866 LDKStr data_arg_conv = java_to_owned_str(env, data_arg);
16867 LDKErrorMessage ret_var = ErrorMessage_new(channel_id_arg_ref, data_arg_conv);
16868 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16869 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16870 uint64_t ret_ref = (uint64_t)ret_var.inner;
16871 if (ret_var.is_owned) {
16877 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ErrorMessage_1clone(JNIEnv *env, jclass clz, int64_t orig) {
16878 LDKErrorMessage orig_conv;
16879 orig_conv.inner = (void*)(orig & (~1));
16880 orig_conv.is_owned = false;
16881 LDKErrorMessage ret_var = ErrorMessage_clone(&orig_conv);
16882 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16883 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16884 uint64_t ret_ref = (uint64_t)ret_var.inner;
16885 if (ret_var.is_owned) {
16891 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Ping_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
16892 LDKPing this_obj_conv;
16893 this_obj_conv.inner = (void*)(this_obj & (~1));
16894 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
16895 Ping_free(this_obj_conv);
16898 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_Ping_1get_1ponglen(JNIEnv *env, jclass clz, int64_t this_ptr) {
16899 LDKPing this_ptr_conv;
16900 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16901 this_ptr_conv.is_owned = false;
16902 int16_t ret_val = Ping_get_ponglen(&this_ptr_conv);
16906 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Ping_1set_1ponglen(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
16907 LDKPing this_ptr_conv;
16908 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16909 this_ptr_conv.is_owned = false;
16910 Ping_set_ponglen(&this_ptr_conv, val);
16913 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_Ping_1get_1byteslen(JNIEnv *env, jclass clz, int64_t this_ptr) {
16914 LDKPing this_ptr_conv;
16915 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16916 this_ptr_conv.is_owned = false;
16917 int16_t ret_val = Ping_get_byteslen(&this_ptr_conv);
16921 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Ping_1set_1byteslen(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
16922 LDKPing this_ptr_conv;
16923 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16924 this_ptr_conv.is_owned = false;
16925 Ping_set_byteslen(&this_ptr_conv, val);
16928 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Ping_1new(JNIEnv *env, jclass clz, int16_t ponglen_arg, int16_t byteslen_arg) {
16929 LDKPing ret_var = Ping_new(ponglen_arg, byteslen_arg);
16930 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16931 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16932 uint64_t ret_ref = (uint64_t)ret_var.inner;
16933 if (ret_var.is_owned) {
16939 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Ping_1clone(JNIEnv *env, jclass clz, int64_t orig) {
16941 orig_conv.inner = (void*)(orig & (~1));
16942 orig_conv.is_owned = false;
16943 LDKPing ret_var = Ping_clone(&orig_conv);
16944 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16945 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16946 uint64_t ret_ref = (uint64_t)ret_var.inner;
16947 if (ret_var.is_owned) {
16953 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Pong_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
16954 LDKPong this_obj_conv;
16955 this_obj_conv.inner = (void*)(this_obj & (~1));
16956 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
16957 Pong_free(this_obj_conv);
16960 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_Pong_1get_1byteslen(JNIEnv *env, jclass clz, int64_t this_ptr) {
16961 LDKPong this_ptr_conv;
16962 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16963 this_ptr_conv.is_owned = false;
16964 int16_t ret_val = Pong_get_byteslen(&this_ptr_conv);
16968 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Pong_1set_1byteslen(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
16969 LDKPong this_ptr_conv;
16970 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16971 this_ptr_conv.is_owned = false;
16972 Pong_set_byteslen(&this_ptr_conv, val);
16975 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Pong_1new(JNIEnv *env, jclass clz, int16_t byteslen_arg) {
16976 LDKPong ret_var = Pong_new(byteslen_arg);
16977 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16978 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16979 uint64_t ret_ref = (uint64_t)ret_var.inner;
16980 if (ret_var.is_owned) {
16986 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Pong_1clone(JNIEnv *env, jclass clz, int64_t orig) {
16988 orig_conv.inner = (void*)(orig & (~1));
16989 orig_conv.is_owned = false;
16990 LDKPong ret_var = Pong_clone(&orig_conv);
16991 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16992 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16993 uint64_t ret_ref = (uint64_t)ret_var.inner;
16994 if (ret_var.is_owned) {
17000 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
17001 LDKOpenChannel this_obj_conv;
17002 this_obj_conv.inner = (void*)(this_obj & (~1));
17003 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
17004 OpenChannel_free(this_obj_conv);
17007 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1chain_1hash(JNIEnv *env, jclass clz, int64_t this_ptr) {
17008 LDKOpenChannel this_ptr_conv;
17009 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17010 this_ptr_conv.is_owned = false;
17011 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
17012 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *OpenChannel_get_chain_hash(&this_ptr_conv));
17016 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1chain_1hash(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17017 LDKOpenChannel this_ptr_conv;
17018 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17019 this_ptr_conv.is_owned = false;
17020 LDKThirtyTwoBytes val_ref;
17021 CHECK((*env)->GetArrayLength(env, val) == 32);
17022 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
17023 OpenChannel_set_chain_hash(&this_ptr_conv, val_ref);
17026 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1temporary_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
17027 LDKOpenChannel this_ptr_conv;
17028 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17029 this_ptr_conv.is_owned = false;
17030 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
17031 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *OpenChannel_get_temporary_channel_id(&this_ptr_conv));
17035 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1temporary_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17036 LDKOpenChannel this_ptr_conv;
17037 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17038 this_ptr_conv.is_owned = false;
17039 LDKThirtyTwoBytes val_ref;
17040 CHECK((*env)->GetArrayLength(env, val) == 32);
17041 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
17042 OpenChannel_set_temporary_channel_id(&this_ptr_conv, val_ref);
17045 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1funding_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr) {
17046 LDKOpenChannel this_ptr_conv;
17047 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17048 this_ptr_conv.is_owned = false;
17049 int64_t ret_val = OpenChannel_get_funding_satoshis(&this_ptr_conv);
17053 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1funding_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
17054 LDKOpenChannel this_ptr_conv;
17055 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17056 this_ptr_conv.is_owned = false;
17057 OpenChannel_set_funding_satoshis(&this_ptr_conv, val);
17060 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1push_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
17061 LDKOpenChannel this_ptr_conv;
17062 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17063 this_ptr_conv.is_owned = false;
17064 int64_t ret_val = OpenChannel_get_push_msat(&this_ptr_conv);
17068 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1push_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
17069 LDKOpenChannel this_ptr_conv;
17070 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17071 this_ptr_conv.is_owned = false;
17072 OpenChannel_set_push_msat(&this_ptr_conv, val);
17075 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1dust_1limit_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr) {
17076 LDKOpenChannel this_ptr_conv;
17077 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17078 this_ptr_conv.is_owned = false;
17079 int64_t ret_val = OpenChannel_get_dust_limit_satoshis(&this_ptr_conv);
17083 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1dust_1limit_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
17084 LDKOpenChannel this_ptr_conv;
17085 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17086 this_ptr_conv.is_owned = false;
17087 OpenChannel_set_dust_limit_satoshis(&this_ptr_conv, val);
17090 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1max_1htlc_1value_1in_1flight_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
17091 LDKOpenChannel this_ptr_conv;
17092 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17093 this_ptr_conv.is_owned = false;
17094 int64_t ret_val = OpenChannel_get_max_htlc_value_in_flight_msat(&this_ptr_conv);
17098 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1max_1htlc_1value_1in_1flight_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
17099 LDKOpenChannel this_ptr_conv;
17100 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17101 this_ptr_conv.is_owned = false;
17102 OpenChannel_set_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
17105 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1channel_1reserve_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr) {
17106 LDKOpenChannel this_ptr_conv;
17107 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17108 this_ptr_conv.is_owned = false;
17109 int64_t ret_val = OpenChannel_get_channel_reserve_satoshis(&this_ptr_conv);
17113 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1channel_1reserve_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
17114 LDKOpenChannel this_ptr_conv;
17115 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17116 this_ptr_conv.is_owned = false;
17117 OpenChannel_set_channel_reserve_satoshis(&this_ptr_conv, val);
17120 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1htlc_1minimum_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
17121 LDKOpenChannel this_ptr_conv;
17122 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17123 this_ptr_conv.is_owned = false;
17124 int64_t ret_val = OpenChannel_get_htlc_minimum_msat(&this_ptr_conv);
17128 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1htlc_1minimum_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
17129 LDKOpenChannel this_ptr_conv;
17130 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17131 this_ptr_conv.is_owned = false;
17132 OpenChannel_set_htlc_minimum_msat(&this_ptr_conv, val);
17135 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1feerate_1per_1kw(JNIEnv *env, jclass clz, int64_t this_ptr) {
17136 LDKOpenChannel this_ptr_conv;
17137 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17138 this_ptr_conv.is_owned = false;
17139 int32_t ret_val = OpenChannel_get_feerate_per_kw(&this_ptr_conv);
17143 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1feerate_1per_1kw(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
17144 LDKOpenChannel this_ptr_conv;
17145 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17146 this_ptr_conv.is_owned = false;
17147 OpenChannel_set_feerate_per_kw(&this_ptr_conv, val);
17150 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1to_1self_1delay(JNIEnv *env, jclass clz, int64_t this_ptr) {
17151 LDKOpenChannel this_ptr_conv;
17152 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17153 this_ptr_conv.is_owned = false;
17154 int16_t ret_val = OpenChannel_get_to_self_delay(&this_ptr_conv);
17158 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1to_1self_1delay(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
17159 LDKOpenChannel this_ptr_conv;
17160 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17161 this_ptr_conv.is_owned = false;
17162 OpenChannel_set_to_self_delay(&this_ptr_conv, val);
17165 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1max_1accepted_1htlcs(JNIEnv *env, jclass clz, int64_t this_ptr) {
17166 LDKOpenChannel this_ptr_conv;
17167 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17168 this_ptr_conv.is_owned = false;
17169 int16_t ret_val = OpenChannel_get_max_accepted_htlcs(&this_ptr_conv);
17173 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1max_1accepted_1htlcs(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
17174 LDKOpenChannel this_ptr_conv;
17175 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17176 this_ptr_conv.is_owned = false;
17177 OpenChannel_set_max_accepted_htlcs(&this_ptr_conv, val);
17180 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1funding_1pubkey(JNIEnv *env, jclass clz, int64_t this_ptr) {
17181 LDKOpenChannel this_ptr_conv;
17182 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17183 this_ptr_conv.is_owned = false;
17184 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
17185 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, OpenChannel_get_funding_pubkey(&this_ptr_conv).compressed_form);
17189 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1funding_1pubkey(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17190 LDKOpenChannel this_ptr_conv;
17191 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17192 this_ptr_conv.is_owned = false;
17193 LDKPublicKey val_ref;
17194 CHECK((*env)->GetArrayLength(env, val) == 33);
17195 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
17196 OpenChannel_set_funding_pubkey(&this_ptr_conv, val_ref);
17199 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1revocation_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr) {
17200 LDKOpenChannel this_ptr_conv;
17201 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17202 this_ptr_conv.is_owned = false;
17203 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
17204 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, OpenChannel_get_revocation_basepoint(&this_ptr_conv).compressed_form);
17208 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1revocation_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17209 LDKOpenChannel this_ptr_conv;
17210 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17211 this_ptr_conv.is_owned = false;
17212 LDKPublicKey val_ref;
17213 CHECK((*env)->GetArrayLength(env, val) == 33);
17214 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
17215 OpenChannel_set_revocation_basepoint(&this_ptr_conv, val_ref);
17218 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1payment_1point(JNIEnv *env, jclass clz, int64_t this_ptr) {
17219 LDKOpenChannel this_ptr_conv;
17220 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17221 this_ptr_conv.is_owned = false;
17222 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
17223 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, OpenChannel_get_payment_point(&this_ptr_conv).compressed_form);
17227 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1payment_1point(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17228 LDKOpenChannel this_ptr_conv;
17229 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17230 this_ptr_conv.is_owned = false;
17231 LDKPublicKey val_ref;
17232 CHECK((*env)->GetArrayLength(env, val) == 33);
17233 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
17234 OpenChannel_set_payment_point(&this_ptr_conv, val_ref);
17237 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1delayed_1payment_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr) {
17238 LDKOpenChannel this_ptr_conv;
17239 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17240 this_ptr_conv.is_owned = false;
17241 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
17242 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, OpenChannel_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form);
17246 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1delayed_1payment_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17247 LDKOpenChannel this_ptr_conv;
17248 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17249 this_ptr_conv.is_owned = false;
17250 LDKPublicKey val_ref;
17251 CHECK((*env)->GetArrayLength(env, val) == 33);
17252 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
17253 OpenChannel_set_delayed_payment_basepoint(&this_ptr_conv, val_ref);
17256 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1htlc_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr) {
17257 LDKOpenChannel this_ptr_conv;
17258 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17259 this_ptr_conv.is_owned = false;
17260 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
17261 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, OpenChannel_get_htlc_basepoint(&this_ptr_conv).compressed_form);
17265 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1htlc_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17266 LDKOpenChannel this_ptr_conv;
17267 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17268 this_ptr_conv.is_owned = false;
17269 LDKPublicKey val_ref;
17270 CHECK((*env)->GetArrayLength(env, val) == 33);
17271 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
17272 OpenChannel_set_htlc_basepoint(&this_ptr_conv, val_ref);
17275 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1first_1per_1commitment_1point(JNIEnv *env, jclass clz, int64_t this_ptr) {
17276 LDKOpenChannel this_ptr_conv;
17277 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17278 this_ptr_conv.is_owned = false;
17279 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
17280 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, OpenChannel_get_first_per_commitment_point(&this_ptr_conv).compressed_form);
17284 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1first_1per_1commitment_1point(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17285 LDKOpenChannel this_ptr_conv;
17286 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17287 this_ptr_conv.is_owned = false;
17288 LDKPublicKey val_ref;
17289 CHECK((*env)->GetArrayLength(env, val) == 33);
17290 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
17291 OpenChannel_set_first_per_commitment_point(&this_ptr_conv, val_ref);
17294 JNIEXPORT int8_t JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1channel_1flags(JNIEnv *env, jclass clz, int64_t this_ptr) {
17295 LDKOpenChannel this_ptr_conv;
17296 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17297 this_ptr_conv.is_owned = false;
17298 int8_t ret_val = OpenChannel_get_channel_flags(&this_ptr_conv);
17302 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1channel_1flags(JNIEnv *env, jclass clz, int64_t this_ptr, int8_t val) {
17303 LDKOpenChannel this_ptr_conv;
17304 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17305 this_ptr_conv.is_owned = false;
17306 OpenChannel_set_channel_flags(&this_ptr_conv, val);
17309 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OpenChannel_1clone(JNIEnv *env, jclass clz, int64_t orig) {
17310 LDKOpenChannel orig_conv;
17311 orig_conv.inner = (void*)(orig & (~1));
17312 orig_conv.is_owned = false;
17313 LDKOpenChannel ret_var = OpenChannel_clone(&orig_conv);
17314 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17315 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17316 uint64_t ret_ref = (uint64_t)ret_var.inner;
17317 if (ret_var.is_owned) {
17323 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
17324 LDKAcceptChannel this_obj_conv;
17325 this_obj_conv.inner = (void*)(this_obj & (~1));
17326 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
17327 AcceptChannel_free(this_obj_conv);
17330 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1get_1temporary_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
17331 LDKAcceptChannel this_ptr_conv;
17332 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17333 this_ptr_conv.is_owned = false;
17334 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
17335 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *AcceptChannel_get_temporary_channel_id(&this_ptr_conv));
17339 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1set_1temporary_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17340 LDKAcceptChannel this_ptr_conv;
17341 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17342 this_ptr_conv.is_owned = false;
17343 LDKThirtyTwoBytes val_ref;
17344 CHECK((*env)->GetArrayLength(env, val) == 32);
17345 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
17346 AcceptChannel_set_temporary_channel_id(&this_ptr_conv, val_ref);
17349 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1get_1dust_1limit_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr) {
17350 LDKAcceptChannel this_ptr_conv;
17351 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17352 this_ptr_conv.is_owned = false;
17353 int64_t ret_val = AcceptChannel_get_dust_limit_satoshis(&this_ptr_conv);
17357 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1set_1dust_1limit_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
17358 LDKAcceptChannel this_ptr_conv;
17359 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17360 this_ptr_conv.is_owned = false;
17361 AcceptChannel_set_dust_limit_satoshis(&this_ptr_conv, val);
17364 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1get_1max_1htlc_1value_1in_1flight_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
17365 LDKAcceptChannel this_ptr_conv;
17366 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17367 this_ptr_conv.is_owned = false;
17368 int64_t ret_val = AcceptChannel_get_max_htlc_value_in_flight_msat(&this_ptr_conv);
17372 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1set_1max_1htlc_1value_1in_1flight_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
17373 LDKAcceptChannel this_ptr_conv;
17374 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17375 this_ptr_conv.is_owned = false;
17376 AcceptChannel_set_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
17379 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1get_1channel_1reserve_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr) {
17380 LDKAcceptChannel this_ptr_conv;
17381 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17382 this_ptr_conv.is_owned = false;
17383 int64_t ret_val = AcceptChannel_get_channel_reserve_satoshis(&this_ptr_conv);
17387 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1set_1channel_1reserve_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
17388 LDKAcceptChannel this_ptr_conv;
17389 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17390 this_ptr_conv.is_owned = false;
17391 AcceptChannel_set_channel_reserve_satoshis(&this_ptr_conv, val);
17394 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1get_1htlc_1minimum_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
17395 LDKAcceptChannel this_ptr_conv;
17396 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17397 this_ptr_conv.is_owned = false;
17398 int64_t ret_val = AcceptChannel_get_htlc_minimum_msat(&this_ptr_conv);
17402 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1set_1htlc_1minimum_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
17403 LDKAcceptChannel this_ptr_conv;
17404 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17405 this_ptr_conv.is_owned = false;
17406 AcceptChannel_set_htlc_minimum_msat(&this_ptr_conv, val);
17409 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1get_1minimum_1depth(JNIEnv *env, jclass clz, int64_t this_ptr) {
17410 LDKAcceptChannel this_ptr_conv;
17411 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17412 this_ptr_conv.is_owned = false;
17413 int32_t ret_val = AcceptChannel_get_minimum_depth(&this_ptr_conv);
17417 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1set_1minimum_1depth(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
17418 LDKAcceptChannel this_ptr_conv;
17419 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17420 this_ptr_conv.is_owned = false;
17421 AcceptChannel_set_minimum_depth(&this_ptr_conv, val);
17424 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1get_1to_1self_1delay(JNIEnv *env, jclass clz, int64_t this_ptr) {
17425 LDKAcceptChannel this_ptr_conv;
17426 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17427 this_ptr_conv.is_owned = false;
17428 int16_t ret_val = AcceptChannel_get_to_self_delay(&this_ptr_conv);
17432 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1set_1to_1self_1delay(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
17433 LDKAcceptChannel this_ptr_conv;
17434 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17435 this_ptr_conv.is_owned = false;
17436 AcceptChannel_set_to_self_delay(&this_ptr_conv, val);
17439 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1get_1max_1accepted_1htlcs(JNIEnv *env, jclass clz, int64_t this_ptr) {
17440 LDKAcceptChannel this_ptr_conv;
17441 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17442 this_ptr_conv.is_owned = false;
17443 int16_t ret_val = AcceptChannel_get_max_accepted_htlcs(&this_ptr_conv);
17447 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1set_1max_1accepted_1htlcs(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
17448 LDKAcceptChannel this_ptr_conv;
17449 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17450 this_ptr_conv.is_owned = false;
17451 AcceptChannel_set_max_accepted_htlcs(&this_ptr_conv, val);
17454 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1get_1funding_1pubkey(JNIEnv *env, jclass clz, int64_t this_ptr) {
17455 LDKAcceptChannel this_ptr_conv;
17456 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17457 this_ptr_conv.is_owned = false;
17458 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
17459 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, AcceptChannel_get_funding_pubkey(&this_ptr_conv).compressed_form);
17463 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1set_1funding_1pubkey(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17464 LDKAcceptChannel this_ptr_conv;
17465 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17466 this_ptr_conv.is_owned = false;
17467 LDKPublicKey val_ref;
17468 CHECK((*env)->GetArrayLength(env, val) == 33);
17469 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
17470 AcceptChannel_set_funding_pubkey(&this_ptr_conv, val_ref);
17473 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1get_1revocation_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr) {
17474 LDKAcceptChannel this_ptr_conv;
17475 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17476 this_ptr_conv.is_owned = false;
17477 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
17478 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, AcceptChannel_get_revocation_basepoint(&this_ptr_conv).compressed_form);
17482 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1set_1revocation_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17483 LDKAcceptChannel this_ptr_conv;
17484 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17485 this_ptr_conv.is_owned = false;
17486 LDKPublicKey val_ref;
17487 CHECK((*env)->GetArrayLength(env, val) == 33);
17488 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
17489 AcceptChannel_set_revocation_basepoint(&this_ptr_conv, val_ref);
17492 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1get_1payment_1point(JNIEnv *env, jclass clz, int64_t this_ptr) {
17493 LDKAcceptChannel this_ptr_conv;
17494 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17495 this_ptr_conv.is_owned = false;
17496 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
17497 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, AcceptChannel_get_payment_point(&this_ptr_conv).compressed_form);
17501 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1set_1payment_1point(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17502 LDKAcceptChannel this_ptr_conv;
17503 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17504 this_ptr_conv.is_owned = false;
17505 LDKPublicKey val_ref;
17506 CHECK((*env)->GetArrayLength(env, val) == 33);
17507 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
17508 AcceptChannel_set_payment_point(&this_ptr_conv, val_ref);
17511 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1get_1delayed_1payment_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr) {
17512 LDKAcceptChannel this_ptr_conv;
17513 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17514 this_ptr_conv.is_owned = false;
17515 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
17516 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, AcceptChannel_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form);
17520 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1set_1delayed_1payment_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17521 LDKAcceptChannel this_ptr_conv;
17522 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17523 this_ptr_conv.is_owned = false;
17524 LDKPublicKey val_ref;
17525 CHECK((*env)->GetArrayLength(env, val) == 33);
17526 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
17527 AcceptChannel_set_delayed_payment_basepoint(&this_ptr_conv, val_ref);
17530 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1get_1htlc_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr) {
17531 LDKAcceptChannel this_ptr_conv;
17532 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17533 this_ptr_conv.is_owned = false;
17534 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
17535 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, AcceptChannel_get_htlc_basepoint(&this_ptr_conv).compressed_form);
17539 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1set_1htlc_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17540 LDKAcceptChannel this_ptr_conv;
17541 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17542 this_ptr_conv.is_owned = false;
17543 LDKPublicKey val_ref;
17544 CHECK((*env)->GetArrayLength(env, val) == 33);
17545 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
17546 AcceptChannel_set_htlc_basepoint(&this_ptr_conv, val_ref);
17549 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1get_1first_1per_1commitment_1point(JNIEnv *env, jclass clz, int64_t this_ptr) {
17550 LDKAcceptChannel this_ptr_conv;
17551 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17552 this_ptr_conv.is_owned = false;
17553 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
17554 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, AcceptChannel_get_first_per_commitment_point(&this_ptr_conv).compressed_form);
17558 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1set_1first_1per_1commitment_1point(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17559 LDKAcceptChannel this_ptr_conv;
17560 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17561 this_ptr_conv.is_owned = false;
17562 LDKPublicKey val_ref;
17563 CHECK((*env)->GetArrayLength(env, val) == 33);
17564 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
17565 AcceptChannel_set_first_per_commitment_point(&this_ptr_conv, val_ref);
17568 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1clone(JNIEnv *env, jclass clz, int64_t orig) {
17569 LDKAcceptChannel orig_conv;
17570 orig_conv.inner = (void*)(orig & (~1));
17571 orig_conv.is_owned = false;
17572 LDKAcceptChannel ret_var = AcceptChannel_clone(&orig_conv);
17573 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17574 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17575 uint64_t ret_ref = (uint64_t)ret_var.inner;
17576 if (ret_var.is_owned) {
17582 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_FundingCreated_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
17583 LDKFundingCreated this_obj_conv;
17584 this_obj_conv.inner = (void*)(this_obj & (~1));
17585 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
17586 FundingCreated_free(this_obj_conv);
17589 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_FundingCreated_1get_1temporary_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
17590 LDKFundingCreated this_ptr_conv;
17591 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17592 this_ptr_conv.is_owned = false;
17593 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
17594 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *FundingCreated_get_temporary_channel_id(&this_ptr_conv));
17598 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_FundingCreated_1set_1temporary_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17599 LDKFundingCreated this_ptr_conv;
17600 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17601 this_ptr_conv.is_owned = false;
17602 LDKThirtyTwoBytes val_ref;
17603 CHECK((*env)->GetArrayLength(env, val) == 32);
17604 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
17605 FundingCreated_set_temporary_channel_id(&this_ptr_conv, val_ref);
17608 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_FundingCreated_1get_1funding_1txid(JNIEnv *env, jclass clz, int64_t this_ptr) {
17609 LDKFundingCreated this_ptr_conv;
17610 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17611 this_ptr_conv.is_owned = false;
17612 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
17613 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *FundingCreated_get_funding_txid(&this_ptr_conv));
17617 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_FundingCreated_1set_1funding_1txid(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17618 LDKFundingCreated this_ptr_conv;
17619 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17620 this_ptr_conv.is_owned = false;
17621 LDKThirtyTwoBytes val_ref;
17622 CHECK((*env)->GetArrayLength(env, val) == 32);
17623 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
17624 FundingCreated_set_funding_txid(&this_ptr_conv, val_ref);
17627 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_FundingCreated_1get_1funding_1output_1index(JNIEnv *env, jclass clz, int64_t this_ptr) {
17628 LDKFundingCreated this_ptr_conv;
17629 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17630 this_ptr_conv.is_owned = false;
17631 int16_t ret_val = FundingCreated_get_funding_output_index(&this_ptr_conv);
17635 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_FundingCreated_1set_1funding_1output_1index(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
17636 LDKFundingCreated this_ptr_conv;
17637 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17638 this_ptr_conv.is_owned = false;
17639 FundingCreated_set_funding_output_index(&this_ptr_conv, val);
17642 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_FundingCreated_1get_1signature(JNIEnv *env, jclass clz, int64_t this_ptr) {
17643 LDKFundingCreated this_ptr_conv;
17644 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17645 this_ptr_conv.is_owned = false;
17646 int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
17647 (*env)->SetByteArrayRegion(env, ret_arr, 0, 64, FundingCreated_get_signature(&this_ptr_conv).compact_form);
17651 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_FundingCreated_1set_1signature(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17652 LDKFundingCreated this_ptr_conv;
17653 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17654 this_ptr_conv.is_owned = false;
17655 LDKSignature val_ref;
17656 CHECK((*env)->GetArrayLength(env, val) == 64);
17657 (*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
17658 FundingCreated_set_signature(&this_ptr_conv, val_ref);
17661 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_FundingCreated_1new(JNIEnv *env, jclass clz, int8_tArray temporary_channel_id_arg, int8_tArray funding_txid_arg, int16_t funding_output_index_arg, int8_tArray signature_arg) {
17662 LDKThirtyTwoBytes temporary_channel_id_arg_ref;
17663 CHECK((*env)->GetArrayLength(env, temporary_channel_id_arg) == 32);
17664 (*env)->GetByteArrayRegion(env, temporary_channel_id_arg, 0, 32, temporary_channel_id_arg_ref.data);
17665 LDKThirtyTwoBytes funding_txid_arg_ref;
17666 CHECK((*env)->GetArrayLength(env, funding_txid_arg) == 32);
17667 (*env)->GetByteArrayRegion(env, funding_txid_arg, 0, 32, funding_txid_arg_ref.data);
17668 LDKSignature signature_arg_ref;
17669 CHECK((*env)->GetArrayLength(env, signature_arg) == 64);
17670 (*env)->GetByteArrayRegion(env, signature_arg, 0, 64, signature_arg_ref.compact_form);
17671 LDKFundingCreated ret_var = FundingCreated_new(temporary_channel_id_arg_ref, funding_txid_arg_ref, funding_output_index_arg, signature_arg_ref);
17672 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17673 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17674 uint64_t ret_ref = (uint64_t)ret_var.inner;
17675 if (ret_var.is_owned) {
17681 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_FundingCreated_1clone(JNIEnv *env, jclass clz, int64_t orig) {
17682 LDKFundingCreated orig_conv;
17683 orig_conv.inner = (void*)(orig & (~1));
17684 orig_conv.is_owned = false;
17685 LDKFundingCreated ret_var = FundingCreated_clone(&orig_conv);
17686 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17687 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17688 uint64_t ret_ref = (uint64_t)ret_var.inner;
17689 if (ret_var.is_owned) {
17695 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_FundingSigned_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
17696 LDKFundingSigned this_obj_conv;
17697 this_obj_conv.inner = (void*)(this_obj & (~1));
17698 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
17699 FundingSigned_free(this_obj_conv);
17702 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_FundingSigned_1get_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
17703 LDKFundingSigned this_ptr_conv;
17704 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17705 this_ptr_conv.is_owned = false;
17706 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
17707 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *FundingSigned_get_channel_id(&this_ptr_conv));
17711 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_FundingSigned_1set_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17712 LDKFundingSigned this_ptr_conv;
17713 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17714 this_ptr_conv.is_owned = false;
17715 LDKThirtyTwoBytes val_ref;
17716 CHECK((*env)->GetArrayLength(env, val) == 32);
17717 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
17718 FundingSigned_set_channel_id(&this_ptr_conv, val_ref);
17721 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_FundingSigned_1get_1signature(JNIEnv *env, jclass clz, int64_t this_ptr) {
17722 LDKFundingSigned this_ptr_conv;
17723 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17724 this_ptr_conv.is_owned = false;
17725 int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
17726 (*env)->SetByteArrayRegion(env, ret_arr, 0, 64, FundingSigned_get_signature(&this_ptr_conv).compact_form);
17730 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_FundingSigned_1set_1signature(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17731 LDKFundingSigned this_ptr_conv;
17732 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17733 this_ptr_conv.is_owned = false;
17734 LDKSignature val_ref;
17735 CHECK((*env)->GetArrayLength(env, val) == 64);
17736 (*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
17737 FundingSigned_set_signature(&this_ptr_conv, val_ref);
17740 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_FundingSigned_1new(JNIEnv *env, jclass clz, int8_tArray channel_id_arg, int8_tArray signature_arg) {
17741 LDKThirtyTwoBytes channel_id_arg_ref;
17742 CHECK((*env)->GetArrayLength(env, channel_id_arg) == 32);
17743 (*env)->GetByteArrayRegion(env, channel_id_arg, 0, 32, channel_id_arg_ref.data);
17744 LDKSignature signature_arg_ref;
17745 CHECK((*env)->GetArrayLength(env, signature_arg) == 64);
17746 (*env)->GetByteArrayRegion(env, signature_arg, 0, 64, signature_arg_ref.compact_form);
17747 LDKFundingSigned ret_var = FundingSigned_new(channel_id_arg_ref, signature_arg_ref);
17748 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17749 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17750 uint64_t ret_ref = (uint64_t)ret_var.inner;
17751 if (ret_var.is_owned) {
17757 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_FundingSigned_1clone(JNIEnv *env, jclass clz, int64_t orig) {
17758 LDKFundingSigned orig_conv;
17759 orig_conv.inner = (void*)(orig & (~1));
17760 orig_conv.is_owned = false;
17761 LDKFundingSigned ret_var = FundingSigned_clone(&orig_conv);
17762 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17763 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17764 uint64_t ret_ref = (uint64_t)ret_var.inner;
17765 if (ret_var.is_owned) {
17771 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_FundingLocked_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
17772 LDKFundingLocked this_obj_conv;
17773 this_obj_conv.inner = (void*)(this_obj & (~1));
17774 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
17775 FundingLocked_free(this_obj_conv);
17778 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_FundingLocked_1get_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
17779 LDKFundingLocked this_ptr_conv;
17780 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17781 this_ptr_conv.is_owned = false;
17782 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
17783 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *FundingLocked_get_channel_id(&this_ptr_conv));
17787 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_FundingLocked_1set_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17788 LDKFundingLocked this_ptr_conv;
17789 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17790 this_ptr_conv.is_owned = false;
17791 LDKThirtyTwoBytes val_ref;
17792 CHECK((*env)->GetArrayLength(env, val) == 32);
17793 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
17794 FundingLocked_set_channel_id(&this_ptr_conv, val_ref);
17797 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_FundingLocked_1get_1next_1per_1commitment_1point(JNIEnv *env, jclass clz, int64_t this_ptr) {
17798 LDKFundingLocked this_ptr_conv;
17799 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17800 this_ptr_conv.is_owned = false;
17801 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
17802 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, FundingLocked_get_next_per_commitment_point(&this_ptr_conv).compressed_form);
17806 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_FundingLocked_1set_1next_1per_1commitment_1point(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17807 LDKFundingLocked this_ptr_conv;
17808 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17809 this_ptr_conv.is_owned = false;
17810 LDKPublicKey val_ref;
17811 CHECK((*env)->GetArrayLength(env, val) == 33);
17812 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
17813 FundingLocked_set_next_per_commitment_point(&this_ptr_conv, val_ref);
17816 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_FundingLocked_1new(JNIEnv *env, jclass clz, int8_tArray channel_id_arg, int8_tArray next_per_commitment_point_arg) {
17817 LDKThirtyTwoBytes channel_id_arg_ref;
17818 CHECK((*env)->GetArrayLength(env, channel_id_arg) == 32);
17819 (*env)->GetByteArrayRegion(env, channel_id_arg, 0, 32, channel_id_arg_ref.data);
17820 LDKPublicKey next_per_commitment_point_arg_ref;
17821 CHECK((*env)->GetArrayLength(env, next_per_commitment_point_arg) == 33);
17822 (*env)->GetByteArrayRegion(env, next_per_commitment_point_arg, 0, 33, next_per_commitment_point_arg_ref.compressed_form);
17823 LDKFundingLocked ret_var = FundingLocked_new(channel_id_arg_ref, next_per_commitment_point_arg_ref);
17824 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17825 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17826 uint64_t ret_ref = (uint64_t)ret_var.inner;
17827 if (ret_var.is_owned) {
17833 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_FundingLocked_1clone(JNIEnv *env, jclass clz, int64_t orig) {
17834 LDKFundingLocked orig_conv;
17835 orig_conv.inner = (void*)(orig & (~1));
17836 orig_conv.is_owned = false;
17837 LDKFundingLocked ret_var = FundingLocked_clone(&orig_conv);
17838 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17839 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17840 uint64_t ret_ref = (uint64_t)ret_var.inner;
17841 if (ret_var.is_owned) {
17847 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Shutdown_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
17848 LDKShutdown this_obj_conv;
17849 this_obj_conv.inner = (void*)(this_obj & (~1));
17850 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
17851 Shutdown_free(this_obj_conv);
17854 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_Shutdown_1get_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
17855 LDKShutdown this_ptr_conv;
17856 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17857 this_ptr_conv.is_owned = false;
17858 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
17859 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *Shutdown_get_channel_id(&this_ptr_conv));
17863 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Shutdown_1set_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17864 LDKShutdown this_ptr_conv;
17865 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17866 this_ptr_conv.is_owned = false;
17867 LDKThirtyTwoBytes val_ref;
17868 CHECK((*env)->GetArrayLength(env, val) == 32);
17869 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
17870 Shutdown_set_channel_id(&this_ptr_conv, val_ref);
17873 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_Shutdown_1get_1scriptpubkey(JNIEnv *env, jclass clz, int64_t this_ptr) {
17874 LDKShutdown this_ptr_conv;
17875 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17876 this_ptr_conv.is_owned = false;
17877 LDKu8slice ret_var = Shutdown_get_scriptpubkey(&this_ptr_conv);
17878 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
17879 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
17883 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Shutdown_1set_1scriptpubkey(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17884 LDKShutdown this_ptr_conv;
17885 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17886 this_ptr_conv.is_owned = false;
17887 LDKCVec_u8Z val_ref;
17888 val_ref.datalen = (*env)->GetArrayLength(env, val);
17889 val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
17890 (*env)->GetByteArrayRegion(env, val, 0, val_ref.datalen, val_ref.data);
17891 Shutdown_set_scriptpubkey(&this_ptr_conv, val_ref);
17894 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Shutdown_1new(JNIEnv *env, jclass clz, int8_tArray channel_id_arg, int8_tArray scriptpubkey_arg) {
17895 LDKThirtyTwoBytes channel_id_arg_ref;
17896 CHECK((*env)->GetArrayLength(env, channel_id_arg) == 32);
17897 (*env)->GetByteArrayRegion(env, channel_id_arg, 0, 32, channel_id_arg_ref.data);
17898 LDKCVec_u8Z scriptpubkey_arg_ref;
17899 scriptpubkey_arg_ref.datalen = (*env)->GetArrayLength(env, scriptpubkey_arg);
17900 scriptpubkey_arg_ref.data = MALLOC(scriptpubkey_arg_ref.datalen, "LDKCVec_u8Z Bytes");
17901 (*env)->GetByteArrayRegion(env, scriptpubkey_arg, 0, scriptpubkey_arg_ref.datalen, scriptpubkey_arg_ref.data);
17902 LDKShutdown ret_var = Shutdown_new(channel_id_arg_ref, scriptpubkey_arg_ref);
17903 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17904 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17905 uint64_t ret_ref = (uint64_t)ret_var.inner;
17906 if (ret_var.is_owned) {
17912 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Shutdown_1clone(JNIEnv *env, jclass clz, int64_t orig) {
17913 LDKShutdown orig_conv;
17914 orig_conv.inner = (void*)(orig & (~1));
17915 orig_conv.is_owned = false;
17916 LDKShutdown ret_var = Shutdown_clone(&orig_conv);
17917 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17918 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17919 uint64_t ret_ref = (uint64_t)ret_var.inner;
17920 if (ret_var.is_owned) {
17926 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ClosingSigned_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
17927 LDKClosingSigned this_obj_conv;
17928 this_obj_conv.inner = (void*)(this_obj & (~1));
17929 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
17930 ClosingSigned_free(this_obj_conv);
17933 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ClosingSigned_1get_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
17934 LDKClosingSigned this_ptr_conv;
17935 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17936 this_ptr_conv.is_owned = false;
17937 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
17938 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *ClosingSigned_get_channel_id(&this_ptr_conv));
17942 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ClosingSigned_1set_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17943 LDKClosingSigned this_ptr_conv;
17944 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17945 this_ptr_conv.is_owned = false;
17946 LDKThirtyTwoBytes val_ref;
17947 CHECK((*env)->GetArrayLength(env, val) == 32);
17948 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
17949 ClosingSigned_set_channel_id(&this_ptr_conv, val_ref);
17952 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ClosingSigned_1get_1fee_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr) {
17953 LDKClosingSigned this_ptr_conv;
17954 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17955 this_ptr_conv.is_owned = false;
17956 int64_t ret_val = ClosingSigned_get_fee_satoshis(&this_ptr_conv);
17960 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ClosingSigned_1set_1fee_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
17961 LDKClosingSigned this_ptr_conv;
17962 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17963 this_ptr_conv.is_owned = false;
17964 ClosingSigned_set_fee_satoshis(&this_ptr_conv, val);
17967 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ClosingSigned_1get_1signature(JNIEnv *env, jclass clz, int64_t this_ptr) {
17968 LDKClosingSigned this_ptr_conv;
17969 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17970 this_ptr_conv.is_owned = false;
17971 int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
17972 (*env)->SetByteArrayRegion(env, ret_arr, 0, 64, ClosingSigned_get_signature(&this_ptr_conv).compact_form);
17976 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ClosingSigned_1set_1signature(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17977 LDKClosingSigned this_ptr_conv;
17978 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17979 this_ptr_conv.is_owned = false;
17980 LDKSignature val_ref;
17981 CHECK((*env)->GetArrayLength(env, val) == 64);
17982 (*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
17983 ClosingSigned_set_signature(&this_ptr_conv, val_ref);
17986 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ClosingSigned_1new(JNIEnv *env, jclass clz, int8_tArray channel_id_arg, int64_t fee_satoshis_arg, int8_tArray signature_arg) {
17987 LDKThirtyTwoBytes channel_id_arg_ref;
17988 CHECK((*env)->GetArrayLength(env, channel_id_arg) == 32);
17989 (*env)->GetByteArrayRegion(env, channel_id_arg, 0, 32, channel_id_arg_ref.data);
17990 LDKSignature signature_arg_ref;
17991 CHECK((*env)->GetArrayLength(env, signature_arg) == 64);
17992 (*env)->GetByteArrayRegion(env, signature_arg, 0, 64, signature_arg_ref.compact_form);
17993 LDKClosingSigned ret_var = ClosingSigned_new(channel_id_arg_ref, fee_satoshis_arg, signature_arg_ref);
17994 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17995 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17996 uint64_t ret_ref = (uint64_t)ret_var.inner;
17997 if (ret_var.is_owned) {
18003 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ClosingSigned_1clone(JNIEnv *env, jclass clz, int64_t orig) {
18004 LDKClosingSigned orig_conv;
18005 orig_conv.inner = (void*)(orig & (~1));
18006 orig_conv.is_owned = false;
18007 LDKClosingSigned ret_var = ClosingSigned_clone(&orig_conv);
18008 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18009 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18010 uint64_t ret_ref = (uint64_t)ret_var.inner;
18011 if (ret_var.is_owned) {
18017 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
18018 LDKUpdateAddHTLC this_obj_conv;
18019 this_obj_conv.inner = (void*)(this_obj & (~1));
18020 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
18021 UpdateAddHTLC_free(this_obj_conv);
18024 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1get_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
18025 LDKUpdateAddHTLC this_ptr_conv;
18026 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18027 this_ptr_conv.is_owned = false;
18028 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
18029 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UpdateAddHTLC_get_channel_id(&this_ptr_conv));
18033 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1set_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
18034 LDKUpdateAddHTLC this_ptr_conv;
18035 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18036 this_ptr_conv.is_owned = false;
18037 LDKThirtyTwoBytes val_ref;
18038 CHECK((*env)->GetArrayLength(env, val) == 32);
18039 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
18040 UpdateAddHTLC_set_channel_id(&this_ptr_conv, val_ref);
18043 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1get_1htlc_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
18044 LDKUpdateAddHTLC this_ptr_conv;
18045 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18046 this_ptr_conv.is_owned = false;
18047 int64_t ret_val = UpdateAddHTLC_get_htlc_id(&this_ptr_conv);
18051 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1set_1htlc_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
18052 LDKUpdateAddHTLC this_ptr_conv;
18053 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18054 this_ptr_conv.is_owned = false;
18055 UpdateAddHTLC_set_htlc_id(&this_ptr_conv, val);
18058 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1get_1amount_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
18059 LDKUpdateAddHTLC this_ptr_conv;
18060 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18061 this_ptr_conv.is_owned = false;
18062 int64_t ret_val = UpdateAddHTLC_get_amount_msat(&this_ptr_conv);
18066 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1set_1amount_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
18067 LDKUpdateAddHTLC this_ptr_conv;
18068 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18069 this_ptr_conv.is_owned = false;
18070 UpdateAddHTLC_set_amount_msat(&this_ptr_conv, val);
18073 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1get_1payment_1hash(JNIEnv *env, jclass clz, int64_t this_ptr) {
18074 LDKUpdateAddHTLC this_ptr_conv;
18075 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18076 this_ptr_conv.is_owned = false;
18077 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
18078 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UpdateAddHTLC_get_payment_hash(&this_ptr_conv));
18082 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1set_1payment_1hash(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
18083 LDKUpdateAddHTLC this_ptr_conv;
18084 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18085 this_ptr_conv.is_owned = false;
18086 LDKThirtyTwoBytes val_ref;
18087 CHECK((*env)->GetArrayLength(env, val) == 32);
18088 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
18089 UpdateAddHTLC_set_payment_hash(&this_ptr_conv, val_ref);
18092 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1get_1cltv_1expiry(JNIEnv *env, jclass clz, int64_t this_ptr) {
18093 LDKUpdateAddHTLC this_ptr_conv;
18094 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18095 this_ptr_conv.is_owned = false;
18096 int32_t ret_val = UpdateAddHTLC_get_cltv_expiry(&this_ptr_conv);
18100 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1set_1cltv_1expiry(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
18101 LDKUpdateAddHTLC this_ptr_conv;
18102 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18103 this_ptr_conv.is_owned = false;
18104 UpdateAddHTLC_set_cltv_expiry(&this_ptr_conv, val);
18107 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1clone(JNIEnv *env, jclass clz, int64_t orig) {
18108 LDKUpdateAddHTLC orig_conv;
18109 orig_conv.inner = (void*)(orig & (~1));
18110 orig_conv.is_owned = false;
18111 LDKUpdateAddHTLC ret_var = UpdateAddHTLC_clone(&orig_conv);
18112 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18113 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18114 uint64_t ret_ref = (uint64_t)ret_var.inner;
18115 if (ret_var.is_owned) {
18121 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateFulfillHTLC_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
18122 LDKUpdateFulfillHTLC this_obj_conv;
18123 this_obj_conv.inner = (void*)(this_obj & (~1));
18124 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
18125 UpdateFulfillHTLC_free(this_obj_conv);
18128 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UpdateFulfillHTLC_1get_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
18129 LDKUpdateFulfillHTLC this_ptr_conv;
18130 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18131 this_ptr_conv.is_owned = false;
18132 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
18133 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UpdateFulfillHTLC_get_channel_id(&this_ptr_conv));
18137 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateFulfillHTLC_1set_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
18138 LDKUpdateFulfillHTLC this_ptr_conv;
18139 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18140 this_ptr_conv.is_owned = false;
18141 LDKThirtyTwoBytes val_ref;
18142 CHECK((*env)->GetArrayLength(env, val) == 32);
18143 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
18144 UpdateFulfillHTLC_set_channel_id(&this_ptr_conv, val_ref);
18147 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFulfillHTLC_1get_1htlc_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
18148 LDKUpdateFulfillHTLC this_ptr_conv;
18149 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18150 this_ptr_conv.is_owned = false;
18151 int64_t ret_val = UpdateFulfillHTLC_get_htlc_id(&this_ptr_conv);
18155 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateFulfillHTLC_1set_1htlc_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
18156 LDKUpdateFulfillHTLC this_ptr_conv;
18157 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18158 this_ptr_conv.is_owned = false;
18159 UpdateFulfillHTLC_set_htlc_id(&this_ptr_conv, val);
18162 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UpdateFulfillHTLC_1get_1payment_1preimage(JNIEnv *env, jclass clz, int64_t this_ptr) {
18163 LDKUpdateFulfillHTLC this_ptr_conv;
18164 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18165 this_ptr_conv.is_owned = false;
18166 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
18167 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UpdateFulfillHTLC_get_payment_preimage(&this_ptr_conv));
18171 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateFulfillHTLC_1set_1payment_1preimage(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
18172 LDKUpdateFulfillHTLC this_ptr_conv;
18173 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18174 this_ptr_conv.is_owned = false;
18175 LDKThirtyTwoBytes val_ref;
18176 CHECK((*env)->GetArrayLength(env, val) == 32);
18177 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
18178 UpdateFulfillHTLC_set_payment_preimage(&this_ptr_conv, val_ref);
18181 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFulfillHTLC_1new(JNIEnv *env, jclass clz, int8_tArray channel_id_arg, int64_t htlc_id_arg, int8_tArray payment_preimage_arg) {
18182 LDKThirtyTwoBytes channel_id_arg_ref;
18183 CHECK((*env)->GetArrayLength(env, channel_id_arg) == 32);
18184 (*env)->GetByteArrayRegion(env, channel_id_arg, 0, 32, channel_id_arg_ref.data);
18185 LDKThirtyTwoBytes payment_preimage_arg_ref;
18186 CHECK((*env)->GetArrayLength(env, payment_preimage_arg) == 32);
18187 (*env)->GetByteArrayRegion(env, payment_preimage_arg, 0, 32, payment_preimage_arg_ref.data);
18188 LDKUpdateFulfillHTLC ret_var = UpdateFulfillHTLC_new(channel_id_arg_ref, htlc_id_arg, payment_preimage_arg_ref);
18189 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18190 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18191 uint64_t ret_ref = (uint64_t)ret_var.inner;
18192 if (ret_var.is_owned) {
18198 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFulfillHTLC_1clone(JNIEnv *env, jclass clz, int64_t orig) {
18199 LDKUpdateFulfillHTLC orig_conv;
18200 orig_conv.inner = (void*)(orig & (~1));
18201 orig_conv.is_owned = false;
18202 LDKUpdateFulfillHTLC ret_var = UpdateFulfillHTLC_clone(&orig_conv);
18203 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18204 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18205 uint64_t ret_ref = (uint64_t)ret_var.inner;
18206 if (ret_var.is_owned) {
18212 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateFailHTLC_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
18213 LDKUpdateFailHTLC this_obj_conv;
18214 this_obj_conv.inner = (void*)(this_obj & (~1));
18215 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
18216 UpdateFailHTLC_free(this_obj_conv);
18219 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UpdateFailHTLC_1get_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
18220 LDKUpdateFailHTLC this_ptr_conv;
18221 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18222 this_ptr_conv.is_owned = false;
18223 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
18224 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UpdateFailHTLC_get_channel_id(&this_ptr_conv));
18228 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateFailHTLC_1set_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
18229 LDKUpdateFailHTLC this_ptr_conv;
18230 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18231 this_ptr_conv.is_owned = false;
18232 LDKThirtyTwoBytes val_ref;
18233 CHECK((*env)->GetArrayLength(env, val) == 32);
18234 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
18235 UpdateFailHTLC_set_channel_id(&this_ptr_conv, val_ref);
18238 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFailHTLC_1get_1htlc_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
18239 LDKUpdateFailHTLC this_ptr_conv;
18240 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18241 this_ptr_conv.is_owned = false;
18242 int64_t ret_val = UpdateFailHTLC_get_htlc_id(&this_ptr_conv);
18246 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateFailHTLC_1set_1htlc_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
18247 LDKUpdateFailHTLC this_ptr_conv;
18248 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18249 this_ptr_conv.is_owned = false;
18250 UpdateFailHTLC_set_htlc_id(&this_ptr_conv, val);
18253 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFailHTLC_1clone(JNIEnv *env, jclass clz, int64_t orig) {
18254 LDKUpdateFailHTLC orig_conv;
18255 orig_conv.inner = (void*)(orig & (~1));
18256 orig_conv.is_owned = false;
18257 LDKUpdateFailHTLC ret_var = UpdateFailHTLC_clone(&orig_conv);
18258 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18259 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18260 uint64_t ret_ref = (uint64_t)ret_var.inner;
18261 if (ret_var.is_owned) {
18267 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateFailMalformedHTLC_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
18268 LDKUpdateFailMalformedHTLC this_obj_conv;
18269 this_obj_conv.inner = (void*)(this_obj & (~1));
18270 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
18271 UpdateFailMalformedHTLC_free(this_obj_conv);
18274 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UpdateFailMalformedHTLC_1get_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
18275 LDKUpdateFailMalformedHTLC this_ptr_conv;
18276 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18277 this_ptr_conv.is_owned = false;
18278 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
18279 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UpdateFailMalformedHTLC_get_channel_id(&this_ptr_conv));
18283 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateFailMalformedHTLC_1set_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
18284 LDKUpdateFailMalformedHTLC this_ptr_conv;
18285 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18286 this_ptr_conv.is_owned = false;
18287 LDKThirtyTwoBytes val_ref;
18288 CHECK((*env)->GetArrayLength(env, val) == 32);
18289 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
18290 UpdateFailMalformedHTLC_set_channel_id(&this_ptr_conv, val_ref);
18293 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFailMalformedHTLC_1get_1htlc_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
18294 LDKUpdateFailMalformedHTLC this_ptr_conv;
18295 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18296 this_ptr_conv.is_owned = false;
18297 int64_t ret_val = UpdateFailMalformedHTLC_get_htlc_id(&this_ptr_conv);
18301 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateFailMalformedHTLC_1set_1htlc_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
18302 LDKUpdateFailMalformedHTLC this_ptr_conv;
18303 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18304 this_ptr_conv.is_owned = false;
18305 UpdateFailMalformedHTLC_set_htlc_id(&this_ptr_conv, val);
18308 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_UpdateFailMalformedHTLC_1get_1failure_1code(JNIEnv *env, jclass clz, int64_t this_ptr) {
18309 LDKUpdateFailMalformedHTLC this_ptr_conv;
18310 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18311 this_ptr_conv.is_owned = false;
18312 int16_t ret_val = UpdateFailMalformedHTLC_get_failure_code(&this_ptr_conv);
18316 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateFailMalformedHTLC_1set_1failure_1code(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
18317 LDKUpdateFailMalformedHTLC this_ptr_conv;
18318 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18319 this_ptr_conv.is_owned = false;
18320 UpdateFailMalformedHTLC_set_failure_code(&this_ptr_conv, val);
18323 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFailMalformedHTLC_1clone(JNIEnv *env, jclass clz, int64_t orig) {
18324 LDKUpdateFailMalformedHTLC orig_conv;
18325 orig_conv.inner = (void*)(orig & (~1));
18326 orig_conv.is_owned = false;
18327 LDKUpdateFailMalformedHTLC ret_var = UpdateFailMalformedHTLC_clone(&orig_conv);
18328 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18329 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18330 uint64_t ret_ref = (uint64_t)ret_var.inner;
18331 if (ret_var.is_owned) {
18337 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CommitmentSigned_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
18338 LDKCommitmentSigned this_obj_conv;
18339 this_obj_conv.inner = (void*)(this_obj & (~1));
18340 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
18341 CommitmentSigned_free(this_obj_conv);
18344 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_CommitmentSigned_1get_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
18345 LDKCommitmentSigned this_ptr_conv;
18346 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18347 this_ptr_conv.is_owned = false;
18348 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
18349 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *CommitmentSigned_get_channel_id(&this_ptr_conv));
18353 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CommitmentSigned_1set_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
18354 LDKCommitmentSigned this_ptr_conv;
18355 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18356 this_ptr_conv.is_owned = false;
18357 LDKThirtyTwoBytes val_ref;
18358 CHECK((*env)->GetArrayLength(env, val) == 32);
18359 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
18360 CommitmentSigned_set_channel_id(&this_ptr_conv, val_ref);
18363 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_CommitmentSigned_1get_1signature(JNIEnv *env, jclass clz, int64_t this_ptr) {
18364 LDKCommitmentSigned this_ptr_conv;
18365 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18366 this_ptr_conv.is_owned = false;
18367 int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
18368 (*env)->SetByteArrayRegion(env, ret_arr, 0, 64, CommitmentSigned_get_signature(&this_ptr_conv).compact_form);
18372 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CommitmentSigned_1set_1signature(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
18373 LDKCommitmentSigned this_ptr_conv;
18374 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18375 this_ptr_conv.is_owned = false;
18376 LDKSignature val_ref;
18377 CHECK((*env)->GetArrayLength(env, val) == 64);
18378 (*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
18379 CommitmentSigned_set_signature(&this_ptr_conv, val_ref);
18382 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CommitmentSigned_1set_1htlc_1signatures(JNIEnv *env, jclass clz, int64_t this_ptr, jobjectArray val) {
18383 LDKCommitmentSigned this_ptr_conv;
18384 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18385 this_ptr_conv.is_owned = false;
18386 LDKCVec_SignatureZ val_constr;
18387 val_constr.datalen = (*env)->GetArrayLength(env, val);
18388 if (val_constr.datalen > 0)
18389 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
18391 val_constr.data = NULL;
18392 for (size_t i = 0; i < val_constr.datalen; i++) {
18393 int8_tArray val_conv_8 = (*env)->GetObjectArrayElement(env, val, i);
18394 LDKSignature val_conv_8_ref;
18395 CHECK((*env)->GetArrayLength(env, val_conv_8) == 64);
18396 (*env)->GetByteArrayRegion(env, val_conv_8, 0, 64, val_conv_8_ref.compact_form);
18397 val_constr.data[i] = val_conv_8_ref;
18399 CommitmentSigned_set_htlc_signatures(&this_ptr_conv, val_constr);
18402 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentSigned_1new(JNIEnv *env, jclass clz, int8_tArray channel_id_arg, int8_tArray signature_arg, jobjectArray htlc_signatures_arg) {
18403 LDKThirtyTwoBytes channel_id_arg_ref;
18404 CHECK((*env)->GetArrayLength(env, channel_id_arg) == 32);
18405 (*env)->GetByteArrayRegion(env, channel_id_arg, 0, 32, channel_id_arg_ref.data);
18406 LDKSignature signature_arg_ref;
18407 CHECK((*env)->GetArrayLength(env, signature_arg) == 64);
18408 (*env)->GetByteArrayRegion(env, signature_arg, 0, 64, signature_arg_ref.compact_form);
18409 LDKCVec_SignatureZ htlc_signatures_arg_constr;
18410 htlc_signatures_arg_constr.datalen = (*env)->GetArrayLength(env, htlc_signatures_arg);
18411 if (htlc_signatures_arg_constr.datalen > 0)
18412 htlc_signatures_arg_constr.data = MALLOC(htlc_signatures_arg_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
18414 htlc_signatures_arg_constr.data = NULL;
18415 for (size_t i = 0; i < htlc_signatures_arg_constr.datalen; i++) {
18416 int8_tArray htlc_signatures_arg_conv_8 = (*env)->GetObjectArrayElement(env, htlc_signatures_arg, i);
18417 LDKSignature htlc_signatures_arg_conv_8_ref;
18418 CHECK((*env)->GetArrayLength(env, htlc_signatures_arg_conv_8) == 64);
18419 (*env)->GetByteArrayRegion(env, htlc_signatures_arg_conv_8, 0, 64, htlc_signatures_arg_conv_8_ref.compact_form);
18420 htlc_signatures_arg_constr.data[i] = htlc_signatures_arg_conv_8_ref;
18422 LDKCommitmentSigned ret_var = CommitmentSigned_new(channel_id_arg_ref, signature_arg_ref, htlc_signatures_arg_constr);
18423 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18424 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18425 uint64_t ret_ref = (uint64_t)ret_var.inner;
18426 if (ret_var.is_owned) {
18432 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentSigned_1clone(JNIEnv *env, jclass clz, int64_t orig) {
18433 LDKCommitmentSigned orig_conv;
18434 orig_conv.inner = (void*)(orig & (~1));
18435 orig_conv.is_owned = false;
18436 LDKCommitmentSigned ret_var = CommitmentSigned_clone(&orig_conv);
18437 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18438 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18439 uint64_t ret_ref = (uint64_t)ret_var.inner;
18440 if (ret_var.is_owned) {
18446 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RevokeAndACK_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
18447 LDKRevokeAndACK this_obj_conv;
18448 this_obj_conv.inner = (void*)(this_obj & (~1));
18449 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
18450 RevokeAndACK_free(this_obj_conv);
18453 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_RevokeAndACK_1get_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
18454 LDKRevokeAndACK this_ptr_conv;
18455 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18456 this_ptr_conv.is_owned = false;
18457 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
18458 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *RevokeAndACK_get_channel_id(&this_ptr_conv));
18462 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RevokeAndACK_1set_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
18463 LDKRevokeAndACK this_ptr_conv;
18464 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18465 this_ptr_conv.is_owned = false;
18466 LDKThirtyTwoBytes val_ref;
18467 CHECK((*env)->GetArrayLength(env, val) == 32);
18468 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
18469 RevokeAndACK_set_channel_id(&this_ptr_conv, val_ref);
18472 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_RevokeAndACK_1get_1per_1commitment_1secret(JNIEnv *env, jclass clz, int64_t this_ptr) {
18473 LDKRevokeAndACK this_ptr_conv;
18474 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18475 this_ptr_conv.is_owned = false;
18476 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
18477 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *RevokeAndACK_get_per_commitment_secret(&this_ptr_conv));
18481 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RevokeAndACK_1set_1per_1commitment_1secret(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
18482 LDKRevokeAndACK this_ptr_conv;
18483 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18484 this_ptr_conv.is_owned = false;
18485 LDKThirtyTwoBytes val_ref;
18486 CHECK((*env)->GetArrayLength(env, val) == 32);
18487 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
18488 RevokeAndACK_set_per_commitment_secret(&this_ptr_conv, val_ref);
18491 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_RevokeAndACK_1get_1next_1per_1commitment_1point(JNIEnv *env, jclass clz, int64_t this_ptr) {
18492 LDKRevokeAndACK this_ptr_conv;
18493 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18494 this_ptr_conv.is_owned = false;
18495 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
18496 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, RevokeAndACK_get_next_per_commitment_point(&this_ptr_conv).compressed_form);
18500 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RevokeAndACK_1set_1next_1per_1commitment_1point(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
18501 LDKRevokeAndACK this_ptr_conv;
18502 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18503 this_ptr_conv.is_owned = false;
18504 LDKPublicKey val_ref;
18505 CHECK((*env)->GetArrayLength(env, val) == 33);
18506 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
18507 RevokeAndACK_set_next_per_commitment_point(&this_ptr_conv, val_ref);
18510 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RevokeAndACK_1new(JNIEnv *env, jclass clz, int8_tArray channel_id_arg, int8_tArray per_commitment_secret_arg, int8_tArray next_per_commitment_point_arg) {
18511 LDKThirtyTwoBytes channel_id_arg_ref;
18512 CHECK((*env)->GetArrayLength(env, channel_id_arg) == 32);
18513 (*env)->GetByteArrayRegion(env, channel_id_arg, 0, 32, channel_id_arg_ref.data);
18514 LDKThirtyTwoBytes per_commitment_secret_arg_ref;
18515 CHECK((*env)->GetArrayLength(env, per_commitment_secret_arg) == 32);
18516 (*env)->GetByteArrayRegion(env, per_commitment_secret_arg, 0, 32, per_commitment_secret_arg_ref.data);
18517 LDKPublicKey next_per_commitment_point_arg_ref;
18518 CHECK((*env)->GetArrayLength(env, next_per_commitment_point_arg) == 33);
18519 (*env)->GetByteArrayRegion(env, next_per_commitment_point_arg, 0, 33, next_per_commitment_point_arg_ref.compressed_form);
18520 LDKRevokeAndACK ret_var = RevokeAndACK_new(channel_id_arg_ref, per_commitment_secret_arg_ref, next_per_commitment_point_arg_ref);
18521 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18522 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18523 uint64_t ret_ref = (uint64_t)ret_var.inner;
18524 if (ret_var.is_owned) {
18530 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RevokeAndACK_1clone(JNIEnv *env, jclass clz, int64_t orig) {
18531 LDKRevokeAndACK orig_conv;
18532 orig_conv.inner = (void*)(orig & (~1));
18533 orig_conv.is_owned = false;
18534 LDKRevokeAndACK ret_var = RevokeAndACK_clone(&orig_conv);
18535 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18536 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18537 uint64_t ret_ref = (uint64_t)ret_var.inner;
18538 if (ret_var.is_owned) {
18544 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateFee_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
18545 LDKUpdateFee this_obj_conv;
18546 this_obj_conv.inner = (void*)(this_obj & (~1));
18547 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
18548 UpdateFee_free(this_obj_conv);
18551 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UpdateFee_1get_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
18552 LDKUpdateFee this_ptr_conv;
18553 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18554 this_ptr_conv.is_owned = false;
18555 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
18556 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UpdateFee_get_channel_id(&this_ptr_conv));
18560 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateFee_1set_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
18561 LDKUpdateFee this_ptr_conv;
18562 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18563 this_ptr_conv.is_owned = false;
18564 LDKThirtyTwoBytes val_ref;
18565 CHECK((*env)->GetArrayLength(env, val) == 32);
18566 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
18567 UpdateFee_set_channel_id(&this_ptr_conv, val_ref);
18570 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_UpdateFee_1get_1feerate_1per_1kw(JNIEnv *env, jclass clz, int64_t this_ptr) {
18571 LDKUpdateFee this_ptr_conv;
18572 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18573 this_ptr_conv.is_owned = false;
18574 int32_t ret_val = UpdateFee_get_feerate_per_kw(&this_ptr_conv);
18578 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateFee_1set_1feerate_1per_1kw(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
18579 LDKUpdateFee this_ptr_conv;
18580 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18581 this_ptr_conv.is_owned = false;
18582 UpdateFee_set_feerate_per_kw(&this_ptr_conv, val);
18585 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFee_1new(JNIEnv *env, jclass clz, int8_tArray channel_id_arg, int32_t feerate_per_kw_arg) {
18586 LDKThirtyTwoBytes channel_id_arg_ref;
18587 CHECK((*env)->GetArrayLength(env, channel_id_arg) == 32);
18588 (*env)->GetByteArrayRegion(env, channel_id_arg, 0, 32, channel_id_arg_ref.data);
18589 LDKUpdateFee ret_var = UpdateFee_new(channel_id_arg_ref, feerate_per_kw_arg);
18590 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18591 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18592 uint64_t ret_ref = (uint64_t)ret_var.inner;
18593 if (ret_var.is_owned) {
18599 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFee_1clone(JNIEnv *env, jclass clz, int64_t orig) {
18600 LDKUpdateFee orig_conv;
18601 orig_conv.inner = (void*)(orig & (~1));
18602 orig_conv.is_owned = false;
18603 LDKUpdateFee ret_var = UpdateFee_clone(&orig_conv);
18604 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18605 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18606 uint64_t ret_ref = (uint64_t)ret_var.inner;
18607 if (ret_var.is_owned) {
18613 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DataLossProtect_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
18614 LDKDataLossProtect this_obj_conv;
18615 this_obj_conv.inner = (void*)(this_obj & (~1));
18616 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
18617 DataLossProtect_free(this_obj_conv);
18620 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_DataLossProtect_1get_1your_1last_1per_1commitment_1secret(JNIEnv *env, jclass clz, int64_t this_ptr) {
18621 LDKDataLossProtect this_ptr_conv;
18622 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18623 this_ptr_conv.is_owned = false;
18624 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
18625 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *DataLossProtect_get_your_last_per_commitment_secret(&this_ptr_conv));
18629 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DataLossProtect_1set_1your_1last_1per_1commitment_1secret(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
18630 LDKDataLossProtect this_ptr_conv;
18631 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18632 this_ptr_conv.is_owned = false;
18633 LDKThirtyTwoBytes val_ref;
18634 CHECK((*env)->GetArrayLength(env, val) == 32);
18635 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
18636 DataLossProtect_set_your_last_per_commitment_secret(&this_ptr_conv, val_ref);
18639 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_DataLossProtect_1get_1my_1current_1per_1commitment_1point(JNIEnv *env, jclass clz, int64_t this_ptr) {
18640 LDKDataLossProtect this_ptr_conv;
18641 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18642 this_ptr_conv.is_owned = false;
18643 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
18644 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, DataLossProtect_get_my_current_per_commitment_point(&this_ptr_conv).compressed_form);
18648 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DataLossProtect_1set_1my_1current_1per_1commitment_1point(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
18649 LDKDataLossProtect this_ptr_conv;
18650 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18651 this_ptr_conv.is_owned = false;
18652 LDKPublicKey val_ref;
18653 CHECK((*env)->GetArrayLength(env, val) == 33);
18654 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
18655 DataLossProtect_set_my_current_per_commitment_point(&this_ptr_conv, val_ref);
18658 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DataLossProtect_1new(JNIEnv *env, jclass clz, int8_tArray your_last_per_commitment_secret_arg, int8_tArray my_current_per_commitment_point_arg) {
18659 LDKThirtyTwoBytes your_last_per_commitment_secret_arg_ref;
18660 CHECK((*env)->GetArrayLength(env, your_last_per_commitment_secret_arg) == 32);
18661 (*env)->GetByteArrayRegion(env, your_last_per_commitment_secret_arg, 0, 32, your_last_per_commitment_secret_arg_ref.data);
18662 LDKPublicKey my_current_per_commitment_point_arg_ref;
18663 CHECK((*env)->GetArrayLength(env, my_current_per_commitment_point_arg) == 33);
18664 (*env)->GetByteArrayRegion(env, my_current_per_commitment_point_arg, 0, 33, my_current_per_commitment_point_arg_ref.compressed_form);
18665 LDKDataLossProtect ret_var = DataLossProtect_new(your_last_per_commitment_secret_arg_ref, my_current_per_commitment_point_arg_ref);
18666 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18667 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18668 uint64_t ret_ref = (uint64_t)ret_var.inner;
18669 if (ret_var.is_owned) {
18675 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DataLossProtect_1clone(JNIEnv *env, jclass clz, int64_t orig) {
18676 LDKDataLossProtect orig_conv;
18677 orig_conv.inner = (void*)(orig & (~1));
18678 orig_conv.is_owned = false;
18679 LDKDataLossProtect ret_var = DataLossProtect_clone(&orig_conv);
18680 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18681 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18682 uint64_t ret_ref = (uint64_t)ret_var.inner;
18683 if (ret_var.is_owned) {
18689 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelReestablish_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
18690 LDKChannelReestablish this_obj_conv;
18691 this_obj_conv.inner = (void*)(this_obj & (~1));
18692 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
18693 ChannelReestablish_free(this_obj_conv);
18696 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelReestablish_1get_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
18697 LDKChannelReestablish this_ptr_conv;
18698 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18699 this_ptr_conv.is_owned = false;
18700 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
18701 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *ChannelReestablish_get_channel_id(&this_ptr_conv));
18705 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelReestablish_1set_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
18706 LDKChannelReestablish this_ptr_conv;
18707 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18708 this_ptr_conv.is_owned = false;
18709 LDKThirtyTwoBytes val_ref;
18710 CHECK((*env)->GetArrayLength(env, val) == 32);
18711 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
18712 ChannelReestablish_set_channel_id(&this_ptr_conv, val_ref);
18715 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelReestablish_1get_1next_1local_1commitment_1number(JNIEnv *env, jclass clz, int64_t this_ptr) {
18716 LDKChannelReestablish this_ptr_conv;
18717 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18718 this_ptr_conv.is_owned = false;
18719 int64_t ret_val = ChannelReestablish_get_next_local_commitment_number(&this_ptr_conv);
18723 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelReestablish_1set_1next_1local_1commitment_1number(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
18724 LDKChannelReestablish this_ptr_conv;
18725 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18726 this_ptr_conv.is_owned = false;
18727 ChannelReestablish_set_next_local_commitment_number(&this_ptr_conv, val);
18730 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelReestablish_1get_1next_1remote_1commitment_1number(JNIEnv *env, jclass clz, int64_t this_ptr) {
18731 LDKChannelReestablish this_ptr_conv;
18732 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18733 this_ptr_conv.is_owned = false;
18734 int64_t ret_val = ChannelReestablish_get_next_remote_commitment_number(&this_ptr_conv);
18738 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelReestablish_1set_1next_1remote_1commitment_1number(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
18739 LDKChannelReestablish this_ptr_conv;
18740 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18741 this_ptr_conv.is_owned = false;
18742 ChannelReestablish_set_next_remote_commitment_number(&this_ptr_conv, val);
18745 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelReestablish_1clone(JNIEnv *env, jclass clz, int64_t orig) {
18746 LDKChannelReestablish orig_conv;
18747 orig_conv.inner = (void*)(orig & (~1));
18748 orig_conv.is_owned = false;
18749 LDKChannelReestablish ret_var = ChannelReestablish_clone(&orig_conv);
18750 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18751 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18752 uint64_t ret_ref = (uint64_t)ret_var.inner;
18753 if (ret_var.is_owned) {
18759 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AnnouncementSignatures_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
18760 LDKAnnouncementSignatures this_obj_conv;
18761 this_obj_conv.inner = (void*)(this_obj & (~1));
18762 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
18763 AnnouncementSignatures_free(this_obj_conv);
18766 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_AnnouncementSignatures_1get_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
18767 LDKAnnouncementSignatures this_ptr_conv;
18768 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18769 this_ptr_conv.is_owned = false;
18770 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
18771 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *AnnouncementSignatures_get_channel_id(&this_ptr_conv));
18775 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AnnouncementSignatures_1set_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
18776 LDKAnnouncementSignatures this_ptr_conv;
18777 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18778 this_ptr_conv.is_owned = false;
18779 LDKThirtyTwoBytes val_ref;
18780 CHECK((*env)->GetArrayLength(env, val) == 32);
18781 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
18782 AnnouncementSignatures_set_channel_id(&this_ptr_conv, val_ref);
18785 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_AnnouncementSignatures_1get_1short_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
18786 LDKAnnouncementSignatures this_ptr_conv;
18787 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18788 this_ptr_conv.is_owned = false;
18789 int64_t ret_val = AnnouncementSignatures_get_short_channel_id(&this_ptr_conv);
18793 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AnnouncementSignatures_1set_1short_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
18794 LDKAnnouncementSignatures this_ptr_conv;
18795 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18796 this_ptr_conv.is_owned = false;
18797 AnnouncementSignatures_set_short_channel_id(&this_ptr_conv, val);
18800 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_AnnouncementSignatures_1get_1node_1signature(JNIEnv *env, jclass clz, int64_t this_ptr) {
18801 LDKAnnouncementSignatures this_ptr_conv;
18802 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18803 this_ptr_conv.is_owned = false;
18804 int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
18805 (*env)->SetByteArrayRegion(env, ret_arr, 0, 64, AnnouncementSignatures_get_node_signature(&this_ptr_conv).compact_form);
18809 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AnnouncementSignatures_1set_1node_1signature(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
18810 LDKAnnouncementSignatures this_ptr_conv;
18811 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18812 this_ptr_conv.is_owned = false;
18813 LDKSignature val_ref;
18814 CHECK((*env)->GetArrayLength(env, val) == 64);
18815 (*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
18816 AnnouncementSignatures_set_node_signature(&this_ptr_conv, val_ref);
18819 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_AnnouncementSignatures_1get_1bitcoin_1signature(JNIEnv *env, jclass clz, int64_t this_ptr) {
18820 LDKAnnouncementSignatures this_ptr_conv;
18821 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18822 this_ptr_conv.is_owned = false;
18823 int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
18824 (*env)->SetByteArrayRegion(env, ret_arr, 0, 64, AnnouncementSignatures_get_bitcoin_signature(&this_ptr_conv).compact_form);
18828 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AnnouncementSignatures_1set_1bitcoin_1signature(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
18829 LDKAnnouncementSignatures this_ptr_conv;
18830 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18831 this_ptr_conv.is_owned = false;
18832 LDKSignature val_ref;
18833 CHECK((*env)->GetArrayLength(env, val) == 64);
18834 (*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
18835 AnnouncementSignatures_set_bitcoin_signature(&this_ptr_conv, val_ref);
18838 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_AnnouncementSignatures_1new(JNIEnv *env, jclass clz, int8_tArray channel_id_arg, int64_t short_channel_id_arg, int8_tArray node_signature_arg, int8_tArray bitcoin_signature_arg) {
18839 LDKThirtyTwoBytes channel_id_arg_ref;
18840 CHECK((*env)->GetArrayLength(env, channel_id_arg) == 32);
18841 (*env)->GetByteArrayRegion(env, channel_id_arg, 0, 32, channel_id_arg_ref.data);
18842 LDKSignature node_signature_arg_ref;
18843 CHECK((*env)->GetArrayLength(env, node_signature_arg) == 64);
18844 (*env)->GetByteArrayRegion(env, node_signature_arg, 0, 64, node_signature_arg_ref.compact_form);
18845 LDKSignature bitcoin_signature_arg_ref;
18846 CHECK((*env)->GetArrayLength(env, bitcoin_signature_arg) == 64);
18847 (*env)->GetByteArrayRegion(env, bitcoin_signature_arg, 0, 64, bitcoin_signature_arg_ref.compact_form);
18848 LDKAnnouncementSignatures ret_var = AnnouncementSignatures_new(channel_id_arg_ref, short_channel_id_arg, node_signature_arg_ref, bitcoin_signature_arg_ref);
18849 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18850 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18851 uint64_t ret_ref = (uint64_t)ret_var.inner;
18852 if (ret_var.is_owned) {
18858 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_AnnouncementSignatures_1clone(JNIEnv *env, jclass clz, int64_t orig) {
18859 LDKAnnouncementSignatures orig_conv;
18860 orig_conv.inner = (void*)(orig & (~1));
18861 orig_conv.is_owned = false;
18862 LDKAnnouncementSignatures ret_var = AnnouncementSignatures_clone(&orig_conv);
18863 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18864 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18865 uint64_t ret_ref = (uint64_t)ret_var.inner;
18866 if (ret_var.is_owned) {
18872 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NetAddress_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
18873 if ((this_ptr & 1) != 0) return;
18874 LDKNetAddress this_ptr_conv = *(LDKNetAddress*)(((uint64_t)this_ptr) & ~1);
18875 FREE((void*)this_ptr);
18876 NetAddress_free(this_ptr_conv);
18879 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetAddress_1clone(JNIEnv *env, jclass clz, int64_t orig) {
18880 LDKNetAddress* orig_conv = (LDKNetAddress*)orig;
18881 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
18882 *ret_copy = NetAddress_clone(orig_conv);
18883 uint64_t ret_ref = (uint64_t)ret_copy;
18887 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_NetAddress_1write(JNIEnv *env, jclass clz, int64_t obj) {
18888 LDKNetAddress* obj_conv = (LDKNetAddress*)obj;
18889 LDKCVec_u8Z ret_var = NetAddress_write(obj_conv);
18890 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
18891 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
18892 CVec_u8Z_free(ret_var);
18896 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Result_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
18897 LDKu8slice ser_ref;
18898 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
18899 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
18900 LDKCResult_CResult_NetAddressu8ZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CResult_NetAddressu8ZDecodeErrorZ), "LDKCResult_CResult_NetAddressu8ZDecodeErrorZ");
18901 *ret_conv = Result_read(ser_ref);
18902 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
18903 return (uint64_t)ret_conv;
18906 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetAddress_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
18907 LDKu8slice ser_ref;
18908 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
18909 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
18910 LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
18911 *ret_conv = NetAddress_read(ser_ref);
18912 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
18913 return (uint64_t)ret_conv;
18916 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
18917 LDKUnsignedNodeAnnouncement this_obj_conv;
18918 this_obj_conv.inner = (void*)(this_obj & (~1));
18919 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
18920 UnsignedNodeAnnouncement_free(this_obj_conv);
18923 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1get_1features(JNIEnv *env, jclass clz, int64_t this_ptr) {
18924 LDKUnsignedNodeAnnouncement this_ptr_conv;
18925 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18926 this_ptr_conv.is_owned = false;
18927 LDKNodeFeatures ret_var = UnsignedNodeAnnouncement_get_features(&this_ptr_conv);
18928 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18929 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18930 uint64_t ret_ref = (uint64_t)ret_var.inner;
18931 if (ret_var.is_owned) {
18937 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1set_1features(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
18938 LDKUnsignedNodeAnnouncement this_ptr_conv;
18939 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18940 this_ptr_conv.is_owned = false;
18941 LDKNodeFeatures val_conv;
18942 val_conv.inner = (void*)(val & (~1));
18943 val_conv.is_owned = (val & 1) || (val == 0);
18944 val_conv = NodeFeatures_clone(&val_conv);
18945 UnsignedNodeAnnouncement_set_features(&this_ptr_conv, val_conv);
18948 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1get_1timestamp(JNIEnv *env, jclass clz, int64_t this_ptr) {
18949 LDKUnsignedNodeAnnouncement this_ptr_conv;
18950 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18951 this_ptr_conv.is_owned = false;
18952 int32_t ret_val = UnsignedNodeAnnouncement_get_timestamp(&this_ptr_conv);
18956 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1set_1timestamp(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
18957 LDKUnsignedNodeAnnouncement this_ptr_conv;
18958 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18959 this_ptr_conv.is_owned = false;
18960 UnsignedNodeAnnouncement_set_timestamp(&this_ptr_conv, val);
18963 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1get_1node_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
18964 LDKUnsignedNodeAnnouncement this_ptr_conv;
18965 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18966 this_ptr_conv.is_owned = false;
18967 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
18968 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, UnsignedNodeAnnouncement_get_node_id(&this_ptr_conv).compressed_form);
18972 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1set_1node_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
18973 LDKUnsignedNodeAnnouncement this_ptr_conv;
18974 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18975 this_ptr_conv.is_owned = false;
18976 LDKPublicKey val_ref;
18977 CHECK((*env)->GetArrayLength(env, val) == 33);
18978 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
18979 UnsignedNodeAnnouncement_set_node_id(&this_ptr_conv, val_ref);
18982 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1get_1rgb(JNIEnv *env, jclass clz, int64_t this_ptr) {
18983 LDKUnsignedNodeAnnouncement this_ptr_conv;
18984 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18985 this_ptr_conv.is_owned = false;
18986 int8_tArray ret_arr = (*env)->NewByteArray(env, 3);
18987 (*env)->SetByteArrayRegion(env, ret_arr, 0, 3, *UnsignedNodeAnnouncement_get_rgb(&this_ptr_conv));
18991 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1set_1rgb(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
18992 LDKUnsignedNodeAnnouncement this_ptr_conv;
18993 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18994 this_ptr_conv.is_owned = false;
18995 LDKThreeBytes val_ref;
18996 CHECK((*env)->GetArrayLength(env, val) == 3);
18997 (*env)->GetByteArrayRegion(env, val, 0, 3, val_ref.data);
18998 UnsignedNodeAnnouncement_set_rgb(&this_ptr_conv, val_ref);
19001 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1get_1alias(JNIEnv *env, jclass clz, int64_t this_ptr) {
19002 LDKUnsignedNodeAnnouncement this_ptr_conv;
19003 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19004 this_ptr_conv.is_owned = false;
19005 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
19006 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UnsignedNodeAnnouncement_get_alias(&this_ptr_conv));
19010 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1set_1alias(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
19011 LDKUnsignedNodeAnnouncement this_ptr_conv;
19012 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19013 this_ptr_conv.is_owned = false;
19014 LDKThirtyTwoBytes val_ref;
19015 CHECK((*env)->GetArrayLength(env, val) == 32);
19016 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
19017 UnsignedNodeAnnouncement_set_alias(&this_ptr_conv, val_ref);
19020 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1set_1addresses(JNIEnv *env, jclass clz, int64_t this_ptr, int64_tArray val) {
19021 LDKUnsignedNodeAnnouncement this_ptr_conv;
19022 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19023 this_ptr_conv.is_owned = false;
19024 LDKCVec_NetAddressZ val_constr;
19025 val_constr.datalen = (*env)->GetArrayLength(env, val);
19026 if (val_constr.datalen > 0)
19027 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
19029 val_constr.data = NULL;
19030 int64_t* val_vals = (*env)->GetLongArrayElements (env, val, NULL);
19031 for (size_t m = 0; m < val_constr.datalen; m++) {
19032 int64_t val_conv_12 = val_vals[m];
19033 LDKNetAddress val_conv_12_conv = *(LDKNetAddress*)(((uint64_t)val_conv_12) & ~1);
19034 val_conv_12_conv = NetAddress_clone((LDKNetAddress*)(((uint64_t)val_conv_12) & ~1));
19035 val_constr.data[m] = val_conv_12_conv;
19037 (*env)->ReleaseLongArrayElements(env, val, val_vals, 0);
19038 UnsignedNodeAnnouncement_set_addresses(&this_ptr_conv, val_constr);
19041 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1clone(JNIEnv *env, jclass clz, int64_t orig) {
19042 LDKUnsignedNodeAnnouncement orig_conv;
19043 orig_conv.inner = (void*)(orig & (~1));
19044 orig_conv.is_owned = false;
19045 LDKUnsignedNodeAnnouncement ret_var = UnsignedNodeAnnouncement_clone(&orig_conv);
19046 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19047 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19048 uint64_t ret_ref = (uint64_t)ret_var.inner;
19049 if (ret_var.is_owned) {
19055 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NodeAnnouncement_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
19056 LDKNodeAnnouncement this_obj_conv;
19057 this_obj_conv.inner = (void*)(this_obj & (~1));
19058 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
19059 NodeAnnouncement_free(this_obj_conv);
19062 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_NodeAnnouncement_1get_1signature(JNIEnv *env, jclass clz, int64_t this_ptr) {
19063 LDKNodeAnnouncement this_ptr_conv;
19064 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19065 this_ptr_conv.is_owned = false;
19066 int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
19067 (*env)->SetByteArrayRegion(env, ret_arr, 0, 64, NodeAnnouncement_get_signature(&this_ptr_conv).compact_form);
19071 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NodeAnnouncement_1set_1signature(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
19072 LDKNodeAnnouncement this_ptr_conv;
19073 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19074 this_ptr_conv.is_owned = false;
19075 LDKSignature val_ref;
19076 CHECK((*env)->GetArrayLength(env, val) == 64);
19077 (*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
19078 NodeAnnouncement_set_signature(&this_ptr_conv, val_ref);
19081 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeAnnouncement_1get_1contents(JNIEnv *env, jclass clz, int64_t this_ptr) {
19082 LDKNodeAnnouncement this_ptr_conv;
19083 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19084 this_ptr_conv.is_owned = false;
19085 LDKUnsignedNodeAnnouncement ret_var = NodeAnnouncement_get_contents(&this_ptr_conv);
19086 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19087 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19088 uint64_t ret_ref = (uint64_t)ret_var.inner;
19089 if (ret_var.is_owned) {
19095 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NodeAnnouncement_1set_1contents(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
19096 LDKNodeAnnouncement this_ptr_conv;
19097 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19098 this_ptr_conv.is_owned = false;
19099 LDKUnsignedNodeAnnouncement val_conv;
19100 val_conv.inner = (void*)(val & (~1));
19101 val_conv.is_owned = (val & 1) || (val == 0);
19102 val_conv = UnsignedNodeAnnouncement_clone(&val_conv);
19103 NodeAnnouncement_set_contents(&this_ptr_conv, val_conv);
19106 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeAnnouncement_1new(JNIEnv *env, jclass clz, int8_tArray signature_arg, int64_t contents_arg) {
19107 LDKSignature signature_arg_ref;
19108 CHECK((*env)->GetArrayLength(env, signature_arg) == 64);
19109 (*env)->GetByteArrayRegion(env, signature_arg, 0, 64, signature_arg_ref.compact_form);
19110 LDKUnsignedNodeAnnouncement contents_arg_conv;
19111 contents_arg_conv.inner = (void*)(contents_arg & (~1));
19112 contents_arg_conv.is_owned = (contents_arg & 1) || (contents_arg == 0);
19113 contents_arg_conv = UnsignedNodeAnnouncement_clone(&contents_arg_conv);
19114 LDKNodeAnnouncement ret_var = NodeAnnouncement_new(signature_arg_ref, contents_arg_conv);
19115 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19116 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19117 uint64_t ret_ref = (uint64_t)ret_var.inner;
19118 if (ret_var.is_owned) {
19124 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeAnnouncement_1clone(JNIEnv *env, jclass clz, int64_t orig) {
19125 LDKNodeAnnouncement orig_conv;
19126 orig_conv.inner = (void*)(orig & (~1));
19127 orig_conv.is_owned = false;
19128 LDKNodeAnnouncement ret_var = NodeAnnouncement_clone(&orig_conv);
19129 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19130 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19131 uint64_t ret_ref = (uint64_t)ret_var.inner;
19132 if (ret_var.is_owned) {
19138 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
19139 LDKUnsignedChannelAnnouncement this_obj_conv;
19140 this_obj_conv.inner = (void*)(this_obj & (~1));
19141 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
19142 UnsignedChannelAnnouncement_free(this_obj_conv);
19145 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1get_1features(JNIEnv *env, jclass clz, int64_t this_ptr) {
19146 LDKUnsignedChannelAnnouncement this_ptr_conv;
19147 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19148 this_ptr_conv.is_owned = false;
19149 LDKChannelFeatures ret_var = UnsignedChannelAnnouncement_get_features(&this_ptr_conv);
19150 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19151 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19152 uint64_t ret_ref = (uint64_t)ret_var.inner;
19153 if (ret_var.is_owned) {
19159 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1set_1features(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
19160 LDKUnsignedChannelAnnouncement this_ptr_conv;
19161 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19162 this_ptr_conv.is_owned = false;
19163 LDKChannelFeatures val_conv;
19164 val_conv.inner = (void*)(val & (~1));
19165 val_conv.is_owned = (val & 1) || (val == 0);
19166 val_conv = ChannelFeatures_clone(&val_conv);
19167 UnsignedChannelAnnouncement_set_features(&this_ptr_conv, val_conv);
19170 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1get_1chain_1hash(JNIEnv *env, jclass clz, int64_t this_ptr) {
19171 LDKUnsignedChannelAnnouncement this_ptr_conv;
19172 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19173 this_ptr_conv.is_owned = false;
19174 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
19175 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UnsignedChannelAnnouncement_get_chain_hash(&this_ptr_conv));
19179 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1set_1chain_1hash(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
19180 LDKUnsignedChannelAnnouncement this_ptr_conv;
19181 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19182 this_ptr_conv.is_owned = false;
19183 LDKThirtyTwoBytes val_ref;
19184 CHECK((*env)->GetArrayLength(env, val) == 32);
19185 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
19186 UnsignedChannelAnnouncement_set_chain_hash(&this_ptr_conv, val_ref);
19189 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1get_1short_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
19190 LDKUnsignedChannelAnnouncement this_ptr_conv;
19191 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19192 this_ptr_conv.is_owned = false;
19193 int64_t ret_val = UnsignedChannelAnnouncement_get_short_channel_id(&this_ptr_conv);
19197 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1set_1short_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
19198 LDKUnsignedChannelAnnouncement this_ptr_conv;
19199 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19200 this_ptr_conv.is_owned = false;
19201 UnsignedChannelAnnouncement_set_short_channel_id(&this_ptr_conv, val);
19204 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1get_1node_1id_11(JNIEnv *env, jclass clz, int64_t this_ptr) {
19205 LDKUnsignedChannelAnnouncement this_ptr_conv;
19206 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19207 this_ptr_conv.is_owned = false;
19208 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
19209 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, UnsignedChannelAnnouncement_get_node_id_1(&this_ptr_conv).compressed_form);
19213 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1set_1node_1id_11(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
19214 LDKUnsignedChannelAnnouncement this_ptr_conv;
19215 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19216 this_ptr_conv.is_owned = false;
19217 LDKPublicKey val_ref;
19218 CHECK((*env)->GetArrayLength(env, val) == 33);
19219 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
19220 UnsignedChannelAnnouncement_set_node_id_1(&this_ptr_conv, val_ref);
19223 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1get_1node_1id_12(JNIEnv *env, jclass clz, int64_t this_ptr) {
19224 LDKUnsignedChannelAnnouncement this_ptr_conv;
19225 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19226 this_ptr_conv.is_owned = false;
19227 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
19228 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, UnsignedChannelAnnouncement_get_node_id_2(&this_ptr_conv).compressed_form);
19232 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1set_1node_1id_12(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
19233 LDKUnsignedChannelAnnouncement this_ptr_conv;
19234 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19235 this_ptr_conv.is_owned = false;
19236 LDKPublicKey val_ref;
19237 CHECK((*env)->GetArrayLength(env, val) == 33);
19238 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
19239 UnsignedChannelAnnouncement_set_node_id_2(&this_ptr_conv, val_ref);
19242 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1get_1bitcoin_1key_11(JNIEnv *env, jclass clz, int64_t this_ptr) {
19243 LDKUnsignedChannelAnnouncement this_ptr_conv;
19244 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19245 this_ptr_conv.is_owned = false;
19246 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
19247 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, UnsignedChannelAnnouncement_get_bitcoin_key_1(&this_ptr_conv).compressed_form);
19251 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1set_1bitcoin_1key_11(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
19252 LDKUnsignedChannelAnnouncement this_ptr_conv;
19253 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19254 this_ptr_conv.is_owned = false;
19255 LDKPublicKey val_ref;
19256 CHECK((*env)->GetArrayLength(env, val) == 33);
19257 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
19258 UnsignedChannelAnnouncement_set_bitcoin_key_1(&this_ptr_conv, val_ref);
19261 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1get_1bitcoin_1key_12(JNIEnv *env, jclass clz, int64_t this_ptr) {
19262 LDKUnsignedChannelAnnouncement this_ptr_conv;
19263 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19264 this_ptr_conv.is_owned = false;
19265 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
19266 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, UnsignedChannelAnnouncement_get_bitcoin_key_2(&this_ptr_conv).compressed_form);
19270 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1set_1bitcoin_1key_12(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
19271 LDKUnsignedChannelAnnouncement this_ptr_conv;
19272 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19273 this_ptr_conv.is_owned = false;
19274 LDKPublicKey val_ref;
19275 CHECK((*env)->GetArrayLength(env, val) == 33);
19276 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
19277 UnsignedChannelAnnouncement_set_bitcoin_key_2(&this_ptr_conv, val_ref);
19280 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1clone(JNIEnv *env, jclass clz, int64_t orig) {
19281 LDKUnsignedChannelAnnouncement orig_conv;
19282 orig_conv.inner = (void*)(orig & (~1));
19283 orig_conv.is_owned = false;
19284 LDKUnsignedChannelAnnouncement ret_var = UnsignedChannelAnnouncement_clone(&orig_conv);
19285 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19286 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19287 uint64_t ret_ref = (uint64_t)ret_var.inner;
19288 if (ret_var.is_owned) {
19294 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
19295 LDKChannelAnnouncement this_obj_conv;
19296 this_obj_conv.inner = (void*)(this_obj & (~1));
19297 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
19298 ChannelAnnouncement_free(this_obj_conv);
19301 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1get_1node_1signature_11(JNIEnv *env, jclass clz, int64_t this_ptr) {
19302 LDKChannelAnnouncement this_ptr_conv;
19303 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19304 this_ptr_conv.is_owned = false;
19305 int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
19306 (*env)->SetByteArrayRegion(env, ret_arr, 0, 64, ChannelAnnouncement_get_node_signature_1(&this_ptr_conv).compact_form);
19310 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1set_1node_1signature_11(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
19311 LDKChannelAnnouncement this_ptr_conv;
19312 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19313 this_ptr_conv.is_owned = false;
19314 LDKSignature val_ref;
19315 CHECK((*env)->GetArrayLength(env, val) == 64);
19316 (*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
19317 ChannelAnnouncement_set_node_signature_1(&this_ptr_conv, val_ref);
19320 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1get_1node_1signature_12(JNIEnv *env, jclass clz, int64_t this_ptr) {
19321 LDKChannelAnnouncement this_ptr_conv;
19322 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19323 this_ptr_conv.is_owned = false;
19324 int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
19325 (*env)->SetByteArrayRegion(env, ret_arr, 0, 64, ChannelAnnouncement_get_node_signature_2(&this_ptr_conv).compact_form);
19329 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1set_1node_1signature_12(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
19330 LDKChannelAnnouncement this_ptr_conv;
19331 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19332 this_ptr_conv.is_owned = false;
19333 LDKSignature val_ref;
19334 CHECK((*env)->GetArrayLength(env, val) == 64);
19335 (*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
19336 ChannelAnnouncement_set_node_signature_2(&this_ptr_conv, val_ref);
19339 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1get_1bitcoin_1signature_11(JNIEnv *env, jclass clz, int64_t this_ptr) {
19340 LDKChannelAnnouncement this_ptr_conv;
19341 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19342 this_ptr_conv.is_owned = false;
19343 int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
19344 (*env)->SetByteArrayRegion(env, ret_arr, 0, 64, ChannelAnnouncement_get_bitcoin_signature_1(&this_ptr_conv).compact_form);
19348 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1set_1bitcoin_1signature_11(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
19349 LDKChannelAnnouncement this_ptr_conv;
19350 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19351 this_ptr_conv.is_owned = false;
19352 LDKSignature val_ref;
19353 CHECK((*env)->GetArrayLength(env, val) == 64);
19354 (*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
19355 ChannelAnnouncement_set_bitcoin_signature_1(&this_ptr_conv, val_ref);
19358 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1get_1bitcoin_1signature_12(JNIEnv *env, jclass clz, int64_t this_ptr) {
19359 LDKChannelAnnouncement this_ptr_conv;
19360 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19361 this_ptr_conv.is_owned = false;
19362 int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
19363 (*env)->SetByteArrayRegion(env, ret_arr, 0, 64, ChannelAnnouncement_get_bitcoin_signature_2(&this_ptr_conv).compact_form);
19367 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1set_1bitcoin_1signature_12(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
19368 LDKChannelAnnouncement this_ptr_conv;
19369 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19370 this_ptr_conv.is_owned = false;
19371 LDKSignature val_ref;
19372 CHECK((*env)->GetArrayLength(env, val) == 64);
19373 (*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
19374 ChannelAnnouncement_set_bitcoin_signature_2(&this_ptr_conv, val_ref);
19377 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1get_1contents(JNIEnv *env, jclass clz, int64_t this_ptr) {
19378 LDKChannelAnnouncement this_ptr_conv;
19379 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19380 this_ptr_conv.is_owned = false;
19381 LDKUnsignedChannelAnnouncement ret_var = ChannelAnnouncement_get_contents(&this_ptr_conv);
19382 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19383 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19384 uint64_t ret_ref = (uint64_t)ret_var.inner;
19385 if (ret_var.is_owned) {
19391 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1set_1contents(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
19392 LDKChannelAnnouncement this_ptr_conv;
19393 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19394 this_ptr_conv.is_owned = false;
19395 LDKUnsignedChannelAnnouncement val_conv;
19396 val_conv.inner = (void*)(val & (~1));
19397 val_conv.is_owned = (val & 1) || (val == 0);
19398 val_conv = UnsignedChannelAnnouncement_clone(&val_conv);
19399 ChannelAnnouncement_set_contents(&this_ptr_conv, val_conv);
19402 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1new(JNIEnv *env, jclass clz, int8_tArray node_signature_1_arg, int8_tArray node_signature_2_arg, int8_tArray bitcoin_signature_1_arg, int8_tArray bitcoin_signature_2_arg, int64_t contents_arg) {
19403 LDKSignature node_signature_1_arg_ref;
19404 CHECK((*env)->GetArrayLength(env, node_signature_1_arg) == 64);
19405 (*env)->GetByteArrayRegion(env, node_signature_1_arg, 0, 64, node_signature_1_arg_ref.compact_form);
19406 LDKSignature node_signature_2_arg_ref;
19407 CHECK((*env)->GetArrayLength(env, node_signature_2_arg) == 64);
19408 (*env)->GetByteArrayRegion(env, node_signature_2_arg, 0, 64, node_signature_2_arg_ref.compact_form);
19409 LDKSignature bitcoin_signature_1_arg_ref;
19410 CHECK((*env)->GetArrayLength(env, bitcoin_signature_1_arg) == 64);
19411 (*env)->GetByteArrayRegion(env, bitcoin_signature_1_arg, 0, 64, bitcoin_signature_1_arg_ref.compact_form);
19412 LDKSignature bitcoin_signature_2_arg_ref;
19413 CHECK((*env)->GetArrayLength(env, bitcoin_signature_2_arg) == 64);
19414 (*env)->GetByteArrayRegion(env, bitcoin_signature_2_arg, 0, 64, bitcoin_signature_2_arg_ref.compact_form);
19415 LDKUnsignedChannelAnnouncement contents_arg_conv;
19416 contents_arg_conv.inner = (void*)(contents_arg & (~1));
19417 contents_arg_conv.is_owned = (contents_arg & 1) || (contents_arg == 0);
19418 contents_arg_conv = UnsignedChannelAnnouncement_clone(&contents_arg_conv);
19419 LDKChannelAnnouncement ret_var = ChannelAnnouncement_new(node_signature_1_arg_ref, node_signature_2_arg_ref, bitcoin_signature_1_arg_ref, bitcoin_signature_2_arg_ref, contents_arg_conv);
19420 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19421 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19422 uint64_t ret_ref = (uint64_t)ret_var.inner;
19423 if (ret_var.is_owned) {
19429 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1clone(JNIEnv *env, jclass clz, int64_t orig) {
19430 LDKChannelAnnouncement orig_conv;
19431 orig_conv.inner = (void*)(orig & (~1));
19432 orig_conv.is_owned = false;
19433 LDKChannelAnnouncement ret_var = ChannelAnnouncement_clone(&orig_conv);
19434 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19435 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19436 uint64_t ret_ref = (uint64_t)ret_var.inner;
19437 if (ret_var.is_owned) {
19443 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
19444 LDKUnsignedChannelUpdate this_obj_conv;
19445 this_obj_conv.inner = (void*)(this_obj & (~1));
19446 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
19447 UnsignedChannelUpdate_free(this_obj_conv);
19450 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1get_1chain_1hash(JNIEnv *env, jclass clz, int64_t this_ptr) {
19451 LDKUnsignedChannelUpdate this_ptr_conv;
19452 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19453 this_ptr_conv.is_owned = false;
19454 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
19455 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UnsignedChannelUpdate_get_chain_hash(&this_ptr_conv));
19459 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1set_1chain_1hash(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
19460 LDKUnsignedChannelUpdate this_ptr_conv;
19461 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19462 this_ptr_conv.is_owned = false;
19463 LDKThirtyTwoBytes val_ref;
19464 CHECK((*env)->GetArrayLength(env, val) == 32);
19465 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
19466 UnsignedChannelUpdate_set_chain_hash(&this_ptr_conv, val_ref);
19469 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1get_1short_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
19470 LDKUnsignedChannelUpdate this_ptr_conv;
19471 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19472 this_ptr_conv.is_owned = false;
19473 int64_t ret_val = UnsignedChannelUpdate_get_short_channel_id(&this_ptr_conv);
19477 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1set_1short_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
19478 LDKUnsignedChannelUpdate this_ptr_conv;
19479 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19480 this_ptr_conv.is_owned = false;
19481 UnsignedChannelUpdate_set_short_channel_id(&this_ptr_conv, val);
19484 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1get_1timestamp(JNIEnv *env, jclass clz, int64_t this_ptr) {
19485 LDKUnsignedChannelUpdate this_ptr_conv;
19486 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19487 this_ptr_conv.is_owned = false;
19488 int32_t ret_val = UnsignedChannelUpdate_get_timestamp(&this_ptr_conv);
19492 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1set_1timestamp(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
19493 LDKUnsignedChannelUpdate this_ptr_conv;
19494 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19495 this_ptr_conv.is_owned = false;
19496 UnsignedChannelUpdate_set_timestamp(&this_ptr_conv, val);
19499 JNIEXPORT int8_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1get_1flags(JNIEnv *env, jclass clz, int64_t this_ptr) {
19500 LDKUnsignedChannelUpdate this_ptr_conv;
19501 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19502 this_ptr_conv.is_owned = false;
19503 int8_t ret_val = UnsignedChannelUpdate_get_flags(&this_ptr_conv);
19507 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1set_1flags(JNIEnv *env, jclass clz, int64_t this_ptr, int8_t val) {
19508 LDKUnsignedChannelUpdate this_ptr_conv;
19509 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19510 this_ptr_conv.is_owned = false;
19511 UnsignedChannelUpdate_set_flags(&this_ptr_conv, val);
19514 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1get_1cltv_1expiry_1delta(JNIEnv *env, jclass clz, int64_t this_ptr) {
19515 LDKUnsignedChannelUpdate this_ptr_conv;
19516 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19517 this_ptr_conv.is_owned = false;
19518 int16_t ret_val = UnsignedChannelUpdate_get_cltv_expiry_delta(&this_ptr_conv);
19522 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1set_1cltv_1expiry_1delta(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
19523 LDKUnsignedChannelUpdate this_ptr_conv;
19524 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19525 this_ptr_conv.is_owned = false;
19526 UnsignedChannelUpdate_set_cltv_expiry_delta(&this_ptr_conv, val);
19529 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1get_1htlc_1minimum_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
19530 LDKUnsignedChannelUpdate this_ptr_conv;
19531 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19532 this_ptr_conv.is_owned = false;
19533 int64_t ret_val = UnsignedChannelUpdate_get_htlc_minimum_msat(&this_ptr_conv);
19537 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1set_1htlc_1minimum_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
19538 LDKUnsignedChannelUpdate this_ptr_conv;
19539 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19540 this_ptr_conv.is_owned = false;
19541 UnsignedChannelUpdate_set_htlc_minimum_msat(&this_ptr_conv, val);
19544 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1get_1fee_1base_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
19545 LDKUnsignedChannelUpdate this_ptr_conv;
19546 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19547 this_ptr_conv.is_owned = false;
19548 int32_t ret_val = UnsignedChannelUpdate_get_fee_base_msat(&this_ptr_conv);
19552 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1set_1fee_1base_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
19553 LDKUnsignedChannelUpdate this_ptr_conv;
19554 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19555 this_ptr_conv.is_owned = false;
19556 UnsignedChannelUpdate_set_fee_base_msat(&this_ptr_conv, val);
19559 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1get_1fee_1proportional_1millionths(JNIEnv *env, jclass clz, int64_t this_ptr) {
19560 LDKUnsignedChannelUpdate this_ptr_conv;
19561 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19562 this_ptr_conv.is_owned = false;
19563 int32_t ret_val = UnsignedChannelUpdate_get_fee_proportional_millionths(&this_ptr_conv);
19567 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1set_1fee_1proportional_1millionths(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
19568 LDKUnsignedChannelUpdate this_ptr_conv;
19569 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19570 this_ptr_conv.is_owned = false;
19571 UnsignedChannelUpdate_set_fee_proportional_millionths(&this_ptr_conv, val);
19574 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1clone(JNIEnv *env, jclass clz, int64_t orig) {
19575 LDKUnsignedChannelUpdate orig_conv;
19576 orig_conv.inner = (void*)(orig & (~1));
19577 orig_conv.is_owned = false;
19578 LDKUnsignedChannelUpdate ret_var = UnsignedChannelUpdate_clone(&orig_conv);
19579 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19580 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19581 uint64_t ret_ref = (uint64_t)ret_var.inner;
19582 if (ret_var.is_owned) {
19588 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelUpdate_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
19589 LDKChannelUpdate this_obj_conv;
19590 this_obj_conv.inner = (void*)(this_obj & (~1));
19591 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
19592 ChannelUpdate_free(this_obj_conv);
19595 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelUpdate_1get_1signature(JNIEnv *env, jclass clz, int64_t this_ptr) {
19596 LDKChannelUpdate this_ptr_conv;
19597 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19598 this_ptr_conv.is_owned = false;
19599 int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
19600 (*env)->SetByteArrayRegion(env, ret_arr, 0, 64, ChannelUpdate_get_signature(&this_ptr_conv).compact_form);
19604 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelUpdate_1set_1signature(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
19605 LDKChannelUpdate this_ptr_conv;
19606 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19607 this_ptr_conv.is_owned = false;
19608 LDKSignature val_ref;
19609 CHECK((*env)->GetArrayLength(env, val) == 64);
19610 (*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
19611 ChannelUpdate_set_signature(&this_ptr_conv, val_ref);
19614 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelUpdate_1get_1contents(JNIEnv *env, jclass clz, int64_t this_ptr) {
19615 LDKChannelUpdate this_ptr_conv;
19616 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19617 this_ptr_conv.is_owned = false;
19618 LDKUnsignedChannelUpdate ret_var = ChannelUpdate_get_contents(&this_ptr_conv);
19619 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19620 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19621 uint64_t ret_ref = (uint64_t)ret_var.inner;
19622 if (ret_var.is_owned) {
19628 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelUpdate_1set_1contents(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
19629 LDKChannelUpdate this_ptr_conv;
19630 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19631 this_ptr_conv.is_owned = false;
19632 LDKUnsignedChannelUpdate val_conv;
19633 val_conv.inner = (void*)(val & (~1));
19634 val_conv.is_owned = (val & 1) || (val == 0);
19635 val_conv = UnsignedChannelUpdate_clone(&val_conv);
19636 ChannelUpdate_set_contents(&this_ptr_conv, val_conv);
19639 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelUpdate_1new(JNIEnv *env, jclass clz, int8_tArray signature_arg, int64_t contents_arg) {
19640 LDKSignature signature_arg_ref;
19641 CHECK((*env)->GetArrayLength(env, signature_arg) == 64);
19642 (*env)->GetByteArrayRegion(env, signature_arg, 0, 64, signature_arg_ref.compact_form);
19643 LDKUnsignedChannelUpdate contents_arg_conv;
19644 contents_arg_conv.inner = (void*)(contents_arg & (~1));
19645 contents_arg_conv.is_owned = (contents_arg & 1) || (contents_arg == 0);
19646 contents_arg_conv = UnsignedChannelUpdate_clone(&contents_arg_conv);
19647 LDKChannelUpdate ret_var = ChannelUpdate_new(signature_arg_ref, contents_arg_conv);
19648 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19649 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19650 uint64_t ret_ref = (uint64_t)ret_var.inner;
19651 if (ret_var.is_owned) {
19657 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelUpdate_1clone(JNIEnv *env, jclass clz, int64_t orig) {
19658 LDKChannelUpdate orig_conv;
19659 orig_conv.inner = (void*)(orig & (~1));
19660 orig_conv.is_owned = false;
19661 LDKChannelUpdate ret_var = ChannelUpdate_clone(&orig_conv);
19662 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19663 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19664 uint64_t ret_ref = (uint64_t)ret_var.inner;
19665 if (ret_var.is_owned) {
19671 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_QueryChannelRange_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
19672 LDKQueryChannelRange this_obj_conv;
19673 this_obj_conv.inner = (void*)(this_obj & (~1));
19674 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
19675 QueryChannelRange_free(this_obj_conv);
19678 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_QueryChannelRange_1get_1chain_1hash(JNIEnv *env, jclass clz, int64_t this_ptr) {
19679 LDKQueryChannelRange this_ptr_conv;
19680 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19681 this_ptr_conv.is_owned = false;
19682 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
19683 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *QueryChannelRange_get_chain_hash(&this_ptr_conv));
19687 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_QueryChannelRange_1set_1chain_1hash(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
19688 LDKQueryChannelRange this_ptr_conv;
19689 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19690 this_ptr_conv.is_owned = false;
19691 LDKThirtyTwoBytes val_ref;
19692 CHECK((*env)->GetArrayLength(env, val) == 32);
19693 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
19694 QueryChannelRange_set_chain_hash(&this_ptr_conv, val_ref);
19697 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_QueryChannelRange_1get_1first_1blocknum(JNIEnv *env, jclass clz, int64_t this_ptr) {
19698 LDKQueryChannelRange this_ptr_conv;
19699 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19700 this_ptr_conv.is_owned = false;
19701 int32_t ret_val = QueryChannelRange_get_first_blocknum(&this_ptr_conv);
19705 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_QueryChannelRange_1set_1first_1blocknum(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
19706 LDKQueryChannelRange this_ptr_conv;
19707 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19708 this_ptr_conv.is_owned = false;
19709 QueryChannelRange_set_first_blocknum(&this_ptr_conv, val);
19712 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_QueryChannelRange_1get_1number_1of_1blocks(JNIEnv *env, jclass clz, int64_t this_ptr) {
19713 LDKQueryChannelRange this_ptr_conv;
19714 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19715 this_ptr_conv.is_owned = false;
19716 int32_t ret_val = QueryChannelRange_get_number_of_blocks(&this_ptr_conv);
19720 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_QueryChannelRange_1set_1number_1of_1blocks(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
19721 LDKQueryChannelRange this_ptr_conv;
19722 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19723 this_ptr_conv.is_owned = false;
19724 QueryChannelRange_set_number_of_blocks(&this_ptr_conv, val);
19727 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_QueryChannelRange_1new(JNIEnv *env, jclass clz, int8_tArray chain_hash_arg, int32_t first_blocknum_arg, int32_t number_of_blocks_arg) {
19728 LDKThirtyTwoBytes chain_hash_arg_ref;
19729 CHECK((*env)->GetArrayLength(env, chain_hash_arg) == 32);
19730 (*env)->GetByteArrayRegion(env, chain_hash_arg, 0, 32, chain_hash_arg_ref.data);
19731 LDKQueryChannelRange ret_var = QueryChannelRange_new(chain_hash_arg_ref, first_blocknum_arg, number_of_blocks_arg);
19732 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19733 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19734 uint64_t ret_ref = (uint64_t)ret_var.inner;
19735 if (ret_var.is_owned) {
19741 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_QueryChannelRange_1clone(JNIEnv *env, jclass clz, int64_t orig) {
19742 LDKQueryChannelRange orig_conv;
19743 orig_conv.inner = (void*)(orig & (~1));
19744 orig_conv.is_owned = false;
19745 LDKQueryChannelRange ret_var = QueryChannelRange_clone(&orig_conv);
19746 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19747 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19748 uint64_t ret_ref = (uint64_t)ret_var.inner;
19749 if (ret_var.is_owned) {
19755 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ReplyChannelRange_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
19756 LDKReplyChannelRange this_obj_conv;
19757 this_obj_conv.inner = (void*)(this_obj & (~1));
19758 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
19759 ReplyChannelRange_free(this_obj_conv);
19762 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ReplyChannelRange_1get_1chain_1hash(JNIEnv *env, jclass clz, int64_t this_ptr) {
19763 LDKReplyChannelRange this_ptr_conv;
19764 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19765 this_ptr_conv.is_owned = false;
19766 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
19767 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *ReplyChannelRange_get_chain_hash(&this_ptr_conv));
19771 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ReplyChannelRange_1set_1chain_1hash(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
19772 LDKReplyChannelRange this_ptr_conv;
19773 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19774 this_ptr_conv.is_owned = false;
19775 LDKThirtyTwoBytes val_ref;
19776 CHECK((*env)->GetArrayLength(env, val) == 32);
19777 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
19778 ReplyChannelRange_set_chain_hash(&this_ptr_conv, val_ref);
19781 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_ReplyChannelRange_1get_1first_1blocknum(JNIEnv *env, jclass clz, int64_t this_ptr) {
19782 LDKReplyChannelRange this_ptr_conv;
19783 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19784 this_ptr_conv.is_owned = false;
19785 int32_t ret_val = ReplyChannelRange_get_first_blocknum(&this_ptr_conv);
19789 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ReplyChannelRange_1set_1first_1blocknum(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
19790 LDKReplyChannelRange this_ptr_conv;
19791 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19792 this_ptr_conv.is_owned = false;
19793 ReplyChannelRange_set_first_blocknum(&this_ptr_conv, val);
19796 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_ReplyChannelRange_1get_1number_1of_1blocks(JNIEnv *env, jclass clz, int64_t this_ptr) {
19797 LDKReplyChannelRange this_ptr_conv;
19798 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19799 this_ptr_conv.is_owned = false;
19800 int32_t ret_val = ReplyChannelRange_get_number_of_blocks(&this_ptr_conv);
19804 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ReplyChannelRange_1set_1number_1of_1blocks(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
19805 LDKReplyChannelRange this_ptr_conv;
19806 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19807 this_ptr_conv.is_owned = false;
19808 ReplyChannelRange_set_number_of_blocks(&this_ptr_conv, val);
19811 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_ReplyChannelRange_1get_1sync_1complete(JNIEnv *env, jclass clz, int64_t this_ptr) {
19812 LDKReplyChannelRange this_ptr_conv;
19813 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19814 this_ptr_conv.is_owned = false;
19815 jboolean ret_val = ReplyChannelRange_get_sync_complete(&this_ptr_conv);
19819 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ReplyChannelRange_1set_1sync_1complete(JNIEnv *env, jclass clz, int64_t this_ptr, jboolean val) {
19820 LDKReplyChannelRange this_ptr_conv;
19821 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19822 this_ptr_conv.is_owned = false;
19823 ReplyChannelRange_set_sync_complete(&this_ptr_conv, val);
19826 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ReplyChannelRange_1set_1short_1channel_1ids(JNIEnv *env, jclass clz, int64_t this_ptr, int64_tArray val) {
19827 LDKReplyChannelRange this_ptr_conv;
19828 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19829 this_ptr_conv.is_owned = false;
19830 LDKCVec_u64Z val_constr;
19831 val_constr.datalen = (*env)->GetArrayLength(env, val);
19832 if (val_constr.datalen > 0)
19833 val_constr.data = MALLOC(val_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
19835 val_constr.data = NULL;
19836 int64_t* val_vals = (*env)->GetLongArrayElements (env, val, NULL);
19837 for (size_t g = 0; g < val_constr.datalen; g++) {
19838 int64_t val_conv_6 = val_vals[g];
19839 val_constr.data[g] = val_conv_6;
19841 (*env)->ReleaseLongArrayElements(env, val, val_vals, 0);
19842 ReplyChannelRange_set_short_channel_ids(&this_ptr_conv, val_constr);
19845 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ReplyChannelRange_1new(JNIEnv *env, jclass clz, int8_tArray chain_hash_arg, int32_t first_blocknum_arg, int32_t number_of_blocks_arg, jboolean sync_complete_arg, int64_tArray short_channel_ids_arg) {
19846 LDKThirtyTwoBytes chain_hash_arg_ref;
19847 CHECK((*env)->GetArrayLength(env, chain_hash_arg) == 32);
19848 (*env)->GetByteArrayRegion(env, chain_hash_arg, 0, 32, chain_hash_arg_ref.data);
19849 LDKCVec_u64Z short_channel_ids_arg_constr;
19850 short_channel_ids_arg_constr.datalen = (*env)->GetArrayLength(env, short_channel_ids_arg);
19851 if (short_channel_ids_arg_constr.datalen > 0)
19852 short_channel_ids_arg_constr.data = MALLOC(short_channel_ids_arg_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
19854 short_channel_ids_arg_constr.data = NULL;
19855 int64_t* short_channel_ids_arg_vals = (*env)->GetLongArrayElements (env, short_channel_ids_arg, NULL);
19856 for (size_t g = 0; g < short_channel_ids_arg_constr.datalen; g++) {
19857 int64_t short_channel_ids_arg_conv_6 = short_channel_ids_arg_vals[g];
19858 short_channel_ids_arg_constr.data[g] = short_channel_ids_arg_conv_6;
19860 (*env)->ReleaseLongArrayElements(env, short_channel_ids_arg, short_channel_ids_arg_vals, 0);
19861 LDKReplyChannelRange ret_var = ReplyChannelRange_new(chain_hash_arg_ref, first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg_constr);
19862 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19863 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19864 uint64_t ret_ref = (uint64_t)ret_var.inner;
19865 if (ret_var.is_owned) {
19871 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ReplyChannelRange_1clone(JNIEnv *env, jclass clz, int64_t orig) {
19872 LDKReplyChannelRange orig_conv;
19873 orig_conv.inner = (void*)(orig & (~1));
19874 orig_conv.is_owned = false;
19875 LDKReplyChannelRange ret_var = ReplyChannelRange_clone(&orig_conv);
19876 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19877 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19878 uint64_t ret_ref = (uint64_t)ret_var.inner;
19879 if (ret_var.is_owned) {
19885 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_QueryShortChannelIds_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
19886 LDKQueryShortChannelIds this_obj_conv;
19887 this_obj_conv.inner = (void*)(this_obj & (~1));
19888 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
19889 QueryShortChannelIds_free(this_obj_conv);
19892 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_QueryShortChannelIds_1get_1chain_1hash(JNIEnv *env, jclass clz, int64_t this_ptr) {
19893 LDKQueryShortChannelIds this_ptr_conv;
19894 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19895 this_ptr_conv.is_owned = false;
19896 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
19897 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *QueryShortChannelIds_get_chain_hash(&this_ptr_conv));
19901 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_QueryShortChannelIds_1set_1chain_1hash(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
19902 LDKQueryShortChannelIds this_ptr_conv;
19903 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19904 this_ptr_conv.is_owned = false;
19905 LDKThirtyTwoBytes val_ref;
19906 CHECK((*env)->GetArrayLength(env, val) == 32);
19907 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
19908 QueryShortChannelIds_set_chain_hash(&this_ptr_conv, val_ref);
19911 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_QueryShortChannelIds_1set_1short_1channel_1ids(JNIEnv *env, jclass clz, int64_t this_ptr, int64_tArray val) {
19912 LDKQueryShortChannelIds this_ptr_conv;
19913 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19914 this_ptr_conv.is_owned = false;
19915 LDKCVec_u64Z val_constr;
19916 val_constr.datalen = (*env)->GetArrayLength(env, val);
19917 if (val_constr.datalen > 0)
19918 val_constr.data = MALLOC(val_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
19920 val_constr.data = NULL;
19921 int64_t* val_vals = (*env)->GetLongArrayElements (env, val, NULL);
19922 for (size_t g = 0; g < val_constr.datalen; g++) {
19923 int64_t val_conv_6 = val_vals[g];
19924 val_constr.data[g] = val_conv_6;
19926 (*env)->ReleaseLongArrayElements(env, val, val_vals, 0);
19927 QueryShortChannelIds_set_short_channel_ids(&this_ptr_conv, val_constr);
19930 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_QueryShortChannelIds_1new(JNIEnv *env, jclass clz, int8_tArray chain_hash_arg, int64_tArray short_channel_ids_arg) {
19931 LDKThirtyTwoBytes chain_hash_arg_ref;
19932 CHECK((*env)->GetArrayLength(env, chain_hash_arg) == 32);
19933 (*env)->GetByteArrayRegion(env, chain_hash_arg, 0, 32, chain_hash_arg_ref.data);
19934 LDKCVec_u64Z short_channel_ids_arg_constr;
19935 short_channel_ids_arg_constr.datalen = (*env)->GetArrayLength(env, short_channel_ids_arg);
19936 if (short_channel_ids_arg_constr.datalen > 0)
19937 short_channel_ids_arg_constr.data = MALLOC(short_channel_ids_arg_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
19939 short_channel_ids_arg_constr.data = NULL;
19940 int64_t* short_channel_ids_arg_vals = (*env)->GetLongArrayElements (env, short_channel_ids_arg, NULL);
19941 for (size_t g = 0; g < short_channel_ids_arg_constr.datalen; g++) {
19942 int64_t short_channel_ids_arg_conv_6 = short_channel_ids_arg_vals[g];
19943 short_channel_ids_arg_constr.data[g] = short_channel_ids_arg_conv_6;
19945 (*env)->ReleaseLongArrayElements(env, short_channel_ids_arg, short_channel_ids_arg_vals, 0);
19946 LDKQueryShortChannelIds ret_var = QueryShortChannelIds_new(chain_hash_arg_ref, short_channel_ids_arg_constr);
19947 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19948 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19949 uint64_t ret_ref = (uint64_t)ret_var.inner;
19950 if (ret_var.is_owned) {
19956 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_QueryShortChannelIds_1clone(JNIEnv *env, jclass clz, int64_t orig) {
19957 LDKQueryShortChannelIds orig_conv;
19958 orig_conv.inner = (void*)(orig & (~1));
19959 orig_conv.is_owned = false;
19960 LDKQueryShortChannelIds ret_var = QueryShortChannelIds_clone(&orig_conv);
19961 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19962 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19963 uint64_t ret_ref = (uint64_t)ret_var.inner;
19964 if (ret_var.is_owned) {
19970 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ReplyShortChannelIdsEnd_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
19971 LDKReplyShortChannelIdsEnd this_obj_conv;
19972 this_obj_conv.inner = (void*)(this_obj & (~1));
19973 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
19974 ReplyShortChannelIdsEnd_free(this_obj_conv);
19977 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ReplyShortChannelIdsEnd_1get_1chain_1hash(JNIEnv *env, jclass clz, int64_t this_ptr) {
19978 LDKReplyShortChannelIdsEnd this_ptr_conv;
19979 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19980 this_ptr_conv.is_owned = false;
19981 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
19982 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *ReplyShortChannelIdsEnd_get_chain_hash(&this_ptr_conv));
19986 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ReplyShortChannelIdsEnd_1set_1chain_1hash(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
19987 LDKReplyShortChannelIdsEnd this_ptr_conv;
19988 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19989 this_ptr_conv.is_owned = false;
19990 LDKThirtyTwoBytes val_ref;
19991 CHECK((*env)->GetArrayLength(env, val) == 32);
19992 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
19993 ReplyShortChannelIdsEnd_set_chain_hash(&this_ptr_conv, val_ref);
19996 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_ReplyShortChannelIdsEnd_1get_1full_1information(JNIEnv *env, jclass clz, int64_t this_ptr) {
19997 LDKReplyShortChannelIdsEnd this_ptr_conv;
19998 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19999 this_ptr_conv.is_owned = false;
20000 jboolean ret_val = ReplyShortChannelIdsEnd_get_full_information(&this_ptr_conv);
20004 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ReplyShortChannelIdsEnd_1set_1full_1information(JNIEnv *env, jclass clz, int64_t this_ptr, jboolean val) {
20005 LDKReplyShortChannelIdsEnd this_ptr_conv;
20006 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20007 this_ptr_conv.is_owned = false;
20008 ReplyShortChannelIdsEnd_set_full_information(&this_ptr_conv, val);
20011 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ReplyShortChannelIdsEnd_1new(JNIEnv *env, jclass clz, int8_tArray chain_hash_arg, jboolean full_information_arg) {
20012 LDKThirtyTwoBytes chain_hash_arg_ref;
20013 CHECK((*env)->GetArrayLength(env, chain_hash_arg) == 32);
20014 (*env)->GetByteArrayRegion(env, chain_hash_arg, 0, 32, chain_hash_arg_ref.data);
20015 LDKReplyShortChannelIdsEnd ret_var = ReplyShortChannelIdsEnd_new(chain_hash_arg_ref, full_information_arg);
20016 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20017 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20018 uint64_t ret_ref = (uint64_t)ret_var.inner;
20019 if (ret_var.is_owned) {
20025 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ReplyShortChannelIdsEnd_1clone(JNIEnv *env, jclass clz, int64_t orig) {
20026 LDKReplyShortChannelIdsEnd orig_conv;
20027 orig_conv.inner = (void*)(orig & (~1));
20028 orig_conv.is_owned = false;
20029 LDKReplyShortChannelIdsEnd ret_var = ReplyShortChannelIdsEnd_clone(&orig_conv);
20030 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20031 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20032 uint64_t ret_ref = (uint64_t)ret_var.inner;
20033 if (ret_var.is_owned) {
20039 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_GossipTimestampFilter_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
20040 LDKGossipTimestampFilter this_obj_conv;
20041 this_obj_conv.inner = (void*)(this_obj & (~1));
20042 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
20043 GossipTimestampFilter_free(this_obj_conv);
20046 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_GossipTimestampFilter_1get_1chain_1hash(JNIEnv *env, jclass clz, int64_t this_ptr) {
20047 LDKGossipTimestampFilter this_ptr_conv;
20048 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20049 this_ptr_conv.is_owned = false;
20050 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
20051 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *GossipTimestampFilter_get_chain_hash(&this_ptr_conv));
20055 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_GossipTimestampFilter_1set_1chain_1hash(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
20056 LDKGossipTimestampFilter this_ptr_conv;
20057 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20058 this_ptr_conv.is_owned = false;
20059 LDKThirtyTwoBytes val_ref;
20060 CHECK((*env)->GetArrayLength(env, val) == 32);
20061 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
20062 GossipTimestampFilter_set_chain_hash(&this_ptr_conv, val_ref);
20065 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_GossipTimestampFilter_1get_1first_1timestamp(JNIEnv *env, jclass clz, int64_t this_ptr) {
20066 LDKGossipTimestampFilter this_ptr_conv;
20067 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20068 this_ptr_conv.is_owned = false;
20069 int32_t ret_val = GossipTimestampFilter_get_first_timestamp(&this_ptr_conv);
20073 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_GossipTimestampFilter_1set_1first_1timestamp(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
20074 LDKGossipTimestampFilter this_ptr_conv;
20075 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20076 this_ptr_conv.is_owned = false;
20077 GossipTimestampFilter_set_first_timestamp(&this_ptr_conv, val);
20080 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_GossipTimestampFilter_1get_1timestamp_1range(JNIEnv *env, jclass clz, int64_t this_ptr) {
20081 LDKGossipTimestampFilter this_ptr_conv;
20082 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20083 this_ptr_conv.is_owned = false;
20084 int32_t ret_val = GossipTimestampFilter_get_timestamp_range(&this_ptr_conv);
20088 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_GossipTimestampFilter_1set_1timestamp_1range(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
20089 LDKGossipTimestampFilter this_ptr_conv;
20090 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20091 this_ptr_conv.is_owned = false;
20092 GossipTimestampFilter_set_timestamp_range(&this_ptr_conv, val);
20095 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_GossipTimestampFilter_1new(JNIEnv *env, jclass clz, int8_tArray chain_hash_arg, int32_t first_timestamp_arg, int32_t timestamp_range_arg) {
20096 LDKThirtyTwoBytes chain_hash_arg_ref;
20097 CHECK((*env)->GetArrayLength(env, chain_hash_arg) == 32);
20098 (*env)->GetByteArrayRegion(env, chain_hash_arg, 0, 32, chain_hash_arg_ref.data);
20099 LDKGossipTimestampFilter ret_var = GossipTimestampFilter_new(chain_hash_arg_ref, first_timestamp_arg, timestamp_range_arg);
20100 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20101 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20102 uint64_t ret_ref = (uint64_t)ret_var.inner;
20103 if (ret_var.is_owned) {
20109 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_GossipTimestampFilter_1clone(JNIEnv *env, jclass clz, int64_t orig) {
20110 LDKGossipTimestampFilter orig_conv;
20111 orig_conv.inner = (void*)(orig & (~1));
20112 orig_conv.is_owned = false;
20113 LDKGossipTimestampFilter ret_var = GossipTimestampFilter_clone(&orig_conv);
20114 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20115 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20116 uint64_t ret_ref = (uint64_t)ret_var.inner;
20117 if (ret_var.is_owned) {
20123 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ErrorAction_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
20124 if ((this_ptr & 1) != 0) return;
20125 LDKErrorAction this_ptr_conv = *(LDKErrorAction*)(((uint64_t)this_ptr) & ~1);
20126 FREE((void*)this_ptr);
20127 ErrorAction_free(this_ptr_conv);
20130 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ErrorAction_1clone(JNIEnv *env, jclass clz, int64_t orig) {
20131 LDKErrorAction* orig_conv = (LDKErrorAction*)orig;
20132 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
20133 *ret_copy = ErrorAction_clone(orig_conv);
20134 uint64_t ret_ref = (uint64_t)ret_copy;
20138 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LightningError_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
20139 LDKLightningError this_obj_conv;
20140 this_obj_conv.inner = (void*)(this_obj & (~1));
20141 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
20142 LightningError_free(this_obj_conv);
20145 JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_LightningError_1get_1err(JNIEnv *env, jclass clz, int64_t this_ptr) {
20146 LDKLightningError this_ptr_conv;
20147 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20148 this_ptr_conv.is_owned = false;
20149 LDKStr ret_str = LightningError_get_err(&this_ptr_conv);
20150 jstring ret_conv = str_ref_to_java(env, ret_str.chars, ret_str.len);
20154 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LightningError_1set_1err(JNIEnv *env, jclass clz, int64_t this_ptr, jstring val) {
20155 LDKLightningError this_ptr_conv;
20156 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20157 this_ptr_conv.is_owned = false;
20158 LDKStr val_conv = java_to_owned_str(env, val);
20159 LightningError_set_err(&this_ptr_conv, val_conv);
20162 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LightningError_1get_1action(JNIEnv *env, jclass clz, int64_t this_ptr) {
20163 LDKLightningError this_ptr_conv;
20164 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20165 this_ptr_conv.is_owned = false;
20166 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
20167 *ret_copy = LightningError_get_action(&this_ptr_conv);
20168 uint64_t ret_ref = (uint64_t)ret_copy;
20172 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LightningError_1set_1action(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
20173 LDKLightningError this_ptr_conv;
20174 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20175 this_ptr_conv.is_owned = false;
20176 LDKErrorAction val_conv = *(LDKErrorAction*)(((uint64_t)val) & ~1);
20177 LightningError_set_action(&this_ptr_conv, val_conv);
20180 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LightningError_1new(JNIEnv *env, jclass clz, jstring err_arg, int64_t action_arg) {
20181 LDKStr err_arg_conv = java_to_owned_str(env, err_arg);
20182 LDKErrorAction action_arg_conv = *(LDKErrorAction*)(((uint64_t)action_arg) & ~1);
20183 LDKLightningError ret_var = LightningError_new(err_arg_conv, action_arg_conv);
20184 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20185 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20186 uint64_t ret_ref = (uint64_t)ret_var.inner;
20187 if (ret_var.is_owned) {
20193 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LightningError_1clone(JNIEnv *env, jclass clz, int64_t orig) {
20194 LDKLightningError orig_conv;
20195 orig_conv.inner = (void*)(orig & (~1));
20196 orig_conv.is_owned = false;
20197 LDKLightningError ret_var = LightningError_clone(&orig_conv);
20198 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20199 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20200 uint64_t ret_ref = (uint64_t)ret_var.inner;
20201 if (ret_var.is_owned) {
20207 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CommitmentUpdate_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
20208 LDKCommitmentUpdate this_obj_conv;
20209 this_obj_conv.inner = (void*)(this_obj & (~1));
20210 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
20211 CommitmentUpdate_free(this_obj_conv);
20214 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CommitmentUpdate_1set_1update_1add_1htlcs(JNIEnv *env, jclass clz, int64_t this_ptr, int64_tArray val) {
20215 LDKCommitmentUpdate this_ptr_conv;
20216 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20217 this_ptr_conv.is_owned = false;
20218 LDKCVec_UpdateAddHTLCZ val_constr;
20219 val_constr.datalen = (*env)->GetArrayLength(env, val);
20220 if (val_constr.datalen > 0)
20221 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKUpdateAddHTLC), "LDKCVec_UpdateAddHTLCZ Elements");
20223 val_constr.data = NULL;
20224 int64_t* val_vals = (*env)->GetLongArrayElements (env, val, NULL);
20225 for (size_t p = 0; p < val_constr.datalen; p++) {
20226 int64_t val_conv_15 = val_vals[p];
20227 LDKUpdateAddHTLC val_conv_15_conv;
20228 val_conv_15_conv.inner = (void*)(val_conv_15 & (~1));
20229 val_conv_15_conv.is_owned = (val_conv_15 & 1) || (val_conv_15 == 0);
20230 val_conv_15_conv = UpdateAddHTLC_clone(&val_conv_15_conv);
20231 val_constr.data[p] = val_conv_15_conv;
20233 (*env)->ReleaseLongArrayElements(env, val, val_vals, 0);
20234 CommitmentUpdate_set_update_add_htlcs(&this_ptr_conv, val_constr);
20237 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CommitmentUpdate_1set_1update_1fulfill_1htlcs(JNIEnv *env, jclass clz, int64_t this_ptr, int64_tArray val) {
20238 LDKCommitmentUpdate this_ptr_conv;
20239 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20240 this_ptr_conv.is_owned = false;
20241 LDKCVec_UpdateFulfillHTLCZ val_constr;
20242 val_constr.datalen = (*env)->GetArrayLength(env, val);
20243 if (val_constr.datalen > 0)
20244 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKUpdateFulfillHTLC), "LDKCVec_UpdateFulfillHTLCZ Elements");
20246 val_constr.data = NULL;
20247 int64_t* val_vals = (*env)->GetLongArrayElements (env, val, NULL);
20248 for (size_t t = 0; t < val_constr.datalen; t++) {
20249 int64_t val_conv_19 = val_vals[t];
20250 LDKUpdateFulfillHTLC val_conv_19_conv;
20251 val_conv_19_conv.inner = (void*)(val_conv_19 & (~1));
20252 val_conv_19_conv.is_owned = (val_conv_19 & 1) || (val_conv_19 == 0);
20253 val_conv_19_conv = UpdateFulfillHTLC_clone(&val_conv_19_conv);
20254 val_constr.data[t] = val_conv_19_conv;
20256 (*env)->ReleaseLongArrayElements(env, val, val_vals, 0);
20257 CommitmentUpdate_set_update_fulfill_htlcs(&this_ptr_conv, val_constr);
20260 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CommitmentUpdate_1set_1update_1fail_1htlcs(JNIEnv *env, jclass clz, int64_t this_ptr, int64_tArray val) {
20261 LDKCommitmentUpdate this_ptr_conv;
20262 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20263 this_ptr_conv.is_owned = false;
20264 LDKCVec_UpdateFailHTLCZ val_constr;
20265 val_constr.datalen = (*env)->GetArrayLength(env, val);
20266 if (val_constr.datalen > 0)
20267 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKUpdateFailHTLC), "LDKCVec_UpdateFailHTLCZ Elements");
20269 val_constr.data = NULL;
20270 int64_t* val_vals = (*env)->GetLongArrayElements (env, val, NULL);
20271 for (size_t q = 0; q < val_constr.datalen; q++) {
20272 int64_t val_conv_16 = val_vals[q];
20273 LDKUpdateFailHTLC val_conv_16_conv;
20274 val_conv_16_conv.inner = (void*)(val_conv_16 & (~1));
20275 val_conv_16_conv.is_owned = (val_conv_16 & 1) || (val_conv_16 == 0);
20276 val_conv_16_conv = UpdateFailHTLC_clone(&val_conv_16_conv);
20277 val_constr.data[q] = val_conv_16_conv;
20279 (*env)->ReleaseLongArrayElements(env, val, val_vals, 0);
20280 CommitmentUpdate_set_update_fail_htlcs(&this_ptr_conv, val_constr);
20283 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CommitmentUpdate_1set_1update_1fail_1malformed_1htlcs(JNIEnv *env, jclass clz, int64_t this_ptr, int64_tArray val) {
20284 LDKCommitmentUpdate this_ptr_conv;
20285 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20286 this_ptr_conv.is_owned = false;
20287 LDKCVec_UpdateFailMalformedHTLCZ val_constr;
20288 val_constr.datalen = (*env)->GetArrayLength(env, val);
20289 if (val_constr.datalen > 0)
20290 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKUpdateFailMalformedHTLC), "LDKCVec_UpdateFailMalformedHTLCZ Elements");
20292 val_constr.data = NULL;
20293 int64_t* val_vals = (*env)->GetLongArrayElements (env, val, NULL);
20294 for (size_t z = 0; z < val_constr.datalen; z++) {
20295 int64_t val_conv_25 = val_vals[z];
20296 LDKUpdateFailMalformedHTLC val_conv_25_conv;
20297 val_conv_25_conv.inner = (void*)(val_conv_25 & (~1));
20298 val_conv_25_conv.is_owned = (val_conv_25 & 1) || (val_conv_25 == 0);
20299 val_conv_25_conv = UpdateFailMalformedHTLC_clone(&val_conv_25_conv);
20300 val_constr.data[z] = val_conv_25_conv;
20302 (*env)->ReleaseLongArrayElements(env, val, val_vals, 0);
20303 CommitmentUpdate_set_update_fail_malformed_htlcs(&this_ptr_conv, val_constr);
20306 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentUpdate_1get_1update_1fee(JNIEnv *env, jclass clz, int64_t this_ptr) {
20307 LDKCommitmentUpdate this_ptr_conv;
20308 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20309 this_ptr_conv.is_owned = false;
20310 LDKUpdateFee ret_var = CommitmentUpdate_get_update_fee(&this_ptr_conv);
20311 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20312 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20313 uint64_t ret_ref = (uint64_t)ret_var.inner;
20314 if (ret_var.is_owned) {
20320 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CommitmentUpdate_1set_1update_1fee(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
20321 LDKCommitmentUpdate this_ptr_conv;
20322 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20323 this_ptr_conv.is_owned = false;
20324 LDKUpdateFee val_conv;
20325 val_conv.inner = (void*)(val & (~1));
20326 val_conv.is_owned = (val & 1) || (val == 0);
20327 val_conv = UpdateFee_clone(&val_conv);
20328 CommitmentUpdate_set_update_fee(&this_ptr_conv, val_conv);
20331 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentUpdate_1get_1commitment_1signed(JNIEnv *env, jclass clz, int64_t this_ptr) {
20332 LDKCommitmentUpdate this_ptr_conv;
20333 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20334 this_ptr_conv.is_owned = false;
20335 LDKCommitmentSigned ret_var = CommitmentUpdate_get_commitment_signed(&this_ptr_conv);
20336 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20337 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20338 uint64_t ret_ref = (uint64_t)ret_var.inner;
20339 if (ret_var.is_owned) {
20345 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CommitmentUpdate_1set_1commitment_1signed(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
20346 LDKCommitmentUpdate this_ptr_conv;
20347 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20348 this_ptr_conv.is_owned = false;
20349 LDKCommitmentSigned val_conv;
20350 val_conv.inner = (void*)(val & (~1));
20351 val_conv.is_owned = (val & 1) || (val == 0);
20352 val_conv = CommitmentSigned_clone(&val_conv);
20353 CommitmentUpdate_set_commitment_signed(&this_ptr_conv, val_conv);
20356 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentUpdate_1new(JNIEnv *env, jclass clz, int64_tArray update_add_htlcs_arg, int64_tArray update_fulfill_htlcs_arg, int64_tArray update_fail_htlcs_arg, int64_tArray update_fail_malformed_htlcs_arg, int64_t update_fee_arg, int64_t commitment_signed_arg) {
20357 LDKCVec_UpdateAddHTLCZ update_add_htlcs_arg_constr;
20358 update_add_htlcs_arg_constr.datalen = (*env)->GetArrayLength(env, update_add_htlcs_arg);
20359 if (update_add_htlcs_arg_constr.datalen > 0)
20360 update_add_htlcs_arg_constr.data = MALLOC(update_add_htlcs_arg_constr.datalen * sizeof(LDKUpdateAddHTLC), "LDKCVec_UpdateAddHTLCZ Elements");
20362 update_add_htlcs_arg_constr.data = NULL;
20363 int64_t* update_add_htlcs_arg_vals = (*env)->GetLongArrayElements (env, update_add_htlcs_arg, NULL);
20364 for (size_t p = 0; p < update_add_htlcs_arg_constr.datalen; p++) {
20365 int64_t update_add_htlcs_arg_conv_15 = update_add_htlcs_arg_vals[p];
20366 LDKUpdateAddHTLC update_add_htlcs_arg_conv_15_conv;
20367 update_add_htlcs_arg_conv_15_conv.inner = (void*)(update_add_htlcs_arg_conv_15 & (~1));
20368 update_add_htlcs_arg_conv_15_conv.is_owned = (update_add_htlcs_arg_conv_15 & 1) || (update_add_htlcs_arg_conv_15 == 0);
20369 update_add_htlcs_arg_conv_15_conv = UpdateAddHTLC_clone(&update_add_htlcs_arg_conv_15_conv);
20370 update_add_htlcs_arg_constr.data[p] = update_add_htlcs_arg_conv_15_conv;
20372 (*env)->ReleaseLongArrayElements(env, update_add_htlcs_arg, update_add_htlcs_arg_vals, 0);
20373 LDKCVec_UpdateFulfillHTLCZ update_fulfill_htlcs_arg_constr;
20374 update_fulfill_htlcs_arg_constr.datalen = (*env)->GetArrayLength(env, update_fulfill_htlcs_arg);
20375 if (update_fulfill_htlcs_arg_constr.datalen > 0)
20376 update_fulfill_htlcs_arg_constr.data = MALLOC(update_fulfill_htlcs_arg_constr.datalen * sizeof(LDKUpdateFulfillHTLC), "LDKCVec_UpdateFulfillHTLCZ Elements");
20378 update_fulfill_htlcs_arg_constr.data = NULL;
20379 int64_t* update_fulfill_htlcs_arg_vals = (*env)->GetLongArrayElements (env, update_fulfill_htlcs_arg, NULL);
20380 for (size_t t = 0; t < update_fulfill_htlcs_arg_constr.datalen; t++) {
20381 int64_t update_fulfill_htlcs_arg_conv_19 = update_fulfill_htlcs_arg_vals[t];
20382 LDKUpdateFulfillHTLC update_fulfill_htlcs_arg_conv_19_conv;
20383 update_fulfill_htlcs_arg_conv_19_conv.inner = (void*)(update_fulfill_htlcs_arg_conv_19 & (~1));
20384 update_fulfill_htlcs_arg_conv_19_conv.is_owned = (update_fulfill_htlcs_arg_conv_19 & 1) || (update_fulfill_htlcs_arg_conv_19 == 0);
20385 update_fulfill_htlcs_arg_conv_19_conv = UpdateFulfillHTLC_clone(&update_fulfill_htlcs_arg_conv_19_conv);
20386 update_fulfill_htlcs_arg_constr.data[t] = update_fulfill_htlcs_arg_conv_19_conv;
20388 (*env)->ReleaseLongArrayElements(env, update_fulfill_htlcs_arg, update_fulfill_htlcs_arg_vals, 0);
20389 LDKCVec_UpdateFailHTLCZ update_fail_htlcs_arg_constr;
20390 update_fail_htlcs_arg_constr.datalen = (*env)->GetArrayLength(env, update_fail_htlcs_arg);
20391 if (update_fail_htlcs_arg_constr.datalen > 0)
20392 update_fail_htlcs_arg_constr.data = MALLOC(update_fail_htlcs_arg_constr.datalen * sizeof(LDKUpdateFailHTLC), "LDKCVec_UpdateFailHTLCZ Elements");
20394 update_fail_htlcs_arg_constr.data = NULL;
20395 int64_t* update_fail_htlcs_arg_vals = (*env)->GetLongArrayElements (env, update_fail_htlcs_arg, NULL);
20396 for (size_t q = 0; q < update_fail_htlcs_arg_constr.datalen; q++) {
20397 int64_t update_fail_htlcs_arg_conv_16 = update_fail_htlcs_arg_vals[q];
20398 LDKUpdateFailHTLC update_fail_htlcs_arg_conv_16_conv;
20399 update_fail_htlcs_arg_conv_16_conv.inner = (void*)(update_fail_htlcs_arg_conv_16 & (~1));
20400 update_fail_htlcs_arg_conv_16_conv.is_owned = (update_fail_htlcs_arg_conv_16 & 1) || (update_fail_htlcs_arg_conv_16 == 0);
20401 update_fail_htlcs_arg_conv_16_conv = UpdateFailHTLC_clone(&update_fail_htlcs_arg_conv_16_conv);
20402 update_fail_htlcs_arg_constr.data[q] = update_fail_htlcs_arg_conv_16_conv;
20404 (*env)->ReleaseLongArrayElements(env, update_fail_htlcs_arg, update_fail_htlcs_arg_vals, 0);
20405 LDKCVec_UpdateFailMalformedHTLCZ update_fail_malformed_htlcs_arg_constr;
20406 update_fail_malformed_htlcs_arg_constr.datalen = (*env)->GetArrayLength(env, update_fail_malformed_htlcs_arg);
20407 if (update_fail_malformed_htlcs_arg_constr.datalen > 0)
20408 update_fail_malformed_htlcs_arg_constr.data = MALLOC(update_fail_malformed_htlcs_arg_constr.datalen * sizeof(LDKUpdateFailMalformedHTLC), "LDKCVec_UpdateFailMalformedHTLCZ Elements");
20410 update_fail_malformed_htlcs_arg_constr.data = NULL;
20411 int64_t* update_fail_malformed_htlcs_arg_vals = (*env)->GetLongArrayElements (env, update_fail_malformed_htlcs_arg, NULL);
20412 for (size_t z = 0; z < update_fail_malformed_htlcs_arg_constr.datalen; z++) {
20413 int64_t update_fail_malformed_htlcs_arg_conv_25 = update_fail_malformed_htlcs_arg_vals[z];
20414 LDKUpdateFailMalformedHTLC update_fail_malformed_htlcs_arg_conv_25_conv;
20415 update_fail_malformed_htlcs_arg_conv_25_conv.inner = (void*)(update_fail_malformed_htlcs_arg_conv_25 & (~1));
20416 update_fail_malformed_htlcs_arg_conv_25_conv.is_owned = (update_fail_malformed_htlcs_arg_conv_25 & 1) || (update_fail_malformed_htlcs_arg_conv_25 == 0);
20417 update_fail_malformed_htlcs_arg_conv_25_conv = UpdateFailMalformedHTLC_clone(&update_fail_malformed_htlcs_arg_conv_25_conv);
20418 update_fail_malformed_htlcs_arg_constr.data[z] = update_fail_malformed_htlcs_arg_conv_25_conv;
20420 (*env)->ReleaseLongArrayElements(env, update_fail_malformed_htlcs_arg, update_fail_malformed_htlcs_arg_vals, 0);
20421 LDKUpdateFee update_fee_arg_conv;
20422 update_fee_arg_conv.inner = (void*)(update_fee_arg & (~1));
20423 update_fee_arg_conv.is_owned = (update_fee_arg & 1) || (update_fee_arg == 0);
20424 update_fee_arg_conv = UpdateFee_clone(&update_fee_arg_conv);
20425 LDKCommitmentSigned commitment_signed_arg_conv;
20426 commitment_signed_arg_conv.inner = (void*)(commitment_signed_arg & (~1));
20427 commitment_signed_arg_conv.is_owned = (commitment_signed_arg & 1) || (commitment_signed_arg == 0);
20428 commitment_signed_arg_conv = CommitmentSigned_clone(&commitment_signed_arg_conv);
20429 LDKCommitmentUpdate ret_var = CommitmentUpdate_new(update_add_htlcs_arg_constr, update_fulfill_htlcs_arg_constr, update_fail_htlcs_arg_constr, update_fail_malformed_htlcs_arg_constr, update_fee_arg_conv, commitment_signed_arg_conv);
20430 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20431 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20432 uint64_t ret_ref = (uint64_t)ret_var.inner;
20433 if (ret_var.is_owned) {
20439 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentUpdate_1clone(JNIEnv *env, jclass clz, int64_t orig) {
20440 LDKCommitmentUpdate orig_conv;
20441 orig_conv.inner = (void*)(orig & (~1));
20442 orig_conv.is_owned = false;
20443 LDKCommitmentUpdate ret_var = CommitmentUpdate_clone(&orig_conv);
20444 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20445 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20446 uint64_t ret_ref = (uint64_t)ret_var.inner;
20447 if (ret_var.is_owned) {
20453 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_HTLCFailChannelUpdate_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
20454 if ((this_ptr & 1) != 0) return;
20455 LDKHTLCFailChannelUpdate this_ptr_conv = *(LDKHTLCFailChannelUpdate*)(((uint64_t)this_ptr) & ~1);
20456 FREE((void*)this_ptr);
20457 HTLCFailChannelUpdate_free(this_ptr_conv);
20460 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_HTLCFailChannelUpdate_1clone(JNIEnv *env, jclass clz, int64_t orig) {
20461 LDKHTLCFailChannelUpdate* orig_conv = (LDKHTLCFailChannelUpdate*)orig;
20462 LDKHTLCFailChannelUpdate *ret_copy = MALLOC(sizeof(LDKHTLCFailChannelUpdate), "LDKHTLCFailChannelUpdate");
20463 *ret_copy = HTLCFailChannelUpdate_clone(orig_conv);
20464 uint64_t ret_ref = (uint64_t)ret_copy;
20468 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMessageHandler_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
20469 if ((this_ptr & 1) != 0) return;
20470 LDKChannelMessageHandler this_ptr_conv = *(LDKChannelMessageHandler*)(((uint64_t)this_ptr) & ~1);
20471 FREE((void*)this_ptr);
20472 ChannelMessageHandler_free(this_ptr_conv);
20475 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RoutingMessageHandler_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
20476 if ((this_ptr & 1) != 0) return;
20477 LDKRoutingMessageHandler this_ptr_conv = *(LDKRoutingMessageHandler*)(((uint64_t)this_ptr) & ~1);
20478 FREE((void*)this_ptr);
20479 RoutingMessageHandler_free(this_ptr_conv);
20482 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1write(JNIEnv *env, jclass clz, int64_t obj) {
20483 LDKAcceptChannel obj_conv;
20484 obj_conv.inner = (void*)(obj & (~1));
20485 obj_conv.is_owned = false;
20486 LDKCVec_u8Z ret_var = AcceptChannel_write(&obj_conv);
20487 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
20488 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
20489 CVec_u8Z_free(ret_var);
20493 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
20494 LDKu8slice ser_ref;
20495 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
20496 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
20497 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
20498 *ret_conv = AcceptChannel_read(ser_ref);
20499 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
20500 return (uint64_t)ret_conv;
20503 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_AnnouncementSignatures_1write(JNIEnv *env, jclass clz, int64_t obj) {
20504 LDKAnnouncementSignatures obj_conv;
20505 obj_conv.inner = (void*)(obj & (~1));
20506 obj_conv.is_owned = false;
20507 LDKCVec_u8Z ret_var = AnnouncementSignatures_write(&obj_conv);
20508 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
20509 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
20510 CVec_u8Z_free(ret_var);
20514 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_AnnouncementSignatures_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
20515 LDKu8slice ser_ref;
20516 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
20517 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
20518 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
20519 *ret_conv = AnnouncementSignatures_read(ser_ref);
20520 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
20521 return (uint64_t)ret_conv;
20524 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelReestablish_1write(JNIEnv *env, jclass clz, int64_t obj) {
20525 LDKChannelReestablish obj_conv;
20526 obj_conv.inner = (void*)(obj & (~1));
20527 obj_conv.is_owned = false;
20528 LDKCVec_u8Z ret_var = ChannelReestablish_write(&obj_conv);
20529 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
20530 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
20531 CVec_u8Z_free(ret_var);
20535 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelReestablish_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
20536 LDKu8slice ser_ref;
20537 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
20538 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
20539 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
20540 *ret_conv = ChannelReestablish_read(ser_ref);
20541 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
20542 return (uint64_t)ret_conv;
20545 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ClosingSigned_1write(JNIEnv *env, jclass clz, int64_t obj) {
20546 LDKClosingSigned obj_conv;
20547 obj_conv.inner = (void*)(obj & (~1));
20548 obj_conv.is_owned = false;
20549 LDKCVec_u8Z ret_var = ClosingSigned_write(&obj_conv);
20550 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
20551 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
20552 CVec_u8Z_free(ret_var);
20556 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ClosingSigned_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
20557 LDKu8slice ser_ref;
20558 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
20559 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
20560 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
20561 *ret_conv = ClosingSigned_read(ser_ref);
20562 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
20563 return (uint64_t)ret_conv;
20566 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_CommitmentSigned_1write(JNIEnv *env, jclass clz, int64_t obj) {
20567 LDKCommitmentSigned obj_conv;
20568 obj_conv.inner = (void*)(obj & (~1));
20569 obj_conv.is_owned = false;
20570 LDKCVec_u8Z ret_var = CommitmentSigned_write(&obj_conv);
20571 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
20572 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
20573 CVec_u8Z_free(ret_var);
20577 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentSigned_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
20578 LDKu8slice ser_ref;
20579 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
20580 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
20581 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
20582 *ret_conv = CommitmentSigned_read(ser_ref);
20583 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
20584 return (uint64_t)ret_conv;
20587 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_FundingCreated_1write(JNIEnv *env, jclass clz, int64_t obj) {
20588 LDKFundingCreated obj_conv;
20589 obj_conv.inner = (void*)(obj & (~1));
20590 obj_conv.is_owned = false;
20591 LDKCVec_u8Z ret_var = FundingCreated_write(&obj_conv);
20592 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
20593 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
20594 CVec_u8Z_free(ret_var);
20598 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_FundingCreated_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
20599 LDKu8slice ser_ref;
20600 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
20601 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
20602 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
20603 *ret_conv = FundingCreated_read(ser_ref);
20604 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
20605 return (uint64_t)ret_conv;
20608 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_FundingSigned_1write(JNIEnv *env, jclass clz, int64_t obj) {
20609 LDKFundingSigned obj_conv;
20610 obj_conv.inner = (void*)(obj & (~1));
20611 obj_conv.is_owned = false;
20612 LDKCVec_u8Z ret_var = FundingSigned_write(&obj_conv);
20613 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
20614 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
20615 CVec_u8Z_free(ret_var);
20619 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_FundingSigned_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
20620 LDKu8slice ser_ref;
20621 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
20622 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
20623 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
20624 *ret_conv = FundingSigned_read(ser_ref);
20625 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
20626 return (uint64_t)ret_conv;
20629 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_FundingLocked_1write(JNIEnv *env, jclass clz, int64_t obj) {
20630 LDKFundingLocked obj_conv;
20631 obj_conv.inner = (void*)(obj & (~1));
20632 obj_conv.is_owned = false;
20633 LDKCVec_u8Z ret_var = FundingLocked_write(&obj_conv);
20634 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
20635 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
20636 CVec_u8Z_free(ret_var);
20640 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_FundingLocked_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
20641 LDKu8slice ser_ref;
20642 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
20643 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
20644 LDKCResult_FundingLockedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingLockedDecodeErrorZ), "LDKCResult_FundingLockedDecodeErrorZ");
20645 *ret_conv = FundingLocked_read(ser_ref);
20646 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
20647 return (uint64_t)ret_conv;
20650 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_Init_1write(JNIEnv *env, jclass clz, int64_t obj) {
20652 obj_conv.inner = (void*)(obj & (~1));
20653 obj_conv.is_owned = false;
20654 LDKCVec_u8Z ret_var = Init_write(&obj_conv);
20655 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
20656 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
20657 CVec_u8Z_free(ret_var);
20661 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Init_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
20662 LDKu8slice ser_ref;
20663 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
20664 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
20665 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
20666 *ret_conv = Init_read(ser_ref);
20667 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
20668 return (uint64_t)ret_conv;
20671 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_OpenChannel_1write(JNIEnv *env, jclass clz, int64_t obj) {
20672 LDKOpenChannel obj_conv;
20673 obj_conv.inner = (void*)(obj & (~1));
20674 obj_conv.is_owned = false;
20675 LDKCVec_u8Z ret_var = OpenChannel_write(&obj_conv);
20676 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
20677 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
20678 CVec_u8Z_free(ret_var);
20682 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OpenChannel_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
20683 LDKu8slice ser_ref;
20684 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
20685 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
20686 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
20687 *ret_conv = OpenChannel_read(ser_ref);
20688 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
20689 return (uint64_t)ret_conv;
20692 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_RevokeAndACK_1write(JNIEnv *env, jclass clz, int64_t obj) {
20693 LDKRevokeAndACK obj_conv;
20694 obj_conv.inner = (void*)(obj & (~1));
20695 obj_conv.is_owned = false;
20696 LDKCVec_u8Z ret_var = RevokeAndACK_write(&obj_conv);
20697 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
20698 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
20699 CVec_u8Z_free(ret_var);
20703 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RevokeAndACK_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
20704 LDKu8slice ser_ref;
20705 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
20706 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
20707 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
20708 *ret_conv = RevokeAndACK_read(ser_ref);
20709 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
20710 return (uint64_t)ret_conv;
20713 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_Shutdown_1write(JNIEnv *env, jclass clz, int64_t obj) {
20714 LDKShutdown obj_conv;
20715 obj_conv.inner = (void*)(obj & (~1));
20716 obj_conv.is_owned = false;
20717 LDKCVec_u8Z ret_var = Shutdown_write(&obj_conv);
20718 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
20719 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
20720 CVec_u8Z_free(ret_var);
20724 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Shutdown_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
20725 LDKu8slice ser_ref;
20726 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
20727 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
20728 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
20729 *ret_conv = Shutdown_read(ser_ref);
20730 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
20731 return (uint64_t)ret_conv;
20734 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UpdateFailHTLC_1write(JNIEnv *env, jclass clz, int64_t obj) {
20735 LDKUpdateFailHTLC obj_conv;
20736 obj_conv.inner = (void*)(obj & (~1));
20737 obj_conv.is_owned = false;
20738 LDKCVec_u8Z ret_var = UpdateFailHTLC_write(&obj_conv);
20739 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
20740 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
20741 CVec_u8Z_free(ret_var);
20745 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFailHTLC_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
20746 LDKu8slice ser_ref;
20747 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
20748 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
20749 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
20750 *ret_conv = UpdateFailHTLC_read(ser_ref);
20751 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
20752 return (uint64_t)ret_conv;
20755 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UpdateFailMalformedHTLC_1write(JNIEnv *env, jclass clz, int64_t obj) {
20756 LDKUpdateFailMalformedHTLC obj_conv;
20757 obj_conv.inner = (void*)(obj & (~1));
20758 obj_conv.is_owned = false;
20759 LDKCVec_u8Z ret_var = UpdateFailMalformedHTLC_write(&obj_conv);
20760 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
20761 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
20762 CVec_u8Z_free(ret_var);
20766 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFailMalformedHTLC_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
20767 LDKu8slice ser_ref;
20768 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
20769 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
20770 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
20771 *ret_conv = UpdateFailMalformedHTLC_read(ser_ref);
20772 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
20773 return (uint64_t)ret_conv;
20776 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UpdateFee_1write(JNIEnv *env, jclass clz, int64_t obj) {
20777 LDKUpdateFee obj_conv;
20778 obj_conv.inner = (void*)(obj & (~1));
20779 obj_conv.is_owned = false;
20780 LDKCVec_u8Z ret_var = UpdateFee_write(&obj_conv);
20781 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
20782 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
20783 CVec_u8Z_free(ret_var);
20787 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFee_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
20788 LDKu8slice ser_ref;
20789 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
20790 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
20791 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
20792 *ret_conv = UpdateFee_read(ser_ref);
20793 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
20794 return (uint64_t)ret_conv;
20797 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UpdateFulfillHTLC_1write(JNIEnv *env, jclass clz, int64_t obj) {
20798 LDKUpdateFulfillHTLC obj_conv;
20799 obj_conv.inner = (void*)(obj & (~1));
20800 obj_conv.is_owned = false;
20801 LDKCVec_u8Z ret_var = UpdateFulfillHTLC_write(&obj_conv);
20802 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
20803 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
20804 CVec_u8Z_free(ret_var);
20808 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFulfillHTLC_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
20809 LDKu8slice ser_ref;
20810 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
20811 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
20812 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
20813 *ret_conv = UpdateFulfillHTLC_read(ser_ref);
20814 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
20815 return (uint64_t)ret_conv;
20818 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1write(JNIEnv *env, jclass clz, int64_t obj) {
20819 LDKUpdateAddHTLC obj_conv;
20820 obj_conv.inner = (void*)(obj & (~1));
20821 obj_conv.is_owned = false;
20822 LDKCVec_u8Z ret_var = UpdateAddHTLC_write(&obj_conv);
20823 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
20824 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
20825 CVec_u8Z_free(ret_var);
20829 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
20830 LDKu8slice ser_ref;
20831 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
20832 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
20833 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
20834 *ret_conv = UpdateAddHTLC_read(ser_ref);
20835 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
20836 return (uint64_t)ret_conv;
20839 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_Ping_1write(JNIEnv *env, jclass clz, int64_t obj) {
20841 obj_conv.inner = (void*)(obj & (~1));
20842 obj_conv.is_owned = false;
20843 LDKCVec_u8Z ret_var = Ping_write(&obj_conv);
20844 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
20845 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
20846 CVec_u8Z_free(ret_var);
20850 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Ping_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
20851 LDKu8slice ser_ref;
20852 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
20853 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
20854 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
20855 *ret_conv = Ping_read(ser_ref);
20856 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
20857 return (uint64_t)ret_conv;
20860 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_Pong_1write(JNIEnv *env, jclass clz, int64_t obj) {
20862 obj_conv.inner = (void*)(obj & (~1));
20863 obj_conv.is_owned = false;
20864 LDKCVec_u8Z ret_var = Pong_write(&obj_conv);
20865 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
20866 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
20867 CVec_u8Z_free(ret_var);
20871 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Pong_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
20872 LDKu8slice ser_ref;
20873 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
20874 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
20875 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
20876 *ret_conv = Pong_read(ser_ref);
20877 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
20878 return (uint64_t)ret_conv;
20881 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1write(JNIEnv *env, jclass clz, int64_t obj) {
20882 LDKUnsignedChannelAnnouncement obj_conv;
20883 obj_conv.inner = (void*)(obj & (~1));
20884 obj_conv.is_owned = false;
20885 LDKCVec_u8Z ret_var = UnsignedChannelAnnouncement_write(&obj_conv);
20886 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
20887 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
20888 CVec_u8Z_free(ret_var);
20892 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
20893 LDKu8slice ser_ref;
20894 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
20895 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
20896 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
20897 *ret_conv = UnsignedChannelAnnouncement_read(ser_ref);
20898 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
20899 return (uint64_t)ret_conv;
20902 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1write(JNIEnv *env, jclass clz, int64_t obj) {
20903 LDKChannelAnnouncement obj_conv;
20904 obj_conv.inner = (void*)(obj & (~1));
20905 obj_conv.is_owned = false;
20906 LDKCVec_u8Z ret_var = ChannelAnnouncement_write(&obj_conv);
20907 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
20908 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
20909 CVec_u8Z_free(ret_var);
20913 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
20914 LDKu8slice ser_ref;
20915 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
20916 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
20917 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
20918 *ret_conv = ChannelAnnouncement_read(ser_ref);
20919 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
20920 return (uint64_t)ret_conv;
20923 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1write(JNIEnv *env, jclass clz, int64_t obj) {
20924 LDKUnsignedChannelUpdate obj_conv;
20925 obj_conv.inner = (void*)(obj & (~1));
20926 obj_conv.is_owned = false;
20927 LDKCVec_u8Z ret_var = UnsignedChannelUpdate_write(&obj_conv);
20928 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
20929 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
20930 CVec_u8Z_free(ret_var);
20934 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
20935 LDKu8slice ser_ref;
20936 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
20937 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
20938 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
20939 *ret_conv = UnsignedChannelUpdate_read(ser_ref);
20940 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
20941 return (uint64_t)ret_conv;
20944 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelUpdate_1write(JNIEnv *env, jclass clz, int64_t obj) {
20945 LDKChannelUpdate obj_conv;
20946 obj_conv.inner = (void*)(obj & (~1));
20947 obj_conv.is_owned = false;
20948 LDKCVec_u8Z ret_var = ChannelUpdate_write(&obj_conv);
20949 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
20950 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
20951 CVec_u8Z_free(ret_var);
20955 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelUpdate_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
20956 LDKu8slice ser_ref;
20957 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
20958 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
20959 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
20960 *ret_conv = ChannelUpdate_read(ser_ref);
20961 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
20962 return (uint64_t)ret_conv;
20965 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ErrorMessage_1write(JNIEnv *env, jclass clz, int64_t obj) {
20966 LDKErrorMessage obj_conv;
20967 obj_conv.inner = (void*)(obj & (~1));
20968 obj_conv.is_owned = false;
20969 LDKCVec_u8Z ret_var = ErrorMessage_write(&obj_conv);
20970 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
20971 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
20972 CVec_u8Z_free(ret_var);
20976 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ErrorMessage_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
20977 LDKu8slice ser_ref;
20978 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
20979 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
20980 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
20981 *ret_conv = ErrorMessage_read(ser_ref);
20982 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
20983 return (uint64_t)ret_conv;
20986 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1write(JNIEnv *env, jclass clz, int64_t obj) {
20987 LDKUnsignedNodeAnnouncement obj_conv;
20988 obj_conv.inner = (void*)(obj & (~1));
20989 obj_conv.is_owned = false;
20990 LDKCVec_u8Z ret_var = UnsignedNodeAnnouncement_write(&obj_conv);
20991 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
20992 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
20993 CVec_u8Z_free(ret_var);
20997 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
20998 LDKu8slice ser_ref;
20999 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
21000 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
21001 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
21002 *ret_conv = UnsignedNodeAnnouncement_read(ser_ref);
21003 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
21004 return (uint64_t)ret_conv;
21007 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_NodeAnnouncement_1write(JNIEnv *env, jclass clz, int64_t obj) {
21008 LDKNodeAnnouncement obj_conv;
21009 obj_conv.inner = (void*)(obj & (~1));
21010 obj_conv.is_owned = false;
21011 LDKCVec_u8Z ret_var = NodeAnnouncement_write(&obj_conv);
21012 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
21013 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
21014 CVec_u8Z_free(ret_var);
21018 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeAnnouncement_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
21019 LDKu8slice ser_ref;
21020 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
21021 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
21022 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
21023 *ret_conv = NodeAnnouncement_read(ser_ref);
21024 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
21025 return (uint64_t)ret_conv;
21028 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_QueryShortChannelIds_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
21029 LDKu8slice ser_ref;
21030 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
21031 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
21032 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
21033 *ret_conv = QueryShortChannelIds_read(ser_ref);
21034 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
21035 return (uint64_t)ret_conv;
21038 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_QueryShortChannelIds_1write(JNIEnv *env, jclass clz, int64_t obj) {
21039 LDKQueryShortChannelIds obj_conv;
21040 obj_conv.inner = (void*)(obj & (~1));
21041 obj_conv.is_owned = false;
21042 LDKCVec_u8Z ret_var = QueryShortChannelIds_write(&obj_conv);
21043 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
21044 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
21045 CVec_u8Z_free(ret_var);
21049 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ReplyShortChannelIdsEnd_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
21050 LDKu8slice ser_ref;
21051 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
21052 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
21053 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
21054 *ret_conv = ReplyShortChannelIdsEnd_read(ser_ref);
21055 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
21056 return (uint64_t)ret_conv;
21059 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ReplyShortChannelIdsEnd_1write(JNIEnv *env, jclass clz, int64_t obj) {
21060 LDKReplyShortChannelIdsEnd obj_conv;
21061 obj_conv.inner = (void*)(obj & (~1));
21062 obj_conv.is_owned = false;
21063 LDKCVec_u8Z ret_var = ReplyShortChannelIdsEnd_write(&obj_conv);
21064 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
21065 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
21066 CVec_u8Z_free(ret_var);
21070 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_QueryChannelRange_1end_1blocknum(JNIEnv *env, jclass clz, int64_t this_arg) {
21071 LDKQueryChannelRange this_arg_conv;
21072 this_arg_conv.inner = (void*)(this_arg & (~1));
21073 this_arg_conv.is_owned = false;
21074 int32_t ret_val = QueryChannelRange_end_blocknum(&this_arg_conv);
21078 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_QueryChannelRange_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
21079 LDKu8slice ser_ref;
21080 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
21081 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
21082 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
21083 *ret_conv = QueryChannelRange_read(ser_ref);
21084 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
21085 return (uint64_t)ret_conv;
21088 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_QueryChannelRange_1write(JNIEnv *env, jclass clz, int64_t obj) {
21089 LDKQueryChannelRange obj_conv;
21090 obj_conv.inner = (void*)(obj & (~1));
21091 obj_conv.is_owned = false;
21092 LDKCVec_u8Z ret_var = QueryChannelRange_write(&obj_conv);
21093 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
21094 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
21095 CVec_u8Z_free(ret_var);
21099 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ReplyChannelRange_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
21100 LDKu8slice ser_ref;
21101 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
21102 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
21103 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
21104 *ret_conv = ReplyChannelRange_read(ser_ref);
21105 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
21106 return (uint64_t)ret_conv;
21109 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ReplyChannelRange_1write(JNIEnv *env, jclass clz, int64_t obj) {
21110 LDKReplyChannelRange obj_conv;
21111 obj_conv.inner = (void*)(obj & (~1));
21112 obj_conv.is_owned = false;
21113 LDKCVec_u8Z ret_var = ReplyChannelRange_write(&obj_conv);
21114 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
21115 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
21116 CVec_u8Z_free(ret_var);
21120 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_GossipTimestampFilter_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
21121 LDKu8slice ser_ref;
21122 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
21123 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
21124 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
21125 *ret_conv = GossipTimestampFilter_read(ser_ref);
21126 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
21127 return (uint64_t)ret_conv;
21130 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_GossipTimestampFilter_1write(JNIEnv *env, jclass clz, int64_t obj) {
21131 LDKGossipTimestampFilter obj_conv;
21132 obj_conv.inner = (void*)(obj & (~1));
21133 obj_conv.is_owned = false;
21134 LDKCVec_u8Z ret_var = GossipTimestampFilter_write(&obj_conv);
21135 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
21136 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
21137 CVec_u8Z_free(ret_var);
21141 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_IgnoringMessageHandler_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
21142 LDKIgnoringMessageHandler this_obj_conv;
21143 this_obj_conv.inner = (void*)(this_obj & (~1));
21144 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
21145 IgnoringMessageHandler_free(this_obj_conv);
21148 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_IgnoringMessageHandler_1new(JNIEnv *env, jclass clz) {
21149 LDKIgnoringMessageHandler ret_var = IgnoringMessageHandler_new();
21150 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21151 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21152 uint64_t ret_ref = (uint64_t)ret_var.inner;
21153 if (ret_var.is_owned) {
21159 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_IgnoringMessageHandler_1as_1MessageSendEventsProvider(JNIEnv *env, jclass clz, int64_t this_arg) {
21160 LDKIgnoringMessageHandler this_arg_conv;
21161 this_arg_conv.inner = (void*)(this_arg & (~1));
21162 this_arg_conv.is_owned = false;
21163 LDKMessageSendEventsProvider* ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
21164 *ret = IgnoringMessageHandler_as_MessageSendEventsProvider(&this_arg_conv);
21165 return (uint64_t)ret;
21168 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_IgnoringMessageHandler_1as_1RoutingMessageHandler(JNIEnv *env, jclass clz, int64_t this_arg) {
21169 LDKIgnoringMessageHandler this_arg_conv;
21170 this_arg_conv.inner = (void*)(this_arg & (~1));
21171 this_arg_conv.is_owned = false;
21172 LDKRoutingMessageHandler* ret = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
21173 *ret = IgnoringMessageHandler_as_RoutingMessageHandler(&this_arg_conv);
21174 return (uint64_t)ret;
21177 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ErroringMessageHandler_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
21178 LDKErroringMessageHandler this_obj_conv;
21179 this_obj_conv.inner = (void*)(this_obj & (~1));
21180 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
21181 ErroringMessageHandler_free(this_obj_conv);
21184 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ErroringMessageHandler_1new(JNIEnv *env, jclass clz) {
21185 LDKErroringMessageHandler ret_var = ErroringMessageHandler_new();
21186 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21187 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21188 uint64_t ret_ref = (uint64_t)ret_var.inner;
21189 if (ret_var.is_owned) {
21195 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ErroringMessageHandler_1as_1MessageSendEventsProvider(JNIEnv *env, jclass clz, int64_t this_arg) {
21196 LDKErroringMessageHandler this_arg_conv;
21197 this_arg_conv.inner = (void*)(this_arg & (~1));
21198 this_arg_conv.is_owned = false;
21199 LDKMessageSendEventsProvider* ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
21200 *ret = ErroringMessageHandler_as_MessageSendEventsProvider(&this_arg_conv);
21201 return (uint64_t)ret;
21204 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ErroringMessageHandler_1as_1ChannelMessageHandler(JNIEnv *env, jclass clz, int64_t this_arg) {
21205 LDKErroringMessageHandler this_arg_conv;
21206 this_arg_conv.inner = (void*)(this_arg & (~1));
21207 this_arg_conv.is_owned = false;
21208 LDKChannelMessageHandler* ret = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
21209 *ret = ErroringMessageHandler_as_ChannelMessageHandler(&this_arg_conv);
21210 return (uint64_t)ret;
21213 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_MessageHandler_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
21214 LDKMessageHandler this_obj_conv;
21215 this_obj_conv.inner = (void*)(this_obj & (~1));
21216 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
21217 MessageHandler_free(this_obj_conv);
21220 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MessageHandler_1get_1chan_1handler(JNIEnv *env, jclass clz, int64_t this_ptr) {
21221 LDKMessageHandler this_ptr_conv;
21222 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21223 this_ptr_conv.is_owned = false;
21224 uint64_t ret_ret = (uint64_t)MessageHandler_get_chan_handler(&this_ptr_conv);
21228 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_MessageHandler_1set_1chan_1handler(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
21229 LDKMessageHandler this_ptr_conv;
21230 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21231 this_ptr_conv.is_owned = false;
21232 LDKChannelMessageHandler val_conv = *(LDKChannelMessageHandler*)(((uint64_t)val) & ~1);
21233 if (val_conv.free == LDKChannelMessageHandler_JCalls_free) {
21234 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
21235 LDKChannelMessageHandler_JCalls_clone(val_conv.this_arg);
21237 MessageHandler_set_chan_handler(&this_ptr_conv, val_conv);
21240 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MessageHandler_1get_1route_1handler(JNIEnv *env, jclass clz, int64_t this_ptr) {
21241 LDKMessageHandler this_ptr_conv;
21242 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21243 this_ptr_conv.is_owned = false;
21244 uint64_t ret_ret = (uint64_t)MessageHandler_get_route_handler(&this_ptr_conv);
21248 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_MessageHandler_1set_1route_1handler(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
21249 LDKMessageHandler this_ptr_conv;
21250 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21251 this_ptr_conv.is_owned = false;
21252 LDKRoutingMessageHandler val_conv = *(LDKRoutingMessageHandler*)(((uint64_t)val) & ~1);
21253 if (val_conv.free == LDKRoutingMessageHandler_JCalls_free) {
21254 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
21255 LDKRoutingMessageHandler_JCalls_clone(val_conv.this_arg);
21257 MessageHandler_set_route_handler(&this_ptr_conv, val_conv);
21260 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MessageHandler_1new(JNIEnv *env, jclass clz, int64_t chan_handler_arg, int64_t route_handler_arg) {
21261 LDKChannelMessageHandler chan_handler_arg_conv = *(LDKChannelMessageHandler*)(((uint64_t)chan_handler_arg) & ~1);
21262 if (chan_handler_arg_conv.free == LDKChannelMessageHandler_JCalls_free) {
21263 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
21264 LDKChannelMessageHandler_JCalls_clone(chan_handler_arg_conv.this_arg);
21266 LDKRoutingMessageHandler route_handler_arg_conv = *(LDKRoutingMessageHandler*)(((uint64_t)route_handler_arg) & ~1);
21267 if (route_handler_arg_conv.free == LDKRoutingMessageHandler_JCalls_free) {
21268 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
21269 LDKRoutingMessageHandler_JCalls_clone(route_handler_arg_conv.this_arg);
21271 LDKMessageHandler ret_var = MessageHandler_new(chan_handler_arg_conv, route_handler_arg_conv);
21272 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21273 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21274 uint64_t ret_ref = (uint64_t)ret_var.inner;
21275 if (ret_var.is_owned) {
21281 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SocketDescriptor_1clone(JNIEnv *env, jclass clz, int64_t orig) {
21282 LDKSocketDescriptor* orig_conv = (LDKSocketDescriptor*)(((uint64_t)orig) & ~1);
21283 LDKSocketDescriptor* ret = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
21284 *ret = SocketDescriptor_clone(orig_conv);
21285 return (uint64_t)ret;
21288 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_SocketDescriptor_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
21289 if ((this_ptr & 1) != 0) return;
21290 LDKSocketDescriptor this_ptr_conv = *(LDKSocketDescriptor*)(((uint64_t)this_ptr) & ~1);
21291 FREE((void*)this_ptr);
21292 SocketDescriptor_free(this_ptr_conv);
21295 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_PeerHandleError_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
21296 LDKPeerHandleError this_obj_conv;
21297 this_obj_conv.inner = (void*)(this_obj & (~1));
21298 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
21299 PeerHandleError_free(this_obj_conv);
21302 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_PeerHandleError_1get_1no_1connection_1possible(JNIEnv *env, jclass clz, int64_t this_ptr) {
21303 LDKPeerHandleError this_ptr_conv;
21304 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21305 this_ptr_conv.is_owned = false;
21306 jboolean ret_val = PeerHandleError_get_no_connection_possible(&this_ptr_conv);
21310 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_PeerHandleError_1set_1no_1connection_1possible(JNIEnv *env, jclass clz, int64_t this_ptr, jboolean val) {
21311 LDKPeerHandleError this_ptr_conv;
21312 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21313 this_ptr_conv.is_owned = false;
21314 PeerHandleError_set_no_connection_possible(&this_ptr_conv, val);
21317 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PeerHandleError_1new(JNIEnv *env, jclass clz, jboolean no_connection_possible_arg) {
21318 LDKPeerHandleError ret_var = PeerHandleError_new(no_connection_possible_arg);
21319 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21320 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21321 uint64_t ret_ref = (uint64_t)ret_var.inner;
21322 if (ret_var.is_owned) {
21328 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PeerHandleError_1clone(JNIEnv *env, jclass clz, int64_t orig) {
21329 LDKPeerHandleError orig_conv;
21330 orig_conv.inner = (void*)(orig & (~1));
21331 orig_conv.is_owned = false;
21332 LDKPeerHandleError ret_var = PeerHandleError_clone(&orig_conv);
21333 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21334 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21335 uint64_t ret_ref = (uint64_t)ret_var.inner;
21336 if (ret_var.is_owned) {
21342 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_PeerManager_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
21343 LDKPeerManager this_obj_conv;
21344 this_obj_conv.inner = (void*)(this_obj & (~1));
21345 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
21346 PeerManager_free(this_obj_conv);
21349 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PeerManager_1new(JNIEnv *env, jclass clz, int64_t message_handler, int8_tArray our_node_secret, int8_tArray ephemeral_random_data, int64_t logger) {
21350 LDKMessageHandler message_handler_conv;
21351 message_handler_conv.inner = (void*)(message_handler & (~1));
21352 message_handler_conv.is_owned = (message_handler & 1) || (message_handler == 0);
21353 // Warning: we need a move here but no clone is available for LDKMessageHandler
21354 LDKSecretKey our_node_secret_ref;
21355 CHECK((*env)->GetArrayLength(env, our_node_secret) == 32);
21356 (*env)->GetByteArrayRegion(env, our_node_secret, 0, 32, our_node_secret_ref.bytes);
21357 unsigned char ephemeral_random_data_arr[32];
21358 CHECK((*env)->GetArrayLength(env, ephemeral_random_data) == 32);
21359 (*env)->GetByteArrayRegion(env, ephemeral_random_data, 0, 32, ephemeral_random_data_arr);
21360 unsigned char (*ephemeral_random_data_ref)[32] = &ephemeral_random_data_arr;
21361 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
21362 if (logger_conv.free == LDKLogger_JCalls_free) {
21363 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
21364 LDKLogger_JCalls_clone(logger_conv.this_arg);
21366 LDKPeerManager ret_var = PeerManager_new(message_handler_conv, our_node_secret_ref, ephemeral_random_data_ref, logger_conv);
21367 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21368 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21369 uint64_t ret_ref = (uint64_t)ret_var.inner;
21370 if (ret_var.is_owned) {
21376 JNIEXPORT jobjectArray JNICALL Java_org_ldk_impl_bindings_PeerManager_1get_1peer_1node_1ids(JNIEnv *env, jclass clz, int64_t this_arg) {
21377 LDKPeerManager this_arg_conv;
21378 this_arg_conv.inner = (void*)(this_arg & (~1));
21379 this_arg_conv.is_owned = false;
21380 LDKCVec_PublicKeyZ ret_var = PeerManager_get_peer_node_ids(&this_arg_conv);
21381 jobjectArray ret_arr = (*env)->NewObjectArray(env, ret_var.datalen, arr_of_B_clz, NULL);
21383 for (size_t i = 0; i < ret_var.datalen; i++) {
21384 int8_tArray ret_conv_8_arr = (*env)->NewByteArray(env, 33);
21385 (*env)->SetByteArrayRegion(env, ret_conv_8_arr, 0, 33, ret_var.data[i].compressed_form);
21386 (*env)->SetObjectArrayElement(env, ret_arr, i, ret_conv_8_arr);
21388 FREE(ret_var.data);
21392 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PeerManager_1new_1outbound_1connection(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray their_node_id, int64_t descriptor) {
21393 LDKPeerManager this_arg_conv;
21394 this_arg_conv.inner = (void*)(this_arg & (~1));
21395 this_arg_conv.is_owned = false;
21396 LDKPublicKey their_node_id_ref;
21397 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
21398 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
21399 LDKSocketDescriptor descriptor_conv = *(LDKSocketDescriptor*)(((uint64_t)descriptor) & ~1);
21400 if (descriptor_conv.free == LDKSocketDescriptor_JCalls_free) {
21401 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
21402 LDKSocketDescriptor_JCalls_clone(descriptor_conv.this_arg);
21404 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
21405 *ret_conv = PeerManager_new_outbound_connection(&this_arg_conv, their_node_id_ref, descriptor_conv);
21406 return (uint64_t)ret_conv;
21409 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PeerManager_1new_1inbound_1connection(JNIEnv *env, jclass clz, int64_t this_arg, int64_t descriptor) {
21410 LDKPeerManager this_arg_conv;
21411 this_arg_conv.inner = (void*)(this_arg & (~1));
21412 this_arg_conv.is_owned = false;
21413 LDKSocketDescriptor descriptor_conv = *(LDKSocketDescriptor*)(((uint64_t)descriptor) & ~1);
21414 if (descriptor_conv.free == LDKSocketDescriptor_JCalls_free) {
21415 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
21416 LDKSocketDescriptor_JCalls_clone(descriptor_conv.this_arg);
21418 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
21419 *ret_conv = PeerManager_new_inbound_connection(&this_arg_conv, descriptor_conv);
21420 return (uint64_t)ret_conv;
21423 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PeerManager_1write_1buffer_1space_1avail(JNIEnv *env, jclass clz, int64_t this_arg, int64_t descriptor) {
21424 LDKPeerManager this_arg_conv;
21425 this_arg_conv.inner = (void*)(this_arg & (~1));
21426 this_arg_conv.is_owned = false;
21427 LDKSocketDescriptor* descriptor_conv = (LDKSocketDescriptor*)(((uint64_t)descriptor) & ~1);
21428 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
21429 *ret_conv = PeerManager_write_buffer_space_avail(&this_arg_conv, descriptor_conv);
21430 return (uint64_t)ret_conv;
21433 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PeerManager_1read_1event(JNIEnv *env, jclass clz, int64_t this_arg, int64_t peer_descriptor, int8_tArray data) {
21434 LDKPeerManager this_arg_conv;
21435 this_arg_conv.inner = (void*)(this_arg & (~1));
21436 this_arg_conv.is_owned = false;
21437 LDKSocketDescriptor* peer_descriptor_conv = (LDKSocketDescriptor*)(((uint64_t)peer_descriptor) & ~1);
21438 LDKu8slice data_ref;
21439 data_ref.datalen = (*env)->GetArrayLength(env, data);
21440 data_ref.data = (*env)->GetByteArrayElements (env, data, NULL);
21441 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
21442 *ret_conv = PeerManager_read_event(&this_arg_conv, peer_descriptor_conv, data_ref);
21443 (*env)->ReleaseByteArrayElements(env, data, (int8_t*)data_ref.data, 0);
21444 return (uint64_t)ret_conv;
21447 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_PeerManager_1process_1events(JNIEnv *env, jclass clz, int64_t this_arg) {
21448 LDKPeerManager this_arg_conv;
21449 this_arg_conv.inner = (void*)(this_arg & (~1));
21450 this_arg_conv.is_owned = false;
21451 PeerManager_process_events(&this_arg_conv);
21454 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_PeerManager_1socket_1disconnected(JNIEnv *env, jclass clz, int64_t this_arg, int64_t descriptor) {
21455 LDKPeerManager this_arg_conv;
21456 this_arg_conv.inner = (void*)(this_arg & (~1));
21457 this_arg_conv.is_owned = false;
21458 LDKSocketDescriptor* descriptor_conv = (LDKSocketDescriptor*)(((uint64_t)descriptor) & ~1);
21459 PeerManager_socket_disconnected(&this_arg_conv, descriptor_conv);
21462 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_PeerManager_1disconnect_1by_1node_1id(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray node_id, jboolean no_connection_possible) {
21463 LDKPeerManager this_arg_conv;
21464 this_arg_conv.inner = (void*)(this_arg & (~1));
21465 this_arg_conv.is_owned = false;
21466 LDKPublicKey node_id_ref;
21467 CHECK((*env)->GetArrayLength(env, node_id) == 33);
21468 (*env)->GetByteArrayRegion(env, node_id, 0, 33, node_id_ref.compressed_form);
21469 PeerManager_disconnect_by_node_id(&this_arg_conv, node_id_ref, no_connection_possible);
21472 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_PeerManager_1timer_1tick_1occurred(JNIEnv *env, jclass clz, int64_t this_arg) {
21473 LDKPeerManager this_arg_conv;
21474 this_arg_conv.inner = (void*)(this_arg & (~1));
21475 this_arg_conv.is_owned = false;
21476 PeerManager_timer_tick_occurred(&this_arg_conv);
21479 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_build_1commitment_1secret(JNIEnv *env, jclass clz, int8_tArray commitment_seed, int64_t idx) {
21480 unsigned char commitment_seed_arr[32];
21481 CHECK((*env)->GetArrayLength(env, commitment_seed) == 32);
21482 (*env)->GetByteArrayRegion(env, commitment_seed, 0, 32, commitment_seed_arr);
21483 unsigned char (*commitment_seed_ref)[32] = &commitment_seed_arr;
21484 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
21485 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, build_commitment_secret(commitment_seed_ref, idx).data);
21489 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_derive_1private_1key(JNIEnv *env, jclass clz, int8_tArray per_commitment_point, int8_tArray base_secret) {
21490 LDKPublicKey per_commitment_point_ref;
21491 CHECK((*env)->GetArrayLength(env, per_commitment_point) == 33);
21492 (*env)->GetByteArrayRegion(env, per_commitment_point, 0, 33, per_commitment_point_ref.compressed_form);
21493 unsigned char base_secret_arr[32];
21494 CHECK((*env)->GetArrayLength(env, base_secret) == 32);
21495 (*env)->GetByteArrayRegion(env, base_secret, 0, 32, base_secret_arr);
21496 unsigned char (*base_secret_ref)[32] = &base_secret_arr;
21497 LDKCResult_SecretKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SecretKeyErrorZ), "LDKCResult_SecretKeyErrorZ");
21498 *ret_conv = derive_private_key(per_commitment_point_ref, base_secret_ref);
21499 return (uint64_t)ret_conv;
21502 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_derive_1public_1key(JNIEnv *env, jclass clz, int8_tArray per_commitment_point, int8_tArray base_point) {
21503 LDKPublicKey per_commitment_point_ref;
21504 CHECK((*env)->GetArrayLength(env, per_commitment_point) == 33);
21505 (*env)->GetByteArrayRegion(env, per_commitment_point, 0, 33, per_commitment_point_ref.compressed_form);
21506 LDKPublicKey base_point_ref;
21507 CHECK((*env)->GetArrayLength(env, base_point) == 33);
21508 (*env)->GetByteArrayRegion(env, base_point, 0, 33, base_point_ref.compressed_form);
21509 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
21510 *ret_conv = derive_public_key(per_commitment_point_ref, base_point_ref);
21511 return (uint64_t)ret_conv;
21514 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_derive_1private_1revocation_1key(JNIEnv *env, jclass clz, int8_tArray per_commitment_secret, int8_tArray countersignatory_revocation_base_secret) {
21515 unsigned char per_commitment_secret_arr[32];
21516 CHECK((*env)->GetArrayLength(env, per_commitment_secret) == 32);
21517 (*env)->GetByteArrayRegion(env, per_commitment_secret, 0, 32, per_commitment_secret_arr);
21518 unsigned char (*per_commitment_secret_ref)[32] = &per_commitment_secret_arr;
21519 unsigned char countersignatory_revocation_base_secret_arr[32];
21520 CHECK((*env)->GetArrayLength(env, countersignatory_revocation_base_secret) == 32);
21521 (*env)->GetByteArrayRegion(env, countersignatory_revocation_base_secret, 0, 32, countersignatory_revocation_base_secret_arr);
21522 unsigned char (*countersignatory_revocation_base_secret_ref)[32] = &countersignatory_revocation_base_secret_arr;
21523 LDKCResult_SecretKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SecretKeyErrorZ), "LDKCResult_SecretKeyErrorZ");
21524 *ret_conv = derive_private_revocation_key(per_commitment_secret_ref, countersignatory_revocation_base_secret_ref);
21525 return (uint64_t)ret_conv;
21528 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_derive_1public_1revocation_1key(JNIEnv *env, jclass clz, int8_tArray per_commitment_point, int8_tArray countersignatory_revocation_base_point) {
21529 LDKPublicKey per_commitment_point_ref;
21530 CHECK((*env)->GetArrayLength(env, per_commitment_point) == 33);
21531 (*env)->GetByteArrayRegion(env, per_commitment_point, 0, 33, per_commitment_point_ref.compressed_form);
21532 LDKPublicKey countersignatory_revocation_base_point_ref;
21533 CHECK((*env)->GetArrayLength(env, countersignatory_revocation_base_point) == 33);
21534 (*env)->GetByteArrayRegion(env, countersignatory_revocation_base_point, 0, 33, countersignatory_revocation_base_point_ref.compressed_form);
21535 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
21536 *ret_conv = derive_public_revocation_key(per_commitment_point_ref, countersignatory_revocation_base_point_ref);
21537 return (uint64_t)ret_conv;
21540 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
21541 LDKTxCreationKeys this_obj_conv;
21542 this_obj_conv.inner = (void*)(this_obj & (~1));
21543 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
21544 TxCreationKeys_free(this_obj_conv);
21547 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1get_1per_1commitment_1point(JNIEnv *env, jclass clz, int64_t this_ptr) {
21548 LDKTxCreationKeys this_ptr_conv;
21549 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21550 this_ptr_conv.is_owned = false;
21551 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
21552 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, TxCreationKeys_get_per_commitment_point(&this_ptr_conv).compressed_form);
21556 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1set_1per_1commitment_1point(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
21557 LDKTxCreationKeys this_ptr_conv;
21558 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21559 this_ptr_conv.is_owned = false;
21560 LDKPublicKey val_ref;
21561 CHECK((*env)->GetArrayLength(env, val) == 33);
21562 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
21563 TxCreationKeys_set_per_commitment_point(&this_ptr_conv, val_ref);
21566 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1get_1revocation_1key(JNIEnv *env, jclass clz, int64_t this_ptr) {
21567 LDKTxCreationKeys this_ptr_conv;
21568 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21569 this_ptr_conv.is_owned = false;
21570 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
21571 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, TxCreationKeys_get_revocation_key(&this_ptr_conv).compressed_form);
21575 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1set_1revocation_1key(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
21576 LDKTxCreationKeys this_ptr_conv;
21577 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21578 this_ptr_conv.is_owned = false;
21579 LDKPublicKey val_ref;
21580 CHECK((*env)->GetArrayLength(env, val) == 33);
21581 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
21582 TxCreationKeys_set_revocation_key(&this_ptr_conv, val_ref);
21585 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1get_1broadcaster_1htlc_1key(JNIEnv *env, jclass clz, int64_t this_ptr) {
21586 LDKTxCreationKeys this_ptr_conv;
21587 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21588 this_ptr_conv.is_owned = false;
21589 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
21590 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, TxCreationKeys_get_broadcaster_htlc_key(&this_ptr_conv).compressed_form);
21594 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1set_1broadcaster_1htlc_1key(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
21595 LDKTxCreationKeys this_ptr_conv;
21596 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21597 this_ptr_conv.is_owned = false;
21598 LDKPublicKey val_ref;
21599 CHECK((*env)->GetArrayLength(env, val) == 33);
21600 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
21601 TxCreationKeys_set_broadcaster_htlc_key(&this_ptr_conv, val_ref);
21604 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1get_1countersignatory_1htlc_1key(JNIEnv *env, jclass clz, int64_t this_ptr) {
21605 LDKTxCreationKeys this_ptr_conv;
21606 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21607 this_ptr_conv.is_owned = false;
21608 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
21609 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, TxCreationKeys_get_countersignatory_htlc_key(&this_ptr_conv).compressed_form);
21613 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1set_1countersignatory_1htlc_1key(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
21614 LDKTxCreationKeys this_ptr_conv;
21615 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21616 this_ptr_conv.is_owned = false;
21617 LDKPublicKey val_ref;
21618 CHECK((*env)->GetArrayLength(env, val) == 33);
21619 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
21620 TxCreationKeys_set_countersignatory_htlc_key(&this_ptr_conv, val_ref);
21623 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1get_1broadcaster_1delayed_1payment_1key(JNIEnv *env, jclass clz, int64_t this_ptr) {
21624 LDKTxCreationKeys this_ptr_conv;
21625 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21626 this_ptr_conv.is_owned = false;
21627 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
21628 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, TxCreationKeys_get_broadcaster_delayed_payment_key(&this_ptr_conv).compressed_form);
21632 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1set_1broadcaster_1delayed_1payment_1key(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
21633 LDKTxCreationKeys this_ptr_conv;
21634 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21635 this_ptr_conv.is_owned = false;
21636 LDKPublicKey val_ref;
21637 CHECK((*env)->GetArrayLength(env, val) == 33);
21638 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
21639 TxCreationKeys_set_broadcaster_delayed_payment_key(&this_ptr_conv, val_ref);
21642 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1new(JNIEnv *env, jclass clz, int8_tArray per_commitment_point_arg, int8_tArray revocation_key_arg, int8_tArray broadcaster_htlc_key_arg, int8_tArray countersignatory_htlc_key_arg, int8_tArray broadcaster_delayed_payment_key_arg) {
21643 LDKPublicKey per_commitment_point_arg_ref;
21644 CHECK((*env)->GetArrayLength(env, per_commitment_point_arg) == 33);
21645 (*env)->GetByteArrayRegion(env, per_commitment_point_arg, 0, 33, per_commitment_point_arg_ref.compressed_form);
21646 LDKPublicKey revocation_key_arg_ref;
21647 CHECK((*env)->GetArrayLength(env, revocation_key_arg) == 33);
21648 (*env)->GetByteArrayRegion(env, revocation_key_arg, 0, 33, revocation_key_arg_ref.compressed_form);
21649 LDKPublicKey broadcaster_htlc_key_arg_ref;
21650 CHECK((*env)->GetArrayLength(env, broadcaster_htlc_key_arg) == 33);
21651 (*env)->GetByteArrayRegion(env, broadcaster_htlc_key_arg, 0, 33, broadcaster_htlc_key_arg_ref.compressed_form);
21652 LDKPublicKey countersignatory_htlc_key_arg_ref;
21653 CHECK((*env)->GetArrayLength(env, countersignatory_htlc_key_arg) == 33);
21654 (*env)->GetByteArrayRegion(env, countersignatory_htlc_key_arg, 0, 33, countersignatory_htlc_key_arg_ref.compressed_form);
21655 LDKPublicKey broadcaster_delayed_payment_key_arg_ref;
21656 CHECK((*env)->GetArrayLength(env, broadcaster_delayed_payment_key_arg) == 33);
21657 (*env)->GetByteArrayRegion(env, broadcaster_delayed_payment_key_arg, 0, 33, broadcaster_delayed_payment_key_arg_ref.compressed_form);
21658 LDKTxCreationKeys ret_var = TxCreationKeys_new(per_commitment_point_arg_ref, revocation_key_arg_ref, broadcaster_htlc_key_arg_ref, countersignatory_htlc_key_arg_ref, broadcaster_delayed_payment_key_arg_ref);
21659 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21660 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21661 uint64_t ret_ref = (uint64_t)ret_var.inner;
21662 if (ret_var.is_owned) {
21668 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1clone(JNIEnv *env, jclass clz, int64_t orig) {
21669 LDKTxCreationKeys orig_conv;
21670 orig_conv.inner = (void*)(orig & (~1));
21671 orig_conv.is_owned = false;
21672 LDKTxCreationKeys ret_var = TxCreationKeys_clone(&orig_conv);
21673 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21674 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21675 uint64_t ret_ref = (uint64_t)ret_var.inner;
21676 if (ret_var.is_owned) {
21682 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1write(JNIEnv *env, jclass clz, int64_t obj) {
21683 LDKTxCreationKeys obj_conv;
21684 obj_conv.inner = (void*)(obj & (~1));
21685 obj_conv.is_owned = false;
21686 LDKCVec_u8Z ret_var = TxCreationKeys_write(&obj_conv);
21687 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
21688 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
21689 CVec_u8Z_free(ret_var);
21693 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
21694 LDKu8slice ser_ref;
21695 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
21696 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
21697 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
21698 *ret_conv = TxCreationKeys_read(ser_ref);
21699 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
21700 return (uint64_t)ret_conv;
21703 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
21704 LDKChannelPublicKeys this_obj_conv;
21705 this_obj_conv.inner = (void*)(this_obj & (~1));
21706 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
21707 ChannelPublicKeys_free(this_obj_conv);
21710 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1get_1funding_1pubkey(JNIEnv *env, jclass clz, int64_t this_ptr) {
21711 LDKChannelPublicKeys this_ptr_conv;
21712 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21713 this_ptr_conv.is_owned = false;
21714 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
21715 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ChannelPublicKeys_get_funding_pubkey(&this_ptr_conv).compressed_form);
21719 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1set_1funding_1pubkey(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
21720 LDKChannelPublicKeys this_ptr_conv;
21721 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21722 this_ptr_conv.is_owned = false;
21723 LDKPublicKey val_ref;
21724 CHECK((*env)->GetArrayLength(env, val) == 33);
21725 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
21726 ChannelPublicKeys_set_funding_pubkey(&this_ptr_conv, val_ref);
21729 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1get_1revocation_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr) {
21730 LDKChannelPublicKeys this_ptr_conv;
21731 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21732 this_ptr_conv.is_owned = false;
21733 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
21734 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ChannelPublicKeys_get_revocation_basepoint(&this_ptr_conv).compressed_form);
21738 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1set_1revocation_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
21739 LDKChannelPublicKeys this_ptr_conv;
21740 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21741 this_ptr_conv.is_owned = false;
21742 LDKPublicKey val_ref;
21743 CHECK((*env)->GetArrayLength(env, val) == 33);
21744 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
21745 ChannelPublicKeys_set_revocation_basepoint(&this_ptr_conv, val_ref);
21748 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1get_1payment_1point(JNIEnv *env, jclass clz, int64_t this_ptr) {
21749 LDKChannelPublicKeys this_ptr_conv;
21750 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21751 this_ptr_conv.is_owned = false;
21752 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
21753 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ChannelPublicKeys_get_payment_point(&this_ptr_conv).compressed_form);
21757 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1set_1payment_1point(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
21758 LDKChannelPublicKeys this_ptr_conv;
21759 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21760 this_ptr_conv.is_owned = false;
21761 LDKPublicKey val_ref;
21762 CHECK((*env)->GetArrayLength(env, val) == 33);
21763 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
21764 ChannelPublicKeys_set_payment_point(&this_ptr_conv, val_ref);
21767 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1get_1delayed_1payment_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr) {
21768 LDKChannelPublicKeys this_ptr_conv;
21769 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21770 this_ptr_conv.is_owned = false;
21771 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
21772 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ChannelPublicKeys_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form);
21776 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1set_1delayed_1payment_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
21777 LDKChannelPublicKeys this_ptr_conv;
21778 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21779 this_ptr_conv.is_owned = false;
21780 LDKPublicKey val_ref;
21781 CHECK((*env)->GetArrayLength(env, val) == 33);
21782 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
21783 ChannelPublicKeys_set_delayed_payment_basepoint(&this_ptr_conv, val_ref);
21786 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1get_1htlc_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr) {
21787 LDKChannelPublicKeys this_ptr_conv;
21788 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21789 this_ptr_conv.is_owned = false;
21790 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
21791 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ChannelPublicKeys_get_htlc_basepoint(&this_ptr_conv).compressed_form);
21795 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1set_1htlc_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
21796 LDKChannelPublicKeys this_ptr_conv;
21797 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21798 this_ptr_conv.is_owned = false;
21799 LDKPublicKey val_ref;
21800 CHECK((*env)->GetArrayLength(env, val) == 33);
21801 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
21802 ChannelPublicKeys_set_htlc_basepoint(&this_ptr_conv, val_ref);
21805 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1new(JNIEnv *env, jclass clz, int8_tArray funding_pubkey_arg, int8_tArray revocation_basepoint_arg, int8_tArray payment_point_arg, int8_tArray delayed_payment_basepoint_arg, int8_tArray htlc_basepoint_arg) {
21806 LDKPublicKey funding_pubkey_arg_ref;
21807 CHECK((*env)->GetArrayLength(env, funding_pubkey_arg) == 33);
21808 (*env)->GetByteArrayRegion(env, funding_pubkey_arg, 0, 33, funding_pubkey_arg_ref.compressed_form);
21809 LDKPublicKey revocation_basepoint_arg_ref;
21810 CHECK((*env)->GetArrayLength(env, revocation_basepoint_arg) == 33);
21811 (*env)->GetByteArrayRegion(env, revocation_basepoint_arg, 0, 33, revocation_basepoint_arg_ref.compressed_form);
21812 LDKPublicKey payment_point_arg_ref;
21813 CHECK((*env)->GetArrayLength(env, payment_point_arg) == 33);
21814 (*env)->GetByteArrayRegion(env, payment_point_arg, 0, 33, payment_point_arg_ref.compressed_form);
21815 LDKPublicKey delayed_payment_basepoint_arg_ref;
21816 CHECK((*env)->GetArrayLength(env, delayed_payment_basepoint_arg) == 33);
21817 (*env)->GetByteArrayRegion(env, delayed_payment_basepoint_arg, 0, 33, delayed_payment_basepoint_arg_ref.compressed_form);
21818 LDKPublicKey htlc_basepoint_arg_ref;
21819 CHECK((*env)->GetArrayLength(env, htlc_basepoint_arg) == 33);
21820 (*env)->GetByteArrayRegion(env, htlc_basepoint_arg, 0, 33, htlc_basepoint_arg_ref.compressed_form);
21821 LDKChannelPublicKeys ret_var = ChannelPublicKeys_new(funding_pubkey_arg_ref, revocation_basepoint_arg_ref, payment_point_arg_ref, delayed_payment_basepoint_arg_ref, htlc_basepoint_arg_ref);
21822 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21823 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21824 uint64_t ret_ref = (uint64_t)ret_var.inner;
21825 if (ret_var.is_owned) {
21831 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1clone(JNIEnv *env, jclass clz, int64_t orig) {
21832 LDKChannelPublicKeys orig_conv;
21833 orig_conv.inner = (void*)(orig & (~1));
21834 orig_conv.is_owned = false;
21835 LDKChannelPublicKeys ret_var = ChannelPublicKeys_clone(&orig_conv);
21836 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21837 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21838 uint64_t ret_ref = (uint64_t)ret_var.inner;
21839 if (ret_var.is_owned) {
21845 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1write(JNIEnv *env, jclass clz, int64_t obj) {
21846 LDKChannelPublicKeys obj_conv;
21847 obj_conv.inner = (void*)(obj & (~1));
21848 obj_conv.is_owned = false;
21849 LDKCVec_u8Z ret_var = ChannelPublicKeys_write(&obj_conv);
21850 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
21851 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
21852 CVec_u8Z_free(ret_var);
21856 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
21857 LDKu8slice ser_ref;
21858 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
21859 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
21860 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
21861 *ret_conv = ChannelPublicKeys_read(ser_ref);
21862 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
21863 return (uint64_t)ret_conv;
21866 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1derive_1new(JNIEnv *env, jclass clz, int8_tArray per_commitment_point, int8_tArray broadcaster_delayed_payment_base, int8_tArray broadcaster_htlc_base, int8_tArray countersignatory_revocation_base, int8_tArray countersignatory_htlc_base) {
21867 LDKPublicKey per_commitment_point_ref;
21868 CHECK((*env)->GetArrayLength(env, per_commitment_point) == 33);
21869 (*env)->GetByteArrayRegion(env, per_commitment_point, 0, 33, per_commitment_point_ref.compressed_form);
21870 LDKPublicKey broadcaster_delayed_payment_base_ref;
21871 CHECK((*env)->GetArrayLength(env, broadcaster_delayed_payment_base) == 33);
21872 (*env)->GetByteArrayRegion(env, broadcaster_delayed_payment_base, 0, 33, broadcaster_delayed_payment_base_ref.compressed_form);
21873 LDKPublicKey broadcaster_htlc_base_ref;
21874 CHECK((*env)->GetArrayLength(env, broadcaster_htlc_base) == 33);
21875 (*env)->GetByteArrayRegion(env, broadcaster_htlc_base, 0, 33, broadcaster_htlc_base_ref.compressed_form);
21876 LDKPublicKey countersignatory_revocation_base_ref;
21877 CHECK((*env)->GetArrayLength(env, countersignatory_revocation_base) == 33);
21878 (*env)->GetByteArrayRegion(env, countersignatory_revocation_base, 0, 33, countersignatory_revocation_base_ref.compressed_form);
21879 LDKPublicKey countersignatory_htlc_base_ref;
21880 CHECK((*env)->GetArrayLength(env, countersignatory_htlc_base) == 33);
21881 (*env)->GetByteArrayRegion(env, countersignatory_htlc_base, 0, 33, countersignatory_htlc_base_ref.compressed_form);
21882 LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
21883 *ret_conv = TxCreationKeys_derive_new(per_commitment_point_ref, broadcaster_delayed_payment_base_ref, broadcaster_htlc_base_ref, countersignatory_revocation_base_ref, countersignatory_htlc_base_ref);
21884 return (uint64_t)ret_conv;
21887 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1from_1channel_1static_1keys(JNIEnv *env, jclass clz, int8_tArray per_commitment_point, int64_t broadcaster_keys, int64_t countersignatory_keys) {
21888 LDKPublicKey per_commitment_point_ref;
21889 CHECK((*env)->GetArrayLength(env, per_commitment_point) == 33);
21890 (*env)->GetByteArrayRegion(env, per_commitment_point, 0, 33, per_commitment_point_ref.compressed_form);
21891 LDKChannelPublicKeys broadcaster_keys_conv;
21892 broadcaster_keys_conv.inner = (void*)(broadcaster_keys & (~1));
21893 broadcaster_keys_conv.is_owned = false;
21894 LDKChannelPublicKeys countersignatory_keys_conv;
21895 countersignatory_keys_conv.inner = (void*)(countersignatory_keys & (~1));
21896 countersignatory_keys_conv.is_owned = false;
21897 LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
21898 *ret_conv = TxCreationKeys_from_channel_static_keys(per_commitment_point_ref, &broadcaster_keys_conv, &countersignatory_keys_conv);
21899 return (uint64_t)ret_conv;
21902 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_get_1revokeable_1redeemscript(JNIEnv *env, jclass clz, int8_tArray revocation_key, int16_t contest_delay, int8_tArray broadcaster_delayed_payment_key) {
21903 LDKPublicKey revocation_key_ref;
21904 CHECK((*env)->GetArrayLength(env, revocation_key) == 33);
21905 (*env)->GetByteArrayRegion(env, revocation_key, 0, 33, revocation_key_ref.compressed_form);
21906 LDKPublicKey broadcaster_delayed_payment_key_ref;
21907 CHECK((*env)->GetArrayLength(env, broadcaster_delayed_payment_key) == 33);
21908 (*env)->GetByteArrayRegion(env, broadcaster_delayed_payment_key, 0, 33, broadcaster_delayed_payment_key_ref.compressed_form);
21909 LDKCVec_u8Z ret_var = get_revokeable_redeemscript(revocation_key_ref, contest_delay, broadcaster_delayed_payment_key_ref);
21910 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
21911 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
21912 CVec_u8Z_free(ret_var);
21916 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_HTLCOutputInCommitment_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
21917 LDKHTLCOutputInCommitment this_obj_conv;
21918 this_obj_conv.inner = (void*)(this_obj & (~1));
21919 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
21920 HTLCOutputInCommitment_free(this_obj_conv);
21923 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_HTLCOutputInCommitment_1get_1offered(JNIEnv *env, jclass clz, int64_t this_ptr) {
21924 LDKHTLCOutputInCommitment this_ptr_conv;
21925 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21926 this_ptr_conv.is_owned = false;
21927 jboolean ret_val = HTLCOutputInCommitment_get_offered(&this_ptr_conv);
21931 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_HTLCOutputInCommitment_1set_1offered(JNIEnv *env, jclass clz, int64_t this_ptr, jboolean val) {
21932 LDKHTLCOutputInCommitment this_ptr_conv;
21933 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21934 this_ptr_conv.is_owned = false;
21935 HTLCOutputInCommitment_set_offered(&this_ptr_conv, val);
21938 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_HTLCOutputInCommitment_1get_1amount_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
21939 LDKHTLCOutputInCommitment this_ptr_conv;
21940 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21941 this_ptr_conv.is_owned = false;
21942 int64_t ret_val = HTLCOutputInCommitment_get_amount_msat(&this_ptr_conv);
21946 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_HTLCOutputInCommitment_1set_1amount_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
21947 LDKHTLCOutputInCommitment this_ptr_conv;
21948 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21949 this_ptr_conv.is_owned = false;
21950 HTLCOutputInCommitment_set_amount_msat(&this_ptr_conv, val);
21953 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_HTLCOutputInCommitment_1get_1cltv_1expiry(JNIEnv *env, jclass clz, int64_t this_ptr) {
21954 LDKHTLCOutputInCommitment this_ptr_conv;
21955 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21956 this_ptr_conv.is_owned = false;
21957 int32_t ret_val = HTLCOutputInCommitment_get_cltv_expiry(&this_ptr_conv);
21961 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_HTLCOutputInCommitment_1set_1cltv_1expiry(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
21962 LDKHTLCOutputInCommitment this_ptr_conv;
21963 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21964 this_ptr_conv.is_owned = false;
21965 HTLCOutputInCommitment_set_cltv_expiry(&this_ptr_conv, val);
21968 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_HTLCOutputInCommitment_1get_1payment_1hash(JNIEnv *env, jclass clz, int64_t this_ptr) {
21969 LDKHTLCOutputInCommitment this_ptr_conv;
21970 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21971 this_ptr_conv.is_owned = false;
21972 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
21973 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *HTLCOutputInCommitment_get_payment_hash(&this_ptr_conv));
21977 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_HTLCOutputInCommitment_1set_1payment_1hash(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
21978 LDKHTLCOutputInCommitment this_ptr_conv;
21979 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21980 this_ptr_conv.is_owned = false;
21981 LDKThirtyTwoBytes val_ref;
21982 CHECK((*env)->GetArrayLength(env, val) == 32);
21983 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
21984 HTLCOutputInCommitment_set_payment_hash(&this_ptr_conv, val_ref);
21987 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_HTLCOutputInCommitment_1get_1transaction_1output_1index(JNIEnv *env, jclass clz, int64_t this_ptr) {
21988 LDKHTLCOutputInCommitment this_ptr_conv;
21989 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21990 this_ptr_conv.is_owned = false;
21991 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
21992 *ret_copy = HTLCOutputInCommitment_get_transaction_output_index(&this_ptr_conv);
21993 uint64_t ret_ref = (uint64_t)ret_copy;
21997 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_HTLCOutputInCommitment_1set_1transaction_1output_1index(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
21998 LDKHTLCOutputInCommitment this_ptr_conv;
21999 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22000 this_ptr_conv.is_owned = false;
22001 LDKCOption_u32Z val_conv = *(LDKCOption_u32Z*)(((uint64_t)val) & ~1);
22002 HTLCOutputInCommitment_set_transaction_output_index(&this_ptr_conv, val_conv);
22005 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_HTLCOutputInCommitment_1new(JNIEnv *env, jclass clz, jboolean offered_arg, int64_t amount_msat_arg, int32_t cltv_expiry_arg, int8_tArray payment_hash_arg, int64_t transaction_output_index_arg) {
22006 LDKThirtyTwoBytes payment_hash_arg_ref;
22007 CHECK((*env)->GetArrayLength(env, payment_hash_arg) == 32);
22008 (*env)->GetByteArrayRegion(env, payment_hash_arg, 0, 32, payment_hash_arg_ref.data);
22009 LDKCOption_u32Z transaction_output_index_arg_conv = *(LDKCOption_u32Z*)(((uint64_t)transaction_output_index_arg) & ~1);
22010 LDKHTLCOutputInCommitment ret_var = HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, payment_hash_arg_ref, transaction_output_index_arg_conv);
22011 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22012 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22013 uint64_t ret_ref = (uint64_t)ret_var.inner;
22014 if (ret_var.is_owned) {
22020 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_HTLCOutputInCommitment_1clone(JNIEnv *env, jclass clz, int64_t orig) {
22021 LDKHTLCOutputInCommitment orig_conv;
22022 orig_conv.inner = (void*)(orig & (~1));
22023 orig_conv.is_owned = false;
22024 LDKHTLCOutputInCommitment ret_var = HTLCOutputInCommitment_clone(&orig_conv);
22025 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22026 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22027 uint64_t ret_ref = (uint64_t)ret_var.inner;
22028 if (ret_var.is_owned) {
22034 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_HTLCOutputInCommitment_1write(JNIEnv *env, jclass clz, int64_t obj) {
22035 LDKHTLCOutputInCommitment obj_conv;
22036 obj_conv.inner = (void*)(obj & (~1));
22037 obj_conv.is_owned = false;
22038 LDKCVec_u8Z ret_var = HTLCOutputInCommitment_write(&obj_conv);
22039 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
22040 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
22041 CVec_u8Z_free(ret_var);
22045 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_HTLCOutputInCommitment_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
22046 LDKu8slice ser_ref;
22047 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
22048 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
22049 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
22050 *ret_conv = HTLCOutputInCommitment_read(ser_ref);
22051 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
22052 return (uint64_t)ret_conv;
22055 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_get_1htlc_1redeemscript(JNIEnv *env, jclass clz, int64_t htlc, int64_t keys) {
22056 LDKHTLCOutputInCommitment htlc_conv;
22057 htlc_conv.inner = (void*)(htlc & (~1));
22058 htlc_conv.is_owned = false;
22059 LDKTxCreationKeys keys_conv;
22060 keys_conv.inner = (void*)(keys & (~1));
22061 keys_conv.is_owned = false;
22062 LDKCVec_u8Z ret_var = get_htlc_redeemscript(&htlc_conv, &keys_conv);
22063 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
22064 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
22065 CVec_u8Z_free(ret_var);
22069 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_make_1funding_1redeemscript(JNIEnv *env, jclass clz, int8_tArray broadcaster, int8_tArray countersignatory) {
22070 LDKPublicKey broadcaster_ref;
22071 CHECK((*env)->GetArrayLength(env, broadcaster) == 33);
22072 (*env)->GetByteArrayRegion(env, broadcaster, 0, 33, broadcaster_ref.compressed_form);
22073 LDKPublicKey countersignatory_ref;
22074 CHECK((*env)->GetArrayLength(env, countersignatory) == 33);
22075 (*env)->GetByteArrayRegion(env, countersignatory, 0, 33, countersignatory_ref.compressed_form);
22076 LDKCVec_u8Z ret_var = make_funding_redeemscript(broadcaster_ref, countersignatory_ref);
22077 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
22078 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
22079 CVec_u8Z_free(ret_var);
22083 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_build_1htlc_1transaction(JNIEnv *env, jclass clz, int8_tArray commitment_txid, int32_t feerate_per_kw, int16_t contest_delay, int64_t htlc, int8_tArray broadcaster_delayed_payment_key, int8_tArray revocation_key) {
22084 unsigned char commitment_txid_arr[32];
22085 CHECK((*env)->GetArrayLength(env, commitment_txid) == 32);
22086 (*env)->GetByteArrayRegion(env, commitment_txid, 0, 32, commitment_txid_arr);
22087 unsigned char (*commitment_txid_ref)[32] = &commitment_txid_arr;
22088 LDKHTLCOutputInCommitment htlc_conv;
22089 htlc_conv.inner = (void*)(htlc & (~1));
22090 htlc_conv.is_owned = false;
22091 LDKPublicKey broadcaster_delayed_payment_key_ref;
22092 CHECK((*env)->GetArrayLength(env, broadcaster_delayed_payment_key) == 33);
22093 (*env)->GetByteArrayRegion(env, broadcaster_delayed_payment_key, 0, 33, broadcaster_delayed_payment_key_ref.compressed_form);
22094 LDKPublicKey revocation_key_ref;
22095 CHECK((*env)->GetArrayLength(env, revocation_key) == 33);
22096 (*env)->GetByteArrayRegion(env, revocation_key, 0, 33, revocation_key_ref.compressed_form);
22097 LDKTransaction ret_var = build_htlc_transaction(commitment_txid_ref, feerate_per_kw, contest_delay, &htlc_conv, broadcaster_delayed_payment_key_ref, revocation_key_ref);
22098 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
22099 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
22100 Transaction_free(ret_var);
22104 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
22105 LDKChannelTransactionParameters this_obj_conv;
22106 this_obj_conv.inner = (void*)(this_obj & (~1));
22107 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
22108 ChannelTransactionParameters_free(this_obj_conv);
22111 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1get_1holder_1pubkeys(JNIEnv *env, jclass clz, int64_t this_ptr) {
22112 LDKChannelTransactionParameters this_ptr_conv;
22113 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22114 this_ptr_conv.is_owned = false;
22115 LDKChannelPublicKeys ret_var = ChannelTransactionParameters_get_holder_pubkeys(&this_ptr_conv);
22116 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22117 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22118 uint64_t ret_ref = (uint64_t)ret_var.inner;
22119 if (ret_var.is_owned) {
22125 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1set_1holder_1pubkeys(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
22126 LDKChannelTransactionParameters this_ptr_conv;
22127 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22128 this_ptr_conv.is_owned = false;
22129 LDKChannelPublicKeys val_conv;
22130 val_conv.inner = (void*)(val & (~1));
22131 val_conv.is_owned = (val & 1) || (val == 0);
22132 val_conv = ChannelPublicKeys_clone(&val_conv);
22133 ChannelTransactionParameters_set_holder_pubkeys(&this_ptr_conv, val_conv);
22136 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1get_1holder_1selected_1contest_1delay(JNIEnv *env, jclass clz, int64_t this_ptr) {
22137 LDKChannelTransactionParameters this_ptr_conv;
22138 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22139 this_ptr_conv.is_owned = false;
22140 int16_t ret_val = ChannelTransactionParameters_get_holder_selected_contest_delay(&this_ptr_conv);
22144 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1set_1holder_1selected_1contest_1delay(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
22145 LDKChannelTransactionParameters this_ptr_conv;
22146 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22147 this_ptr_conv.is_owned = false;
22148 ChannelTransactionParameters_set_holder_selected_contest_delay(&this_ptr_conv, val);
22151 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1get_1is_1outbound_1from_1holder(JNIEnv *env, jclass clz, int64_t this_ptr) {
22152 LDKChannelTransactionParameters this_ptr_conv;
22153 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22154 this_ptr_conv.is_owned = false;
22155 jboolean ret_val = ChannelTransactionParameters_get_is_outbound_from_holder(&this_ptr_conv);
22159 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1set_1is_1outbound_1from_1holder(JNIEnv *env, jclass clz, int64_t this_ptr, jboolean val) {
22160 LDKChannelTransactionParameters this_ptr_conv;
22161 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22162 this_ptr_conv.is_owned = false;
22163 ChannelTransactionParameters_set_is_outbound_from_holder(&this_ptr_conv, val);
22166 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1get_1counterparty_1parameters(JNIEnv *env, jclass clz, int64_t this_ptr) {
22167 LDKChannelTransactionParameters this_ptr_conv;
22168 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22169 this_ptr_conv.is_owned = false;
22170 LDKCounterpartyChannelTransactionParameters ret_var = ChannelTransactionParameters_get_counterparty_parameters(&this_ptr_conv);
22171 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22172 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22173 uint64_t ret_ref = (uint64_t)ret_var.inner;
22174 if (ret_var.is_owned) {
22180 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1set_1counterparty_1parameters(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
22181 LDKChannelTransactionParameters this_ptr_conv;
22182 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22183 this_ptr_conv.is_owned = false;
22184 LDKCounterpartyChannelTransactionParameters val_conv;
22185 val_conv.inner = (void*)(val & (~1));
22186 val_conv.is_owned = (val & 1) || (val == 0);
22187 val_conv = CounterpartyChannelTransactionParameters_clone(&val_conv);
22188 ChannelTransactionParameters_set_counterparty_parameters(&this_ptr_conv, val_conv);
22191 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1get_1funding_1outpoint(JNIEnv *env, jclass clz, int64_t this_ptr) {
22192 LDKChannelTransactionParameters this_ptr_conv;
22193 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22194 this_ptr_conv.is_owned = false;
22195 LDKOutPoint ret_var = ChannelTransactionParameters_get_funding_outpoint(&this_ptr_conv);
22196 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22197 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22198 uint64_t ret_ref = (uint64_t)ret_var.inner;
22199 if (ret_var.is_owned) {
22205 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1set_1funding_1outpoint(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
22206 LDKChannelTransactionParameters this_ptr_conv;
22207 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22208 this_ptr_conv.is_owned = false;
22209 LDKOutPoint val_conv;
22210 val_conv.inner = (void*)(val & (~1));
22211 val_conv.is_owned = (val & 1) || (val == 0);
22212 val_conv = OutPoint_clone(&val_conv);
22213 ChannelTransactionParameters_set_funding_outpoint(&this_ptr_conv, val_conv);
22216 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1new(JNIEnv *env, jclass clz, int64_t holder_pubkeys_arg, int16_t holder_selected_contest_delay_arg, jboolean is_outbound_from_holder_arg, int64_t counterparty_parameters_arg, int64_t funding_outpoint_arg) {
22217 LDKChannelPublicKeys holder_pubkeys_arg_conv;
22218 holder_pubkeys_arg_conv.inner = (void*)(holder_pubkeys_arg & (~1));
22219 holder_pubkeys_arg_conv.is_owned = (holder_pubkeys_arg & 1) || (holder_pubkeys_arg == 0);
22220 holder_pubkeys_arg_conv = ChannelPublicKeys_clone(&holder_pubkeys_arg_conv);
22221 LDKCounterpartyChannelTransactionParameters counterparty_parameters_arg_conv;
22222 counterparty_parameters_arg_conv.inner = (void*)(counterparty_parameters_arg & (~1));
22223 counterparty_parameters_arg_conv.is_owned = (counterparty_parameters_arg & 1) || (counterparty_parameters_arg == 0);
22224 counterparty_parameters_arg_conv = CounterpartyChannelTransactionParameters_clone(&counterparty_parameters_arg_conv);
22225 LDKOutPoint funding_outpoint_arg_conv;
22226 funding_outpoint_arg_conv.inner = (void*)(funding_outpoint_arg & (~1));
22227 funding_outpoint_arg_conv.is_owned = (funding_outpoint_arg & 1) || (funding_outpoint_arg == 0);
22228 funding_outpoint_arg_conv = OutPoint_clone(&funding_outpoint_arg_conv);
22229 LDKChannelTransactionParameters ret_var = ChannelTransactionParameters_new(holder_pubkeys_arg_conv, holder_selected_contest_delay_arg, is_outbound_from_holder_arg, counterparty_parameters_arg_conv, funding_outpoint_arg_conv);
22230 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22231 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22232 uint64_t ret_ref = (uint64_t)ret_var.inner;
22233 if (ret_var.is_owned) {
22239 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1clone(JNIEnv *env, jclass clz, int64_t orig) {
22240 LDKChannelTransactionParameters orig_conv;
22241 orig_conv.inner = (void*)(orig & (~1));
22242 orig_conv.is_owned = false;
22243 LDKChannelTransactionParameters ret_var = ChannelTransactionParameters_clone(&orig_conv);
22244 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22245 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22246 uint64_t ret_ref = (uint64_t)ret_var.inner;
22247 if (ret_var.is_owned) {
22253 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CounterpartyChannelTransactionParameters_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
22254 LDKCounterpartyChannelTransactionParameters this_obj_conv;
22255 this_obj_conv.inner = (void*)(this_obj & (~1));
22256 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
22257 CounterpartyChannelTransactionParameters_free(this_obj_conv);
22260 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CounterpartyChannelTransactionParameters_1get_1pubkeys(JNIEnv *env, jclass clz, int64_t this_ptr) {
22261 LDKCounterpartyChannelTransactionParameters this_ptr_conv;
22262 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22263 this_ptr_conv.is_owned = false;
22264 LDKChannelPublicKeys ret_var = CounterpartyChannelTransactionParameters_get_pubkeys(&this_ptr_conv);
22265 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22266 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22267 uint64_t ret_ref = (uint64_t)ret_var.inner;
22268 if (ret_var.is_owned) {
22274 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CounterpartyChannelTransactionParameters_1set_1pubkeys(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
22275 LDKCounterpartyChannelTransactionParameters this_ptr_conv;
22276 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22277 this_ptr_conv.is_owned = false;
22278 LDKChannelPublicKeys val_conv;
22279 val_conv.inner = (void*)(val & (~1));
22280 val_conv.is_owned = (val & 1) || (val == 0);
22281 val_conv = ChannelPublicKeys_clone(&val_conv);
22282 CounterpartyChannelTransactionParameters_set_pubkeys(&this_ptr_conv, val_conv);
22285 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_CounterpartyChannelTransactionParameters_1get_1selected_1contest_1delay(JNIEnv *env, jclass clz, int64_t this_ptr) {
22286 LDKCounterpartyChannelTransactionParameters this_ptr_conv;
22287 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22288 this_ptr_conv.is_owned = false;
22289 int16_t ret_val = CounterpartyChannelTransactionParameters_get_selected_contest_delay(&this_ptr_conv);
22293 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CounterpartyChannelTransactionParameters_1set_1selected_1contest_1delay(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
22294 LDKCounterpartyChannelTransactionParameters this_ptr_conv;
22295 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22296 this_ptr_conv.is_owned = false;
22297 CounterpartyChannelTransactionParameters_set_selected_contest_delay(&this_ptr_conv, val);
22300 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CounterpartyChannelTransactionParameters_1new(JNIEnv *env, jclass clz, int64_t pubkeys_arg, int16_t selected_contest_delay_arg) {
22301 LDKChannelPublicKeys pubkeys_arg_conv;
22302 pubkeys_arg_conv.inner = (void*)(pubkeys_arg & (~1));
22303 pubkeys_arg_conv.is_owned = (pubkeys_arg & 1) || (pubkeys_arg == 0);
22304 pubkeys_arg_conv = ChannelPublicKeys_clone(&pubkeys_arg_conv);
22305 LDKCounterpartyChannelTransactionParameters ret_var = CounterpartyChannelTransactionParameters_new(pubkeys_arg_conv, selected_contest_delay_arg);
22306 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22307 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22308 uint64_t ret_ref = (uint64_t)ret_var.inner;
22309 if (ret_var.is_owned) {
22315 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CounterpartyChannelTransactionParameters_1clone(JNIEnv *env, jclass clz, int64_t orig) {
22316 LDKCounterpartyChannelTransactionParameters orig_conv;
22317 orig_conv.inner = (void*)(orig & (~1));
22318 orig_conv.is_owned = false;
22319 LDKCounterpartyChannelTransactionParameters ret_var = CounterpartyChannelTransactionParameters_clone(&orig_conv);
22320 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22321 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22322 uint64_t ret_ref = (uint64_t)ret_var.inner;
22323 if (ret_var.is_owned) {
22329 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1is_1populated(JNIEnv *env, jclass clz, int64_t this_arg) {
22330 LDKChannelTransactionParameters this_arg_conv;
22331 this_arg_conv.inner = (void*)(this_arg & (~1));
22332 this_arg_conv.is_owned = false;
22333 jboolean ret_val = ChannelTransactionParameters_is_populated(&this_arg_conv);
22337 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1as_1holder_1broadcastable(JNIEnv *env, jclass clz, int64_t this_arg) {
22338 LDKChannelTransactionParameters this_arg_conv;
22339 this_arg_conv.inner = (void*)(this_arg & (~1));
22340 this_arg_conv.is_owned = false;
22341 LDKDirectedChannelTransactionParameters ret_var = ChannelTransactionParameters_as_holder_broadcastable(&this_arg_conv);
22342 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22343 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22344 uint64_t ret_ref = (uint64_t)ret_var.inner;
22345 if (ret_var.is_owned) {
22351 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1as_1counterparty_1broadcastable(JNIEnv *env, jclass clz, int64_t this_arg) {
22352 LDKChannelTransactionParameters this_arg_conv;
22353 this_arg_conv.inner = (void*)(this_arg & (~1));
22354 this_arg_conv.is_owned = false;
22355 LDKDirectedChannelTransactionParameters ret_var = ChannelTransactionParameters_as_counterparty_broadcastable(&this_arg_conv);
22356 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22357 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22358 uint64_t ret_ref = (uint64_t)ret_var.inner;
22359 if (ret_var.is_owned) {
22365 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_CounterpartyChannelTransactionParameters_1write(JNIEnv *env, jclass clz, int64_t obj) {
22366 LDKCounterpartyChannelTransactionParameters obj_conv;
22367 obj_conv.inner = (void*)(obj & (~1));
22368 obj_conv.is_owned = false;
22369 LDKCVec_u8Z ret_var = CounterpartyChannelTransactionParameters_write(&obj_conv);
22370 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
22371 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
22372 CVec_u8Z_free(ret_var);
22376 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CounterpartyChannelTransactionParameters_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
22377 LDKu8slice ser_ref;
22378 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
22379 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
22380 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
22381 *ret_conv = CounterpartyChannelTransactionParameters_read(ser_ref);
22382 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
22383 return (uint64_t)ret_conv;
22386 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1write(JNIEnv *env, jclass clz, int64_t obj) {
22387 LDKChannelTransactionParameters obj_conv;
22388 obj_conv.inner = (void*)(obj & (~1));
22389 obj_conv.is_owned = false;
22390 LDKCVec_u8Z ret_var = ChannelTransactionParameters_write(&obj_conv);
22391 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
22392 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
22393 CVec_u8Z_free(ret_var);
22397 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
22398 LDKu8slice ser_ref;
22399 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
22400 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
22401 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
22402 *ret_conv = ChannelTransactionParameters_read(ser_ref);
22403 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
22404 return (uint64_t)ret_conv;
22407 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DirectedChannelTransactionParameters_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
22408 LDKDirectedChannelTransactionParameters this_obj_conv;
22409 this_obj_conv.inner = (void*)(this_obj & (~1));
22410 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
22411 DirectedChannelTransactionParameters_free(this_obj_conv);
22414 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DirectedChannelTransactionParameters_1broadcaster_1pubkeys(JNIEnv *env, jclass clz, int64_t this_arg) {
22415 LDKDirectedChannelTransactionParameters this_arg_conv;
22416 this_arg_conv.inner = (void*)(this_arg & (~1));
22417 this_arg_conv.is_owned = false;
22418 LDKChannelPublicKeys ret_var = DirectedChannelTransactionParameters_broadcaster_pubkeys(&this_arg_conv);
22419 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22420 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22421 uint64_t ret_ref = (uint64_t)ret_var.inner;
22422 if (ret_var.is_owned) {
22428 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DirectedChannelTransactionParameters_1countersignatory_1pubkeys(JNIEnv *env, jclass clz, int64_t this_arg) {
22429 LDKDirectedChannelTransactionParameters this_arg_conv;
22430 this_arg_conv.inner = (void*)(this_arg & (~1));
22431 this_arg_conv.is_owned = false;
22432 LDKChannelPublicKeys ret_var = DirectedChannelTransactionParameters_countersignatory_pubkeys(&this_arg_conv);
22433 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22434 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22435 uint64_t ret_ref = (uint64_t)ret_var.inner;
22436 if (ret_var.is_owned) {
22442 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_DirectedChannelTransactionParameters_1contest_1delay(JNIEnv *env, jclass clz, int64_t this_arg) {
22443 LDKDirectedChannelTransactionParameters this_arg_conv;
22444 this_arg_conv.inner = (void*)(this_arg & (~1));
22445 this_arg_conv.is_owned = false;
22446 int16_t ret_val = DirectedChannelTransactionParameters_contest_delay(&this_arg_conv);
22450 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_DirectedChannelTransactionParameters_1is_1outbound(JNIEnv *env, jclass clz, int64_t this_arg) {
22451 LDKDirectedChannelTransactionParameters this_arg_conv;
22452 this_arg_conv.inner = (void*)(this_arg & (~1));
22453 this_arg_conv.is_owned = false;
22454 jboolean ret_val = DirectedChannelTransactionParameters_is_outbound(&this_arg_conv);
22458 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DirectedChannelTransactionParameters_1funding_1outpoint(JNIEnv *env, jclass clz, int64_t this_arg) {
22459 LDKDirectedChannelTransactionParameters this_arg_conv;
22460 this_arg_conv.inner = (void*)(this_arg & (~1));
22461 this_arg_conv.is_owned = false;
22462 LDKOutPoint ret_var = DirectedChannelTransactionParameters_funding_outpoint(&this_arg_conv);
22463 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22464 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22465 uint64_t ret_ref = (uint64_t)ret_var.inner;
22466 if (ret_var.is_owned) {
22472 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_HolderCommitmentTransaction_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
22473 LDKHolderCommitmentTransaction this_obj_conv;
22474 this_obj_conv.inner = (void*)(this_obj & (~1));
22475 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
22476 HolderCommitmentTransaction_free(this_obj_conv);
22479 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_HolderCommitmentTransaction_1get_1counterparty_1sig(JNIEnv *env, jclass clz, int64_t this_ptr) {
22480 LDKHolderCommitmentTransaction this_ptr_conv;
22481 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22482 this_ptr_conv.is_owned = false;
22483 int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
22484 (*env)->SetByteArrayRegion(env, ret_arr, 0, 64, HolderCommitmentTransaction_get_counterparty_sig(&this_ptr_conv).compact_form);
22488 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_HolderCommitmentTransaction_1set_1counterparty_1sig(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
22489 LDKHolderCommitmentTransaction this_ptr_conv;
22490 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22491 this_ptr_conv.is_owned = false;
22492 LDKSignature val_ref;
22493 CHECK((*env)->GetArrayLength(env, val) == 64);
22494 (*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
22495 HolderCommitmentTransaction_set_counterparty_sig(&this_ptr_conv, val_ref);
22498 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_HolderCommitmentTransaction_1set_1counterparty_1htlc_1sigs(JNIEnv *env, jclass clz, int64_t this_ptr, jobjectArray val) {
22499 LDKHolderCommitmentTransaction this_ptr_conv;
22500 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22501 this_ptr_conv.is_owned = false;
22502 LDKCVec_SignatureZ val_constr;
22503 val_constr.datalen = (*env)->GetArrayLength(env, val);
22504 if (val_constr.datalen > 0)
22505 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
22507 val_constr.data = NULL;
22508 for (size_t i = 0; i < val_constr.datalen; i++) {
22509 int8_tArray val_conv_8 = (*env)->GetObjectArrayElement(env, val, i);
22510 LDKSignature val_conv_8_ref;
22511 CHECK((*env)->GetArrayLength(env, val_conv_8) == 64);
22512 (*env)->GetByteArrayRegion(env, val_conv_8, 0, 64, val_conv_8_ref.compact_form);
22513 val_constr.data[i] = val_conv_8_ref;
22515 HolderCommitmentTransaction_set_counterparty_htlc_sigs(&this_ptr_conv, val_constr);
22518 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_HolderCommitmentTransaction_1clone(JNIEnv *env, jclass clz, int64_t orig) {
22519 LDKHolderCommitmentTransaction orig_conv;
22520 orig_conv.inner = (void*)(orig & (~1));
22521 orig_conv.is_owned = false;
22522 LDKHolderCommitmentTransaction ret_var = HolderCommitmentTransaction_clone(&orig_conv);
22523 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22524 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22525 uint64_t ret_ref = (uint64_t)ret_var.inner;
22526 if (ret_var.is_owned) {
22532 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_HolderCommitmentTransaction_1write(JNIEnv *env, jclass clz, int64_t obj) {
22533 LDKHolderCommitmentTransaction obj_conv;
22534 obj_conv.inner = (void*)(obj & (~1));
22535 obj_conv.is_owned = false;
22536 LDKCVec_u8Z ret_var = HolderCommitmentTransaction_write(&obj_conv);
22537 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
22538 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
22539 CVec_u8Z_free(ret_var);
22543 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_HolderCommitmentTransaction_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
22544 LDKu8slice ser_ref;
22545 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
22546 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
22547 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
22548 *ret_conv = HolderCommitmentTransaction_read(ser_ref);
22549 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
22550 return (uint64_t)ret_conv;
22553 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_HolderCommitmentTransaction_1new(JNIEnv *env, jclass clz, int64_t commitment_tx, int8_tArray counterparty_sig, jobjectArray counterparty_htlc_sigs, int8_tArray holder_funding_key, int8_tArray counterparty_funding_key) {
22554 LDKCommitmentTransaction commitment_tx_conv;
22555 commitment_tx_conv.inner = (void*)(commitment_tx & (~1));
22556 commitment_tx_conv.is_owned = (commitment_tx & 1) || (commitment_tx == 0);
22557 commitment_tx_conv = CommitmentTransaction_clone(&commitment_tx_conv);
22558 LDKSignature counterparty_sig_ref;
22559 CHECK((*env)->GetArrayLength(env, counterparty_sig) == 64);
22560 (*env)->GetByteArrayRegion(env, counterparty_sig, 0, 64, counterparty_sig_ref.compact_form);
22561 LDKCVec_SignatureZ counterparty_htlc_sigs_constr;
22562 counterparty_htlc_sigs_constr.datalen = (*env)->GetArrayLength(env, counterparty_htlc_sigs);
22563 if (counterparty_htlc_sigs_constr.datalen > 0)
22564 counterparty_htlc_sigs_constr.data = MALLOC(counterparty_htlc_sigs_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
22566 counterparty_htlc_sigs_constr.data = NULL;
22567 for (size_t i = 0; i < counterparty_htlc_sigs_constr.datalen; i++) {
22568 int8_tArray counterparty_htlc_sigs_conv_8 = (*env)->GetObjectArrayElement(env, counterparty_htlc_sigs, i);
22569 LDKSignature counterparty_htlc_sigs_conv_8_ref;
22570 CHECK((*env)->GetArrayLength(env, counterparty_htlc_sigs_conv_8) == 64);
22571 (*env)->GetByteArrayRegion(env, counterparty_htlc_sigs_conv_8, 0, 64, counterparty_htlc_sigs_conv_8_ref.compact_form);
22572 counterparty_htlc_sigs_constr.data[i] = counterparty_htlc_sigs_conv_8_ref;
22574 LDKPublicKey holder_funding_key_ref;
22575 CHECK((*env)->GetArrayLength(env, holder_funding_key) == 33);
22576 (*env)->GetByteArrayRegion(env, holder_funding_key, 0, 33, holder_funding_key_ref.compressed_form);
22577 LDKPublicKey counterparty_funding_key_ref;
22578 CHECK((*env)->GetArrayLength(env, counterparty_funding_key) == 33);
22579 (*env)->GetByteArrayRegion(env, counterparty_funding_key, 0, 33, counterparty_funding_key_ref.compressed_form);
22580 LDKHolderCommitmentTransaction ret_var = HolderCommitmentTransaction_new(commitment_tx_conv, counterparty_sig_ref, counterparty_htlc_sigs_constr, holder_funding_key_ref, counterparty_funding_key_ref);
22581 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22582 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22583 uint64_t ret_ref = (uint64_t)ret_var.inner;
22584 if (ret_var.is_owned) {
22590 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_BuiltCommitmentTransaction_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
22591 LDKBuiltCommitmentTransaction this_obj_conv;
22592 this_obj_conv.inner = (void*)(this_obj & (~1));
22593 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
22594 BuiltCommitmentTransaction_free(this_obj_conv);
22597 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_BuiltCommitmentTransaction_1get_1transaction(JNIEnv *env, jclass clz, int64_t this_ptr) {
22598 LDKBuiltCommitmentTransaction this_ptr_conv;
22599 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22600 this_ptr_conv.is_owned = false;
22601 LDKTransaction ret_var = BuiltCommitmentTransaction_get_transaction(&this_ptr_conv);
22602 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
22603 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
22604 Transaction_free(ret_var);
22608 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_BuiltCommitmentTransaction_1set_1transaction(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
22609 LDKBuiltCommitmentTransaction this_ptr_conv;
22610 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22611 this_ptr_conv.is_owned = false;
22612 LDKTransaction val_ref;
22613 val_ref.datalen = (*env)->GetArrayLength(env, val);
22614 val_ref.data = MALLOC(val_ref.datalen, "LDKTransaction Bytes");
22615 (*env)->GetByteArrayRegion(env, val, 0, val_ref.datalen, val_ref.data);
22616 val_ref.data_is_owned = true;
22617 BuiltCommitmentTransaction_set_transaction(&this_ptr_conv, val_ref);
22620 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_BuiltCommitmentTransaction_1get_1txid(JNIEnv *env, jclass clz, int64_t this_ptr) {
22621 LDKBuiltCommitmentTransaction this_ptr_conv;
22622 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22623 this_ptr_conv.is_owned = false;
22624 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
22625 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *BuiltCommitmentTransaction_get_txid(&this_ptr_conv));
22629 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_BuiltCommitmentTransaction_1set_1txid(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
22630 LDKBuiltCommitmentTransaction this_ptr_conv;
22631 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22632 this_ptr_conv.is_owned = false;
22633 LDKThirtyTwoBytes val_ref;
22634 CHECK((*env)->GetArrayLength(env, val) == 32);
22635 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
22636 BuiltCommitmentTransaction_set_txid(&this_ptr_conv, val_ref);
22639 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_BuiltCommitmentTransaction_1new(JNIEnv *env, jclass clz, int8_tArray transaction_arg, int8_tArray txid_arg) {
22640 LDKTransaction transaction_arg_ref;
22641 transaction_arg_ref.datalen = (*env)->GetArrayLength(env, transaction_arg);
22642 transaction_arg_ref.data = MALLOC(transaction_arg_ref.datalen, "LDKTransaction Bytes");
22643 (*env)->GetByteArrayRegion(env, transaction_arg, 0, transaction_arg_ref.datalen, transaction_arg_ref.data);
22644 transaction_arg_ref.data_is_owned = true;
22645 LDKThirtyTwoBytes txid_arg_ref;
22646 CHECK((*env)->GetArrayLength(env, txid_arg) == 32);
22647 (*env)->GetByteArrayRegion(env, txid_arg, 0, 32, txid_arg_ref.data);
22648 LDKBuiltCommitmentTransaction ret_var = BuiltCommitmentTransaction_new(transaction_arg_ref, txid_arg_ref);
22649 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22650 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22651 uint64_t ret_ref = (uint64_t)ret_var.inner;
22652 if (ret_var.is_owned) {
22658 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_BuiltCommitmentTransaction_1clone(JNIEnv *env, jclass clz, int64_t orig) {
22659 LDKBuiltCommitmentTransaction orig_conv;
22660 orig_conv.inner = (void*)(orig & (~1));
22661 orig_conv.is_owned = false;
22662 LDKBuiltCommitmentTransaction ret_var = BuiltCommitmentTransaction_clone(&orig_conv);
22663 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22664 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22665 uint64_t ret_ref = (uint64_t)ret_var.inner;
22666 if (ret_var.is_owned) {
22672 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_BuiltCommitmentTransaction_1write(JNIEnv *env, jclass clz, int64_t obj) {
22673 LDKBuiltCommitmentTransaction obj_conv;
22674 obj_conv.inner = (void*)(obj & (~1));
22675 obj_conv.is_owned = false;
22676 LDKCVec_u8Z ret_var = BuiltCommitmentTransaction_write(&obj_conv);
22677 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
22678 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
22679 CVec_u8Z_free(ret_var);
22683 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_BuiltCommitmentTransaction_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
22684 LDKu8slice ser_ref;
22685 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
22686 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
22687 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
22688 *ret_conv = BuiltCommitmentTransaction_read(ser_ref);
22689 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
22690 return (uint64_t)ret_conv;
22693 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_BuiltCommitmentTransaction_1get_1sighash_1all(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray funding_redeemscript, int64_t channel_value_satoshis) {
22694 LDKBuiltCommitmentTransaction this_arg_conv;
22695 this_arg_conv.inner = (void*)(this_arg & (~1));
22696 this_arg_conv.is_owned = false;
22697 LDKu8slice funding_redeemscript_ref;
22698 funding_redeemscript_ref.datalen = (*env)->GetArrayLength(env, funding_redeemscript);
22699 funding_redeemscript_ref.data = (*env)->GetByteArrayElements (env, funding_redeemscript, NULL);
22700 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
22701 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, BuiltCommitmentTransaction_get_sighash_all(&this_arg_conv, funding_redeemscript_ref, channel_value_satoshis).data);
22702 (*env)->ReleaseByteArrayElements(env, funding_redeemscript, (int8_t*)funding_redeemscript_ref.data, 0);
22706 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_BuiltCommitmentTransaction_1sign(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray funding_key, int8_tArray funding_redeemscript, int64_t channel_value_satoshis) {
22707 LDKBuiltCommitmentTransaction this_arg_conv;
22708 this_arg_conv.inner = (void*)(this_arg & (~1));
22709 this_arg_conv.is_owned = false;
22710 unsigned char funding_key_arr[32];
22711 CHECK((*env)->GetArrayLength(env, funding_key) == 32);
22712 (*env)->GetByteArrayRegion(env, funding_key, 0, 32, funding_key_arr);
22713 unsigned char (*funding_key_ref)[32] = &funding_key_arr;
22714 LDKu8slice funding_redeemscript_ref;
22715 funding_redeemscript_ref.datalen = (*env)->GetArrayLength(env, funding_redeemscript);
22716 funding_redeemscript_ref.data = (*env)->GetByteArrayElements (env, funding_redeemscript, NULL);
22717 int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
22718 (*env)->SetByteArrayRegion(env, ret_arr, 0, 64, BuiltCommitmentTransaction_sign(&this_arg_conv, funding_key_ref, funding_redeemscript_ref, channel_value_satoshis).compact_form);
22719 (*env)->ReleaseByteArrayElements(env, funding_redeemscript, (int8_t*)funding_redeemscript_ref.data, 0);
22723 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CommitmentTransaction_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
22724 LDKCommitmentTransaction this_obj_conv;
22725 this_obj_conv.inner = (void*)(this_obj & (~1));
22726 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
22727 CommitmentTransaction_free(this_obj_conv);
22730 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentTransaction_1clone(JNIEnv *env, jclass clz, int64_t orig) {
22731 LDKCommitmentTransaction orig_conv;
22732 orig_conv.inner = (void*)(orig & (~1));
22733 orig_conv.is_owned = false;
22734 LDKCommitmentTransaction ret_var = CommitmentTransaction_clone(&orig_conv);
22735 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22736 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22737 uint64_t ret_ref = (uint64_t)ret_var.inner;
22738 if (ret_var.is_owned) {
22744 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_CommitmentTransaction_1write(JNIEnv *env, jclass clz, int64_t obj) {
22745 LDKCommitmentTransaction obj_conv;
22746 obj_conv.inner = (void*)(obj & (~1));
22747 obj_conv.is_owned = false;
22748 LDKCVec_u8Z ret_var = CommitmentTransaction_write(&obj_conv);
22749 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
22750 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
22751 CVec_u8Z_free(ret_var);
22755 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentTransaction_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
22756 LDKu8slice ser_ref;
22757 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
22758 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
22759 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
22760 *ret_conv = CommitmentTransaction_read(ser_ref);
22761 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
22762 return (uint64_t)ret_conv;
22765 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentTransaction_1commitment_1number(JNIEnv *env, jclass clz, int64_t this_arg) {
22766 LDKCommitmentTransaction this_arg_conv;
22767 this_arg_conv.inner = (void*)(this_arg & (~1));
22768 this_arg_conv.is_owned = false;
22769 int64_t ret_val = CommitmentTransaction_commitment_number(&this_arg_conv);
22773 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentTransaction_1to_1broadcaster_1value_1sat(JNIEnv *env, jclass clz, int64_t this_arg) {
22774 LDKCommitmentTransaction this_arg_conv;
22775 this_arg_conv.inner = (void*)(this_arg & (~1));
22776 this_arg_conv.is_owned = false;
22777 int64_t ret_val = CommitmentTransaction_to_broadcaster_value_sat(&this_arg_conv);
22781 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentTransaction_1to_1countersignatory_1value_1sat(JNIEnv *env, jclass clz, int64_t this_arg) {
22782 LDKCommitmentTransaction this_arg_conv;
22783 this_arg_conv.inner = (void*)(this_arg & (~1));
22784 this_arg_conv.is_owned = false;
22785 int64_t ret_val = CommitmentTransaction_to_countersignatory_value_sat(&this_arg_conv);
22789 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_CommitmentTransaction_1feerate_1per_1kw(JNIEnv *env, jclass clz, int64_t this_arg) {
22790 LDKCommitmentTransaction this_arg_conv;
22791 this_arg_conv.inner = (void*)(this_arg & (~1));
22792 this_arg_conv.is_owned = false;
22793 int32_t ret_val = CommitmentTransaction_feerate_per_kw(&this_arg_conv);
22797 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentTransaction_1trust(JNIEnv *env, jclass clz, int64_t this_arg) {
22798 LDKCommitmentTransaction this_arg_conv;
22799 this_arg_conv.inner = (void*)(this_arg & (~1));
22800 this_arg_conv.is_owned = false;
22801 LDKTrustedCommitmentTransaction ret_var = CommitmentTransaction_trust(&this_arg_conv);
22802 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22803 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22804 uint64_t ret_ref = (uint64_t)ret_var.inner;
22805 if (ret_var.is_owned) {
22811 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentTransaction_1verify(JNIEnv *env, jclass clz, int64_t this_arg, int64_t channel_parameters, int64_t broadcaster_keys, int64_t countersignatory_keys) {
22812 LDKCommitmentTransaction this_arg_conv;
22813 this_arg_conv.inner = (void*)(this_arg & (~1));
22814 this_arg_conv.is_owned = false;
22815 LDKDirectedChannelTransactionParameters channel_parameters_conv;
22816 channel_parameters_conv.inner = (void*)(channel_parameters & (~1));
22817 channel_parameters_conv.is_owned = false;
22818 LDKChannelPublicKeys broadcaster_keys_conv;
22819 broadcaster_keys_conv.inner = (void*)(broadcaster_keys & (~1));
22820 broadcaster_keys_conv.is_owned = false;
22821 LDKChannelPublicKeys countersignatory_keys_conv;
22822 countersignatory_keys_conv.inner = (void*)(countersignatory_keys & (~1));
22823 countersignatory_keys_conv.is_owned = false;
22824 LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
22825 *ret_conv = CommitmentTransaction_verify(&this_arg_conv, &channel_parameters_conv, &broadcaster_keys_conv, &countersignatory_keys_conv);
22826 return (uint64_t)ret_conv;
22829 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_TrustedCommitmentTransaction_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
22830 LDKTrustedCommitmentTransaction this_obj_conv;
22831 this_obj_conv.inner = (void*)(this_obj & (~1));
22832 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
22833 TrustedCommitmentTransaction_free(this_obj_conv);
22836 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_TrustedCommitmentTransaction_1txid(JNIEnv *env, jclass clz, int64_t this_arg) {
22837 LDKTrustedCommitmentTransaction this_arg_conv;
22838 this_arg_conv.inner = (void*)(this_arg & (~1));
22839 this_arg_conv.is_owned = false;
22840 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
22841 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, TrustedCommitmentTransaction_txid(&this_arg_conv).data);
22845 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_TrustedCommitmentTransaction_1built_1transaction(JNIEnv *env, jclass clz, int64_t this_arg) {
22846 LDKTrustedCommitmentTransaction this_arg_conv;
22847 this_arg_conv.inner = (void*)(this_arg & (~1));
22848 this_arg_conv.is_owned = false;
22849 LDKBuiltCommitmentTransaction ret_var = TrustedCommitmentTransaction_built_transaction(&this_arg_conv);
22850 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22851 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22852 uint64_t ret_ref = (uint64_t)ret_var.inner;
22853 if (ret_var.is_owned) {
22859 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_TrustedCommitmentTransaction_1keys(JNIEnv *env, jclass clz, int64_t this_arg) {
22860 LDKTrustedCommitmentTransaction this_arg_conv;
22861 this_arg_conv.inner = (void*)(this_arg & (~1));
22862 this_arg_conv.is_owned = false;
22863 LDKTxCreationKeys ret_var = TrustedCommitmentTransaction_keys(&this_arg_conv);
22864 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22865 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22866 uint64_t ret_ref = (uint64_t)ret_var.inner;
22867 if (ret_var.is_owned) {
22873 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_TrustedCommitmentTransaction_1get_1htlc_1sigs(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray htlc_base_key, int64_t channel_parameters) {
22874 LDKTrustedCommitmentTransaction this_arg_conv;
22875 this_arg_conv.inner = (void*)(this_arg & (~1));
22876 this_arg_conv.is_owned = false;
22877 unsigned char htlc_base_key_arr[32];
22878 CHECK((*env)->GetArrayLength(env, htlc_base_key) == 32);
22879 (*env)->GetByteArrayRegion(env, htlc_base_key, 0, 32, htlc_base_key_arr);
22880 unsigned char (*htlc_base_key_ref)[32] = &htlc_base_key_arr;
22881 LDKDirectedChannelTransactionParameters channel_parameters_conv;
22882 channel_parameters_conv.inner = (void*)(channel_parameters & (~1));
22883 channel_parameters_conv.is_owned = false;
22884 LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
22885 *ret_conv = TrustedCommitmentTransaction_get_htlc_sigs(&this_arg_conv, htlc_base_key_ref, &channel_parameters_conv);
22886 return (uint64_t)ret_conv;
22889 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_get_1commitment_1transaction_1number_1obscure_1factor(JNIEnv *env, jclass clz, int8_tArray broadcaster_payment_basepoint, int8_tArray countersignatory_payment_basepoint, jboolean outbound_from_broadcaster) {
22890 LDKPublicKey broadcaster_payment_basepoint_ref;
22891 CHECK((*env)->GetArrayLength(env, broadcaster_payment_basepoint) == 33);
22892 (*env)->GetByteArrayRegion(env, broadcaster_payment_basepoint, 0, 33, broadcaster_payment_basepoint_ref.compressed_form);
22893 LDKPublicKey countersignatory_payment_basepoint_ref;
22894 CHECK((*env)->GetArrayLength(env, countersignatory_payment_basepoint) == 33);
22895 (*env)->GetByteArrayRegion(env, countersignatory_payment_basepoint, 0, 33, countersignatory_payment_basepoint_ref.compressed_form);
22896 int64_t ret_val = get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint_ref, countersignatory_payment_basepoint_ref, outbound_from_broadcaster);
22900 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_InitFeatures_1eq(JNIEnv *env, jclass clz, int64_t a, int64_t b) {
22901 LDKInitFeatures a_conv;
22902 a_conv.inner = (void*)(a & (~1));
22903 a_conv.is_owned = false;
22904 LDKInitFeatures b_conv;
22905 b_conv.inner = (void*)(b & (~1));
22906 b_conv.is_owned = false;
22907 jboolean ret_val = InitFeatures_eq(&a_conv, &b_conv);
22911 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_NodeFeatures_1eq(JNIEnv *env, jclass clz, int64_t a, int64_t b) {
22912 LDKNodeFeatures a_conv;
22913 a_conv.inner = (void*)(a & (~1));
22914 a_conv.is_owned = false;
22915 LDKNodeFeatures b_conv;
22916 b_conv.inner = (void*)(b & (~1));
22917 b_conv.is_owned = false;
22918 jboolean ret_val = NodeFeatures_eq(&a_conv, &b_conv);
22922 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_ChannelFeatures_1eq(JNIEnv *env, jclass clz, int64_t a, int64_t b) {
22923 LDKChannelFeatures a_conv;
22924 a_conv.inner = (void*)(a & (~1));
22925 a_conv.is_owned = false;
22926 LDKChannelFeatures b_conv;
22927 b_conv.inner = (void*)(b & (~1));
22928 b_conv.is_owned = false;
22929 jboolean ret_val = ChannelFeatures_eq(&a_conv, &b_conv);
22933 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_InvoiceFeatures_1eq(JNIEnv *env, jclass clz, int64_t a, int64_t b) {
22934 LDKInvoiceFeatures a_conv;
22935 a_conv.inner = (void*)(a & (~1));
22936 a_conv.is_owned = false;
22937 LDKInvoiceFeatures b_conv;
22938 b_conv.inner = (void*)(b & (~1));
22939 b_conv.is_owned = false;
22940 jboolean ret_val = InvoiceFeatures_eq(&a_conv, &b_conv);
22944 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InitFeatures_1clone(JNIEnv *env, jclass clz, int64_t orig) {
22945 LDKInitFeatures orig_conv;
22946 orig_conv.inner = (void*)(orig & (~1));
22947 orig_conv.is_owned = false;
22948 LDKInitFeatures ret_var = InitFeatures_clone(&orig_conv);
22949 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22950 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22951 uint64_t ret_ref = (uint64_t)ret_var.inner;
22952 if (ret_var.is_owned) {
22958 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeFeatures_1clone(JNIEnv *env, jclass clz, int64_t orig) {
22959 LDKNodeFeatures orig_conv;
22960 orig_conv.inner = (void*)(orig & (~1));
22961 orig_conv.is_owned = false;
22962 LDKNodeFeatures ret_var = NodeFeatures_clone(&orig_conv);
22963 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22964 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22965 uint64_t ret_ref = (uint64_t)ret_var.inner;
22966 if (ret_var.is_owned) {
22972 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelFeatures_1clone(JNIEnv *env, jclass clz, int64_t orig) {
22973 LDKChannelFeatures orig_conv;
22974 orig_conv.inner = (void*)(orig & (~1));
22975 orig_conv.is_owned = false;
22976 LDKChannelFeatures ret_var = ChannelFeatures_clone(&orig_conv);
22977 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22978 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22979 uint64_t ret_ref = (uint64_t)ret_var.inner;
22980 if (ret_var.is_owned) {
22986 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InvoiceFeatures_1clone(JNIEnv *env, jclass clz, int64_t orig) {
22987 LDKInvoiceFeatures orig_conv;
22988 orig_conv.inner = (void*)(orig & (~1));
22989 orig_conv.is_owned = false;
22990 LDKInvoiceFeatures ret_var = InvoiceFeatures_clone(&orig_conv);
22991 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22992 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22993 uint64_t ret_ref = (uint64_t)ret_var.inner;
22994 if (ret_var.is_owned) {
23000 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_InitFeatures_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
23001 LDKInitFeatures this_obj_conv;
23002 this_obj_conv.inner = (void*)(this_obj & (~1));
23003 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
23004 InitFeatures_free(this_obj_conv);
23007 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NodeFeatures_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
23008 LDKNodeFeatures this_obj_conv;
23009 this_obj_conv.inner = (void*)(this_obj & (~1));
23010 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
23011 NodeFeatures_free(this_obj_conv);
23014 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelFeatures_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
23015 LDKChannelFeatures this_obj_conv;
23016 this_obj_conv.inner = (void*)(this_obj & (~1));
23017 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
23018 ChannelFeatures_free(this_obj_conv);
23021 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_InvoiceFeatures_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
23022 LDKInvoiceFeatures this_obj_conv;
23023 this_obj_conv.inner = (void*)(this_obj & (~1));
23024 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
23025 InvoiceFeatures_free(this_obj_conv);
23028 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InitFeatures_1empty(JNIEnv *env, jclass clz) {
23029 LDKInitFeatures ret_var = InitFeatures_empty();
23030 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23031 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23032 uint64_t ret_ref = (uint64_t)ret_var.inner;
23033 if (ret_var.is_owned) {
23039 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InitFeatures_1known(JNIEnv *env, jclass clz) {
23040 LDKInitFeatures ret_var = InitFeatures_known();
23041 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23042 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23043 uint64_t ret_ref = (uint64_t)ret_var.inner;
23044 if (ret_var.is_owned) {
23050 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeFeatures_1empty(JNIEnv *env, jclass clz) {
23051 LDKNodeFeatures ret_var = NodeFeatures_empty();
23052 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23053 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23054 uint64_t ret_ref = (uint64_t)ret_var.inner;
23055 if (ret_var.is_owned) {
23061 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeFeatures_1known(JNIEnv *env, jclass clz) {
23062 LDKNodeFeatures ret_var = NodeFeatures_known();
23063 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23064 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23065 uint64_t ret_ref = (uint64_t)ret_var.inner;
23066 if (ret_var.is_owned) {
23072 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelFeatures_1empty(JNIEnv *env, jclass clz) {
23073 LDKChannelFeatures ret_var = ChannelFeatures_empty();
23074 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23075 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23076 uint64_t ret_ref = (uint64_t)ret_var.inner;
23077 if (ret_var.is_owned) {
23083 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelFeatures_1known(JNIEnv *env, jclass clz) {
23084 LDKChannelFeatures ret_var = ChannelFeatures_known();
23085 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23086 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23087 uint64_t ret_ref = (uint64_t)ret_var.inner;
23088 if (ret_var.is_owned) {
23094 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InvoiceFeatures_1empty(JNIEnv *env, jclass clz) {
23095 LDKInvoiceFeatures ret_var = InvoiceFeatures_empty();
23096 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23097 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23098 uint64_t ret_ref = (uint64_t)ret_var.inner;
23099 if (ret_var.is_owned) {
23105 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InvoiceFeatures_1known(JNIEnv *env, jclass clz) {
23106 LDKInvoiceFeatures ret_var = InvoiceFeatures_known();
23107 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23108 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23109 uint64_t ret_ref = (uint64_t)ret_var.inner;
23110 if (ret_var.is_owned) {
23116 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_InitFeatures_1supports_1payment_1secret(JNIEnv *env, jclass clz, int64_t this_arg) {
23117 LDKInitFeatures this_arg_conv;
23118 this_arg_conv.inner = (void*)(this_arg & (~1));
23119 this_arg_conv.is_owned = false;
23120 jboolean ret_val = InitFeatures_supports_payment_secret(&this_arg_conv);
23124 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_NodeFeatures_1supports_1payment_1secret(JNIEnv *env, jclass clz, int64_t this_arg) {
23125 LDKNodeFeatures this_arg_conv;
23126 this_arg_conv.inner = (void*)(this_arg & (~1));
23127 this_arg_conv.is_owned = false;
23128 jboolean ret_val = NodeFeatures_supports_payment_secret(&this_arg_conv);
23132 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_InvoiceFeatures_1supports_1payment_1secret(JNIEnv *env, jclass clz, int64_t this_arg) {
23133 LDKInvoiceFeatures this_arg_conv;
23134 this_arg_conv.inner = (void*)(this_arg & (~1));
23135 this_arg_conv.is_owned = false;
23136 jboolean ret_val = InvoiceFeatures_supports_payment_secret(&this_arg_conv);
23140 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_InitFeatures_1write(JNIEnv *env, jclass clz, int64_t obj) {
23141 LDKInitFeatures obj_conv;
23142 obj_conv.inner = (void*)(obj & (~1));
23143 obj_conv.is_owned = false;
23144 LDKCVec_u8Z ret_var = InitFeatures_write(&obj_conv);
23145 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
23146 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
23147 CVec_u8Z_free(ret_var);
23151 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_NodeFeatures_1write(JNIEnv *env, jclass clz, int64_t obj) {
23152 LDKNodeFeatures obj_conv;
23153 obj_conv.inner = (void*)(obj & (~1));
23154 obj_conv.is_owned = false;
23155 LDKCVec_u8Z ret_var = NodeFeatures_write(&obj_conv);
23156 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
23157 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
23158 CVec_u8Z_free(ret_var);
23162 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelFeatures_1write(JNIEnv *env, jclass clz, int64_t obj) {
23163 LDKChannelFeatures obj_conv;
23164 obj_conv.inner = (void*)(obj & (~1));
23165 obj_conv.is_owned = false;
23166 LDKCVec_u8Z ret_var = ChannelFeatures_write(&obj_conv);
23167 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
23168 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
23169 CVec_u8Z_free(ret_var);
23173 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_InvoiceFeatures_1write(JNIEnv *env, jclass clz, int64_t obj) {
23174 LDKInvoiceFeatures obj_conv;
23175 obj_conv.inner = (void*)(obj & (~1));
23176 obj_conv.is_owned = false;
23177 LDKCVec_u8Z ret_var = InvoiceFeatures_write(&obj_conv);
23178 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
23179 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
23180 CVec_u8Z_free(ret_var);
23184 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InitFeatures_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
23185 LDKu8slice ser_ref;
23186 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
23187 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
23188 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
23189 *ret_conv = InitFeatures_read(ser_ref);
23190 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
23191 return (uint64_t)ret_conv;
23194 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeFeatures_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
23195 LDKu8slice ser_ref;
23196 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
23197 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
23198 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
23199 *ret_conv = NodeFeatures_read(ser_ref);
23200 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
23201 return (uint64_t)ret_conv;
23204 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelFeatures_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
23205 LDKu8slice ser_ref;
23206 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
23207 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
23208 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
23209 *ret_conv = ChannelFeatures_read(ser_ref);
23210 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
23211 return (uint64_t)ret_conv;
23214 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InvoiceFeatures_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
23215 LDKu8slice ser_ref;
23216 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
23217 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
23218 LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
23219 *ret_conv = InvoiceFeatures_read(ser_ref);
23220 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
23221 return (uint64_t)ret_conv;
23224 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RouteHop_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
23225 LDKRouteHop this_obj_conv;
23226 this_obj_conv.inner = (void*)(this_obj & (~1));
23227 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
23228 RouteHop_free(this_obj_conv);
23231 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_RouteHop_1get_1pubkey(JNIEnv *env, jclass clz, int64_t this_ptr) {
23232 LDKRouteHop this_ptr_conv;
23233 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23234 this_ptr_conv.is_owned = false;
23235 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
23236 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, RouteHop_get_pubkey(&this_ptr_conv).compressed_form);
23240 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RouteHop_1set_1pubkey(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
23241 LDKRouteHop this_ptr_conv;
23242 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23243 this_ptr_conv.is_owned = false;
23244 LDKPublicKey val_ref;
23245 CHECK((*env)->GetArrayLength(env, val) == 33);
23246 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
23247 RouteHop_set_pubkey(&this_ptr_conv, val_ref);
23250 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHop_1get_1node_1features(JNIEnv *env, jclass clz, int64_t this_ptr) {
23251 LDKRouteHop this_ptr_conv;
23252 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23253 this_ptr_conv.is_owned = false;
23254 LDKNodeFeatures ret_var = RouteHop_get_node_features(&this_ptr_conv);
23255 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23256 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23257 uint64_t ret_ref = (uint64_t)ret_var.inner;
23258 if (ret_var.is_owned) {
23264 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RouteHop_1set_1node_1features(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
23265 LDKRouteHop this_ptr_conv;
23266 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23267 this_ptr_conv.is_owned = false;
23268 LDKNodeFeatures val_conv;
23269 val_conv.inner = (void*)(val & (~1));
23270 val_conv.is_owned = (val & 1) || (val == 0);
23271 val_conv = NodeFeatures_clone(&val_conv);
23272 RouteHop_set_node_features(&this_ptr_conv, val_conv);
23275 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHop_1get_1short_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
23276 LDKRouteHop this_ptr_conv;
23277 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23278 this_ptr_conv.is_owned = false;
23279 int64_t ret_val = RouteHop_get_short_channel_id(&this_ptr_conv);
23283 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RouteHop_1set_1short_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
23284 LDKRouteHop this_ptr_conv;
23285 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23286 this_ptr_conv.is_owned = false;
23287 RouteHop_set_short_channel_id(&this_ptr_conv, val);
23290 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHop_1get_1channel_1features(JNIEnv *env, jclass clz, int64_t this_ptr) {
23291 LDKRouteHop this_ptr_conv;
23292 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23293 this_ptr_conv.is_owned = false;
23294 LDKChannelFeatures ret_var = RouteHop_get_channel_features(&this_ptr_conv);
23295 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23296 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23297 uint64_t ret_ref = (uint64_t)ret_var.inner;
23298 if (ret_var.is_owned) {
23304 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RouteHop_1set_1channel_1features(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
23305 LDKRouteHop this_ptr_conv;
23306 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23307 this_ptr_conv.is_owned = false;
23308 LDKChannelFeatures val_conv;
23309 val_conv.inner = (void*)(val & (~1));
23310 val_conv.is_owned = (val & 1) || (val == 0);
23311 val_conv = ChannelFeatures_clone(&val_conv);
23312 RouteHop_set_channel_features(&this_ptr_conv, val_conv);
23315 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHop_1get_1fee_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
23316 LDKRouteHop this_ptr_conv;
23317 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23318 this_ptr_conv.is_owned = false;
23319 int64_t ret_val = RouteHop_get_fee_msat(&this_ptr_conv);
23323 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RouteHop_1set_1fee_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
23324 LDKRouteHop this_ptr_conv;
23325 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23326 this_ptr_conv.is_owned = false;
23327 RouteHop_set_fee_msat(&this_ptr_conv, val);
23330 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_RouteHop_1get_1cltv_1expiry_1delta(JNIEnv *env, jclass clz, int64_t this_ptr) {
23331 LDKRouteHop this_ptr_conv;
23332 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23333 this_ptr_conv.is_owned = false;
23334 int32_t ret_val = RouteHop_get_cltv_expiry_delta(&this_ptr_conv);
23338 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RouteHop_1set_1cltv_1expiry_1delta(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
23339 LDKRouteHop this_ptr_conv;
23340 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23341 this_ptr_conv.is_owned = false;
23342 RouteHop_set_cltv_expiry_delta(&this_ptr_conv, val);
23345 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHop_1new(JNIEnv *env, jclass clz, int8_tArray pubkey_arg, int64_t node_features_arg, int64_t short_channel_id_arg, int64_t channel_features_arg, int64_t fee_msat_arg, int32_t cltv_expiry_delta_arg) {
23346 LDKPublicKey pubkey_arg_ref;
23347 CHECK((*env)->GetArrayLength(env, pubkey_arg) == 33);
23348 (*env)->GetByteArrayRegion(env, pubkey_arg, 0, 33, pubkey_arg_ref.compressed_form);
23349 LDKNodeFeatures node_features_arg_conv;
23350 node_features_arg_conv.inner = (void*)(node_features_arg & (~1));
23351 node_features_arg_conv.is_owned = (node_features_arg & 1) || (node_features_arg == 0);
23352 node_features_arg_conv = NodeFeatures_clone(&node_features_arg_conv);
23353 LDKChannelFeatures channel_features_arg_conv;
23354 channel_features_arg_conv.inner = (void*)(channel_features_arg & (~1));
23355 channel_features_arg_conv.is_owned = (channel_features_arg & 1) || (channel_features_arg == 0);
23356 channel_features_arg_conv = ChannelFeatures_clone(&channel_features_arg_conv);
23357 LDKRouteHop ret_var = RouteHop_new(pubkey_arg_ref, node_features_arg_conv, short_channel_id_arg, channel_features_arg_conv, fee_msat_arg, cltv_expiry_delta_arg);
23358 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23359 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23360 uint64_t ret_ref = (uint64_t)ret_var.inner;
23361 if (ret_var.is_owned) {
23367 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHop_1clone(JNIEnv *env, jclass clz, int64_t orig) {
23368 LDKRouteHop orig_conv;
23369 orig_conv.inner = (void*)(orig & (~1));
23370 orig_conv.is_owned = false;
23371 LDKRouteHop ret_var = RouteHop_clone(&orig_conv);
23372 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23373 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23374 uint64_t ret_ref = (uint64_t)ret_var.inner;
23375 if (ret_var.is_owned) {
23381 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_RouteHop_1write(JNIEnv *env, jclass clz, int64_t obj) {
23382 LDKRouteHop obj_conv;
23383 obj_conv.inner = (void*)(obj & (~1));
23384 obj_conv.is_owned = false;
23385 LDKCVec_u8Z ret_var = RouteHop_write(&obj_conv);
23386 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
23387 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
23388 CVec_u8Z_free(ret_var);
23392 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHop_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
23393 LDKu8slice ser_ref;
23394 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
23395 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
23396 LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
23397 *ret_conv = RouteHop_read(ser_ref);
23398 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
23399 return (uint64_t)ret_conv;
23402 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Route_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
23403 LDKRoute this_obj_conv;
23404 this_obj_conv.inner = (void*)(this_obj & (~1));
23405 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
23406 Route_free(this_obj_conv);
23409 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Route_1set_1paths(JNIEnv *env, jclass clz, int64_t this_ptr, jobjectArray val) {
23410 LDKRoute this_ptr_conv;
23411 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23412 this_ptr_conv.is_owned = false;
23413 LDKCVec_CVec_RouteHopZZ val_constr;
23414 val_constr.datalen = (*env)->GetArrayLength(env, val);
23415 if (val_constr.datalen > 0)
23416 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKCVec_RouteHopZ), "LDKCVec_CVec_RouteHopZZ Elements");
23418 val_constr.data = NULL;
23419 for (size_t m = 0; m < val_constr.datalen; m++) {
23420 int64_tArray val_conv_12 = (*env)->GetObjectArrayElement(env, val, m);
23421 LDKCVec_RouteHopZ val_conv_12_constr;
23422 val_conv_12_constr.datalen = (*env)->GetArrayLength(env, val_conv_12);
23423 if (val_conv_12_constr.datalen > 0)
23424 val_conv_12_constr.data = MALLOC(val_conv_12_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
23426 val_conv_12_constr.data = NULL;
23427 int64_t* val_conv_12_vals = (*env)->GetLongArrayElements (env, val_conv_12, NULL);
23428 for (size_t k = 0; k < val_conv_12_constr.datalen; k++) {
23429 int64_t val_conv_12_conv_10 = val_conv_12_vals[k];
23430 LDKRouteHop val_conv_12_conv_10_conv;
23431 val_conv_12_conv_10_conv.inner = (void*)(val_conv_12_conv_10 & (~1));
23432 val_conv_12_conv_10_conv.is_owned = (val_conv_12_conv_10 & 1) || (val_conv_12_conv_10 == 0);
23433 val_conv_12_conv_10_conv = RouteHop_clone(&val_conv_12_conv_10_conv);
23434 val_conv_12_constr.data[k] = val_conv_12_conv_10_conv;
23436 (*env)->ReleaseLongArrayElements(env, val_conv_12, val_conv_12_vals, 0);
23437 val_constr.data[m] = val_conv_12_constr;
23439 Route_set_paths(&this_ptr_conv, val_constr);
23442 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Route_1new(JNIEnv *env, jclass clz, jobjectArray paths_arg) {
23443 LDKCVec_CVec_RouteHopZZ paths_arg_constr;
23444 paths_arg_constr.datalen = (*env)->GetArrayLength(env, paths_arg);
23445 if (paths_arg_constr.datalen > 0)
23446 paths_arg_constr.data = MALLOC(paths_arg_constr.datalen * sizeof(LDKCVec_RouteHopZ), "LDKCVec_CVec_RouteHopZZ Elements");
23448 paths_arg_constr.data = NULL;
23449 for (size_t m = 0; m < paths_arg_constr.datalen; m++) {
23450 int64_tArray paths_arg_conv_12 = (*env)->GetObjectArrayElement(env, paths_arg, m);
23451 LDKCVec_RouteHopZ paths_arg_conv_12_constr;
23452 paths_arg_conv_12_constr.datalen = (*env)->GetArrayLength(env, paths_arg_conv_12);
23453 if (paths_arg_conv_12_constr.datalen > 0)
23454 paths_arg_conv_12_constr.data = MALLOC(paths_arg_conv_12_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
23456 paths_arg_conv_12_constr.data = NULL;
23457 int64_t* paths_arg_conv_12_vals = (*env)->GetLongArrayElements (env, paths_arg_conv_12, NULL);
23458 for (size_t k = 0; k < paths_arg_conv_12_constr.datalen; k++) {
23459 int64_t paths_arg_conv_12_conv_10 = paths_arg_conv_12_vals[k];
23460 LDKRouteHop paths_arg_conv_12_conv_10_conv;
23461 paths_arg_conv_12_conv_10_conv.inner = (void*)(paths_arg_conv_12_conv_10 & (~1));
23462 paths_arg_conv_12_conv_10_conv.is_owned = (paths_arg_conv_12_conv_10 & 1) || (paths_arg_conv_12_conv_10 == 0);
23463 paths_arg_conv_12_conv_10_conv = RouteHop_clone(&paths_arg_conv_12_conv_10_conv);
23464 paths_arg_conv_12_constr.data[k] = paths_arg_conv_12_conv_10_conv;
23466 (*env)->ReleaseLongArrayElements(env, paths_arg_conv_12, paths_arg_conv_12_vals, 0);
23467 paths_arg_constr.data[m] = paths_arg_conv_12_constr;
23469 LDKRoute ret_var = Route_new(paths_arg_constr);
23470 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23471 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23472 uint64_t ret_ref = (uint64_t)ret_var.inner;
23473 if (ret_var.is_owned) {
23479 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Route_1clone(JNIEnv *env, jclass clz, int64_t orig) {
23480 LDKRoute orig_conv;
23481 orig_conv.inner = (void*)(orig & (~1));
23482 orig_conv.is_owned = false;
23483 LDKRoute ret_var = Route_clone(&orig_conv);
23484 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23485 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23486 uint64_t ret_ref = (uint64_t)ret_var.inner;
23487 if (ret_var.is_owned) {
23493 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_Route_1write(JNIEnv *env, jclass clz, int64_t obj) {
23495 obj_conv.inner = (void*)(obj & (~1));
23496 obj_conv.is_owned = false;
23497 LDKCVec_u8Z ret_var = Route_write(&obj_conv);
23498 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
23499 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
23500 CVec_u8Z_free(ret_var);
23504 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Route_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
23505 LDKu8slice ser_ref;
23506 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
23507 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
23508 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
23509 *ret_conv = Route_read(ser_ref);
23510 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
23511 return (uint64_t)ret_conv;
23514 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RouteHint_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
23515 LDKRouteHint this_obj_conv;
23516 this_obj_conv.inner = (void*)(this_obj & (~1));
23517 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
23518 RouteHint_free(this_obj_conv);
23521 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_RouteHint_1eq(JNIEnv *env, jclass clz, int64_t a, int64_t b) {
23522 LDKRouteHint a_conv;
23523 a_conv.inner = (void*)(a & (~1));
23524 a_conv.is_owned = false;
23525 LDKRouteHint b_conv;
23526 b_conv.inner = (void*)(b & (~1));
23527 b_conv.is_owned = false;
23528 jboolean ret_val = RouteHint_eq(&a_conv, &b_conv);
23532 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHint_1clone(JNIEnv *env, jclass clz, int64_t orig) {
23533 LDKRouteHint orig_conv;
23534 orig_conv.inner = (void*)(orig & (~1));
23535 orig_conv.is_owned = false;
23536 LDKRouteHint ret_var = RouteHint_clone(&orig_conv);
23537 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23538 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23539 uint64_t ret_ref = (uint64_t)ret_var.inner;
23540 if (ret_var.is_owned) {
23546 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RouteHintHop_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
23547 LDKRouteHintHop this_obj_conv;
23548 this_obj_conv.inner = (void*)(this_obj & (~1));
23549 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
23550 RouteHintHop_free(this_obj_conv);
23553 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_RouteHintHop_1get_1src_1node_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
23554 LDKRouteHintHop this_ptr_conv;
23555 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23556 this_ptr_conv.is_owned = false;
23557 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
23558 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, RouteHintHop_get_src_node_id(&this_ptr_conv).compressed_form);
23562 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RouteHintHop_1set_1src_1node_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
23563 LDKRouteHintHop this_ptr_conv;
23564 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23565 this_ptr_conv.is_owned = false;
23566 LDKPublicKey val_ref;
23567 CHECK((*env)->GetArrayLength(env, val) == 33);
23568 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
23569 RouteHintHop_set_src_node_id(&this_ptr_conv, val_ref);
23572 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHintHop_1get_1short_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
23573 LDKRouteHintHop this_ptr_conv;
23574 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23575 this_ptr_conv.is_owned = false;
23576 int64_t ret_val = RouteHintHop_get_short_channel_id(&this_ptr_conv);
23580 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RouteHintHop_1set_1short_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
23581 LDKRouteHintHop this_ptr_conv;
23582 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23583 this_ptr_conv.is_owned = false;
23584 RouteHintHop_set_short_channel_id(&this_ptr_conv, val);
23587 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHintHop_1get_1fees(JNIEnv *env, jclass clz, int64_t this_ptr) {
23588 LDKRouteHintHop this_ptr_conv;
23589 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23590 this_ptr_conv.is_owned = false;
23591 LDKRoutingFees ret_var = RouteHintHop_get_fees(&this_ptr_conv);
23592 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23593 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23594 uint64_t ret_ref = (uint64_t)ret_var.inner;
23595 if (ret_var.is_owned) {
23601 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RouteHintHop_1set_1fees(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
23602 LDKRouteHintHop this_ptr_conv;
23603 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23604 this_ptr_conv.is_owned = false;
23605 LDKRoutingFees val_conv;
23606 val_conv.inner = (void*)(val & (~1));
23607 val_conv.is_owned = (val & 1) || (val == 0);
23608 val_conv = RoutingFees_clone(&val_conv);
23609 RouteHintHop_set_fees(&this_ptr_conv, val_conv);
23612 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_RouteHintHop_1get_1cltv_1expiry_1delta(JNIEnv *env, jclass clz, int64_t this_ptr) {
23613 LDKRouteHintHop this_ptr_conv;
23614 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23615 this_ptr_conv.is_owned = false;
23616 int16_t ret_val = RouteHintHop_get_cltv_expiry_delta(&this_ptr_conv);
23620 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RouteHintHop_1set_1cltv_1expiry_1delta(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
23621 LDKRouteHintHop this_ptr_conv;
23622 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23623 this_ptr_conv.is_owned = false;
23624 RouteHintHop_set_cltv_expiry_delta(&this_ptr_conv, val);
23627 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHintHop_1get_1htlc_1minimum_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
23628 LDKRouteHintHop this_ptr_conv;
23629 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23630 this_ptr_conv.is_owned = false;
23631 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
23632 *ret_copy = RouteHintHop_get_htlc_minimum_msat(&this_ptr_conv);
23633 uint64_t ret_ref = (uint64_t)ret_copy;
23637 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RouteHintHop_1set_1htlc_1minimum_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
23638 LDKRouteHintHop this_ptr_conv;
23639 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23640 this_ptr_conv.is_owned = false;
23641 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(((uint64_t)val) & ~1);
23642 RouteHintHop_set_htlc_minimum_msat(&this_ptr_conv, val_conv);
23645 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHintHop_1get_1htlc_1maximum_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
23646 LDKRouteHintHop this_ptr_conv;
23647 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23648 this_ptr_conv.is_owned = false;
23649 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
23650 *ret_copy = RouteHintHop_get_htlc_maximum_msat(&this_ptr_conv);
23651 uint64_t ret_ref = (uint64_t)ret_copy;
23655 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RouteHintHop_1set_1htlc_1maximum_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
23656 LDKRouteHintHop this_ptr_conv;
23657 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23658 this_ptr_conv.is_owned = false;
23659 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(((uint64_t)val) & ~1);
23660 RouteHintHop_set_htlc_maximum_msat(&this_ptr_conv, val_conv);
23663 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHintHop_1new(JNIEnv *env, jclass clz, int8_tArray src_node_id_arg, int64_t short_channel_id_arg, int64_t fees_arg, int16_t cltv_expiry_delta_arg, int64_t htlc_minimum_msat_arg, int64_t htlc_maximum_msat_arg) {
23664 LDKPublicKey src_node_id_arg_ref;
23665 CHECK((*env)->GetArrayLength(env, src_node_id_arg) == 33);
23666 (*env)->GetByteArrayRegion(env, src_node_id_arg, 0, 33, src_node_id_arg_ref.compressed_form);
23667 LDKRoutingFees fees_arg_conv;
23668 fees_arg_conv.inner = (void*)(fees_arg & (~1));
23669 fees_arg_conv.is_owned = (fees_arg & 1) || (fees_arg == 0);
23670 fees_arg_conv = RoutingFees_clone(&fees_arg_conv);
23671 LDKCOption_u64Z htlc_minimum_msat_arg_conv = *(LDKCOption_u64Z*)(((uint64_t)htlc_minimum_msat_arg) & ~1);
23672 LDKCOption_u64Z htlc_maximum_msat_arg_conv = *(LDKCOption_u64Z*)(((uint64_t)htlc_maximum_msat_arg) & ~1);
23673 LDKRouteHintHop ret_var = RouteHintHop_new(src_node_id_arg_ref, short_channel_id_arg, fees_arg_conv, cltv_expiry_delta_arg, htlc_minimum_msat_arg_conv, htlc_maximum_msat_arg_conv);
23674 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23675 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23676 uint64_t ret_ref = (uint64_t)ret_var.inner;
23677 if (ret_var.is_owned) {
23683 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_RouteHintHop_1eq(JNIEnv *env, jclass clz, int64_t a, int64_t b) {
23684 LDKRouteHintHop a_conv;
23685 a_conv.inner = (void*)(a & (~1));
23686 a_conv.is_owned = false;
23687 LDKRouteHintHop b_conv;
23688 b_conv.inner = (void*)(b & (~1));
23689 b_conv.is_owned = false;
23690 jboolean ret_val = RouteHintHop_eq(&a_conv, &b_conv);
23694 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHintHop_1clone(JNIEnv *env, jclass clz, int64_t orig) {
23695 LDKRouteHintHop orig_conv;
23696 orig_conv.inner = (void*)(orig & (~1));
23697 orig_conv.is_owned = false;
23698 LDKRouteHintHop ret_var = RouteHintHop_clone(&orig_conv);
23699 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23700 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23701 uint64_t ret_ref = (uint64_t)ret_var.inner;
23702 if (ret_var.is_owned) {
23708 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_get_1route(JNIEnv *env, jclass clz, int8_tArray our_node_id, int64_t network, int8_tArray payee, int64_t payee_features, int64_tArray first_hops, int64_tArray last_hops, int64_t final_value_msat, int32_t final_cltv, int64_t logger) {
23709 LDKPublicKey our_node_id_ref;
23710 CHECK((*env)->GetArrayLength(env, our_node_id) == 33);
23711 (*env)->GetByteArrayRegion(env, our_node_id, 0, 33, our_node_id_ref.compressed_form);
23712 LDKNetworkGraph network_conv;
23713 network_conv.inner = (void*)(network & (~1));
23714 network_conv.is_owned = false;
23715 LDKPublicKey payee_ref;
23716 CHECK((*env)->GetArrayLength(env, payee) == 33);
23717 (*env)->GetByteArrayRegion(env, payee, 0, 33, payee_ref.compressed_form);
23718 LDKInvoiceFeatures payee_features_conv;
23719 payee_features_conv.inner = (void*)(payee_features & (~1));
23720 payee_features_conv.is_owned = (payee_features & 1) || (payee_features == 0);
23721 payee_features_conv = InvoiceFeatures_clone(&payee_features_conv);
23722 LDKCVec_ChannelDetailsZ first_hops_constr;
23723 first_hops_constr.datalen = (*env)->GetArrayLength(env, first_hops);
23724 if (first_hops_constr.datalen > 0)
23725 first_hops_constr.data = MALLOC(first_hops_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
23727 first_hops_constr.data = NULL;
23728 int64_t* first_hops_vals = (*env)->GetLongArrayElements (env, first_hops, NULL);
23729 for (size_t q = 0; q < first_hops_constr.datalen; q++) {
23730 int64_t first_hops_conv_16 = first_hops_vals[q];
23731 LDKChannelDetails first_hops_conv_16_conv;
23732 first_hops_conv_16_conv.inner = (void*)(first_hops_conv_16 & (~1));
23733 first_hops_conv_16_conv.is_owned = (first_hops_conv_16 & 1) || (first_hops_conv_16 == 0);
23734 first_hops_constr.data[q] = first_hops_conv_16_conv;
23736 (*env)->ReleaseLongArrayElements(env, first_hops, first_hops_vals, 0);
23737 LDKCVec_RouteHintZ last_hops_constr;
23738 last_hops_constr.datalen = (*env)->GetArrayLength(env, last_hops);
23739 if (last_hops_constr.datalen > 0)
23740 last_hops_constr.data = MALLOC(last_hops_constr.datalen * sizeof(LDKRouteHint), "LDKCVec_RouteHintZ Elements");
23742 last_hops_constr.data = NULL;
23743 int64_t* last_hops_vals = (*env)->GetLongArrayElements (env, last_hops, NULL);
23744 for (size_t l = 0; l < last_hops_constr.datalen; l++) {
23745 int64_t last_hops_conv_11 = last_hops_vals[l];
23746 LDKRouteHint last_hops_conv_11_conv;
23747 last_hops_conv_11_conv.inner = (void*)(last_hops_conv_11 & (~1));
23748 last_hops_conv_11_conv.is_owned = (last_hops_conv_11 & 1) || (last_hops_conv_11 == 0);
23749 last_hops_conv_11_conv = RouteHint_clone(&last_hops_conv_11_conv);
23750 last_hops_constr.data[l] = last_hops_conv_11_conv;
23752 (*env)->ReleaseLongArrayElements(env, last_hops, last_hops_vals, 0);
23753 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
23754 if (logger_conv.free == LDKLogger_JCalls_free) {
23755 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
23756 LDKLogger_JCalls_clone(logger_conv.this_arg);
23758 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
23759 *ret_conv = get_route(our_node_id_ref, &network_conv, payee_ref, payee_features_conv, &first_hops_constr, last_hops_constr, final_value_msat, final_cltv, logger_conv);
23760 FREE(first_hops_constr.data);
23761 return (uint64_t)ret_conv;
23764 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NetworkGraph_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
23765 LDKNetworkGraph this_obj_conv;
23766 this_obj_conv.inner = (void*)(this_obj & (~1));
23767 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
23768 NetworkGraph_free(this_obj_conv);
23771 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetworkGraph_1clone(JNIEnv *env, jclass clz, int64_t orig) {
23772 LDKNetworkGraph orig_conv;
23773 orig_conv.inner = (void*)(orig & (~1));
23774 orig_conv.is_owned = false;
23775 LDKNetworkGraph ret_var = NetworkGraph_clone(&orig_conv);
23776 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23777 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23778 uint64_t ret_ref = (uint64_t)ret_var.inner;
23779 if (ret_var.is_owned) {
23785 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LockedNetworkGraph_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
23786 LDKLockedNetworkGraph this_obj_conv;
23787 this_obj_conv.inner = (void*)(this_obj & (~1));
23788 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
23789 LockedNetworkGraph_free(this_obj_conv);
23792 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NetGraphMsgHandler_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
23793 LDKNetGraphMsgHandler this_obj_conv;
23794 this_obj_conv.inner = (void*)(this_obj & (~1));
23795 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
23796 NetGraphMsgHandler_free(this_obj_conv);
23799 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetGraphMsgHandler_1new(JNIEnv *env, jclass clz, int8_tArray genesis_hash, int64_t chain_access, int64_t logger) {
23800 LDKThirtyTwoBytes genesis_hash_ref;
23801 CHECK((*env)->GetArrayLength(env, genesis_hash) == 32);
23802 (*env)->GetByteArrayRegion(env, genesis_hash, 0, 32, genesis_hash_ref.data);
23803 LDKAccess *chain_access_conv_ptr = NULL;
23804 if (chain_access != 0) {
23805 LDKAccess chain_access_conv;
23806 chain_access_conv = *(LDKAccess*)(((uint64_t)chain_access) & ~1);
23807 if (chain_access_conv.free == LDKAccess_JCalls_free) {
23808 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
23809 LDKAccess_JCalls_clone(chain_access_conv.this_arg);
23811 chain_access_conv_ptr = MALLOC(sizeof(LDKAccess), "LDKAccess");
23812 *chain_access_conv_ptr = chain_access_conv;
23814 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
23815 if (logger_conv.free == LDKLogger_JCalls_free) {
23816 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
23817 LDKLogger_JCalls_clone(logger_conv.this_arg);
23819 LDKNetGraphMsgHandler ret_var = NetGraphMsgHandler_new(genesis_hash_ref, chain_access_conv_ptr, logger_conv);
23820 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23821 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23822 uint64_t ret_ref = (uint64_t)ret_var.inner;
23823 if (ret_var.is_owned) {
23829 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetGraphMsgHandler_1from_1net_1graph(JNIEnv *env, jclass clz, int64_t chain_access, int64_t logger, int64_t network_graph) {
23830 LDKAccess *chain_access_conv_ptr = NULL;
23831 if (chain_access != 0) {
23832 LDKAccess chain_access_conv;
23833 chain_access_conv = *(LDKAccess*)(((uint64_t)chain_access) & ~1);
23834 if (chain_access_conv.free == LDKAccess_JCalls_free) {
23835 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
23836 LDKAccess_JCalls_clone(chain_access_conv.this_arg);
23838 chain_access_conv_ptr = MALLOC(sizeof(LDKAccess), "LDKAccess");
23839 *chain_access_conv_ptr = chain_access_conv;
23841 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
23842 if (logger_conv.free == LDKLogger_JCalls_free) {
23843 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
23844 LDKLogger_JCalls_clone(logger_conv.this_arg);
23846 LDKNetworkGraph network_graph_conv;
23847 network_graph_conv.inner = (void*)(network_graph & (~1));
23848 network_graph_conv.is_owned = (network_graph & 1) || (network_graph == 0);
23849 network_graph_conv = NetworkGraph_clone(&network_graph_conv);
23850 LDKNetGraphMsgHandler ret_var = NetGraphMsgHandler_from_net_graph(chain_access_conv_ptr, logger_conv, network_graph_conv);
23851 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23852 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23853 uint64_t ret_ref = (uint64_t)ret_var.inner;
23854 if (ret_var.is_owned) {
23860 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NetGraphMsgHandler_1add_1chain_1access(JNIEnv *env, jclass clz, int64_t this_arg, int64_t chain_access) {
23861 LDKNetGraphMsgHandler this_arg_conv;
23862 this_arg_conv.inner = (void*)(this_arg & (~1));
23863 this_arg_conv.is_owned = false;
23864 LDKAccess *chain_access_conv_ptr = NULL;
23865 if (chain_access != 0) {
23866 LDKAccess chain_access_conv;
23867 chain_access_conv = *(LDKAccess*)(((uint64_t)chain_access) & ~1);
23868 if (chain_access_conv.free == LDKAccess_JCalls_free) {
23869 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
23870 LDKAccess_JCalls_clone(chain_access_conv.this_arg);
23872 chain_access_conv_ptr = MALLOC(sizeof(LDKAccess), "LDKAccess");
23873 *chain_access_conv_ptr = chain_access_conv;
23875 NetGraphMsgHandler_add_chain_access(&this_arg_conv, chain_access_conv_ptr);
23878 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetGraphMsgHandler_1read_1locked_1graph(JNIEnv *env, jclass clz, int64_t this_arg) {
23879 LDKNetGraphMsgHandler this_arg_conv;
23880 this_arg_conv.inner = (void*)(this_arg & (~1));
23881 this_arg_conv.is_owned = false;
23882 LDKLockedNetworkGraph ret_var = NetGraphMsgHandler_read_locked_graph(&this_arg_conv);
23883 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23884 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23885 uint64_t ret_ref = (uint64_t)ret_var.inner;
23886 if (ret_var.is_owned) {
23892 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LockedNetworkGraph_1graph(JNIEnv *env, jclass clz, int64_t this_arg) {
23893 LDKLockedNetworkGraph this_arg_conv;
23894 this_arg_conv.inner = (void*)(this_arg & (~1));
23895 this_arg_conv.is_owned = false;
23896 LDKNetworkGraph ret_var = LockedNetworkGraph_graph(&this_arg_conv);
23897 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23898 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23899 uint64_t ret_ref = (uint64_t)ret_var.inner;
23900 if (ret_var.is_owned) {
23906 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetGraphMsgHandler_1as_1RoutingMessageHandler(JNIEnv *env, jclass clz, int64_t this_arg) {
23907 LDKNetGraphMsgHandler this_arg_conv;
23908 this_arg_conv.inner = (void*)(this_arg & (~1));
23909 this_arg_conv.is_owned = false;
23910 LDKRoutingMessageHandler* ret = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
23911 *ret = NetGraphMsgHandler_as_RoutingMessageHandler(&this_arg_conv);
23912 return (uint64_t)ret;
23915 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetGraphMsgHandler_1as_1MessageSendEventsProvider(JNIEnv *env, jclass clz, int64_t this_arg) {
23916 LDKNetGraphMsgHandler this_arg_conv;
23917 this_arg_conv.inner = (void*)(this_arg & (~1));
23918 this_arg_conv.is_owned = false;
23919 LDKMessageSendEventsProvider* ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
23920 *ret = NetGraphMsgHandler_as_MessageSendEventsProvider(&this_arg_conv);
23921 return (uint64_t)ret;
23924 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
23925 LDKDirectionalChannelInfo this_obj_conv;
23926 this_obj_conv.inner = (void*)(this_obj & (~1));
23927 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
23928 DirectionalChannelInfo_free(this_obj_conv);
23931 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1get_1last_1update(JNIEnv *env, jclass clz, int64_t this_ptr) {
23932 LDKDirectionalChannelInfo this_ptr_conv;
23933 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23934 this_ptr_conv.is_owned = false;
23935 int32_t ret_val = DirectionalChannelInfo_get_last_update(&this_ptr_conv);
23939 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1set_1last_1update(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
23940 LDKDirectionalChannelInfo this_ptr_conv;
23941 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23942 this_ptr_conv.is_owned = false;
23943 DirectionalChannelInfo_set_last_update(&this_ptr_conv, val);
23946 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1get_1enabled(JNIEnv *env, jclass clz, int64_t this_ptr) {
23947 LDKDirectionalChannelInfo this_ptr_conv;
23948 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23949 this_ptr_conv.is_owned = false;
23950 jboolean ret_val = DirectionalChannelInfo_get_enabled(&this_ptr_conv);
23954 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1set_1enabled(JNIEnv *env, jclass clz, int64_t this_ptr, jboolean val) {
23955 LDKDirectionalChannelInfo this_ptr_conv;
23956 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23957 this_ptr_conv.is_owned = false;
23958 DirectionalChannelInfo_set_enabled(&this_ptr_conv, val);
23961 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1get_1cltv_1expiry_1delta(JNIEnv *env, jclass clz, int64_t this_ptr) {
23962 LDKDirectionalChannelInfo this_ptr_conv;
23963 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23964 this_ptr_conv.is_owned = false;
23965 int16_t ret_val = DirectionalChannelInfo_get_cltv_expiry_delta(&this_ptr_conv);
23969 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1set_1cltv_1expiry_1delta(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
23970 LDKDirectionalChannelInfo this_ptr_conv;
23971 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23972 this_ptr_conv.is_owned = false;
23973 DirectionalChannelInfo_set_cltv_expiry_delta(&this_ptr_conv, val);
23976 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1get_1htlc_1minimum_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
23977 LDKDirectionalChannelInfo this_ptr_conv;
23978 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23979 this_ptr_conv.is_owned = false;
23980 int64_t ret_val = DirectionalChannelInfo_get_htlc_minimum_msat(&this_ptr_conv);
23984 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1set_1htlc_1minimum_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
23985 LDKDirectionalChannelInfo this_ptr_conv;
23986 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23987 this_ptr_conv.is_owned = false;
23988 DirectionalChannelInfo_set_htlc_minimum_msat(&this_ptr_conv, val);
23991 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1get_1htlc_1maximum_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
23992 LDKDirectionalChannelInfo this_ptr_conv;
23993 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23994 this_ptr_conv.is_owned = false;
23995 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
23996 *ret_copy = DirectionalChannelInfo_get_htlc_maximum_msat(&this_ptr_conv);
23997 uint64_t ret_ref = (uint64_t)ret_copy;
24001 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1set_1htlc_1maximum_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
24002 LDKDirectionalChannelInfo this_ptr_conv;
24003 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24004 this_ptr_conv.is_owned = false;
24005 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(((uint64_t)val) & ~1);
24006 DirectionalChannelInfo_set_htlc_maximum_msat(&this_ptr_conv, val_conv);
24009 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1get_1fees(JNIEnv *env, jclass clz, int64_t this_ptr) {
24010 LDKDirectionalChannelInfo this_ptr_conv;
24011 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24012 this_ptr_conv.is_owned = false;
24013 LDKRoutingFees ret_var = DirectionalChannelInfo_get_fees(&this_ptr_conv);
24014 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24015 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24016 uint64_t ret_ref = (uint64_t)ret_var.inner;
24017 if (ret_var.is_owned) {
24023 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1set_1fees(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
24024 LDKDirectionalChannelInfo this_ptr_conv;
24025 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24026 this_ptr_conv.is_owned = false;
24027 LDKRoutingFees val_conv;
24028 val_conv.inner = (void*)(val & (~1));
24029 val_conv.is_owned = (val & 1) || (val == 0);
24030 val_conv = RoutingFees_clone(&val_conv);
24031 DirectionalChannelInfo_set_fees(&this_ptr_conv, val_conv);
24034 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1get_1last_1update_1message(JNIEnv *env, jclass clz, int64_t this_ptr) {
24035 LDKDirectionalChannelInfo this_ptr_conv;
24036 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24037 this_ptr_conv.is_owned = false;
24038 LDKChannelUpdate ret_var = DirectionalChannelInfo_get_last_update_message(&this_ptr_conv);
24039 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24040 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24041 uint64_t ret_ref = (uint64_t)ret_var.inner;
24042 if (ret_var.is_owned) {
24048 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1set_1last_1update_1message(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
24049 LDKDirectionalChannelInfo this_ptr_conv;
24050 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24051 this_ptr_conv.is_owned = false;
24052 LDKChannelUpdate val_conv;
24053 val_conv.inner = (void*)(val & (~1));
24054 val_conv.is_owned = (val & 1) || (val == 0);
24055 val_conv = ChannelUpdate_clone(&val_conv);
24056 DirectionalChannelInfo_set_last_update_message(&this_ptr_conv, val_conv);
24059 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1new(JNIEnv *env, jclass clz, int32_t last_update_arg, jboolean enabled_arg, int16_t cltv_expiry_delta_arg, int64_t htlc_minimum_msat_arg, int64_t htlc_maximum_msat_arg, int64_t fees_arg, int64_t last_update_message_arg) {
24060 LDKCOption_u64Z htlc_maximum_msat_arg_conv = *(LDKCOption_u64Z*)(((uint64_t)htlc_maximum_msat_arg) & ~1);
24061 LDKRoutingFees fees_arg_conv;
24062 fees_arg_conv.inner = (void*)(fees_arg & (~1));
24063 fees_arg_conv.is_owned = (fees_arg & 1) || (fees_arg == 0);
24064 fees_arg_conv = RoutingFees_clone(&fees_arg_conv);
24065 LDKChannelUpdate last_update_message_arg_conv;
24066 last_update_message_arg_conv.inner = (void*)(last_update_message_arg & (~1));
24067 last_update_message_arg_conv.is_owned = (last_update_message_arg & 1) || (last_update_message_arg == 0);
24068 last_update_message_arg_conv = ChannelUpdate_clone(&last_update_message_arg_conv);
24069 LDKDirectionalChannelInfo ret_var = DirectionalChannelInfo_new(last_update_arg, enabled_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg, htlc_maximum_msat_arg_conv, fees_arg_conv, last_update_message_arg_conv);
24070 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24071 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24072 uint64_t ret_ref = (uint64_t)ret_var.inner;
24073 if (ret_var.is_owned) {
24079 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1clone(JNIEnv *env, jclass clz, int64_t orig) {
24080 LDKDirectionalChannelInfo orig_conv;
24081 orig_conv.inner = (void*)(orig & (~1));
24082 orig_conv.is_owned = false;
24083 LDKDirectionalChannelInfo ret_var = DirectionalChannelInfo_clone(&orig_conv);
24084 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24085 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24086 uint64_t ret_ref = (uint64_t)ret_var.inner;
24087 if (ret_var.is_owned) {
24093 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1write(JNIEnv *env, jclass clz, int64_t obj) {
24094 LDKDirectionalChannelInfo obj_conv;
24095 obj_conv.inner = (void*)(obj & (~1));
24096 obj_conv.is_owned = false;
24097 LDKCVec_u8Z ret_var = DirectionalChannelInfo_write(&obj_conv);
24098 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
24099 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
24100 CVec_u8Z_free(ret_var);
24104 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
24105 LDKu8slice ser_ref;
24106 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
24107 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
24108 LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ");
24109 *ret_conv = DirectionalChannelInfo_read(ser_ref);
24110 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
24111 return (uint64_t)ret_conv;
24114 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
24115 LDKChannelInfo this_obj_conv;
24116 this_obj_conv.inner = (void*)(this_obj & (~1));
24117 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
24118 ChannelInfo_free(this_obj_conv);
24121 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1get_1features(JNIEnv *env, jclass clz, int64_t this_ptr) {
24122 LDKChannelInfo this_ptr_conv;
24123 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24124 this_ptr_conv.is_owned = false;
24125 LDKChannelFeatures ret_var = ChannelInfo_get_features(&this_ptr_conv);
24126 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24127 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24128 uint64_t ret_ref = (uint64_t)ret_var.inner;
24129 if (ret_var.is_owned) {
24135 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1set_1features(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
24136 LDKChannelInfo this_ptr_conv;
24137 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24138 this_ptr_conv.is_owned = false;
24139 LDKChannelFeatures val_conv;
24140 val_conv.inner = (void*)(val & (~1));
24141 val_conv.is_owned = (val & 1) || (val == 0);
24142 val_conv = ChannelFeatures_clone(&val_conv);
24143 ChannelInfo_set_features(&this_ptr_conv, val_conv);
24146 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1get_1node_1one(JNIEnv *env, jclass clz, int64_t this_ptr) {
24147 LDKChannelInfo this_ptr_conv;
24148 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24149 this_ptr_conv.is_owned = false;
24150 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
24151 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ChannelInfo_get_node_one(&this_ptr_conv).compressed_form);
24155 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1set_1node_1one(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
24156 LDKChannelInfo this_ptr_conv;
24157 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24158 this_ptr_conv.is_owned = false;
24159 LDKPublicKey val_ref;
24160 CHECK((*env)->GetArrayLength(env, val) == 33);
24161 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
24162 ChannelInfo_set_node_one(&this_ptr_conv, val_ref);
24165 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1get_1one_1to_1two(JNIEnv *env, jclass clz, int64_t this_ptr) {
24166 LDKChannelInfo this_ptr_conv;
24167 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24168 this_ptr_conv.is_owned = false;
24169 LDKDirectionalChannelInfo ret_var = ChannelInfo_get_one_to_two(&this_ptr_conv);
24170 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24171 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24172 uint64_t ret_ref = (uint64_t)ret_var.inner;
24173 if (ret_var.is_owned) {
24179 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1set_1one_1to_1two(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
24180 LDKChannelInfo this_ptr_conv;
24181 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24182 this_ptr_conv.is_owned = false;
24183 LDKDirectionalChannelInfo val_conv;
24184 val_conv.inner = (void*)(val & (~1));
24185 val_conv.is_owned = (val & 1) || (val == 0);
24186 val_conv = DirectionalChannelInfo_clone(&val_conv);
24187 ChannelInfo_set_one_to_two(&this_ptr_conv, val_conv);
24190 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1get_1node_1two(JNIEnv *env, jclass clz, int64_t this_ptr) {
24191 LDKChannelInfo this_ptr_conv;
24192 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24193 this_ptr_conv.is_owned = false;
24194 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
24195 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ChannelInfo_get_node_two(&this_ptr_conv).compressed_form);
24199 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1set_1node_1two(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
24200 LDKChannelInfo this_ptr_conv;
24201 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24202 this_ptr_conv.is_owned = false;
24203 LDKPublicKey val_ref;
24204 CHECK((*env)->GetArrayLength(env, val) == 33);
24205 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
24206 ChannelInfo_set_node_two(&this_ptr_conv, val_ref);
24209 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1get_1two_1to_1one(JNIEnv *env, jclass clz, int64_t this_ptr) {
24210 LDKChannelInfo this_ptr_conv;
24211 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24212 this_ptr_conv.is_owned = false;
24213 LDKDirectionalChannelInfo ret_var = ChannelInfo_get_two_to_one(&this_ptr_conv);
24214 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24215 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24216 uint64_t ret_ref = (uint64_t)ret_var.inner;
24217 if (ret_var.is_owned) {
24223 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1set_1two_1to_1one(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
24224 LDKChannelInfo this_ptr_conv;
24225 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24226 this_ptr_conv.is_owned = false;
24227 LDKDirectionalChannelInfo val_conv;
24228 val_conv.inner = (void*)(val & (~1));
24229 val_conv.is_owned = (val & 1) || (val == 0);
24230 val_conv = DirectionalChannelInfo_clone(&val_conv);
24231 ChannelInfo_set_two_to_one(&this_ptr_conv, val_conv);
24234 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1get_1capacity_1sats(JNIEnv *env, jclass clz, int64_t this_ptr) {
24235 LDKChannelInfo this_ptr_conv;
24236 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24237 this_ptr_conv.is_owned = false;
24238 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
24239 *ret_copy = ChannelInfo_get_capacity_sats(&this_ptr_conv);
24240 uint64_t ret_ref = (uint64_t)ret_copy;
24244 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1set_1capacity_1sats(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
24245 LDKChannelInfo this_ptr_conv;
24246 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24247 this_ptr_conv.is_owned = false;
24248 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(((uint64_t)val) & ~1);
24249 ChannelInfo_set_capacity_sats(&this_ptr_conv, val_conv);
24252 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1get_1announcement_1message(JNIEnv *env, jclass clz, int64_t this_ptr) {
24253 LDKChannelInfo this_ptr_conv;
24254 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24255 this_ptr_conv.is_owned = false;
24256 LDKChannelAnnouncement ret_var = ChannelInfo_get_announcement_message(&this_ptr_conv);
24257 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24258 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24259 uint64_t ret_ref = (uint64_t)ret_var.inner;
24260 if (ret_var.is_owned) {
24266 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1set_1announcement_1message(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
24267 LDKChannelInfo this_ptr_conv;
24268 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24269 this_ptr_conv.is_owned = false;
24270 LDKChannelAnnouncement val_conv;
24271 val_conv.inner = (void*)(val & (~1));
24272 val_conv.is_owned = (val & 1) || (val == 0);
24273 val_conv = ChannelAnnouncement_clone(&val_conv);
24274 ChannelInfo_set_announcement_message(&this_ptr_conv, val_conv);
24277 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1new(JNIEnv *env, jclass clz, int64_t features_arg, int8_tArray node_one_arg, int64_t one_to_two_arg, int8_tArray node_two_arg, int64_t two_to_one_arg, int64_t capacity_sats_arg, int64_t announcement_message_arg) {
24278 LDKChannelFeatures features_arg_conv;
24279 features_arg_conv.inner = (void*)(features_arg & (~1));
24280 features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0);
24281 features_arg_conv = ChannelFeatures_clone(&features_arg_conv);
24282 LDKPublicKey node_one_arg_ref;
24283 CHECK((*env)->GetArrayLength(env, node_one_arg) == 33);
24284 (*env)->GetByteArrayRegion(env, node_one_arg, 0, 33, node_one_arg_ref.compressed_form);
24285 LDKDirectionalChannelInfo one_to_two_arg_conv;
24286 one_to_two_arg_conv.inner = (void*)(one_to_two_arg & (~1));
24287 one_to_two_arg_conv.is_owned = (one_to_two_arg & 1) || (one_to_two_arg == 0);
24288 one_to_two_arg_conv = DirectionalChannelInfo_clone(&one_to_two_arg_conv);
24289 LDKPublicKey node_two_arg_ref;
24290 CHECK((*env)->GetArrayLength(env, node_two_arg) == 33);
24291 (*env)->GetByteArrayRegion(env, node_two_arg, 0, 33, node_two_arg_ref.compressed_form);
24292 LDKDirectionalChannelInfo two_to_one_arg_conv;
24293 two_to_one_arg_conv.inner = (void*)(two_to_one_arg & (~1));
24294 two_to_one_arg_conv.is_owned = (two_to_one_arg & 1) || (two_to_one_arg == 0);
24295 two_to_one_arg_conv = DirectionalChannelInfo_clone(&two_to_one_arg_conv);
24296 LDKCOption_u64Z capacity_sats_arg_conv = *(LDKCOption_u64Z*)(((uint64_t)capacity_sats_arg) & ~1);
24297 LDKChannelAnnouncement announcement_message_arg_conv;
24298 announcement_message_arg_conv.inner = (void*)(announcement_message_arg & (~1));
24299 announcement_message_arg_conv.is_owned = (announcement_message_arg & 1) || (announcement_message_arg == 0);
24300 announcement_message_arg_conv = ChannelAnnouncement_clone(&announcement_message_arg_conv);
24301 LDKChannelInfo ret_var = ChannelInfo_new(features_arg_conv, node_one_arg_ref, one_to_two_arg_conv, node_two_arg_ref, two_to_one_arg_conv, capacity_sats_arg_conv, announcement_message_arg_conv);
24302 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24303 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24304 uint64_t ret_ref = (uint64_t)ret_var.inner;
24305 if (ret_var.is_owned) {
24311 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1clone(JNIEnv *env, jclass clz, int64_t orig) {
24312 LDKChannelInfo orig_conv;
24313 orig_conv.inner = (void*)(orig & (~1));
24314 orig_conv.is_owned = false;
24315 LDKChannelInfo ret_var = ChannelInfo_clone(&orig_conv);
24316 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24317 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24318 uint64_t ret_ref = (uint64_t)ret_var.inner;
24319 if (ret_var.is_owned) {
24325 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1write(JNIEnv *env, jclass clz, int64_t obj) {
24326 LDKChannelInfo obj_conv;
24327 obj_conv.inner = (void*)(obj & (~1));
24328 obj_conv.is_owned = false;
24329 LDKCVec_u8Z ret_var = ChannelInfo_write(&obj_conv);
24330 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
24331 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
24332 CVec_u8Z_free(ret_var);
24336 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
24337 LDKu8slice ser_ref;
24338 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
24339 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
24340 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
24341 *ret_conv = ChannelInfo_read(ser_ref);
24342 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
24343 return (uint64_t)ret_conv;
24346 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RoutingFees_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
24347 LDKRoutingFees this_obj_conv;
24348 this_obj_conv.inner = (void*)(this_obj & (~1));
24349 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
24350 RoutingFees_free(this_obj_conv);
24353 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_RoutingFees_1get_1base_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
24354 LDKRoutingFees this_ptr_conv;
24355 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24356 this_ptr_conv.is_owned = false;
24357 int32_t ret_val = RoutingFees_get_base_msat(&this_ptr_conv);
24361 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RoutingFees_1set_1base_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
24362 LDKRoutingFees this_ptr_conv;
24363 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24364 this_ptr_conv.is_owned = false;
24365 RoutingFees_set_base_msat(&this_ptr_conv, val);
24368 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_RoutingFees_1get_1proportional_1millionths(JNIEnv *env, jclass clz, int64_t this_ptr) {
24369 LDKRoutingFees this_ptr_conv;
24370 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24371 this_ptr_conv.is_owned = false;
24372 int32_t ret_val = RoutingFees_get_proportional_millionths(&this_ptr_conv);
24376 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RoutingFees_1set_1proportional_1millionths(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
24377 LDKRoutingFees this_ptr_conv;
24378 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24379 this_ptr_conv.is_owned = false;
24380 RoutingFees_set_proportional_millionths(&this_ptr_conv, val);
24383 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RoutingFees_1new(JNIEnv *env, jclass clz, int32_t base_msat_arg, int32_t proportional_millionths_arg) {
24384 LDKRoutingFees ret_var = RoutingFees_new(base_msat_arg, proportional_millionths_arg);
24385 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24386 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24387 uint64_t ret_ref = (uint64_t)ret_var.inner;
24388 if (ret_var.is_owned) {
24394 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_RoutingFees_1eq(JNIEnv *env, jclass clz, int64_t a, int64_t b) {
24395 LDKRoutingFees a_conv;
24396 a_conv.inner = (void*)(a & (~1));
24397 a_conv.is_owned = false;
24398 LDKRoutingFees b_conv;
24399 b_conv.inner = (void*)(b & (~1));
24400 b_conv.is_owned = false;
24401 jboolean ret_val = RoutingFees_eq(&a_conv, &b_conv);
24405 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RoutingFees_1clone(JNIEnv *env, jclass clz, int64_t orig) {
24406 LDKRoutingFees orig_conv;
24407 orig_conv.inner = (void*)(orig & (~1));
24408 orig_conv.is_owned = false;
24409 LDKRoutingFees ret_var = RoutingFees_clone(&orig_conv);
24410 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24411 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24412 uint64_t ret_ref = (uint64_t)ret_var.inner;
24413 if (ret_var.is_owned) {
24419 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_RoutingFees_1write(JNIEnv *env, jclass clz, int64_t obj) {
24420 LDKRoutingFees obj_conv;
24421 obj_conv.inner = (void*)(obj & (~1));
24422 obj_conv.is_owned = false;
24423 LDKCVec_u8Z ret_var = RoutingFees_write(&obj_conv);
24424 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
24425 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
24426 CVec_u8Z_free(ret_var);
24430 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RoutingFees_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
24431 LDKu8slice ser_ref;
24432 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
24433 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
24434 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
24435 *ret_conv = RoutingFees_read(ser_ref);
24436 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
24437 return (uint64_t)ret_conv;
24440 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
24441 LDKNodeAnnouncementInfo this_obj_conv;
24442 this_obj_conv.inner = (void*)(this_obj & (~1));
24443 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
24444 NodeAnnouncementInfo_free(this_obj_conv);
24447 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1get_1features(JNIEnv *env, jclass clz, int64_t this_ptr) {
24448 LDKNodeAnnouncementInfo this_ptr_conv;
24449 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24450 this_ptr_conv.is_owned = false;
24451 LDKNodeFeatures ret_var = NodeAnnouncementInfo_get_features(&this_ptr_conv);
24452 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24453 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24454 uint64_t ret_ref = (uint64_t)ret_var.inner;
24455 if (ret_var.is_owned) {
24461 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1set_1features(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
24462 LDKNodeAnnouncementInfo this_ptr_conv;
24463 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24464 this_ptr_conv.is_owned = false;
24465 LDKNodeFeatures val_conv;
24466 val_conv.inner = (void*)(val & (~1));
24467 val_conv.is_owned = (val & 1) || (val == 0);
24468 val_conv = NodeFeatures_clone(&val_conv);
24469 NodeAnnouncementInfo_set_features(&this_ptr_conv, val_conv);
24472 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1get_1last_1update(JNIEnv *env, jclass clz, int64_t this_ptr) {
24473 LDKNodeAnnouncementInfo this_ptr_conv;
24474 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24475 this_ptr_conv.is_owned = false;
24476 int32_t ret_val = NodeAnnouncementInfo_get_last_update(&this_ptr_conv);
24480 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1set_1last_1update(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
24481 LDKNodeAnnouncementInfo this_ptr_conv;
24482 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24483 this_ptr_conv.is_owned = false;
24484 NodeAnnouncementInfo_set_last_update(&this_ptr_conv, val);
24487 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1get_1rgb(JNIEnv *env, jclass clz, int64_t this_ptr) {
24488 LDKNodeAnnouncementInfo this_ptr_conv;
24489 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24490 this_ptr_conv.is_owned = false;
24491 int8_tArray ret_arr = (*env)->NewByteArray(env, 3);
24492 (*env)->SetByteArrayRegion(env, ret_arr, 0, 3, *NodeAnnouncementInfo_get_rgb(&this_ptr_conv));
24496 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1set_1rgb(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
24497 LDKNodeAnnouncementInfo this_ptr_conv;
24498 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24499 this_ptr_conv.is_owned = false;
24500 LDKThreeBytes val_ref;
24501 CHECK((*env)->GetArrayLength(env, val) == 3);
24502 (*env)->GetByteArrayRegion(env, val, 0, 3, val_ref.data);
24503 NodeAnnouncementInfo_set_rgb(&this_ptr_conv, val_ref);
24506 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1get_1alias(JNIEnv *env, jclass clz, int64_t this_ptr) {
24507 LDKNodeAnnouncementInfo this_ptr_conv;
24508 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24509 this_ptr_conv.is_owned = false;
24510 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
24511 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *NodeAnnouncementInfo_get_alias(&this_ptr_conv));
24515 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1set_1alias(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
24516 LDKNodeAnnouncementInfo this_ptr_conv;
24517 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24518 this_ptr_conv.is_owned = false;
24519 LDKThirtyTwoBytes val_ref;
24520 CHECK((*env)->GetArrayLength(env, val) == 32);
24521 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
24522 NodeAnnouncementInfo_set_alias(&this_ptr_conv, val_ref);
24525 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1set_1addresses(JNIEnv *env, jclass clz, int64_t this_ptr, int64_tArray val) {
24526 LDKNodeAnnouncementInfo this_ptr_conv;
24527 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24528 this_ptr_conv.is_owned = false;
24529 LDKCVec_NetAddressZ val_constr;
24530 val_constr.datalen = (*env)->GetArrayLength(env, val);
24531 if (val_constr.datalen > 0)
24532 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
24534 val_constr.data = NULL;
24535 int64_t* val_vals = (*env)->GetLongArrayElements (env, val, NULL);
24536 for (size_t m = 0; m < val_constr.datalen; m++) {
24537 int64_t val_conv_12 = val_vals[m];
24538 LDKNetAddress val_conv_12_conv = *(LDKNetAddress*)(((uint64_t)val_conv_12) & ~1);
24539 val_conv_12_conv = NetAddress_clone((LDKNetAddress*)(((uint64_t)val_conv_12) & ~1));
24540 val_constr.data[m] = val_conv_12_conv;
24542 (*env)->ReleaseLongArrayElements(env, val, val_vals, 0);
24543 NodeAnnouncementInfo_set_addresses(&this_ptr_conv, val_constr);
24546 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1get_1announcement_1message(JNIEnv *env, jclass clz, int64_t this_ptr) {
24547 LDKNodeAnnouncementInfo this_ptr_conv;
24548 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24549 this_ptr_conv.is_owned = false;
24550 LDKNodeAnnouncement ret_var = NodeAnnouncementInfo_get_announcement_message(&this_ptr_conv);
24551 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24552 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24553 uint64_t ret_ref = (uint64_t)ret_var.inner;
24554 if (ret_var.is_owned) {
24560 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1set_1announcement_1message(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
24561 LDKNodeAnnouncementInfo this_ptr_conv;
24562 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24563 this_ptr_conv.is_owned = false;
24564 LDKNodeAnnouncement val_conv;
24565 val_conv.inner = (void*)(val & (~1));
24566 val_conv.is_owned = (val & 1) || (val == 0);
24567 val_conv = NodeAnnouncement_clone(&val_conv);
24568 NodeAnnouncementInfo_set_announcement_message(&this_ptr_conv, val_conv);
24571 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1new(JNIEnv *env, jclass clz, int64_t features_arg, int32_t last_update_arg, int8_tArray rgb_arg, int8_tArray alias_arg, int64_tArray addresses_arg, int64_t announcement_message_arg) {
24572 LDKNodeFeatures features_arg_conv;
24573 features_arg_conv.inner = (void*)(features_arg & (~1));
24574 features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0);
24575 features_arg_conv = NodeFeatures_clone(&features_arg_conv);
24576 LDKThreeBytes rgb_arg_ref;
24577 CHECK((*env)->GetArrayLength(env, rgb_arg) == 3);
24578 (*env)->GetByteArrayRegion(env, rgb_arg, 0, 3, rgb_arg_ref.data);
24579 LDKThirtyTwoBytes alias_arg_ref;
24580 CHECK((*env)->GetArrayLength(env, alias_arg) == 32);
24581 (*env)->GetByteArrayRegion(env, alias_arg, 0, 32, alias_arg_ref.data);
24582 LDKCVec_NetAddressZ addresses_arg_constr;
24583 addresses_arg_constr.datalen = (*env)->GetArrayLength(env, addresses_arg);
24584 if (addresses_arg_constr.datalen > 0)
24585 addresses_arg_constr.data = MALLOC(addresses_arg_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
24587 addresses_arg_constr.data = NULL;
24588 int64_t* addresses_arg_vals = (*env)->GetLongArrayElements (env, addresses_arg, NULL);
24589 for (size_t m = 0; m < addresses_arg_constr.datalen; m++) {
24590 int64_t addresses_arg_conv_12 = addresses_arg_vals[m];
24591 LDKNetAddress addresses_arg_conv_12_conv = *(LDKNetAddress*)(((uint64_t)addresses_arg_conv_12) & ~1);
24592 addresses_arg_constr.data[m] = addresses_arg_conv_12_conv;
24594 (*env)->ReleaseLongArrayElements(env, addresses_arg, addresses_arg_vals, 0);
24595 LDKNodeAnnouncement announcement_message_arg_conv;
24596 announcement_message_arg_conv.inner = (void*)(announcement_message_arg & (~1));
24597 announcement_message_arg_conv.is_owned = (announcement_message_arg & 1) || (announcement_message_arg == 0);
24598 announcement_message_arg_conv = NodeAnnouncement_clone(&announcement_message_arg_conv);
24599 LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_new(features_arg_conv, last_update_arg, rgb_arg_ref, alias_arg_ref, addresses_arg_constr, announcement_message_arg_conv);
24600 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24601 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24602 uint64_t ret_ref = (uint64_t)ret_var.inner;
24603 if (ret_var.is_owned) {
24609 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1clone(JNIEnv *env, jclass clz, int64_t orig) {
24610 LDKNodeAnnouncementInfo orig_conv;
24611 orig_conv.inner = (void*)(orig & (~1));
24612 orig_conv.is_owned = false;
24613 LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_clone(&orig_conv);
24614 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24615 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24616 uint64_t ret_ref = (uint64_t)ret_var.inner;
24617 if (ret_var.is_owned) {
24623 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1write(JNIEnv *env, jclass clz, int64_t obj) {
24624 LDKNodeAnnouncementInfo obj_conv;
24625 obj_conv.inner = (void*)(obj & (~1));
24626 obj_conv.is_owned = false;
24627 LDKCVec_u8Z ret_var = NodeAnnouncementInfo_write(&obj_conv);
24628 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
24629 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
24630 CVec_u8Z_free(ret_var);
24634 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
24635 LDKu8slice ser_ref;
24636 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
24637 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
24638 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
24639 *ret_conv = NodeAnnouncementInfo_read(ser_ref);
24640 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
24641 return (uint64_t)ret_conv;
24644 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NodeInfo_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
24645 LDKNodeInfo this_obj_conv;
24646 this_obj_conv.inner = (void*)(this_obj & (~1));
24647 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
24648 NodeInfo_free(this_obj_conv);
24651 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NodeInfo_1set_1channels(JNIEnv *env, jclass clz, int64_t this_ptr, int64_tArray val) {
24652 LDKNodeInfo this_ptr_conv;
24653 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24654 this_ptr_conv.is_owned = false;
24655 LDKCVec_u64Z val_constr;
24656 val_constr.datalen = (*env)->GetArrayLength(env, val);
24657 if (val_constr.datalen > 0)
24658 val_constr.data = MALLOC(val_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
24660 val_constr.data = NULL;
24661 int64_t* val_vals = (*env)->GetLongArrayElements (env, val, NULL);
24662 for (size_t g = 0; g < val_constr.datalen; g++) {
24663 int64_t val_conv_6 = val_vals[g];
24664 val_constr.data[g] = val_conv_6;
24666 (*env)->ReleaseLongArrayElements(env, val, val_vals, 0);
24667 NodeInfo_set_channels(&this_ptr_conv, val_constr);
24670 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeInfo_1get_1lowest_1inbound_1channel_1fees(JNIEnv *env, jclass clz, int64_t this_ptr) {
24671 LDKNodeInfo this_ptr_conv;
24672 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24673 this_ptr_conv.is_owned = false;
24674 LDKRoutingFees ret_var = NodeInfo_get_lowest_inbound_channel_fees(&this_ptr_conv);
24675 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24676 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24677 uint64_t ret_ref = (uint64_t)ret_var.inner;
24678 if (ret_var.is_owned) {
24684 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NodeInfo_1set_1lowest_1inbound_1channel_1fees(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
24685 LDKNodeInfo this_ptr_conv;
24686 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24687 this_ptr_conv.is_owned = false;
24688 LDKRoutingFees val_conv;
24689 val_conv.inner = (void*)(val & (~1));
24690 val_conv.is_owned = (val & 1) || (val == 0);
24691 val_conv = RoutingFees_clone(&val_conv);
24692 NodeInfo_set_lowest_inbound_channel_fees(&this_ptr_conv, val_conv);
24695 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeInfo_1get_1announcement_1info(JNIEnv *env, jclass clz, int64_t this_ptr) {
24696 LDKNodeInfo this_ptr_conv;
24697 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24698 this_ptr_conv.is_owned = false;
24699 LDKNodeAnnouncementInfo ret_var = NodeInfo_get_announcement_info(&this_ptr_conv);
24700 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24701 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24702 uint64_t ret_ref = (uint64_t)ret_var.inner;
24703 if (ret_var.is_owned) {
24709 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NodeInfo_1set_1announcement_1info(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
24710 LDKNodeInfo this_ptr_conv;
24711 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24712 this_ptr_conv.is_owned = false;
24713 LDKNodeAnnouncementInfo val_conv;
24714 val_conv.inner = (void*)(val & (~1));
24715 val_conv.is_owned = (val & 1) || (val == 0);
24716 val_conv = NodeAnnouncementInfo_clone(&val_conv);
24717 NodeInfo_set_announcement_info(&this_ptr_conv, val_conv);
24720 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeInfo_1new(JNIEnv *env, jclass clz, int64_tArray channels_arg, int64_t lowest_inbound_channel_fees_arg, int64_t announcement_info_arg) {
24721 LDKCVec_u64Z channels_arg_constr;
24722 channels_arg_constr.datalen = (*env)->GetArrayLength(env, channels_arg);
24723 if (channels_arg_constr.datalen > 0)
24724 channels_arg_constr.data = MALLOC(channels_arg_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
24726 channels_arg_constr.data = NULL;
24727 int64_t* channels_arg_vals = (*env)->GetLongArrayElements (env, channels_arg, NULL);
24728 for (size_t g = 0; g < channels_arg_constr.datalen; g++) {
24729 int64_t channels_arg_conv_6 = channels_arg_vals[g];
24730 channels_arg_constr.data[g] = channels_arg_conv_6;
24732 (*env)->ReleaseLongArrayElements(env, channels_arg, channels_arg_vals, 0);
24733 LDKRoutingFees lowest_inbound_channel_fees_arg_conv;
24734 lowest_inbound_channel_fees_arg_conv.inner = (void*)(lowest_inbound_channel_fees_arg & (~1));
24735 lowest_inbound_channel_fees_arg_conv.is_owned = (lowest_inbound_channel_fees_arg & 1) || (lowest_inbound_channel_fees_arg == 0);
24736 lowest_inbound_channel_fees_arg_conv = RoutingFees_clone(&lowest_inbound_channel_fees_arg_conv);
24737 LDKNodeAnnouncementInfo announcement_info_arg_conv;
24738 announcement_info_arg_conv.inner = (void*)(announcement_info_arg & (~1));
24739 announcement_info_arg_conv.is_owned = (announcement_info_arg & 1) || (announcement_info_arg == 0);
24740 announcement_info_arg_conv = NodeAnnouncementInfo_clone(&announcement_info_arg_conv);
24741 LDKNodeInfo ret_var = NodeInfo_new(channels_arg_constr, lowest_inbound_channel_fees_arg_conv, announcement_info_arg_conv);
24742 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24743 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24744 uint64_t ret_ref = (uint64_t)ret_var.inner;
24745 if (ret_var.is_owned) {
24751 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeInfo_1clone(JNIEnv *env, jclass clz, int64_t orig) {
24752 LDKNodeInfo orig_conv;
24753 orig_conv.inner = (void*)(orig & (~1));
24754 orig_conv.is_owned = false;
24755 LDKNodeInfo ret_var = NodeInfo_clone(&orig_conv);
24756 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24757 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24758 uint64_t ret_ref = (uint64_t)ret_var.inner;
24759 if (ret_var.is_owned) {
24765 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_NodeInfo_1write(JNIEnv *env, jclass clz, int64_t obj) {
24766 LDKNodeInfo obj_conv;
24767 obj_conv.inner = (void*)(obj & (~1));
24768 obj_conv.is_owned = false;
24769 LDKCVec_u8Z ret_var = NodeInfo_write(&obj_conv);
24770 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
24771 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
24772 CVec_u8Z_free(ret_var);
24776 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeInfo_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
24777 LDKu8slice ser_ref;
24778 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
24779 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
24780 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
24781 *ret_conv = NodeInfo_read(ser_ref);
24782 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
24783 return (uint64_t)ret_conv;
24786 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_NetworkGraph_1write(JNIEnv *env, jclass clz, int64_t obj) {
24787 LDKNetworkGraph obj_conv;
24788 obj_conv.inner = (void*)(obj & (~1));
24789 obj_conv.is_owned = false;
24790 LDKCVec_u8Z ret_var = NetworkGraph_write(&obj_conv);
24791 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
24792 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
24793 CVec_u8Z_free(ret_var);
24797 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetworkGraph_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
24798 LDKu8slice ser_ref;
24799 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
24800 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
24801 LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
24802 *ret_conv = NetworkGraph_read(ser_ref);
24803 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
24804 return (uint64_t)ret_conv;
24807 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetworkGraph_1new(JNIEnv *env, jclass clz, int8_tArray genesis_hash) {
24808 LDKThirtyTwoBytes genesis_hash_ref;
24809 CHECK((*env)->GetArrayLength(env, genesis_hash) == 32);
24810 (*env)->GetByteArrayRegion(env, genesis_hash, 0, 32, genesis_hash_ref.data);
24811 LDKNetworkGraph ret_var = NetworkGraph_new(genesis_hash_ref);
24812 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24813 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24814 uint64_t ret_ref = (uint64_t)ret_var.inner;
24815 if (ret_var.is_owned) {
24821 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetworkGraph_1update_1node_1from_1announcement(JNIEnv *env, jclass clz, int64_t this_arg, int64_t msg) {
24822 LDKNetworkGraph this_arg_conv;
24823 this_arg_conv.inner = (void*)(this_arg & (~1));
24824 this_arg_conv.is_owned = false;
24825 LDKNodeAnnouncement msg_conv;
24826 msg_conv.inner = (void*)(msg & (~1));
24827 msg_conv.is_owned = false;
24828 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
24829 *ret_conv = NetworkGraph_update_node_from_announcement(&this_arg_conv, &msg_conv);
24830 return (uint64_t)ret_conv;
24833 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetworkGraph_1update_1node_1from_1unsigned_1announcement(JNIEnv *env, jclass clz, int64_t this_arg, int64_t msg) {
24834 LDKNetworkGraph this_arg_conv;
24835 this_arg_conv.inner = (void*)(this_arg & (~1));
24836 this_arg_conv.is_owned = false;
24837 LDKUnsignedNodeAnnouncement msg_conv;
24838 msg_conv.inner = (void*)(msg & (~1));
24839 msg_conv.is_owned = false;
24840 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
24841 *ret_conv = NetworkGraph_update_node_from_unsigned_announcement(&this_arg_conv, &msg_conv);
24842 return (uint64_t)ret_conv;
24845 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetworkGraph_1update_1channel_1from_1announcement(JNIEnv *env, jclass clz, int64_t this_arg, int64_t msg, int64_t chain_access) {
24846 LDKNetworkGraph this_arg_conv;
24847 this_arg_conv.inner = (void*)(this_arg & (~1));
24848 this_arg_conv.is_owned = false;
24849 LDKChannelAnnouncement msg_conv;
24850 msg_conv.inner = (void*)(msg & (~1));
24851 msg_conv.is_owned = false;
24852 LDKAccess *chain_access_conv_ptr = NULL;
24853 if (chain_access != 0) {
24854 LDKAccess chain_access_conv;
24855 chain_access_conv = *(LDKAccess*)(((uint64_t)chain_access) & ~1);
24856 if (chain_access_conv.free == LDKAccess_JCalls_free) {
24857 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
24858 LDKAccess_JCalls_clone(chain_access_conv.this_arg);
24860 chain_access_conv_ptr = MALLOC(sizeof(LDKAccess), "LDKAccess");
24861 *chain_access_conv_ptr = chain_access_conv;
24863 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
24864 *ret_conv = NetworkGraph_update_channel_from_announcement(&this_arg_conv, &msg_conv, chain_access_conv_ptr);
24865 return (uint64_t)ret_conv;
24868 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetworkGraph_1update_1channel_1from_1unsigned_1announcement(JNIEnv *env, jclass clz, int64_t this_arg, int64_t msg, int64_t chain_access) {
24869 LDKNetworkGraph this_arg_conv;
24870 this_arg_conv.inner = (void*)(this_arg & (~1));
24871 this_arg_conv.is_owned = false;
24872 LDKUnsignedChannelAnnouncement msg_conv;
24873 msg_conv.inner = (void*)(msg & (~1));
24874 msg_conv.is_owned = false;
24875 LDKAccess *chain_access_conv_ptr = NULL;
24876 if (chain_access != 0) {
24877 LDKAccess chain_access_conv;
24878 chain_access_conv = *(LDKAccess*)(((uint64_t)chain_access) & ~1);
24879 if (chain_access_conv.free == LDKAccess_JCalls_free) {
24880 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
24881 LDKAccess_JCalls_clone(chain_access_conv.this_arg);
24883 chain_access_conv_ptr = MALLOC(sizeof(LDKAccess), "LDKAccess");
24884 *chain_access_conv_ptr = chain_access_conv;
24886 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
24887 *ret_conv = NetworkGraph_update_channel_from_unsigned_announcement(&this_arg_conv, &msg_conv, chain_access_conv_ptr);
24888 return (uint64_t)ret_conv;
24891 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NetworkGraph_1close_1channel_1from_1update(JNIEnv *env, jclass clz, int64_t this_arg, int64_t short_channel_id, jboolean is_permanent) {
24892 LDKNetworkGraph this_arg_conv;
24893 this_arg_conv.inner = (void*)(this_arg & (~1));
24894 this_arg_conv.is_owned = false;
24895 NetworkGraph_close_channel_from_update(&this_arg_conv, short_channel_id, is_permanent);
24898 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetworkGraph_1update_1channel(JNIEnv *env, jclass clz, int64_t this_arg, int64_t msg) {
24899 LDKNetworkGraph this_arg_conv;
24900 this_arg_conv.inner = (void*)(this_arg & (~1));
24901 this_arg_conv.is_owned = false;
24902 LDKChannelUpdate msg_conv;
24903 msg_conv.inner = (void*)(msg & (~1));
24904 msg_conv.is_owned = false;
24905 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
24906 *ret_conv = NetworkGraph_update_channel(&this_arg_conv, &msg_conv);
24907 return (uint64_t)ret_conv;
24910 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetworkGraph_1update_1channel_1unsigned(JNIEnv *env, jclass clz, int64_t this_arg, int64_t msg) {
24911 LDKNetworkGraph this_arg_conv;
24912 this_arg_conv.inner = (void*)(this_arg & (~1));
24913 this_arg_conv.is_owned = false;
24914 LDKUnsignedChannelUpdate msg_conv;
24915 msg_conv.inner = (void*)(msg & (~1));
24916 msg_conv.is_owned = false;
24917 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
24918 *ret_conv = NetworkGraph_update_channel_unsigned(&this_arg_conv, &msg_conv);
24919 return (uint64_t)ret_conv;
24922 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_FilesystemPersister_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
24923 LDKFilesystemPersister this_obj_conv;
24924 this_obj_conv.inner = (void*)(this_obj & (~1));
24925 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
24926 FilesystemPersister_free(this_obj_conv);
24929 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_FilesystemPersister_1new(JNIEnv *env, jclass clz, jstring path_to_channel_data) {
24930 LDKStr path_to_channel_data_conv = java_to_owned_str(env, path_to_channel_data);
24931 LDKFilesystemPersister ret_var = FilesystemPersister_new(path_to_channel_data_conv);
24932 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24933 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24934 uint64_t ret_ref = (uint64_t)ret_var.inner;
24935 if (ret_var.is_owned) {
24941 JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_FilesystemPersister_1get_1data_1dir(JNIEnv *env, jclass clz, int64_t this_arg) {
24942 LDKFilesystemPersister this_arg_conv;
24943 this_arg_conv.inner = (void*)(this_arg & (~1));
24944 this_arg_conv.is_owned = false;
24945 LDKStr ret_str = FilesystemPersister_get_data_dir(&this_arg_conv);
24946 jstring ret_conv = str_ref_to_java(env, ret_str.chars, ret_str.len);
24950 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_FilesystemPersister_1persist_1manager(JNIEnv *env, jclass clz, jstring data_dir, int64_t manager) {
24951 LDKStr data_dir_conv = java_to_owned_str(env, data_dir);
24952 LDKChannelManager manager_conv;
24953 manager_conv.inner = (void*)(manager & (~1));
24954 manager_conv.is_owned = false;
24955 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
24956 *ret_conv = FilesystemPersister_persist_manager(data_dir_conv, &manager_conv);
24957 return (uint64_t)ret_conv;
24960 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_FilesystemPersister_1read_1channelmonitors(JNIEnv *env, jclass clz, int64_t this_arg, int64_t keys_manager) {
24961 LDKFilesystemPersister this_arg_conv;
24962 this_arg_conv.inner = (void*)(this_arg & (~1));
24963 this_arg_conv.is_owned = false;
24964 LDKKeysInterface keys_manager_conv = *(LDKKeysInterface*)(((uint64_t)keys_manager) & ~1);
24965 if (keys_manager_conv.free == LDKKeysInterface_JCalls_free) {
24966 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
24967 LDKKeysInterface_JCalls_clone(keys_manager_conv.this_arg);
24969 LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ), "LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ");
24970 *ret_conv = FilesystemPersister_read_channelmonitors(&this_arg_conv, keys_manager_conv);
24971 return (uint64_t)ret_conv;
24974 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_FilesystemPersister_1as_1Persist(JNIEnv *env, jclass clz, int64_t this_arg) {
24975 LDKFilesystemPersister this_arg_conv;
24976 this_arg_conv.inner = (void*)(this_arg & (~1));
24977 this_arg_conv.is_owned = false;
24978 LDKPersist* ret = MALLOC(sizeof(LDKPersist), "LDKPersist");
24979 *ret = FilesystemPersister_as_Persist(&this_arg_conv);
24980 return (uint64_t)ret;
24983 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_BackgroundProcessor_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
24984 LDKBackgroundProcessor this_obj_conv;
24985 this_obj_conv.inner = (void*)(this_obj & (~1));
24986 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
24987 BackgroundProcessor_free(this_obj_conv);
24990 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelManagerPersister_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
24991 if ((this_ptr & 1) != 0) return;
24992 LDKChannelManagerPersister this_ptr_conv = *(LDKChannelManagerPersister*)(((uint64_t)this_ptr) & ~1);
24993 FREE((void*)this_ptr);
24994 ChannelManagerPersister_free(this_ptr_conv);
24997 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_BackgroundProcessor_1start(JNIEnv *env, jclass clz, int64_t persister, int64_t event_handler, int64_t chain_monitor, int64_t channel_manager, int64_t peer_manager, int64_t logger) {
24998 LDKChannelManagerPersister persister_conv = *(LDKChannelManagerPersister*)(((uint64_t)persister) & ~1);
24999 if (persister_conv.free == LDKChannelManagerPersister_JCalls_free) {
25000 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25001 LDKChannelManagerPersister_JCalls_clone(persister_conv.this_arg);
25003 LDKEventHandler event_handler_conv = *(LDKEventHandler*)(((uint64_t)event_handler) & ~1);
25004 if (event_handler_conv.free == LDKEventHandler_JCalls_free) {
25005 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25006 LDKEventHandler_JCalls_clone(event_handler_conv.this_arg);
25008 LDKChainMonitor chain_monitor_conv;
25009 chain_monitor_conv.inner = (void*)(chain_monitor & (~1));
25010 chain_monitor_conv.is_owned = false;
25011 LDKChannelManager channel_manager_conv;
25012 channel_manager_conv.inner = (void*)(channel_manager & (~1));
25013 channel_manager_conv.is_owned = false;
25014 LDKPeerManager peer_manager_conv;
25015 peer_manager_conv.inner = (void*)(peer_manager & (~1));
25016 peer_manager_conv.is_owned = false;
25017 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
25018 if (logger_conv.free == LDKLogger_JCalls_free) {
25019 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25020 LDKLogger_JCalls_clone(logger_conv.this_arg);
25022 LDKBackgroundProcessor ret_var = BackgroundProcessor_start(persister_conv, event_handler_conv, &chain_monitor_conv, &channel_manager_conv, &peer_manager_conv, logger_conv);
25023 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25024 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25025 uint64_t ret_ref = (uint64_t)ret_var.inner;
25026 if (ret_var.is_owned) {
25032 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_BackgroundProcessor_1stop(JNIEnv *env, jclass clz, int64_t this_arg) {
25033 LDKBackgroundProcessor this_arg_conv;
25034 this_arg_conv.inner = (void*)(this_arg & (~1));
25035 this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
25036 // Warning: we need a move here but no clone is available for LDKBackgroundProcessor
25037 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
25038 *ret_conv = BackgroundProcessor_stop(this_arg_conv);
25039 return (uint64_t)ret_conv;
25042 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_check_1platform(JNIEnv *env, jclass clz) {
25046 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Invoice_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
25047 LDKInvoice this_obj_conv;
25048 this_obj_conv.inner = (void*)(this_obj & (~1));
25049 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
25050 Invoice_free(this_obj_conv);
25053 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_Invoice_1eq(JNIEnv *env, jclass clz, int64_t a, int64_t b) {
25055 a_conv.inner = (void*)(a & (~1));
25056 a_conv.is_owned = false;
25058 b_conv.inner = (void*)(b & (~1));
25059 b_conv.is_owned = false;
25060 jboolean ret_val = Invoice_eq(&a_conv, &b_conv);
25064 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Invoice_1clone(JNIEnv *env, jclass clz, int64_t orig) {
25065 LDKInvoice orig_conv;
25066 orig_conv.inner = (void*)(orig & (~1));
25067 orig_conv.is_owned = false;
25068 LDKInvoice ret_var = Invoice_clone(&orig_conv);
25069 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25070 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25071 uint64_t ret_ref = (uint64_t)ret_var.inner;
25072 if (ret_var.is_owned) {
25078 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_SignedRawInvoice_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
25079 LDKSignedRawInvoice this_obj_conv;
25080 this_obj_conv.inner = (void*)(this_obj & (~1));
25081 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
25082 SignedRawInvoice_free(this_obj_conv);
25085 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_SignedRawInvoice_1eq(JNIEnv *env, jclass clz, int64_t a, int64_t b) {
25086 LDKSignedRawInvoice a_conv;
25087 a_conv.inner = (void*)(a & (~1));
25088 a_conv.is_owned = false;
25089 LDKSignedRawInvoice b_conv;
25090 b_conv.inner = (void*)(b & (~1));
25091 b_conv.is_owned = false;
25092 jboolean ret_val = SignedRawInvoice_eq(&a_conv, &b_conv);
25096 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SignedRawInvoice_1clone(JNIEnv *env, jclass clz, int64_t orig) {
25097 LDKSignedRawInvoice orig_conv;
25098 orig_conv.inner = (void*)(orig & (~1));
25099 orig_conv.is_owned = false;
25100 LDKSignedRawInvoice ret_var = SignedRawInvoice_clone(&orig_conv);
25101 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25102 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25103 uint64_t ret_ref = (uint64_t)ret_var.inner;
25104 if (ret_var.is_owned) {
25110 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RawInvoice_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
25111 LDKRawInvoice this_obj_conv;
25112 this_obj_conv.inner = (void*)(this_obj & (~1));
25113 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
25114 RawInvoice_free(this_obj_conv);
25117 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RawInvoice_1get_1data(JNIEnv *env, jclass clz, int64_t this_ptr) {
25118 LDKRawInvoice this_ptr_conv;
25119 this_ptr_conv.inner = (void*)(this_ptr & (~1));
25120 this_ptr_conv.is_owned = false;
25121 LDKRawDataPart ret_var = RawInvoice_get_data(&this_ptr_conv);
25122 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25123 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25124 uint64_t ret_ref = (uint64_t)ret_var.inner;
25125 if (ret_var.is_owned) {
25131 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RawInvoice_1set_1data(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
25132 LDKRawInvoice this_ptr_conv;
25133 this_ptr_conv.inner = (void*)(this_ptr & (~1));
25134 this_ptr_conv.is_owned = false;
25135 LDKRawDataPart val_conv;
25136 val_conv.inner = (void*)(val & (~1));
25137 val_conv.is_owned = (val & 1) || (val == 0);
25138 val_conv = RawDataPart_clone(&val_conv);
25139 RawInvoice_set_data(&this_ptr_conv, val_conv);
25142 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_RawInvoice_1eq(JNIEnv *env, jclass clz, int64_t a, int64_t b) {
25143 LDKRawInvoice a_conv;
25144 a_conv.inner = (void*)(a & (~1));
25145 a_conv.is_owned = false;
25146 LDKRawInvoice b_conv;
25147 b_conv.inner = (void*)(b & (~1));
25148 b_conv.is_owned = false;
25149 jboolean ret_val = RawInvoice_eq(&a_conv, &b_conv);
25153 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RawInvoice_1clone(JNIEnv *env, jclass clz, int64_t orig) {
25154 LDKRawInvoice orig_conv;
25155 orig_conv.inner = (void*)(orig & (~1));
25156 orig_conv.is_owned = false;
25157 LDKRawInvoice ret_var = RawInvoice_clone(&orig_conv);
25158 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25159 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25160 uint64_t ret_ref = (uint64_t)ret_var.inner;
25161 if (ret_var.is_owned) {
25167 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RawDataPart_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
25168 LDKRawDataPart this_obj_conv;
25169 this_obj_conv.inner = (void*)(this_obj & (~1));
25170 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
25171 RawDataPart_free(this_obj_conv);
25174 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RawDataPart_1get_1timestamp(JNIEnv *env, jclass clz, int64_t this_ptr) {
25175 LDKRawDataPart this_ptr_conv;
25176 this_ptr_conv.inner = (void*)(this_ptr & (~1));
25177 this_ptr_conv.is_owned = false;
25178 LDKPositiveTimestamp ret_var = RawDataPart_get_timestamp(&this_ptr_conv);
25179 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25180 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25181 uint64_t ret_ref = (uint64_t)ret_var.inner;
25182 if (ret_var.is_owned) {
25188 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RawDataPart_1set_1timestamp(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
25189 LDKRawDataPart this_ptr_conv;
25190 this_ptr_conv.inner = (void*)(this_ptr & (~1));
25191 this_ptr_conv.is_owned = false;
25192 LDKPositiveTimestamp val_conv;
25193 val_conv.inner = (void*)(val & (~1));
25194 val_conv.is_owned = (val & 1) || (val == 0);
25195 val_conv = PositiveTimestamp_clone(&val_conv);
25196 RawDataPart_set_timestamp(&this_ptr_conv, val_conv);
25199 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_RawDataPart_1eq(JNIEnv *env, jclass clz, int64_t a, int64_t b) {
25200 LDKRawDataPart a_conv;
25201 a_conv.inner = (void*)(a & (~1));
25202 a_conv.is_owned = false;
25203 LDKRawDataPart b_conv;
25204 b_conv.inner = (void*)(b & (~1));
25205 b_conv.is_owned = false;
25206 jboolean ret_val = RawDataPart_eq(&a_conv, &b_conv);
25210 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RawDataPart_1clone(JNIEnv *env, jclass clz, int64_t orig) {
25211 LDKRawDataPart orig_conv;
25212 orig_conv.inner = (void*)(orig & (~1));
25213 orig_conv.is_owned = false;
25214 LDKRawDataPart ret_var = RawDataPart_clone(&orig_conv);
25215 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25216 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25217 uint64_t ret_ref = (uint64_t)ret_var.inner;
25218 if (ret_var.is_owned) {
25224 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_PositiveTimestamp_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
25225 LDKPositiveTimestamp this_obj_conv;
25226 this_obj_conv.inner = (void*)(this_obj & (~1));
25227 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
25228 PositiveTimestamp_free(this_obj_conv);
25231 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_PositiveTimestamp_1eq(JNIEnv *env, jclass clz, int64_t a, int64_t b) {
25232 LDKPositiveTimestamp a_conv;
25233 a_conv.inner = (void*)(a & (~1));
25234 a_conv.is_owned = false;
25235 LDKPositiveTimestamp b_conv;
25236 b_conv.inner = (void*)(b & (~1));
25237 b_conv.is_owned = false;
25238 jboolean ret_val = PositiveTimestamp_eq(&a_conv, &b_conv);
25242 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PositiveTimestamp_1clone(JNIEnv *env, jclass clz, int64_t orig) {
25243 LDKPositiveTimestamp orig_conv;
25244 orig_conv.inner = (void*)(orig & (~1));
25245 orig_conv.is_owned = false;
25246 LDKPositiveTimestamp ret_var = PositiveTimestamp_clone(&orig_conv);
25247 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25248 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25249 uint64_t ret_ref = (uint64_t)ret_var.inner;
25250 if (ret_var.is_owned) {
25256 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_SiPrefix_1clone(JNIEnv *env, jclass clz, int64_t orig) {
25257 LDKSiPrefix* orig_conv = (LDKSiPrefix*)(orig & ~1);
25258 jclass ret_conv = LDKSiPrefix_to_java(env, SiPrefix_clone(orig_conv));
25262 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_SiPrefix_1eq(JNIEnv *env, jclass clz, int64_t a, int64_t b) {
25263 LDKSiPrefix* a_conv = (LDKSiPrefix*)(a & ~1);
25264 LDKSiPrefix* b_conv = (LDKSiPrefix*)(b & ~1);
25265 jboolean ret_val = SiPrefix_eq(a_conv, b_conv);
25269 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SiPrefix_1multiplier(JNIEnv *env, jclass clz, int64_t this_arg) {
25270 LDKSiPrefix* this_arg_conv = (LDKSiPrefix*)(this_arg & ~1);
25271 int64_t ret_val = SiPrefix_multiplier(this_arg_conv);
25275 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_Currency_1clone(JNIEnv *env, jclass clz, int64_t orig) {
25276 LDKCurrency* orig_conv = (LDKCurrency*)(orig & ~1);
25277 jclass ret_conv = LDKCurrency_to_java(env, Currency_clone(orig_conv));
25281 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_Currency_1eq(JNIEnv *env, jclass clz, int64_t a, int64_t b) {
25282 LDKCurrency* a_conv = (LDKCurrency*)(a & ~1);
25283 LDKCurrency* b_conv = (LDKCurrency*)(b & ~1);
25284 jboolean ret_val = Currency_eq(a_conv, b_conv);
25288 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Sha256_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
25289 LDKSha256 this_obj_conv;
25290 this_obj_conv.inner = (void*)(this_obj & (~1));
25291 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
25292 Sha256_free(this_obj_conv);
25295 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_Sha256_1eq(JNIEnv *env, jclass clz, int64_t a, int64_t b) {
25297 a_conv.inner = (void*)(a & (~1));
25298 a_conv.is_owned = false;
25300 b_conv.inner = (void*)(b & (~1));
25301 b_conv.is_owned = false;
25302 jboolean ret_val = Sha256_eq(&a_conv, &b_conv);
25306 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Sha256_1clone(JNIEnv *env, jclass clz, int64_t orig) {
25307 LDKSha256 orig_conv;
25308 orig_conv.inner = (void*)(orig & (~1));
25309 orig_conv.is_owned = false;
25310 LDKSha256 ret_var = Sha256_clone(&orig_conv);
25311 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25312 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25313 uint64_t ret_ref = (uint64_t)ret_var.inner;
25314 if (ret_var.is_owned) {
25320 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Description_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
25321 LDKDescription this_obj_conv;
25322 this_obj_conv.inner = (void*)(this_obj & (~1));
25323 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
25324 Description_free(this_obj_conv);
25327 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_Description_1eq(JNIEnv *env, jclass clz, int64_t a, int64_t b) {
25328 LDKDescription a_conv;
25329 a_conv.inner = (void*)(a & (~1));
25330 a_conv.is_owned = false;
25331 LDKDescription b_conv;
25332 b_conv.inner = (void*)(b & (~1));
25333 b_conv.is_owned = false;
25334 jboolean ret_val = Description_eq(&a_conv, &b_conv);
25338 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Description_1clone(JNIEnv *env, jclass clz, int64_t orig) {
25339 LDKDescription orig_conv;
25340 orig_conv.inner = (void*)(orig & (~1));
25341 orig_conv.is_owned = false;
25342 LDKDescription ret_var = Description_clone(&orig_conv);
25343 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25344 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25345 uint64_t ret_ref = (uint64_t)ret_var.inner;
25346 if (ret_var.is_owned) {
25352 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_PayeePubKey_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
25353 LDKPayeePubKey this_obj_conv;
25354 this_obj_conv.inner = (void*)(this_obj & (~1));
25355 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
25356 PayeePubKey_free(this_obj_conv);
25359 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_PayeePubKey_1eq(JNIEnv *env, jclass clz, int64_t a, int64_t b) {
25360 LDKPayeePubKey a_conv;
25361 a_conv.inner = (void*)(a & (~1));
25362 a_conv.is_owned = false;
25363 LDKPayeePubKey b_conv;
25364 b_conv.inner = (void*)(b & (~1));
25365 b_conv.is_owned = false;
25366 jboolean ret_val = PayeePubKey_eq(&a_conv, &b_conv);
25370 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PayeePubKey_1clone(JNIEnv *env, jclass clz, int64_t orig) {
25371 LDKPayeePubKey orig_conv;
25372 orig_conv.inner = (void*)(orig & (~1));
25373 orig_conv.is_owned = false;
25374 LDKPayeePubKey ret_var = PayeePubKey_clone(&orig_conv);
25375 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25376 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25377 uint64_t ret_ref = (uint64_t)ret_var.inner;
25378 if (ret_var.is_owned) {
25384 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ExpiryTime_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
25385 LDKExpiryTime this_obj_conv;
25386 this_obj_conv.inner = (void*)(this_obj & (~1));
25387 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
25388 ExpiryTime_free(this_obj_conv);
25391 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_ExpiryTime_1eq(JNIEnv *env, jclass clz, int64_t a, int64_t b) {
25392 LDKExpiryTime a_conv;
25393 a_conv.inner = (void*)(a & (~1));
25394 a_conv.is_owned = false;
25395 LDKExpiryTime b_conv;
25396 b_conv.inner = (void*)(b & (~1));
25397 b_conv.is_owned = false;
25398 jboolean ret_val = ExpiryTime_eq(&a_conv, &b_conv);
25402 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ExpiryTime_1clone(JNIEnv *env, jclass clz, int64_t orig) {
25403 LDKExpiryTime orig_conv;
25404 orig_conv.inner = (void*)(orig & (~1));
25405 orig_conv.is_owned = false;
25406 LDKExpiryTime ret_var = ExpiryTime_clone(&orig_conv);
25407 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25408 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25409 uint64_t ret_ref = (uint64_t)ret_var.inner;
25410 if (ret_var.is_owned) {
25416 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_MinFinalCltvExpiry_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
25417 LDKMinFinalCltvExpiry this_obj_conv;
25418 this_obj_conv.inner = (void*)(this_obj & (~1));
25419 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
25420 MinFinalCltvExpiry_free(this_obj_conv);
25423 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_MinFinalCltvExpiry_1eq(JNIEnv *env, jclass clz, int64_t a, int64_t b) {
25424 LDKMinFinalCltvExpiry a_conv;
25425 a_conv.inner = (void*)(a & (~1));
25426 a_conv.is_owned = false;
25427 LDKMinFinalCltvExpiry b_conv;
25428 b_conv.inner = (void*)(b & (~1));
25429 b_conv.is_owned = false;
25430 jboolean ret_val = MinFinalCltvExpiry_eq(&a_conv, &b_conv);
25434 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MinFinalCltvExpiry_1clone(JNIEnv *env, jclass clz, int64_t orig) {
25435 LDKMinFinalCltvExpiry orig_conv;
25436 orig_conv.inner = (void*)(orig & (~1));
25437 orig_conv.is_owned = false;
25438 LDKMinFinalCltvExpiry ret_var = MinFinalCltvExpiry_clone(&orig_conv);
25439 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25440 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25441 uint64_t ret_ref = (uint64_t)ret_var.inner;
25442 if (ret_var.is_owned) {
25448 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Fallback_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
25449 if ((this_ptr & 1) != 0) return;
25450 LDKFallback this_ptr_conv = *(LDKFallback*)(((uint64_t)this_ptr) & ~1);
25451 FREE((void*)this_ptr);
25452 Fallback_free(this_ptr_conv);
25455 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Fallback_1clone(JNIEnv *env, jclass clz, int64_t orig) {
25456 LDKFallback* orig_conv = (LDKFallback*)orig;
25457 LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
25458 *ret_copy = Fallback_clone(orig_conv);
25459 uint64_t ret_ref = (uint64_t)ret_copy;
25463 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_Fallback_1eq(JNIEnv *env, jclass clz, int64_t a, int64_t b) {
25464 LDKFallback* a_conv = (LDKFallback*)a;
25465 LDKFallback* b_conv = (LDKFallback*)b;
25466 jboolean ret_val = Fallback_eq(a_conv, b_conv);
25470 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_InvoiceSignature_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
25471 LDKInvoiceSignature this_obj_conv;
25472 this_obj_conv.inner = (void*)(this_obj & (~1));
25473 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
25474 InvoiceSignature_free(this_obj_conv);
25477 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_InvoiceSignature_1eq(JNIEnv *env, jclass clz, int64_t a, int64_t b) {
25478 LDKInvoiceSignature a_conv;
25479 a_conv.inner = (void*)(a & (~1));
25480 a_conv.is_owned = false;
25481 LDKInvoiceSignature b_conv;
25482 b_conv.inner = (void*)(b & (~1));
25483 b_conv.is_owned = false;
25484 jboolean ret_val = InvoiceSignature_eq(&a_conv, &b_conv);
25488 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InvoiceSignature_1clone(JNIEnv *env, jclass clz, int64_t orig) {
25489 LDKInvoiceSignature orig_conv;
25490 orig_conv.inner = (void*)(orig & (~1));
25491 orig_conv.is_owned = false;
25492 LDKInvoiceSignature ret_var = InvoiceSignature_clone(&orig_conv);
25493 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25494 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25495 uint64_t ret_ref = (uint64_t)ret_var.inner;
25496 if (ret_var.is_owned) {
25502 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_PrivateRoute_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
25503 LDKPrivateRoute this_obj_conv;
25504 this_obj_conv.inner = (void*)(this_obj & (~1));
25505 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
25506 PrivateRoute_free(this_obj_conv);
25509 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_PrivateRoute_1eq(JNIEnv *env, jclass clz, int64_t a, int64_t b) {
25510 LDKPrivateRoute a_conv;
25511 a_conv.inner = (void*)(a & (~1));
25512 a_conv.is_owned = false;
25513 LDKPrivateRoute b_conv;
25514 b_conv.inner = (void*)(b & (~1));
25515 b_conv.is_owned = false;
25516 jboolean ret_val = PrivateRoute_eq(&a_conv, &b_conv);
25520 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PrivateRoute_1clone(JNIEnv *env, jclass clz, int64_t orig) {
25521 LDKPrivateRoute orig_conv;
25522 orig_conv.inner = (void*)(orig & (~1));
25523 orig_conv.is_owned = false;
25524 LDKPrivateRoute ret_var = PrivateRoute_clone(&orig_conv);
25525 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25526 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25527 uint64_t ret_ref = (uint64_t)ret_var.inner;
25528 if (ret_var.is_owned) {
25534 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SignedRawInvoice_1into_1parts(JNIEnv *env, jclass clz, int64_t this_arg) {
25535 LDKSignedRawInvoice this_arg_conv;
25536 this_arg_conv.inner = (void*)(this_arg & (~1));
25537 this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
25538 this_arg_conv = SignedRawInvoice_clone(&this_arg_conv);
25539 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_ref = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
25540 *ret_ref = SignedRawInvoice_into_parts(this_arg_conv);
25541 return (uint64_t)ret_ref;
25544 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SignedRawInvoice_1raw_1invoice(JNIEnv *env, jclass clz, int64_t this_arg) {
25545 LDKSignedRawInvoice this_arg_conv;
25546 this_arg_conv.inner = (void*)(this_arg & (~1));
25547 this_arg_conv.is_owned = false;
25548 LDKRawInvoice ret_var = SignedRawInvoice_raw_invoice(&this_arg_conv);
25549 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25550 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25551 uint64_t ret_ref = (uint64_t)ret_var.inner;
25552 if (ret_var.is_owned) {
25558 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_SignedRawInvoice_1hash(JNIEnv *env, jclass clz, int64_t this_arg) {
25559 LDKSignedRawInvoice this_arg_conv;
25560 this_arg_conv.inner = (void*)(this_arg & (~1));
25561 this_arg_conv.is_owned = false;
25562 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
25563 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *SignedRawInvoice_hash(&this_arg_conv));
25567 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SignedRawInvoice_1signature(JNIEnv *env, jclass clz, int64_t this_arg) {
25568 LDKSignedRawInvoice this_arg_conv;
25569 this_arg_conv.inner = (void*)(this_arg & (~1));
25570 this_arg_conv.is_owned = false;
25571 LDKInvoiceSignature ret_var = SignedRawInvoice_signature(&this_arg_conv);
25572 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25573 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25574 uint64_t ret_ref = (uint64_t)ret_var.inner;
25575 if (ret_var.is_owned) {
25581 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SignedRawInvoice_1recover_1payee_1pub_1key(JNIEnv *env, jclass clz, int64_t this_arg) {
25582 LDKSignedRawInvoice this_arg_conv;
25583 this_arg_conv.inner = (void*)(this_arg & (~1));
25584 this_arg_conv.is_owned = false;
25585 LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
25586 *ret_conv = SignedRawInvoice_recover_payee_pub_key(&this_arg_conv);
25587 return (uint64_t)ret_conv;
25590 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_SignedRawInvoice_1check_1signature(JNIEnv *env, jclass clz, int64_t this_arg) {
25591 LDKSignedRawInvoice this_arg_conv;
25592 this_arg_conv.inner = (void*)(this_arg & (~1));
25593 this_arg_conv.is_owned = false;
25594 jboolean ret_val = SignedRawInvoice_check_signature(&this_arg_conv);
25598 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_RawInvoice_1hash(JNIEnv *env, jclass clz, int64_t this_arg) {
25599 LDKRawInvoice this_arg_conv;
25600 this_arg_conv.inner = (void*)(this_arg & (~1));
25601 this_arg_conv.is_owned = false;
25602 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
25603 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, RawInvoice_hash(&this_arg_conv).data);
25607 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RawInvoice_1payment_1hash(JNIEnv *env, jclass clz, int64_t this_arg) {
25608 LDKRawInvoice this_arg_conv;
25609 this_arg_conv.inner = (void*)(this_arg & (~1));
25610 this_arg_conv.is_owned = false;
25611 LDKSha256 ret_var = RawInvoice_payment_hash(&this_arg_conv);
25612 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25613 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25614 uint64_t ret_ref = (uint64_t)ret_var.inner;
25615 if (ret_var.is_owned) {
25621 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RawInvoice_1description(JNIEnv *env, jclass clz, int64_t this_arg) {
25622 LDKRawInvoice this_arg_conv;
25623 this_arg_conv.inner = (void*)(this_arg & (~1));
25624 this_arg_conv.is_owned = false;
25625 LDKDescription ret_var = RawInvoice_description(&this_arg_conv);
25626 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25627 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25628 uint64_t ret_ref = (uint64_t)ret_var.inner;
25629 if (ret_var.is_owned) {
25635 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RawInvoice_1payee_1pub_1key(JNIEnv *env, jclass clz, int64_t this_arg) {
25636 LDKRawInvoice this_arg_conv;
25637 this_arg_conv.inner = (void*)(this_arg & (~1));
25638 this_arg_conv.is_owned = false;
25639 LDKPayeePubKey ret_var = RawInvoice_payee_pub_key(&this_arg_conv);
25640 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25641 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25642 uint64_t ret_ref = (uint64_t)ret_var.inner;
25643 if (ret_var.is_owned) {
25649 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RawInvoice_1description_1hash(JNIEnv *env, jclass clz, int64_t this_arg) {
25650 LDKRawInvoice this_arg_conv;
25651 this_arg_conv.inner = (void*)(this_arg & (~1));
25652 this_arg_conv.is_owned = false;
25653 LDKSha256 ret_var = RawInvoice_description_hash(&this_arg_conv);
25654 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25655 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25656 uint64_t ret_ref = (uint64_t)ret_var.inner;
25657 if (ret_var.is_owned) {
25663 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RawInvoice_1expiry_1time(JNIEnv *env, jclass clz, int64_t this_arg) {
25664 LDKRawInvoice this_arg_conv;
25665 this_arg_conv.inner = (void*)(this_arg & (~1));
25666 this_arg_conv.is_owned = false;
25667 LDKExpiryTime ret_var = RawInvoice_expiry_time(&this_arg_conv);
25668 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25669 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25670 uint64_t ret_ref = (uint64_t)ret_var.inner;
25671 if (ret_var.is_owned) {
25677 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RawInvoice_1min_1final_1cltv_1expiry(JNIEnv *env, jclass clz, int64_t this_arg) {
25678 LDKRawInvoice this_arg_conv;
25679 this_arg_conv.inner = (void*)(this_arg & (~1));
25680 this_arg_conv.is_owned = false;
25681 LDKMinFinalCltvExpiry ret_var = RawInvoice_min_final_cltv_expiry(&this_arg_conv);
25682 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25683 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25684 uint64_t ret_ref = (uint64_t)ret_var.inner;
25685 if (ret_var.is_owned) {
25691 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_RawInvoice_1payment_1secret(JNIEnv *env, jclass clz, int64_t this_arg) {
25692 LDKRawInvoice this_arg_conv;
25693 this_arg_conv.inner = (void*)(this_arg & (~1));
25694 this_arg_conv.is_owned = false;
25695 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
25696 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, RawInvoice_payment_secret(&this_arg_conv).data);
25700 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RawInvoice_1features(JNIEnv *env, jclass clz, int64_t this_arg) {
25701 LDKRawInvoice this_arg_conv;
25702 this_arg_conv.inner = (void*)(this_arg & (~1));
25703 this_arg_conv.is_owned = false;
25704 LDKInvoiceFeatures ret_var = RawInvoice_features(&this_arg_conv);
25705 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25706 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25707 uint64_t ret_ref = (uint64_t)ret_var.inner;
25708 if (ret_var.is_owned) {
25714 JNIEXPORT int64_tArray JNICALL Java_org_ldk_impl_bindings_RawInvoice_1private_1routes(JNIEnv *env, jclass clz, int64_t this_arg) {
25715 LDKRawInvoice this_arg_conv;
25716 this_arg_conv.inner = (void*)(this_arg & (~1));
25717 this_arg_conv.is_owned = false;
25718 LDKCVec_PrivateRouteZ ret_var = RawInvoice_private_routes(&this_arg_conv);
25719 int64_tArray ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
25720 int64_t *ret_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, ret_arr, NULL);
25721 for (size_t o = 0; o < ret_var.datalen; o++) {
25722 LDKPrivateRoute ret_conv_14_var = ret_var.data[o];
25723 CHECK((((uint64_t)ret_conv_14_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25724 CHECK((((uint64_t)&ret_conv_14_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25725 uint64_t ret_conv_14_ref = (uint64_t)ret_conv_14_var.inner;
25726 if (ret_conv_14_var.is_owned) {
25727 ret_conv_14_ref |= 1;
25729 ret_arr_ptr[o] = ret_conv_14_ref;
25731 (*env)->ReleasePrimitiveArrayCritical(env, ret_arr, ret_arr_ptr, 0);
25732 FREE(ret_var.data);
25736 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RawInvoice_1amount_1pico_1btc(JNIEnv *env, jclass clz, int64_t this_arg) {
25737 LDKRawInvoice this_arg_conv;
25738 this_arg_conv.inner = (void*)(this_arg & (~1));
25739 this_arg_conv.is_owned = false;
25740 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
25741 *ret_copy = RawInvoice_amount_pico_btc(&this_arg_conv);
25742 uint64_t ret_ref = (uint64_t)ret_copy;
25746 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_RawInvoice_1currency(JNIEnv *env, jclass clz, int64_t this_arg) {
25747 LDKRawInvoice this_arg_conv;
25748 this_arg_conv.inner = (void*)(this_arg & (~1));
25749 this_arg_conv.is_owned = false;
25750 jclass ret_conv = LDKCurrency_to_java(env, RawInvoice_currency(&this_arg_conv));
25754 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PositiveTimestamp_1from_1unix_1timestamp(JNIEnv *env, jclass clz, int64_t unix_seconds) {
25755 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
25756 *ret_conv = PositiveTimestamp_from_unix_timestamp(unix_seconds);
25757 return (uint64_t)ret_conv;
25760 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PositiveTimestamp_1from_1system_1time(JNIEnv *env, jclass clz, int64_t time) {
25761 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
25762 *ret_conv = PositiveTimestamp_from_system_time(time);
25763 return (uint64_t)ret_conv;
25766 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PositiveTimestamp_1as_1unix_1timestamp(JNIEnv *env, jclass clz, int64_t this_arg) {
25767 LDKPositiveTimestamp this_arg_conv;
25768 this_arg_conv.inner = (void*)(this_arg & (~1));
25769 this_arg_conv.is_owned = false;
25770 int64_t ret_val = PositiveTimestamp_as_unix_timestamp(&this_arg_conv);
25774 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PositiveTimestamp_1as_1time(JNIEnv *env, jclass clz, int64_t this_arg) {
25775 LDKPositiveTimestamp this_arg_conv;
25776 this_arg_conv.inner = (void*)(this_arg & (~1));
25777 this_arg_conv.is_owned = false;
25778 int64_t ret_val = PositiveTimestamp_as_time(&this_arg_conv);
25782 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Invoice_1into_1signed_1raw(JNIEnv *env, jclass clz, int64_t this_arg) {
25783 LDKInvoice this_arg_conv;
25784 this_arg_conv.inner = (void*)(this_arg & (~1));
25785 this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
25786 this_arg_conv = Invoice_clone(&this_arg_conv);
25787 LDKSignedRawInvoice ret_var = Invoice_into_signed_raw(this_arg_conv);
25788 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25789 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25790 uint64_t ret_ref = (uint64_t)ret_var.inner;
25791 if (ret_var.is_owned) {
25797 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Invoice_1check_1signature(JNIEnv *env, jclass clz, int64_t this_arg) {
25798 LDKInvoice this_arg_conv;
25799 this_arg_conv.inner = (void*)(this_arg & (~1));
25800 this_arg_conv.is_owned = false;
25801 LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
25802 *ret_conv = Invoice_check_signature(&this_arg_conv);
25803 return (uint64_t)ret_conv;
25806 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Invoice_1from_1signed(JNIEnv *env, jclass clz, int64_t signed_invoice) {
25807 LDKSignedRawInvoice signed_invoice_conv;
25808 signed_invoice_conv.inner = (void*)(signed_invoice & (~1));
25809 signed_invoice_conv.is_owned = (signed_invoice & 1) || (signed_invoice == 0);
25810 signed_invoice_conv = SignedRawInvoice_clone(&signed_invoice_conv);
25811 LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
25812 *ret_conv = Invoice_from_signed(signed_invoice_conv);
25813 return (uint64_t)ret_conv;
25816 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Invoice_1timestamp(JNIEnv *env, jclass clz, int64_t this_arg) {
25817 LDKInvoice this_arg_conv;
25818 this_arg_conv.inner = (void*)(this_arg & (~1));
25819 this_arg_conv.is_owned = false;
25820 int64_t ret_val = Invoice_timestamp(&this_arg_conv);
25824 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_Invoice_1payment_1hash(JNIEnv *env, jclass clz, int64_t this_arg) {
25825 LDKInvoice this_arg_conv;
25826 this_arg_conv.inner = (void*)(this_arg & (~1));
25827 this_arg_conv.is_owned = false;
25828 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
25829 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *Invoice_payment_hash(&this_arg_conv));
25833 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_Invoice_1payee_1pub_1key(JNIEnv *env, jclass clz, int64_t this_arg) {
25834 LDKInvoice this_arg_conv;
25835 this_arg_conv.inner = (void*)(this_arg & (~1));
25836 this_arg_conv.is_owned = false;
25837 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
25838 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, Invoice_payee_pub_key(&this_arg_conv).compressed_form);
25842 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_Invoice_1payment_1secret(JNIEnv *env, jclass clz, int64_t this_arg) {
25843 LDKInvoice this_arg_conv;
25844 this_arg_conv.inner = (void*)(this_arg & (~1));
25845 this_arg_conv.is_owned = false;
25846 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
25847 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, Invoice_payment_secret(&this_arg_conv).data);
25851 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Invoice_1features(JNIEnv *env, jclass clz, int64_t this_arg) {
25852 LDKInvoice this_arg_conv;
25853 this_arg_conv.inner = (void*)(this_arg & (~1));
25854 this_arg_conv.is_owned = false;
25855 LDKInvoiceFeatures ret_var = Invoice_features(&this_arg_conv);
25856 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25857 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25858 uint64_t ret_ref = (uint64_t)ret_var.inner;
25859 if (ret_var.is_owned) {
25865 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_Invoice_1recover_1payee_1pub_1key(JNIEnv *env, jclass clz, int64_t this_arg) {
25866 LDKInvoice this_arg_conv;
25867 this_arg_conv.inner = (void*)(this_arg & (~1));
25868 this_arg_conv.is_owned = false;
25869 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
25870 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, Invoice_recover_payee_pub_key(&this_arg_conv).compressed_form);
25874 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Invoice_1expiry_1time(JNIEnv *env, jclass clz, int64_t this_arg) {
25875 LDKInvoice this_arg_conv;
25876 this_arg_conv.inner = (void*)(this_arg & (~1));
25877 this_arg_conv.is_owned = false;
25878 int64_t ret_val = Invoice_expiry_time(&this_arg_conv);
25882 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Invoice_1min_1final_1cltv_1expiry(JNIEnv *env, jclass clz, int64_t this_arg) {
25883 LDKInvoice this_arg_conv;
25884 this_arg_conv.inner = (void*)(this_arg & (~1));
25885 this_arg_conv.is_owned = false;
25886 int64_t ret_val = Invoice_min_final_cltv_expiry(&this_arg_conv);
25890 JNIEXPORT int64_tArray JNICALL Java_org_ldk_impl_bindings_Invoice_1private_1routes(JNIEnv *env, jclass clz, int64_t this_arg) {
25891 LDKInvoice this_arg_conv;
25892 this_arg_conv.inner = (void*)(this_arg & (~1));
25893 this_arg_conv.is_owned = false;
25894 LDKCVec_PrivateRouteZ ret_var = Invoice_private_routes(&this_arg_conv);
25895 int64_tArray ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
25896 int64_t *ret_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, ret_arr, NULL);
25897 for (size_t o = 0; o < ret_var.datalen; o++) {
25898 LDKPrivateRoute ret_conv_14_var = ret_var.data[o];
25899 CHECK((((uint64_t)ret_conv_14_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25900 CHECK((((uint64_t)&ret_conv_14_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25901 uint64_t ret_conv_14_ref = (uint64_t)ret_conv_14_var.inner;
25902 if (ret_conv_14_var.is_owned) {
25903 ret_conv_14_ref |= 1;
25905 ret_arr_ptr[o] = ret_conv_14_ref;
25907 (*env)->ReleasePrimitiveArrayCritical(env, ret_arr, ret_arr_ptr, 0);
25908 FREE(ret_var.data);
25912 JNIEXPORT int64_tArray JNICALL Java_org_ldk_impl_bindings_Invoice_1route_1hints(JNIEnv *env, jclass clz, int64_t this_arg) {
25913 LDKInvoice this_arg_conv;
25914 this_arg_conv.inner = (void*)(this_arg & (~1));
25915 this_arg_conv.is_owned = false;
25916 LDKCVec_RouteHintZ ret_var = Invoice_route_hints(&this_arg_conv);
25917 int64_tArray ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
25918 int64_t *ret_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, ret_arr, NULL);
25919 for (size_t l = 0; l < ret_var.datalen; l++) {
25920 LDKRouteHint ret_conv_11_var = ret_var.data[l];
25921 CHECK((((uint64_t)ret_conv_11_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25922 CHECK((((uint64_t)&ret_conv_11_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25923 uint64_t ret_conv_11_ref = (uint64_t)ret_conv_11_var.inner;
25924 if (ret_conv_11_var.is_owned) {
25925 ret_conv_11_ref |= 1;
25927 ret_arr_ptr[l] = ret_conv_11_ref;
25929 (*env)->ReleasePrimitiveArrayCritical(env, ret_arr, ret_arr_ptr, 0);
25930 FREE(ret_var.data);
25934 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_Invoice_1currency(JNIEnv *env, jclass clz, int64_t this_arg) {
25935 LDKInvoice this_arg_conv;
25936 this_arg_conv.inner = (void*)(this_arg & (~1));
25937 this_arg_conv.is_owned = false;
25938 jclass ret_conv = LDKCurrency_to_java(env, Invoice_currency(&this_arg_conv));
25942 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Invoice_1amount_1pico_1btc(JNIEnv *env, jclass clz, int64_t this_arg) {
25943 LDKInvoice this_arg_conv;
25944 this_arg_conv.inner = (void*)(this_arg & (~1));
25945 this_arg_conv.is_owned = false;
25946 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
25947 *ret_copy = Invoice_amount_pico_btc(&this_arg_conv);
25948 uint64_t ret_ref = (uint64_t)ret_copy;
25952 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Description_1new(JNIEnv *env, jclass clz, jstring description) {
25953 LDKStr description_conv = java_to_owned_str(env, description);
25954 LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
25955 *ret_conv = Description_new(description_conv);
25956 return (uint64_t)ret_conv;
25959 JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_Description_1into_1inner(JNIEnv *env, jclass clz, int64_t this_arg) {
25960 LDKDescription this_arg_conv;
25961 this_arg_conv.inner = (void*)(this_arg & (~1));
25962 this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
25963 this_arg_conv = Description_clone(&this_arg_conv);
25964 LDKStr ret_str = Description_into_inner(this_arg_conv);
25965 jstring ret_conv = str_ref_to_java(env, ret_str.chars, ret_str.len);
25969 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ExpiryTime_1from_1seconds(JNIEnv *env, jclass clz, int64_t seconds) {
25970 LDKCResult_ExpiryTimeCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ExpiryTimeCreationErrorZ), "LDKCResult_ExpiryTimeCreationErrorZ");
25971 *ret_conv = ExpiryTime_from_seconds(seconds);
25972 return (uint64_t)ret_conv;
25975 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ExpiryTime_1from_1duration(JNIEnv *env, jclass clz, int64_t duration) {
25976 LDKCResult_ExpiryTimeCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ExpiryTimeCreationErrorZ), "LDKCResult_ExpiryTimeCreationErrorZ");
25977 *ret_conv = ExpiryTime_from_duration(duration);
25978 return (uint64_t)ret_conv;
25981 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ExpiryTime_1as_1seconds(JNIEnv *env, jclass clz, int64_t this_arg) {
25982 LDKExpiryTime this_arg_conv;
25983 this_arg_conv.inner = (void*)(this_arg & (~1));
25984 this_arg_conv.is_owned = false;
25985 int64_t ret_val = ExpiryTime_as_seconds(&this_arg_conv);
25989 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ExpiryTime_1as_1duration(JNIEnv *env, jclass clz, int64_t this_arg) {
25990 LDKExpiryTime this_arg_conv;
25991 this_arg_conv.inner = (void*)(this_arg & (~1));
25992 this_arg_conv.is_owned = false;
25993 int64_t ret_val = ExpiryTime_as_duration(&this_arg_conv);
25997 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PrivateRoute_1new(JNIEnv *env, jclass clz, int64_t hops) {
25998 LDKRouteHint hops_conv;
25999 hops_conv.inner = (void*)(hops & (~1));
26000 hops_conv.is_owned = (hops & 1) || (hops == 0);
26001 hops_conv = RouteHint_clone(&hops_conv);
26002 LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
26003 *ret_conv = PrivateRoute_new(hops_conv);
26004 return (uint64_t)ret_conv;
26007 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PrivateRoute_1into_1inner(JNIEnv *env, jclass clz, int64_t this_arg) {
26008 LDKPrivateRoute this_arg_conv;
26009 this_arg_conv.inner = (void*)(this_arg & (~1));
26010 this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
26011 this_arg_conv = PrivateRoute_clone(&this_arg_conv);
26012 LDKRouteHint ret_var = PrivateRoute_into_inner(this_arg_conv);
26013 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
26014 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
26015 uint64_t ret_ref = (uint64_t)ret_var.inner;
26016 if (ret_var.is_owned) {
26022 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_CreationError_1clone(JNIEnv *env, jclass clz, int64_t orig) {
26023 LDKCreationError* orig_conv = (LDKCreationError*)(orig & ~1);
26024 jclass ret_conv = LDKCreationError_to_java(env, CreationError_clone(orig_conv));
26028 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CreationError_1eq(JNIEnv *env, jclass clz, int64_t a, int64_t b) {
26029 LDKCreationError* a_conv = (LDKCreationError*)(a & ~1);
26030 LDKCreationError* b_conv = (LDKCreationError*)(b & ~1);
26031 jboolean ret_val = CreationError_eq(a_conv, b_conv);
26035 JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_CreationError_1to_1str(JNIEnv *env, jclass clz, int64_t o) {
26036 LDKCreationError* o_conv = (LDKCreationError*)(o & ~1);
26037 LDKStr ret_str = CreationError_to_str(o_conv);
26038 jstring ret_conv = str_ref_to_java(env, ret_str.chars, ret_str.len);
26042 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_SemanticError_1clone(JNIEnv *env, jclass clz, int64_t orig) {
26043 LDKSemanticError* orig_conv = (LDKSemanticError*)(orig & ~1);
26044 jclass ret_conv = LDKSemanticError_to_java(env, SemanticError_clone(orig_conv));
26048 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_SemanticError_1eq(JNIEnv *env, jclass clz, int64_t a, int64_t b) {
26049 LDKSemanticError* a_conv = (LDKSemanticError*)(a & ~1);
26050 LDKSemanticError* b_conv = (LDKSemanticError*)(b & ~1);
26051 jboolean ret_val = SemanticError_eq(a_conv, b_conv);
26055 JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_SemanticError_1to_1str(JNIEnv *env, jclass clz, int64_t o) {
26056 LDKSemanticError* o_conv = (LDKSemanticError*)(o & ~1);
26057 LDKStr ret_str = SemanticError_to_str(o_conv);
26058 jstring ret_conv = str_ref_to_java(env, ret_str.chars, ret_str.len);
26062 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_SignOrCreationError_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
26063 if ((this_ptr & 1) != 0) return;
26064 LDKSignOrCreationError this_ptr_conv = *(LDKSignOrCreationError*)(((uint64_t)this_ptr) & ~1);
26065 FREE((void*)this_ptr);
26066 SignOrCreationError_free(this_ptr_conv);
26069 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SignOrCreationError_1clone(JNIEnv *env, jclass clz, int64_t orig) {
26070 LDKSignOrCreationError* orig_conv = (LDKSignOrCreationError*)orig;
26071 LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
26072 *ret_copy = SignOrCreationError_clone(orig_conv);
26073 uint64_t ret_ref = (uint64_t)ret_copy;
26077 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_SignOrCreationError_1eq(JNIEnv *env, jclass clz, int64_t a, int64_t b) {
26078 LDKSignOrCreationError* a_conv = (LDKSignOrCreationError*)a;
26079 LDKSignOrCreationError* b_conv = (LDKSignOrCreationError*)b;
26080 jboolean ret_val = SignOrCreationError_eq(a_conv, b_conv);
26084 JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_SignOrCreationError_1to_1str(JNIEnv *env, jclass clz, int64_t o) {
26085 LDKSignOrCreationError* o_conv = (LDKSignOrCreationError*)o;
26086 LDKStr ret_str = SignOrCreationError_to_str(o_conv);
26087 jstring ret_conv = str_ref_to_java(env, ret_str.chars, ret_str.len);
26091 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_create_1invoice_1from_1channelmanager(JNIEnv *env, jclass clz, int64_t channelmanager, int64_t keys_manager, jclass network, int64_t amt_msat, jstring description) {
26092 LDKChannelManager channelmanager_conv;
26093 channelmanager_conv.inner = (void*)(channelmanager & (~1));
26094 channelmanager_conv.is_owned = false;
26095 LDKKeysInterface keys_manager_conv = *(LDKKeysInterface*)(((uint64_t)keys_manager) & ~1);
26096 if (keys_manager_conv.free == LDKKeysInterface_JCalls_free) {
26097 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
26098 LDKKeysInterface_JCalls_clone(keys_manager_conv.this_arg);
26100 LDKCurrency network_conv = LDKCurrency_from_java(env, network);
26101 LDKCOption_u64Z amt_msat_conv = *(LDKCOption_u64Z*)(((uint64_t)amt_msat) & ~1);
26102 LDKStr description_conv = java_to_owned_str(env, description);
26103 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
26104 *ret_conv = create_invoice_from_channelmanager(&channelmanager_conv, keys_manager_conv, network_conv, amt_msat_conv, description_conv);
26105 return (uint64_t)ret_conv;
26108 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SiPrefix_1from_1str(JNIEnv *env, jclass clz, jstring s) {
26109 LDKStr s_conv = java_to_owned_str(env, s);
26110 LDKCResult_SiPrefixNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixNoneZ), "LDKCResult_SiPrefixNoneZ");
26111 *ret_conv = SiPrefix_from_str(s_conv);
26112 return (uint64_t)ret_conv;
26115 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Invoice_1from_1str(JNIEnv *env, jclass clz, jstring s) {
26116 LDKStr s_conv = java_to_owned_str(env, s);
26117 LDKCResult_InvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceNoneZ), "LDKCResult_InvoiceNoneZ");
26118 *ret_conv = Invoice_from_str(s_conv);
26119 return (uint64_t)ret_conv;
26122 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SignedRawInvoice_1from_1str(JNIEnv *env, jclass clz, jstring s) {
26123 LDKStr s_conv = java_to_owned_str(env, s);
26124 LDKCResult_SignedRawInvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceNoneZ), "LDKCResult_SignedRawInvoiceNoneZ");
26125 *ret_conv = SignedRawInvoice_from_str(s_conv);
26126 return (uint64_t)ret_conv;
26129 JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_Invoice_1to_1str(JNIEnv *env, jclass clz, int64_t o) {
26131 o_conv.inner = (void*)(o & (~1));
26132 o_conv.is_owned = false;
26133 LDKStr ret_str = Invoice_to_str(&o_conv);
26134 jstring ret_conv = str_ref_to_java(env, ret_str.chars, ret_str.len);
26138 JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_SignedRawInvoice_1to_1str(JNIEnv *env, jclass clz, int64_t o) {
26139 LDKSignedRawInvoice o_conv;
26140 o_conv.inner = (void*)(o & (~1));
26141 o_conv.is_owned = false;
26142 LDKStr ret_str = SignedRawInvoice_to_str(&o_conv);
26143 jstring ret_conv = str_ref_to_java(env, ret_str.chars, ret_str.len);
26147 JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_Currency_1to_1str(JNIEnv *env, jclass clz, int64_t o) {
26148 LDKCurrency* o_conv = (LDKCurrency*)(o & ~1);
26149 LDKStr ret_str = Currency_to_str(o_conv);
26150 jstring ret_conv = str_ref_to_java(env, ret_str.chars, ret_str.len);
26154 JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_SiPrefix_1to_1str(JNIEnv *env, jclass clz, int64_t o) {
26155 LDKSiPrefix* o_conv = (LDKSiPrefix*)(o & ~1);
26156 LDKStr ret_str = SiPrefix_to_str(o_conv);
26157 jstring ret_conv = str_ref_to_java(env, ret_str.chars, ret_str.len);