1 #include "org_ldk_impl_bindings.h"
2 #include <rust_types.h>
8 #define MALLOC(a, _) malloc(a)
9 #define FREE(p) if ((long)(p) > 1024) { free(p); }
10 #define DO_ASSERT(a) (void)(a)
13 static jmethodID ordinal_meth = NULL;
14 static jmethodID slicedef_meth = NULL;
15 static jclass slicedef_cls = NULL;
16 JNIEXPORT void Java_org_ldk_impl_bindings_init(JNIEnv * env, jclass _b, jclass enum_class, jclass slicedef_class) {
17 ordinal_meth = (*env)->GetMethodID(env, enum_class, "ordinal", "()I");
18 CHECK(ordinal_meth != NULL);
19 slicedef_meth = (*env)->GetMethodID(env, slicedef_class, "<init>", "(JJJ)V");
20 CHECK(slicedef_meth != NULL);
21 slicedef_cls = (*env)->NewGlobalRef(env, slicedef_class);
22 CHECK(slicedef_cls != NULL);
25 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_deref_1bool (JNIEnv * env, jclass _a, jlong ptr) {
28 JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_deref_1long (JNIEnv * env, jclass _a, jlong ptr) {
31 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_free_1heap_1ptr (JNIEnv * env, jclass _a, jlong ptr) {
34 JNIEXPORT jbyteArray JNICALL Java_org_ldk_impl_bindings_read_1bytes (JNIEnv * env, jclass _b, jlong ptr, jlong len) {
35 jbyteArray ret_arr = (*env)->NewByteArray(env, len);
36 (*env)->SetByteArrayRegion(env, ret_arr, 0, len, (unsigned char*)ptr);
39 JNIEXPORT jbyteArray JNICALL Java_org_ldk_impl_bindings_get_1u8_1slice_1bytes (JNIEnv * env, jclass _b, jlong slice_ptr) {
40 LDKu8slice *slice = (LDKu8slice*)slice_ptr;
41 jbyteArray ret_arr = (*env)->NewByteArray(env, slice->datalen);
42 (*env)->SetByteArrayRegion(env, ret_arr, 0, slice->datalen, slice->data);
45 JNIEXPORT int64_t impl_bindings_bytes_1to_1u8_1vec (JNIEnv * env, jclass _b, jbyteArray bytes) {
46 LDKCVec_u8Z *vec = (LDKCVec_u8Z*)MALLOC(sizeof(LDKCVec_u8Z), "LDKCVec_u8");
47 vec->datalen = (*env)->GetArrayLength(env, bytes);
48 vec->data = (uint8_t*)MALLOC(vec->datalen, "LDKCVec_u8Z Bytes");
49 (*env)->GetByteArrayRegion (env, bytes, 0, vec->datalen, vec->data);
52 JNIEXPORT jbyteArray JNICALL Java_org_ldk_impl_bindings_txpointer_1get_1buffer (JNIEnv * env, jclass _b, jlong ptr) {
53 LDKTransaction *txdata = (LDKTransaction*)ptr;
55 slice.data = txdata->data;
56 slice.datalen = txdata->datalen;
57 return Java_org_ldk_impl_bindings_get_1u8_1slice_1bytes(env, _b, (long)&slice);
59 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_new_1txpointer_1copy_1data (JNIEnv * env, jclass _b, jbyteArray bytes) {
60 LDKTransaction *txdata = (LDKTransaction*)MALLOC(sizeof(LDKTransaction), "LDKTransaction");
61 txdata->datalen = (*env)->GetArrayLength(env, bytes);
62 txdata->data = (uint8_t*)MALLOC(txdata->datalen, "Tx Data Bytes");
63 txdata->data_is_owned = false;
64 (*env)->GetByteArrayRegion (env, bytes, 0, txdata->datalen, txdata->data);
67 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_txpointer_1free (JNIEnv * env, jclass _b, jlong ptr) {
68 LDKTransaction *tx = (LDKTransaction*)ptr;
69 tx->data_is_owned = true;
70 Transaction_free(*tx);
73 JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_vec_1slice_1len (JNIEnv * env, jclass _a, jlong ptr) {
74 // Check offsets of a few Vec types are all consistent as we're meant to be generic across types
75 _Static_assert(offsetof(LDKCVec_u8Z, datalen) == offsetof(LDKCVec_SignatureZ, datalen), "Vec<*> needs to be mapped identically");
76 _Static_assert(offsetof(LDKCVec_u8Z, datalen) == offsetof(LDKCVec_MessageSendEventZ, datalen), "Vec<*> needs to be mapped identically");
77 _Static_assert(offsetof(LDKCVec_u8Z, datalen) == offsetof(LDKCVec_EventZ, datalen), "Vec<*> needs to be mapped identically");
78 _Static_assert(offsetof(LDKCVec_u8Z, datalen) == offsetof(LDKCVec_C2Tuple_usizeTransactionZZ, datalen), "Vec<*> needs to be mapped identically");
79 LDKCVec_u8Z *vec = (LDKCVec_u8Z*)ptr;
80 return (long)vec->datalen;
82 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_new_1empty_1slice_1vec (JNIEnv * env, jclass _b) {
83 // Check sizes of a few Vec types are all consistent as we're meant to be generic across types
84 _Static_assert(sizeof(LDKCVec_u8Z) == sizeof(LDKCVec_SignatureZ), "Vec<*> needs to be mapped identically");
85 _Static_assert(sizeof(LDKCVec_u8Z) == sizeof(LDKCVec_MessageSendEventZ), "Vec<*> needs to be mapped identically");
86 _Static_assert(sizeof(LDKCVec_u8Z) == sizeof(LDKCVec_EventZ), "Vec<*> needs to be mapped identically");
87 _Static_assert(sizeof(LDKCVec_u8Z) == sizeof(LDKCVec_C2Tuple_usizeTransactionZZ), "Vec<*> needs to be mapped identically");
88 LDKCVec_u8Z *vec = (LDKCVec_u8Z*)MALLOC(sizeof(LDKCVec_u8Z), "Empty LDKCVec");
94 // We assume that CVec_u8Z and u8slice are the same size and layout (and thus pointers to the two can be mixed)
95 _Static_assert(sizeof(LDKCVec_u8Z) == sizeof(LDKu8slice), "Vec<u8> and [u8] need to have been mapped identically");
96 _Static_assert(offsetof(LDKCVec_u8Z, data) == offsetof(LDKu8slice, data), "Vec<u8> and [u8] need to have been mapped identically");
97 _Static_assert(offsetof(LDKCVec_u8Z, datalen) == offsetof(LDKu8slice, datalen), "Vec<u8> and [u8] need to have been mapped identically");
99 _Static_assert(sizeof(jlong) == sizeof(int64_t), "We assume that j-types are the same as C types");
100 _Static_assert(sizeof(jbyte) == sizeof(char), "We assume that j-types are the same as C types");
101 _Static_assert(sizeof(void*) <= 8, "Pointers must fit into 64 bits");
103 typedef jlongArray int64_tArray;
104 typedef jbyteArray int8_tArray;
106 static inline jstring str_ref_to_java(JNIEnv *env, const char* chars, size_t len) {
107 // Sadly we need to create a temporary because Java can't accept a char* without a 0-terminator
108 char* err_buf = MALLOC(len + 1, "str conv buf");
109 memcpy(err_buf, chars, len);
111 jstring err_conv = (*env)->NewStringUTF(env, chars);
115 static jclass arr_of_J_clz = NULL;
116 static jclass arr_of_B_clz = NULL;
117 JNIEXPORT void Java_org_ldk_impl_bindings_init_1class_1cache(JNIEnv * env, jclass clz) {
118 arr_of_J_clz = (*env)->FindClass(env, "[J");
119 CHECK(arr_of_J_clz != NULL);
120 arr_of_J_clz = (*env)->NewGlobalRef(env, arr_of_J_clz);
121 arr_of_B_clz = (*env)->FindClass(env, "[B");
122 CHECK(arr_of_B_clz != NULL);
123 arr_of_B_clz = (*env)->NewGlobalRef(env, arr_of_B_clz);
125 static inline struct LDKThirtyTwoBytes ThirtyTwoBytes_clone(const struct LDKThirtyTwoBytes *orig) { struct LDKThirtyTwoBytes ret; memcpy(ret.data, orig->data, 32); return ret; }
126 static inline LDKAccessError LDKAccessError_from_java(JNIEnv *env, jclass clz) {
127 switch ((*env)->CallIntMethod(env, clz, ordinal_meth)) {
128 case 0: return LDKAccessError_UnknownChain;
129 case 1: return LDKAccessError_UnknownTx;
133 static jclass LDKAccessError_class = NULL;
134 static jfieldID LDKAccessError_LDKAccessError_UnknownChain = NULL;
135 static jfieldID LDKAccessError_LDKAccessError_UnknownTx = NULL;
136 JNIEXPORT void JNICALL Java_org_ldk_enums_LDKAccessError_init (JNIEnv *env, jclass clz) {
137 LDKAccessError_class = (*env)->NewGlobalRef(env, clz);
138 CHECK(LDKAccessError_class != NULL);
139 LDKAccessError_LDKAccessError_UnknownChain = (*env)->GetStaticFieldID(env, LDKAccessError_class, "LDKAccessError_UnknownChain", "Lorg/ldk/enums/LDKAccessError;");
140 CHECK(LDKAccessError_LDKAccessError_UnknownChain != NULL);
141 LDKAccessError_LDKAccessError_UnknownTx = (*env)->GetStaticFieldID(env, LDKAccessError_class, "LDKAccessError_UnknownTx", "Lorg/ldk/enums/LDKAccessError;");
142 CHECK(LDKAccessError_LDKAccessError_UnknownTx != NULL);
144 static inline jclass LDKAccessError_to_java(JNIEnv *env, LDKAccessError val) {
146 case LDKAccessError_UnknownChain:
147 return (*env)->GetStaticObjectField(env, LDKAccessError_class, LDKAccessError_LDKAccessError_UnknownChain);
148 case LDKAccessError_UnknownTx:
149 return (*env)->GetStaticObjectField(env, LDKAccessError_class, LDKAccessError_LDKAccessError_UnknownTx);
154 static inline LDKChannelMonitorUpdateErr LDKChannelMonitorUpdateErr_from_java(JNIEnv *env, jclass clz) {
155 switch ((*env)->CallIntMethod(env, clz, ordinal_meth)) {
156 case 0: return LDKChannelMonitorUpdateErr_TemporaryFailure;
157 case 1: return LDKChannelMonitorUpdateErr_PermanentFailure;
161 static jclass LDKChannelMonitorUpdateErr_class = NULL;
162 static jfieldID LDKChannelMonitorUpdateErr_LDKChannelMonitorUpdateErr_TemporaryFailure = NULL;
163 static jfieldID LDKChannelMonitorUpdateErr_LDKChannelMonitorUpdateErr_PermanentFailure = NULL;
164 JNIEXPORT void JNICALL Java_org_ldk_enums_LDKChannelMonitorUpdateErr_init (JNIEnv *env, jclass clz) {
165 LDKChannelMonitorUpdateErr_class = (*env)->NewGlobalRef(env, clz);
166 CHECK(LDKChannelMonitorUpdateErr_class != NULL);
167 LDKChannelMonitorUpdateErr_LDKChannelMonitorUpdateErr_TemporaryFailure = (*env)->GetStaticFieldID(env, LDKChannelMonitorUpdateErr_class, "LDKChannelMonitorUpdateErr_TemporaryFailure", "Lorg/ldk/enums/LDKChannelMonitorUpdateErr;");
168 CHECK(LDKChannelMonitorUpdateErr_LDKChannelMonitorUpdateErr_TemporaryFailure != NULL);
169 LDKChannelMonitorUpdateErr_LDKChannelMonitorUpdateErr_PermanentFailure = (*env)->GetStaticFieldID(env, LDKChannelMonitorUpdateErr_class, "LDKChannelMonitorUpdateErr_PermanentFailure", "Lorg/ldk/enums/LDKChannelMonitorUpdateErr;");
170 CHECK(LDKChannelMonitorUpdateErr_LDKChannelMonitorUpdateErr_PermanentFailure != NULL);
172 static inline jclass LDKChannelMonitorUpdateErr_to_java(JNIEnv *env, LDKChannelMonitorUpdateErr val) {
174 case LDKChannelMonitorUpdateErr_TemporaryFailure:
175 return (*env)->GetStaticObjectField(env, LDKChannelMonitorUpdateErr_class, LDKChannelMonitorUpdateErr_LDKChannelMonitorUpdateErr_TemporaryFailure);
176 case LDKChannelMonitorUpdateErr_PermanentFailure:
177 return (*env)->GetStaticObjectField(env, LDKChannelMonitorUpdateErr_class, LDKChannelMonitorUpdateErr_LDKChannelMonitorUpdateErr_PermanentFailure);
182 static inline LDKConfirmationTarget LDKConfirmationTarget_from_java(JNIEnv *env, jclass clz) {
183 switch ((*env)->CallIntMethod(env, clz, ordinal_meth)) {
184 case 0: return LDKConfirmationTarget_Background;
185 case 1: return LDKConfirmationTarget_Normal;
186 case 2: return LDKConfirmationTarget_HighPriority;
190 static jclass LDKConfirmationTarget_class = NULL;
191 static jfieldID LDKConfirmationTarget_LDKConfirmationTarget_Background = NULL;
192 static jfieldID LDKConfirmationTarget_LDKConfirmationTarget_Normal = NULL;
193 static jfieldID LDKConfirmationTarget_LDKConfirmationTarget_HighPriority = NULL;
194 JNIEXPORT void JNICALL Java_org_ldk_enums_LDKConfirmationTarget_init (JNIEnv *env, jclass clz) {
195 LDKConfirmationTarget_class = (*env)->NewGlobalRef(env, clz);
196 CHECK(LDKConfirmationTarget_class != NULL);
197 LDKConfirmationTarget_LDKConfirmationTarget_Background = (*env)->GetStaticFieldID(env, LDKConfirmationTarget_class, "LDKConfirmationTarget_Background", "Lorg/ldk/enums/LDKConfirmationTarget;");
198 CHECK(LDKConfirmationTarget_LDKConfirmationTarget_Background != NULL);
199 LDKConfirmationTarget_LDKConfirmationTarget_Normal = (*env)->GetStaticFieldID(env, LDKConfirmationTarget_class, "LDKConfirmationTarget_Normal", "Lorg/ldk/enums/LDKConfirmationTarget;");
200 CHECK(LDKConfirmationTarget_LDKConfirmationTarget_Normal != NULL);
201 LDKConfirmationTarget_LDKConfirmationTarget_HighPriority = (*env)->GetStaticFieldID(env, LDKConfirmationTarget_class, "LDKConfirmationTarget_HighPriority", "Lorg/ldk/enums/LDKConfirmationTarget;");
202 CHECK(LDKConfirmationTarget_LDKConfirmationTarget_HighPriority != NULL);
204 static inline jclass LDKConfirmationTarget_to_java(JNIEnv *env, LDKConfirmationTarget val) {
206 case LDKConfirmationTarget_Background:
207 return (*env)->GetStaticObjectField(env, LDKConfirmationTarget_class, LDKConfirmationTarget_LDKConfirmationTarget_Background);
208 case LDKConfirmationTarget_Normal:
209 return (*env)->GetStaticObjectField(env, LDKConfirmationTarget_class, LDKConfirmationTarget_LDKConfirmationTarget_Normal);
210 case LDKConfirmationTarget_HighPriority:
211 return (*env)->GetStaticObjectField(env, LDKConfirmationTarget_class, LDKConfirmationTarget_LDKConfirmationTarget_HighPriority);
216 static inline LDKLevel LDKLevel_from_java(JNIEnv *env, jclass clz) {
217 switch ((*env)->CallIntMethod(env, clz, ordinal_meth)) {
218 case 0: return LDKLevel_Off;
219 case 1: return LDKLevel_Error;
220 case 2: return LDKLevel_Warn;
221 case 3: return LDKLevel_Info;
222 case 4: return LDKLevel_Debug;
223 case 5: return LDKLevel_Trace;
227 static jclass LDKLevel_class = NULL;
228 static jfieldID LDKLevel_LDKLevel_Off = NULL;
229 static jfieldID LDKLevel_LDKLevel_Error = NULL;
230 static jfieldID LDKLevel_LDKLevel_Warn = NULL;
231 static jfieldID LDKLevel_LDKLevel_Info = NULL;
232 static jfieldID LDKLevel_LDKLevel_Debug = NULL;
233 static jfieldID LDKLevel_LDKLevel_Trace = NULL;
234 JNIEXPORT void JNICALL Java_org_ldk_enums_LDKLevel_init (JNIEnv *env, jclass clz) {
235 LDKLevel_class = (*env)->NewGlobalRef(env, clz);
236 CHECK(LDKLevel_class != NULL);
237 LDKLevel_LDKLevel_Off = (*env)->GetStaticFieldID(env, LDKLevel_class, "LDKLevel_Off", "Lorg/ldk/enums/LDKLevel;");
238 CHECK(LDKLevel_LDKLevel_Off != NULL);
239 LDKLevel_LDKLevel_Error = (*env)->GetStaticFieldID(env, LDKLevel_class, "LDKLevel_Error", "Lorg/ldk/enums/LDKLevel;");
240 CHECK(LDKLevel_LDKLevel_Error != NULL);
241 LDKLevel_LDKLevel_Warn = (*env)->GetStaticFieldID(env, LDKLevel_class, "LDKLevel_Warn", "Lorg/ldk/enums/LDKLevel;");
242 CHECK(LDKLevel_LDKLevel_Warn != NULL);
243 LDKLevel_LDKLevel_Info = (*env)->GetStaticFieldID(env, LDKLevel_class, "LDKLevel_Info", "Lorg/ldk/enums/LDKLevel;");
244 CHECK(LDKLevel_LDKLevel_Info != NULL);
245 LDKLevel_LDKLevel_Debug = (*env)->GetStaticFieldID(env, LDKLevel_class, "LDKLevel_Debug", "Lorg/ldk/enums/LDKLevel;");
246 CHECK(LDKLevel_LDKLevel_Debug != NULL);
247 LDKLevel_LDKLevel_Trace = (*env)->GetStaticFieldID(env, LDKLevel_class, "LDKLevel_Trace", "Lorg/ldk/enums/LDKLevel;");
248 CHECK(LDKLevel_LDKLevel_Trace != NULL);
250 static inline jclass LDKLevel_to_java(JNIEnv *env, LDKLevel val) {
253 return (*env)->GetStaticObjectField(env, LDKLevel_class, LDKLevel_LDKLevel_Off);
255 return (*env)->GetStaticObjectField(env, LDKLevel_class, LDKLevel_LDKLevel_Error);
257 return (*env)->GetStaticObjectField(env, LDKLevel_class, LDKLevel_LDKLevel_Warn);
259 return (*env)->GetStaticObjectField(env, LDKLevel_class, LDKLevel_LDKLevel_Info);
261 return (*env)->GetStaticObjectField(env, LDKLevel_class, LDKLevel_LDKLevel_Debug);
263 return (*env)->GetStaticObjectField(env, LDKLevel_class, LDKLevel_LDKLevel_Trace);
268 static inline LDKNetwork LDKNetwork_from_java(JNIEnv *env, jclass clz) {
269 switch ((*env)->CallIntMethod(env, clz, ordinal_meth)) {
270 case 0: return LDKNetwork_Bitcoin;
271 case 1: return LDKNetwork_Testnet;
272 case 2: return LDKNetwork_Regtest;
273 case 3: return LDKNetwork_Signet;
277 static jclass LDKNetwork_class = NULL;
278 static jfieldID LDKNetwork_LDKNetwork_Bitcoin = NULL;
279 static jfieldID LDKNetwork_LDKNetwork_Testnet = NULL;
280 static jfieldID LDKNetwork_LDKNetwork_Regtest = NULL;
281 static jfieldID LDKNetwork_LDKNetwork_Signet = NULL;
282 JNIEXPORT void JNICALL Java_org_ldk_enums_LDKNetwork_init (JNIEnv *env, jclass clz) {
283 LDKNetwork_class = (*env)->NewGlobalRef(env, clz);
284 CHECK(LDKNetwork_class != NULL);
285 LDKNetwork_LDKNetwork_Bitcoin = (*env)->GetStaticFieldID(env, LDKNetwork_class, "LDKNetwork_Bitcoin", "Lorg/ldk/enums/LDKNetwork;");
286 CHECK(LDKNetwork_LDKNetwork_Bitcoin != NULL);
287 LDKNetwork_LDKNetwork_Testnet = (*env)->GetStaticFieldID(env, LDKNetwork_class, "LDKNetwork_Testnet", "Lorg/ldk/enums/LDKNetwork;");
288 CHECK(LDKNetwork_LDKNetwork_Testnet != NULL);
289 LDKNetwork_LDKNetwork_Regtest = (*env)->GetStaticFieldID(env, LDKNetwork_class, "LDKNetwork_Regtest", "Lorg/ldk/enums/LDKNetwork;");
290 CHECK(LDKNetwork_LDKNetwork_Regtest != NULL);
291 LDKNetwork_LDKNetwork_Signet = (*env)->GetStaticFieldID(env, LDKNetwork_class, "LDKNetwork_Signet", "Lorg/ldk/enums/LDKNetwork;");
292 CHECK(LDKNetwork_LDKNetwork_Signet != NULL);
294 static inline jclass LDKNetwork_to_java(JNIEnv *env, LDKNetwork val) {
296 case LDKNetwork_Bitcoin:
297 return (*env)->GetStaticObjectField(env, LDKNetwork_class, LDKNetwork_LDKNetwork_Bitcoin);
298 case LDKNetwork_Testnet:
299 return (*env)->GetStaticObjectField(env, LDKNetwork_class, LDKNetwork_LDKNetwork_Testnet);
300 case LDKNetwork_Regtest:
301 return (*env)->GetStaticObjectField(env, LDKNetwork_class, LDKNetwork_LDKNetwork_Regtest);
302 case LDKNetwork_Signet:
303 return (*env)->GetStaticObjectField(env, LDKNetwork_class, LDKNetwork_LDKNetwork_Signet);
308 static inline LDKSecp256k1Error LDKSecp256k1Error_from_java(JNIEnv *env, jclass clz) {
309 switch ((*env)->CallIntMethod(env, clz, ordinal_meth)) {
310 case 0: return LDKSecp256k1Error_IncorrectSignature;
311 case 1: return LDKSecp256k1Error_InvalidMessage;
312 case 2: return LDKSecp256k1Error_InvalidPublicKey;
313 case 3: return LDKSecp256k1Error_InvalidSignature;
314 case 4: return LDKSecp256k1Error_InvalidSecretKey;
315 case 5: return LDKSecp256k1Error_InvalidRecoveryId;
316 case 6: return LDKSecp256k1Error_InvalidTweak;
317 case 7: return LDKSecp256k1Error_TweakCheckFailed;
318 case 8: return LDKSecp256k1Error_NotEnoughMemory;
322 static jclass LDKSecp256k1Error_class = NULL;
323 static jfieldID LDKSecp256k1Error_LDKSecp256k1Error_IncorrectSignature = NULL;
324 static jfieldID LDKSecp256k1Error_LDKSecp256k1Error_InvalidMessage = NULL;
325 static jfieldID LDKSecp256k1Error_LDKSecp256k1Error_InvalidPublicKey = NULL;
326 static jfieldID LDKSecp256k1Error_LDKSecp256k1Error_InvalidSignature = NULL;
327 static jfieldID LDKSecp256k1Error_LDKSecp256k1Error_InvalidSecretKey = NULL;
328 static jfieldID LDKSecp256k1Error_LDKSecp256k1Error_InvalidRecoveryId = NULL;
329 static jfieldID LDKSecp256k1Error_LDKSecp256k1Error_InvalidTweak = NULL;
330 static jfieldID LDKSecp256k1Error_LDKSecp256k1Error_TweakCheckFailed = NULL;
331 static jfieldID LDKSecp256k1Error_LDKSecp256k1Error_NotEnoughMemory = NULL;
332 JNIEXPORT void JNICALL Java_org_ldk_enums_LDKSecp256k1Error_init (JNIEnv *env, jclass clz) {
333 LDKSecp256k1Error_class = (*env)->NewGlobalRef(env, clz);
334 CHECK(LDKSecp256k1Error_class != NULL);
335 LDKSecp256k1Error_LDKSecp256k1Error_IncorrectSignature = (*env)->GetStaticFieldID(env, LDKSecp256k1Error_class, "LDKSecp256k1Error_IncorrectSignature", "Lorg/ldk/enums/LDKSecp256k1Error;");
336 CHECK(LDKSecp256k1Error_LDKSecp256k1Error_IncorrectSignature != NULL);
337 LDKSecp256k1Error_LDKSecp256k1Error_InvalidMessage = (*env)->GetStaticFieldID(env, LDKSecp256k1Error_class, "LDKSecp256k1Error_InvalidMessage", "Lorg/ldk/enums/LDKSecp256k1Error;");
338 CHECK(LDKSecp256k1Error_LDKSecp256k1Error_InvalidMessage != NULL);
339 LDKSecp256k1Error_LDKSecp256k1Error_InvalidPublicKey = (*env)->GetStaticFieldID(env, LDKSecp256k1Error_class, "LDKSecp256k1Error_InvalidPublicKey", "Lorg/ldk/enums/LDKSecp256k1Error;");
340 CHECK(LDKSecp256k1Error_LDKSecp256k1Error_InvalidPublicKey != NULL);
341 LDKSecp256k1Error_LDKSecp256k1Error_InvalidSignature = (*env)->GetStaticFieldID(env, LDKSecp256k1Error_class, "LDKSecp256k1Error_InvalidSignature", "Lorg/ldk/enums/LDKSecp256k1Error;");
342 CHECK(LDKSecp256k1Error_LDKSecp256k1Error_InvalidSignature != NULL);
343 LDKSecp256k1Error_LDKSecp256k1Error_InvalidSecretKey = (*env)->GetStaticFieldID(env, LDKSecp256k1Error_class, "LDKSecp256k1Error_InvalidSecretKey", "Lorg/ldk/enums/LDKSecp256k1Error;");
344 CHECK(LDKSecp256k1Error_LDKSecp256k1Error_InvalidSecretKey != NULL);
345 LDKSecp256k1Error_LDKSecp256k1Error_InvalidRecoveryId = (*env)->GetStaticFieldID(env, LDKSecp256k1Error_class, "LDKSecp256k1Error_InvalidRecoveryId", "Lorg/ldk/enums/LDKSecp256k1Error;");
346 CHECK(LDKSecp256k1Error_LDKSecp256k1Error_InvalidRecoveryId != NULL);
347 LDKSecp256k1Error_LDKSecp256k1Error_InvalidTweak = (*env)->GetStaticFieldID(env, LDKSecp256k1Error_class, "LDKSecp256k1Error_InvalidTweak", "Lorg/ldk/enums/LDKSecp256k1Error;");
348 CHECK(LDKSecp256k1Error_LDKSecp256k1Error_InvalidTweak != NULL);
349 LDKSecp256k1Error_LDKSecp256k1Error_TweakCheckFailed = (*env)->GetStaticFieldID(env, LDKSecp256k1Error_class, "LDKSecp256k1Error_TweakCheckFailed", "Lorg/ldk/enums/LDKSecp256k1Error;");
350 CHECK(LDKSecp256k1Error_LDKSecp256k1Error_TweakCheckFailed != NULL);
351 LDKSecp256k1Error_LDKSecp256k1Error_NotEnoughMemory = (*env)->GetStaticFieldID(env, LDKSecp256k1Error_class, "LDKSecp256k1Error_NotEnoughMemory", "Lorg/ldk/enums/LDKSecp256k1Error;");
352 CHECK(LDKSecp256k1Error_LDKSecp256k1Error_NotEnoughMemory != NULL);
354 static inline jclass LDKSecp256k1Error_to_java(JNIEnv *env, LDKSecp256k1Error val) {
356 case LDKSecp256k1Error_IncorrectSignature:
357 return (*env)->GetStaticObjectField(env, LDKSecp256k1Error_class, LDKSecp256k1Error_LDKSecp256k1Error_IncorrectSignature);
358 case LDKSecp256k1Error_InvalidMessage:
359 return (*env)->GetStaticObjectField(env, LDKSecp256k1Error_class, LDKSecp256k1Error_LDKSecp256k1Error_InvalidMessage);
360 case LDKSecp256k1Error_InvalidPublicKey:
361 return (*env)->GetStaticObjectField(env, LDKSecp256k1Error_class, LDKSecp256k1Error_LDKSecp256k1Error_InvalidPublicKey);
362 case LDKSecp256k1Error_InvalidSignature:
363 return (*env)->GetStaticObjectField(env, LDKSecp256k1Error_class, LDKSecp256k1Error_LDKSecp256k1Error_InvalidSignature);
364 case LDKSecp256k1Error_InvalidSecretKey:
365 return (*env)->GetStaticObjectField(env, LDKSecp256k1Error_class, LDKSecp256k1Error_LDKSecp256k1Error_InvalidSecretKey);
366 case LDKSecp256k1Error_InvalidRecoveryId:
367 return (*env)->GetStaticObjectField(env, LDKSecp256k1Error_class, LDKSecp256k1Error_LDKSecp256k1Error_InvalidRecoveryId);
368 case LDKSecp256k1Error_InvalidTweak:
369 return (*env)->GetStaticObjectField(env, LDKSecp256k1Error_class, LDKSecp256k1Error_LDKSecp256k1Error_InvalidTweak);
370 case LDKSecp256k1Error_TweakCheckFailed:
371 return (*env)->GetStaticObjectField(env, LDKSecp256k1Error_class, LDKSecp256k1Error_LDKSecp256k1Error_TweakCheckFailed);
372 case LDKSecp256k1Error_NotEnoughMemory:
373 return (*env)->GetStaticObjectField(env, LDKSecp256k1Error_class, LDKSecp256k1Error_LDKSecp256k1Error_NotEnoughMemory);
378 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1u8Z_1new(JNIEnv *env, jclass clz, int8_tArray elems) {
379 LDKCVec_u8Z *ret = MALLOC(sizeof(LDKCVec_u8Z), "LDKCVec_u8Z");
380 ret->datalen = (*env)->GetArrayLength(env, elems);
381 if (ret->datalen == 0) {
384 ret->data = MALLOC(sizeof(uint8_t) * ret->datalen, "LDKCVec_u8Z Data");
385 int8_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
386 for (size_t i = 0; i < ret->datalen; i++) {
387 ret->data[i] = java_elems[i];
389 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
393 static inline LDKCVec_u8Z CVec_u8Z_clone(const LDKCVec_u8Z *orig) {
394 LDKCVec_u8Z ret = { .data = MALLOC(sizeof(int8_t) * orig->datalen, "LDKCVec_u8Z clone bytes"), .datalen = orig->datalen };
395 memcpy(ret.data, orig->data, sizeof(int8_t) * ret.datalen);
398 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SecretKeyErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
399 return ((LDKCResult_SecretKeyErrorZ*)arg)->result_ok;
401 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SecretKeyErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
402 LDKCResult_SecretKeyErrorZ *val = (LDKCResult_SecretKeyErrorZ*)(arg & ~1);
403 CHECK(val->result_ok);
404 int8_tArray res_arr = (*env)->NewByteArray(env, 32);
405 (*env)->SetByteArrayRegion(env, res_arr, 0, 32, (*val->contents.result).bytes);
408 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SecretKeyErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
409 LDKCResult_SecretKeyErrorZ *val = (LDKCResult_SecretKeyErrorZ*)(arg & ~1);
410 CHECK(!val->result_ok);
411 jclass err_conv = LDKSecp256k1Error_to_java(env, (*val->contents.err));
414 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PublicKeyErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
415 return ((LDKCResult_PublicKeyErrorZ*)arg)->result_ok;
417 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PublicKeyErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
418 LDKCResult_PublicKeyErrorZ *val = (LDKCResult_PublicKeyErrorZ*)(arg & ~1);
419 CHECK(val->result_ok);
420 int8_tArray res_arr = (*env)->NewByteArray(env, 33);
421 (*env)->SetByteArrayRegion(env, res_arr, 0, 33, (*val->contents.result).compressed_form);
424 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PublicKeyErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
425 LDKCResult_PublicKeyErrorZ *val = (LDKCResult_PublicKeyErrorZ*)(arg & ~1);
426 CHECK(!val->result_ok);
427 jclass err_conv = LDKSecp256k1Error_to_java(env, (*val->contents.err));
430 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxCreationKeysDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
431 return ((LDKCResult_TxCreationKeysDecodeErrorZ*)arg)->result_ok;
433 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxCreationKeysDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
434 LDKCResult_TxCreationKeysDecodeErrorZ *val = (LDKCResult_TxCreationKeysDecodeErrorZ*)(arg & ~1);
435 CHECK(val->result_ok);
436 LDKTxCreationKeys res_var = (*val->contents.result);
437 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
438 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
439 long res_ref = (long)res_var.inner & ~1;
442 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxCreationKeysDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
443 LDKCResult_TxCreationKeysDecodeErrorZ *val = (LDKCResult_TxCreationKeysDecodeErrorZ*)(arg & ~1);
444 CHECK(!val->result_ok);
445 LDKDecodeError err_var = (*val->contents.err);
446 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
447 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
448 long err_ref = (long)err_var.inner & ~1;
451 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelPublicKeysDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
452 return ((LDKCResult_ChannelPublicKeysDecodeErrorZ*)arg)->result_ok;
454 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelPublicKeysDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
455 LDKCResult_ChannelPublicKeysDecodeErrorZ *val = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)(arg & ~1);
456 CHECK(val->result_ok);
457 LDKChannelPublicKeys res_var = (*val->contents.result);
458 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
459 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
460 long res_ref = (long)res_var.inner & ~1;
463 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelPublicKeysDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
464 LDKCResult_ChannelPublicKeysDecodeErrorZ *val = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)(arg & ~1);
465 CHECK(!val->result_ok);
466 LDKDecodeError err_var = (*val->contents.err);
467 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
468 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
469 long err_ref = (long)err_var.inner & ~1;
472 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxCreationKeysErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
473 return ((LDKCResult_TxCreationKeysErrorZ*)arg)->result_ok;
475 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxCreationKeysErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
476 LDKCResult_TxCreationKeysErrorZ *val = (LDKCResult_TxCreationKeysErrorZ*)(arg & ~1);
477 CHECK(val->result_ok);
478 LDKTxCreationKeys res_var = (*val->contents.result);
479 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
480 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
481 long res_ref = (long)res_var.inner & ~1;
484 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxCreationKeysErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
485 LDKCResult_TxCreationKeysErrorZ *val = (LDKCResult_TxCreationKeysErrorZ*)(arg & ~1);
486 CHECK(!val->result_ok);
487 jclass err_conv = LDKSecp256k1Error_to_java(env, (*val->contents.err));
490 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HTLCOutputInCommitmentDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
491 return ((LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)arg)->result_ok;
493 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HTLCOutputInCommitmentDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
494 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *val = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(arg & ~1);
495 CHECK(val->result_ok);
496 LDKHTLCOutputInCommitment res_var = (*val->contents.result);
497 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
498 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
499 long res_ref = (long)res_var.inner & ~1;
502 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HTLCOutputInCommitmentDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
503 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *val = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(arg & ~1);
504 CHECK(!val->result_ok);
505 LDKDecodeError err_var = (*val->contents.err);
506 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
507 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
508 long err_ref = (long)err_var.inner & ~1;
511 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CounterpartyChannelTransactionParametersDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
512 return ((LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)arg)->result_ok;
514 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CounterpartyChannelTransactionParametersDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
515 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *val = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(arg & ~1);
516 CHECK(val->result_ok);
517 LDKCounterpartyChannelTransactionParameters res_var = (*val->contents.result);
518 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
519 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
520 long res_ref = (long)res_var.inner & ~1;
523 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CounterpartyChannelTransactionParametersDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
524 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *val = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(arg & ~1);
525 CHECK(!val->result_ok);
526 LDKDecodeError err_var = (*val->contents.err);
527 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
528 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
529 long err_ref = (long)err_var.inner & ~1;
532 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelTransactionParametersDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
533 return ((LDKCResult_ChannelTransactionParametersDecodeErrorZ*)arg)->result_ok;
535 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelTransactionParametersDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
536 LDKCResult_ChannelTransactionParametersDecodeErrorZ *val = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(arg & ~1);
537 CHECK(val->result_ok);
538 LDKChannelTransactionParameters res_var = (*val->contents.result);
539 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
540 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
541 long res_ref = (long)res_var.inner & ~1;
544 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelTransactionParametersDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
545 LDKCResult_ChannelTransactionParametersDecodeErrorZ *val = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(arg & ~1);
546 CHECK(!val->result_ok);
547 LDKDecodeError err_var = (*val->contents.err);
548 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
549 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
550 long err_ref = (long)err_var.inner & ~1;
553 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HolderCommitmentTransactionDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
554 return ((LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)arg)->result_ok;
556 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HolderCommitmentTransactionDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
557 LDKCResult_HolderCommitmentTransactionDecodeErrorZ *val = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(arg & ~1);
558 CHECK(val->result_ok);
559 LDKHolderCommitmentTransaction res_var = (*val->contents.result);
560 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
561 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
562 long res_ref = (long)res_var.inner & ~1;
565 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HolderCommitmentTransactionDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
566 LDKCResult_HolderCommitmentTransactionDecodeErrorZ *val = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(arg & ~1);
567 CHECK(!val->result_ok);
568 LDKDecodeError err_var = (*val->contents.err);
569 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
570 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
571 long err_ref = (long)err_var.inner & ~1;
574 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1BuiltCommitmentTransactionDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
575 return ((LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)arg)->result_ok;
577 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1BuiltCommitmentTransactionDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
578 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *val = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(arg & ~1);
579 CHECK(val->result_ok);
580 LDKBuiltCommitmentTransaction res_var = (*val->contents.result);
581 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
582 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
583 long res_ref = (long)res_var.inner & ~1;
586 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1BuiltCommitmentTransactionDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
587 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *val = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(arg & ~1);
588 CHECK(!val->result_ok);
589 LDKDecodeError err_var = (*val->contents.err);
590 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
591 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
592 long err_ref = (long)err_var.inner & ~1;
595 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CommitmentTransactionDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
596 return ((LDKCResult_CommitmentTransactionDecodeErrorZ*)arg)->result_ok;
598 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CommitmentTransactionDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
599 LDKCResult_CommitmentTransactionDecodeErrorZ *val = (LDKCResult_CommitmentTransactionDecodeErrorZ*)(arg & ~1);
600 CHECK(val->result_ok);
601 LDKCommitmentTransaction res_var = (*val->contents.result);
602 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
603 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
604 long res_ref = (long)res_var.inner & ~1;
607 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CommitmentTransactionDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
608 LDKCResult_CommitmentTransactionDecodeErrorZ *val = (LDKCResult_CommitmentTransactionDecodeErrorZ*)(arg & ~1);
609 CHECK(!val->result_ok);
610 LDKDecodeError err_var = (*val->contents.err);
611 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
612 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
613 long err_ref = (long)err_var.inner & ~1;
616 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TrustedCommitmentTransactionNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
617 return ((LDKCResult_TrustedCommitmentTransactionNoneZ*)arg)->result_ok;
619 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TrustedCommitmentTransactionNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
620 LDKCResult_TrustedCommitmentTransactionNoneZ *val = (LDKCResult_TrustedCommitmentTransactionNoneZ*)(arg & ~1);
621 CHECK(val->result_ok);
622 LDKTrustedCommitmentTransaction res_var = (*val->contents.result);
623 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
624 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
625 long res_ref = (long)res_var.inner & ~1;
628 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TrustedCommitmentTransactionNoneZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
629 LDKCResult_TrustedCommitmentTransactionNoneZ *val = (LDKCResult_TrustedCommitmentTransactionNoneZ*)(arg & ~1);
630 CHECK(!val->result_ok);
631 return *val->contents.err;
633 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1SignatureZNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
634 return ((LDKCResult_CVec_SignatureZNoneZ*)arg)->result_ok;
636 JNIEXPORT jobjectArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1SignatureZNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
637 LDKCResult_CVec_SignatureZNoneZ *val = (LDKCResult_CVec_SignatureZNoneZ*)(arg & ~1);
638 CHECK(val->result_ok);
639 LDKCVec_SignatureZ res_var = (*val->contents.result);
640 jobjectArray res_arr = (*env)->NewObjectArray(env, res_var.datalen, arr_of_B_clz, NULL);
642 for (size_t i = 0; i < res_var.datalen; i++) {
643 int8_tArray res_conv_8_arr = (*env)->NewByteArray(env, 64);
644 (*env)->SetByteArrayRegion(env, res_conv_8_arr, 0, 64, res_var.data[i].compact_form);
645 (*env)->SetObjectArrayElement(env, res_arr, i, res_conv_8_arr);
649 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1SignatureZNoneZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
650 LDKCResult_CVec_SignatureZNoneZ *val = (LDKCResult_CVec_SignatureZNoneZ*)(arg & ~1);
651 CHECK(!val->result_ok);
652 return *val->contents.err;
654 static jclass LDKErrorAction_DisconnectPeer_class = NULL;
655 static jmethodID LDKErrorAction_DisconnectPeer_meth = NULL;
656 static jclass LDKErrorAction_IgnoreError_class = NULL;
657 static jmethodID LDKErrorAction_IgnoreError_meth = NULL;
658 static jclass LDKErrorAction_SendErrorMessage_class = NULL;
659 static jmethodID LDKErrorAction_SendErrorMessage_meth = NULL;
660 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKErrorAction_init (JNIEnv *env, jclass clz) {
661 LDKErrorAction_DisconnectPeer_class =
662 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKErrorAction$DisconnectPeer;"));
663 CHECK(LDKErrorAction_DisconnectPeer_class != NULL);
664 LDKErrorAction_DisconnectPeer_meth = (*env)->GetMethodID(env, LDKErrorAction_DisconnectPeer_class, "<init>", "(J)V");
665 CHECK(LDKErrorAction_DisconnectPeer_meth != NULL);
666 LDKErrorAction_IgnoreError_class =
667 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKErrorAction$IgnoreError;"));
668 CHECK(LDKErrorAction_IgnoreError_class != NULL);
669 LDKErrorAction_IgnoreError_meth = (*env)->GetMethodID(env, LDKErrorAction_IgnoreError_class, "<init>", "()V");
670 CHECK(LDKErrorAction_IgnoreError_meth != NULL);
671 LDKErrorAction_SendErrorMessage_class =
672 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKErrorAction$SendErrorMessage;"));
673 CHECK(LDKErrorAction_SendErrorMessage_class != NULL);
674 LDKErrorAction_SendErrorMessage_meth = (*env)->GetMethodID(env, LDKErrorAction_SendErrorMessage_class, "<init>", "(J)V");
675 CHECK(LDKErrorAction_SendErrorMessage_meth != NULL);
677 JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKErrorAction_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
678 LDKErrorAction *obj = (LDKErrorAction*)ptr;
680 case LDKErrorAction_DisconnectPeer: {
681 LDKErrorMessage msg_var = obj->disconnect_peer.msg;
682 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
683 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
684 long msg_ref = (long)msg_var.inner & ~1;
685 return (*env)->NewObject(env, LDKErrorAction_DisconnectPeer_class, LDKErrorAction_DisconnectPeer_meth, msg_ref);
687 case LDKErrorAction_IgnoreError: {
688 return (*env)->NewObject(env, LDKErrorAction_IgnoreError_class, LDKErrorAction_IgnoreError_meth);
690 case LDKErrorAction_SendErrorMessage: {
691 LDKErrorMessage msg_var = obj->send_error_message.msg;
692 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
693 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
694 long msg_ref = (long)msg_var.inner & ~1;
695 return (*env)->NewObject(env, LDKErrorAction_SendErrorMessage_class, LDKErrorAction_SendErrorMessage_meth, msg_ref);
700 static jclass LDKHTLCFailChannelUpdate_ChannelUpdateMessage_class = NULL;
701 static jmethodID LDKHTLCFailChannelUpdate_ChannelUpdateMessage_meth = NULL;
702 static jclass LDKHTLCFailChannelUpdate_ChannelClosed_class = NULL;
703 static jmethodID LDKHTLCFailChannelUpdate_ChannelClosed_meth = NULL;
704 static jclass LDKHTLCFailChannelUpdate_NodeFailure_class = NULL;
705 static jmethodID LDKHTLCFailChannelUpdate_NodeFailure_meth = NULL;
706 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKHTLCFailChannelUpdate_init (JNIEnv *env, jclass clz) {
707 LDKHTLCFailChannelUpdate_ChannelUpdateMessage_class =
708 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKHTLCFailChannelUpdate$ChannelUpdateMessage;"));
709 CHECK(LDKHTLCFailChannelUpdate_ChannelUpdateMessage_class != NULL);
710 LDKHTLCFailChannelUpdate_ChannelUpdateMessage_meth = (*env)->GetMethodID(env, LDKHTLCFailChannelUpdate_ChannelUpdateMessage_class, "<init>", "(J)V");
711 CHECK(LDKHTLCFailChannelUpdate_ChannelUpdateMessage_meth != NULL);
712 LDKHTLCFailChannelUpdate_ChannelClosed_class =
713 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKHTLCFailChannelUpdate$ChannelClosed;"));
714 CHECK(LDKHTLCFailChannelUpdate_ChannelClosed_class != NULL);
715 LDKHTLCFailChannelUpdate_ChannelClosed_meth = (*env)->GetMethodID(env, LDKHTLCFailChannelUpdate_ChannelClosed_class, "<init>", "(JZ)V");
716 CHECK(LDKHTLCFailChannelUpdate_ChannelClosed_meth != NULL);
717 LDKHTLCFailChannelUpdate_NodeFailure_class =
718 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKHTLCFailChannelUpdate$NodeFailure;"));
719 CHECK(LDKHTLCFailChannelUpdate_NodeFailure_class != NULL);
720 LDKHTLCFailChannelUpdate_NodeFailure_meth = (*env)->GetMethodID(env, LDKHTLCFailChannelUpdate_NodeFailure_class, "<init>", "([BZ)V");
721 CHECK(LDKHTLCFailChannelUpdate_NodeFailure_meth != NULL);
723 JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKHTLCFailChannelUpdate_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
724 LDKHTLCFailChannelUpdate *obj = (LDKHTLCFailChannelUpdate*)ptr;
726 case LDKHTLCFailChannelUpdate_ChannelUpdateMessage: {
727 LDKChannelUpdate msg_var = obj->channel_update_message.msg;
728 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
729 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
730 long msg_ref = (long)msg_var.inner & ~1;
731 return (*env)->NewObject(env, LDKHTLCFailChannelUpdate_ChannelUpdateMessage_class, LDKHTLCFailChannelUpdate_ChannelUpdateMessage_meth, msg_ref);
733 case LDKHTLCFailChannelUpdate_ChannelClosed: {
734 return (*env)->NewObject(env, LDKHTLCFailChannelUpdate_ChannelClosed_class, LDKHTLCFailChannelUpdate_ChannelClosed_meth, obj->channel_closed.short_channel_id, obj->channel_closed.is_permanent);
736 case LDKHTLCFailChannelUpdate_NodeFailure: {
737 int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
738 (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->node_failure.node_id.compressed_form);
739 return (*env)->NewObject(env, LDKHTLCFailChannelUpdate_NodeFailure_class, LDKHTLCFailChannelUpdate_NodeFailure_meth, node_id_arr, obj->node_failure.is_permanent);
744 static jclass LDKMessageSendEvent_SendAcceptChannel_class = NULL;
745 static jmethodID LDKMessageSendEvent_SendAcceptChannel_meth = NULL;
746 static jclass LDKMessageSendEvent_SendOpenChannel_class = NULL;
747 static jmethodID LDKMessageSendEvent_SendOpenChannel_meth = NULL;
748 static jclass LDKMessageSendEvent_SendFundingCreated_class = NULL;
749 static jmethodID LDKMessageSendEvent_SendFundingCreated_meth = NULL;
750 static jclass LDKMessageSendEvent_SendFundingSigned_class = NULL;
751 static jmethodID LDKMessageSendEvent_SendFundingSigned_meth = NULL;
752 static jclass LDKMessageSendEvent_SendFundingLocked_class = NULL;
753 static jmethodID LDKMessageSendEvent_SendFundingLocked_meth = NULL;
754 static jclass LDKMessageSendEvent_SendAnnouncementSignatures_class = NULL;
755 static jmethodID LDKMessageSendEvent_SendAnnouncementSignatures_meth = NULL;
756 static jclass LDKMessageSendEvent_UpdateHTLCs_class = NULL;
757 static jmethodID LDKMessageSendEvent_UpdateHTLCs_meth = NULL;
758 static jclass LDKMessageSendEvent_SendRevokeAndACK_class = NULL;
759 static jmethodID LDKMessageSendEvent_SendRevokeAndACK_meth = NULL;
760 static jclass LDKMessageSendEvent_SendClosingSigned_class = NULL;
761 static jmethodID LDKMessageSendEvent_SendClosingSigned_meth = NULL;
762 static jclass LDKMessageSendEvent_SendShutdown_class = NULL;
763 static jmethodID LDKMessageSendEvent_SendShutdown_meth = NULL;
764 static jclass LDKMessageSendEvent_SendChannelReestablish_class = NULL;
765 static jmethodID LDKMessageSendEvent_SendChannelReestablish_meth = NULL;
766 static jclass LDKMessageSendEvent_BroadcastChannelAnnouncement_class = NULL;
767 static jmethodID LDKMessageSendEvent_BroadcastChannelAnnouncement_meth = NULL;
768 static jclass LDKMessageSendEvent_BroadcastNodeAnnouncement_class = NULL;
769 static jmethodID LDKMessageSendEvent_BroadcastNodeAnnouncement_meth = NULL;
770 static jclass LDKMessageSendEvent_BroadcastChannelUpdate_class = NULL;
771 static jmethodID LDKMessageSendEvent_BroadcastChannelUpdate_meth = NULL;
772 static jclass LDKMessageSendEvent_HandleError_class = NULL;
773 static jmethodID LDKMessageSendEvent_HandleError_meth = NULL;
774 static jclass LDKMessageSendEvent_PaymentFailureNetworkUpdate_class = NULL;
775 static jmethodID LDKMessageSendEvent_PaymentFailureNetworkUpdate_meth = NULL;
776 static jclass LDKMessageSendEvent_SendChannelRangeQuery_class = NULL;
777 static jmethodID LDKMessageSendEvent_SendChannelRangeQuery_meth = NULL;
778 static jclass LDKMessageSendEvent_SendShortIdsQuery_class = NULL;
779 static jmethodID LDKMessageSendEvent_SendShortIdsQuery_meth = NULL;
780 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKMessageSendEvent_init (JNIEnv *env, jclass clz) {
781 LDKMessageSendEvent_SendAcceptChannel_class =
782 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendAcceptChannel;"));
783 CHECK(LDKMessageSendEvent_SendAcceptChannel_class != NULL);
784 LDKMessageSendEvent_SendAcceptChannel_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendAcceptChannel_class, "<init>", "([BJ)V");
785 CHECK(LDKMessageSendEvent_SendAcceptChannel_meth != NULL);
786 LDKMessageSendEvent_SendOpenChannel_class =
787 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendOpenChannel;"));
788 CHECK(LDKMessageSendEvent_SendOpenChannel_class != NULL);
789 LDKMessageSendEvent_SendOpenChannel_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendOpenChannel_class, "<init>", "([BJ)V");
790 CHECK(LDKMessageSendEvent_SendOpenChannel_meth != NULL);
791 LDKMessageSendEvent_SendFundingCreated_class =
792 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendFundingCreated;"));
793 CHECK(LDKMessageSendEvent_SendFundingCreated_class != NULL);
794 LDKMessageSendEvent_SendFundingCreated_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendFundingCreated_class, "<init>", "([BJ)V");
795 CHECK(LDKMessageSendEvent_SendFundingCreated_meth != NULL);
796 LDKMessageSendEvent_SendFundingSigned_class =
797 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendFundingSigned;"));
798 CHECK(LDKMessageSendEvent_SendFundingSigned_class != NULL);
799 LDKMessageSendEvent_SendFundingSigned_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendFundingSigned_class, "<init>", "([BJ)V");
800 CHECK(LDKMessageSendEvent_SendFundingSigned_meth != NULL);
801 LDKMessageSendEvent_SendFundingLocked_class =
802 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendFundingLocked;"));
803 CHECK(LDKMessageSendEvent_SendFundingLocked_class != NULL);
804 LDKMessageSendEvent_SendFundingLocked_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendFundingLocked_class, "<init>", "([BJ)V");
805 CHECK(LDKMessageSendEvent_SendFundingLocked_meth != NULL);
806 LDKMessageSendEvent_SendAnnouncementSignatures_class =
807 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendAnnouncementSignatures;"));
808 CHECK(LDKMessageSendEvent_SendAnnouncementSignatures_class != NULL);
809 LDKMessageSendEvent_SendAnnouncementSignatures_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendAnnouncementSignatures_class, "<init>", "([BJ)V");
810 CHECK(LDKMessageSendEvent_SendAnnouncementSignatures_meth != NULL);
811 LDKMessageSendEvent_UpdateHTLCs_class =
812 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$UpdateHTLCs;"));
813 CHECK(LDKMessageSendEvent_UpdateHTLCs_class != NULL);
814 LDKMessageSendEvent_UpdateHTLCs_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_UpdateHTLCs_class, "<init>", "([BJ)V");
815 CHECK(LDKMessageSendEvent_UpdateHTLCs_meth != NULL);
816 LDKMessageSendEvent_SendRevokeAndACK_class =
817 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendRevokeAndACK;"));
818 CHECK(LDKMessageSendEvent_SendRevokeAndACK_class != NULL);
819 LDKMessageSendEvent_SendRevokeAndACK_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendRevokeAndACK_class, "<init>", "([BJ)V");
820 CHECK(LDKMessageSendEvent_SendRevokeAndACK_meth != NULL);
821 LDKMessageSendEvent_SendClosingSigned_class =
822 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendClosingSigned;"));
823 CHECK(LDKMessageSendEvent_SendClosingSigned_class != NULL);
824 LDKMessageSendEvent_SendClosingSigned_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendClosingSigned_class, "<init>", "([BJ)V");
825 CHECK(LDKMessageSendEvent_SendClosingSigned_meth != NULL);
826 LDKMessageSendEvent_SendShutdown_class =
827 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendShutdown;"));
828 CHECK(LDKMessageSendEvent_SendShutdown_class != NULL);
829 LDKMessageSendEvent_SendShutdown_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendShutdown_class, "<init>", "([BJ)V");
830 CHECK(LDKMessageSendEvent_SendShutdown_meth != NULL);
831 LDKMessageSendEvent_SendChannelReestablish_class =
832 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendChannelReestablish;"));
833 CHECK(LDKMessageSendEvent_SendChannelReestablish_class != NULL);
834 LDKMessageSendEvent_SendChannelReestablish_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendChannelReestablish_class, "<init>", "([BJ)V");
835 CHECK(LDKMessageSendEvent_SendChannelReestablish_meth != NULL);
836 LDKMessageSendEvent_BroadcastChannelAnnouncement_class =
837 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$BroadcastChannelAnnouncement;"));
838 CHECK(LDKMessageSendEvent_BroadcastChannelAnnouncement_class != NULL);
839 LDKMessageSendEvent_BroadcastChannelAnnouncement_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_BroadcastChannelAnnouncement_class, "<init>", "(JJ)V");
840 CHECK(LDKMessageSendEvent_BroadcastChannelAnnouncement_meth != NULL);
841 LDKMessageSendEvent_BroadcastNodeAnnouncement_class =
842 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$BroadcastNodeAnnouncement;"));
843 CHECK(LDKMessageSendEvent_BroadcastNodeAnnouncement_class != NULL);
844 LDKMessageSendEvent_BroadcastNodeAnnouncement_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_BroadcastNodeAnnouncement_class, "<init>", "(J)V");
845 CHECK(LDKMessageSendEvent_BroadcastNodeAnnouncement_meth != NULL);
846 LDKMessageSendEvent_BroadcastChannelUpdate_class =
847 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$BroadcastChannelUpdate;"));
848 CHECK(LDKMessageSendEvent_BroadcastChannelUpdate_class != NULL);
849 LDKMessageSendEvent_BroadcastChannelUpdate_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_BroadcastChannelUpdate_class, "<init>", "(J)V");
850 CHECK(LDKMessageSendEvent_BroadcastChannelUpdate_meth != NULL);
851 LDKMessageSendEvent_HandleError_class =
852 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$HandleError;"));
853 CHECK(LDKMessageSendEvent_HandleError_class != NULL);
854 LDKMessageSendEvent_HandleError_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_HandleError_class, "<init>", "([BJ)V");
855 CHECK(LDKMessageSendEvent_HandleError_meth != NULL);
856 LDKMessageSendEvent_PaymentFailureNetworkUpdate_class =
857 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$PaymentFailureNetworkUpdate;"));
858 CHECK(LDKMessageSendEvent_PaymentFailureNetworkUpdate_class != NULL);
859 LDKMessageSendEvent_PaymentFailureNetworkUpdate_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_PaymentFailureNetworkUpdate_class, "<init>", "(J)V");
860 CHECK(LDKMessageSendEvent_PaymentFailureNetworkUpdate_meth != NULL);
861 LDKMessageSendEvent_SendChannelRangeQuery_class =
862 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendChannelRangeQuery;"));
863 CHECK(LDKMessageSendEvent_SendChannelRangeQuery_class != NULL);
864 LDKMessageSendEvent_SendChannelRangeQuery_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendChannelRangeQuery_class, "<init>", "([BJ)V");
865 CHECK(LDKMessageSendEvent_SendChannelRangeQuery_meth != NULL);
866 LDKMessageSendEvent_SendShortIdsQuery_class =
867 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMessageSendEvent$SendShortIdsQuery;"));
868 CHECK(LDKMessageSendEvent_SendShortIdsQuery_class != NULL);
869 LDKMessageSendEvent_SendShortIdsQuery_meth = (*env)->GetMethodID(env, LDKMessageSendEvent_SendShortIdsQuery_class, "<init>", "([BJ)V");
870 CHECK(LDKMessageSendEvent_SendShortIdsQuery_meth != NULL);
872 JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKMessageSendEvent_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
873 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)ptr;
875 case LDKMessageSendEvent_SendAcceptChannel: {
876 int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
877 (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->send_accept_channel.node_id.compressed_form);
878 LDKAcceptChannel msg_var = obj->send_accept_channel.msg;
879 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
880 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
881 long msg_ref = (long)msg_var.inner & ~1;
882 return (*env)->NewObject(env, LDKMessageSendEvent_SendAcceptChannel_class, LDKMessageSendEvent_SendAcceptChannel_meth, node_id_arr, msg_ref);
884 case LDKMessageSendEvent_SendOpenChannel: {
885 int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
886 (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->send_open_channel.node_id.compressed_form);
887 LDKOpenChannel msg_var = obj->send_open_channel.msg;
888 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
889 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
890 long msg_ref = (long)msg_var.inner & ~1;
891 return (*env)->NewObject(env, LDKMessageSendEvent_SendOpenChannel_class, LDKMessageSendEvent_SendOpenChannel_meth, node_id_arr, msg_ref);
893 case LDKMessageSendEvent_SendFundingCreated: {
894 int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
895 (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->send_funding_created.node_id.compressed_form);
896 LDKFundingCreated msg_var = obj->send_funding_created.msg;
897 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
898 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
899 long msg_ref = (long)msg_var.inner & ~1;
900 return (*env)->NewObject(env, LDKMessageSendEvent_SendFundingCreated_class, LDKMessageSendEvent_SendFundingCreated_meth, node_id_arr, msg_ref);
902 case LDKMessageSendEvent_SendFundingSigned: {
903 int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
904 (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->send_funding_signed.node_id.compressed_form);
905 LDKFundingSigned msg_var = obj->send_funding_signed.msg;
906 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
907 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
908 long msg_ref = (long)msg_var.inner & ~1;
909 return (*env)->NewObject(env, LDKMessageSendEvent_SendFundingSigned_class, LDKMessageSendEvent_SendFundingSigned_meth, node_id_arr, msg_ref);
911 case LDKMessageSendEvent_SendFundingLocked: {
912 int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
913 (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->send_funding_locked.node_id.compressed_form);
914 LDKFundingLocked msg_var = obj->send_funding_locked.msg;
915 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
916 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
917 long msg_ref = (long)msg_var.inner & ~1;
918 return (*env)->NewObject(env, LDKMessageSendEvent_SendFundingLocked_class, LDKMessageSendEvent_SendFundingLocked_meth, node_id_arr, msg_ref);
920 case LDKMessageSendEvent_SendAnnouncementSignatures: {
921 int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
922 (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->send_announcement_signatures.node_id.compressed_form);
923 LDKAnnouncementSignatures msg_var = obj->send_announcement_signatures.msg;
924 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
925 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
926 long msg_ref = (long)msg_var.inner & ~1;
927 return (*env)->NewObject(env, LDKMessageSendEvent_SendAnnouncementSignatures_class, LDKMessageSendEvent_SendAnnouncementSignatures_meth, node_id_arr, msg_ref);
929 case LDKMessageSendEvent_UpdateHTLCs: {
930 int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
931 (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->update_htl_cs.node_id.compressed_form);
932 LDKCommitmentUpdate updates_var = obj->update_htl_cs.updates;
933 CHECK((((long)updates_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
934 CHECK((((long)&updates_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
935 long updates_ref = (long)updates_var.inner & ~1;
936 return (*env)->NewObject(env, LDKMessageSendEvent_UpdateHTLCs_class, LDKMessageSendEvent_UpdateHTLCs_meth, node_id_arr, updates_ref);
938 case LDKMessageSendEvent_SendRevokeAndACK: {
939 int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
940 (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->send_revoke_and_ack.node_id.compressed_form);
941 LDKRevokeAndACK msg_var = obj->send_revoke_and_ack.msg;
942 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
943 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
944 long msg_ref = (long)msg_var.inner & ~1;
945 return (*env)->NewObject(env, LDKMessageSendEvent_SendRevokeAndACK_class, LDKMessageSendEvent_SendRevokeAndACK_meth, node_id_arr, msg_ref);
947 case LDKMessageSendEvent_SendClosingSigned: {
948 int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
949 (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->send_closing_signed.node_id.compressed_form);
950 LDKClosingSigned msg_var = obj->send_closing_signed.msg;
951 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
952 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
953 long msg_ref = (long)msg_var.inner & ~1;
954 return (*env)->NewObject(env, LDKMessageSendEvent_SendClosingSigned_class, LDKMessageSendEvent_SendClosingSigned_meth, node_id_arr, msg_ref);
956 case LDKMessageSendEvent_SendShutdown: {
957 int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
958 (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->send_shutdown.node_id.compressed_form);
959 LDKShutdown msg_var = obj->send_shutdown.msg;
960 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
961 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
962 long msg_ref = (long)msg_var.inner & ~1;
963 return (*env)->NewObject(env, LDKMessageSendEvent_SendShutdown_class, LDKMessageSendEvent_SendShutdown_meth, node_id_arr, msg_ref);
965 case LDKMessageSendEvent_SendChannelReestablish: {
966 int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
967 (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->send_channel_reestablish.node_id.compressed_form);
968 LDKChannelReestablish msg_var = obj->send_channel_reestablish.msg;
969 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
970 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
971 long msg_ref = (long)msg_var.inner & ~1;
972 return (*env)->NewObject(env, LDKMessageSendEvent_SendChannelReestablish_class, LDKMessageSendEvent_SendChannelReestablish_meth, node_id_arr, msg_ref);
974 case LDKMessageSendEvent_BroadcastChannelAnnouncement: {
975 LDKChannelAnnouncement msg_var = obj->broadcast_channel_announcement.msg;
976 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
977 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
978 long msg_ref = (long)msg_var.inner & ~1;
979 LDKChannelUpdate update_msg_var = obj->broadcast_channel_announcement.update_msg;
980 CHECK((((long)update_msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
981 CHECK((((long)&update_msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
982 long update_msg_ref = (long)update_msg_var.inner & ~1;
983 return (*env)->NewObject(env, LDKMessageSendEvent_BroadcastChannelAnnouncement_class, LDKMessageSendEvent_BroadcastChannelAnnouncement_meth, msg_ref, update_msg_ref);
985 case LDKMessageSendEvent_BroadcastNodeAnnouncement: {
986 LDKNodeAnnouncement msg_var = obj->broadcast_node_announcement.msg;
987 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
988 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
989 long msg_ref = (long)msg_var.inner & ~1;
990 return (*env)->NewObject(env, LDKMessageSendEvent_BroadcastNodeAnnouncement_class, LDKMessageSendEvent_BroadcastNodeAnnouncement_meth, msg_ref);
992 case LDKMessageSendEvent_BroadcastChannelUpdate: {
993 LDKChannelUpdate msg_var = obj->broadcast_channel_update.msg;
994 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
995 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
996 long msg_ref = (long)msg_var.inner & ~1;
997 return (*env)->NewObject(env, LDKMessageSendEvent_BroadcastChannelUpdate_class, LDKMessageSendEvent_BroadcastChannelUpdate_meth, msg_ref);
999 case LDKMessageSendEvent_HandleError: {
1000 int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
1001 (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->handle_error.node_id.compressed_form);
1002 long action_ref = ((long)&obj->handle_error.action) | 1;
1003 return (*env)->NewObject(env, LDKMessageSendEvent_HandleError_class, LDKMessageSendEvent_HandleError_meth, node_id_arr, action_ref);
1005 case LDKMessageSendEvent_PaymentFailureNetworkUpdate: {
1006 long update_ref = ((long)&obj->payment_failure_network_update.update) | 1;
1007 return (*env)->NewObject(env, LDKMessageSendEvent_PaymentFailureNetworkUpdate_class, LDKMessageSendEvent_PaymentFailureNetworkUpdate_meth, update_ref);
1009 case LDKMessageSendEvent_SendChannelRangeQuery: {
1010 int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
1011 (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->send_channel_range_query.node_id.compressed_form);
1012 LDKQueryChannelRange msg_var = obj->send_channel_range_query.msg;
1013 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1014 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1015 long msg_ref = (long)msg_var.inner & ~1;
1016 return (*env)->NewObject(env, LDKMessageSendEvent_SendChannelRangeQuery_class, LDKMessageSendEvent_SendChannelRangeQuery_meth, node_id_arr, msg_ref);
1018 case LDKMessageSendEvent_SendShortIdsQuery: {
1019 int8_tArray node_id_arr = (*env)->NewByteArray(env, 33);
1020 (*env)->SetByteArrayRegion(env, node_id_arr, 0, 33, obj->send_short_ids_query.node_id.compressed_form);
1021 LDKQueryShortChannelIds msg_var = obj->send_short_ids_query.msg;
1022 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1023 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1024 long msg_ref = (long)msg_var.inner & ~1;
1025 return (*env)->NewObject(env, LDKMessageSendEvent_SendShortIdsQuery_class, LDKMessageSendEvent_SendShortIdsQuery_meth, node_id_arr, msg_ref);
1030 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1MessageSendEventZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
1031 LDKCVec_MessageSendEventZ *ret = MALLOC(sizeof(LDKCVec_MessageSendEventZ), "LDKCVec_MessageSendEventZ");
1032 ret->datalen = (*env)->GetArrayLength(env, elems);
1033 if (ret->datalen == 0) {
1036 ret->data = MALLOC(sizeof(LDKMessageSendEvent) * ret->datalen, "LDKCVec_MessageSendEventZ Data");
1037 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
1038 for (size_t i = 0; i < ret->datalen; i++) {
1039 int64_t arr_elem = java_elems[i];
1040 LDKMessageSendEvent arr_elem_conv = *(LDKMessageSendEvent*)(((uint64_t)arr_elem) & ~1);
1041 FREE((void*)arr_elem);
1042 ret->data[i] = arr_elem_conv;
1044 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
1048 static inline LDKCVec_MessageSendEventZ CVec_MessageSendEventZ_clone(const LDKCVec_MessageSendEventZ *orig) {
1049 LDKCVec_MessageSendEventZ ret = { .data = MALLOC(sizeof(LDKMessageSendEvent) * orig->datalen, "LDKCVec_MessageSendEventZ clone bytes"), .datalen = orig->datalen };
1050 for (size_t i = 0; i < ret.datalen; i++) {
1051 ret.data[i] = MessageSendEvent_clone(&orig->data[i]);
1055 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolLightningErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1056 return ((LDKCResult_boolLightningErrorZ*)arg)->result_ok;
1058 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolLightningErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1059 LDKCResult_boolLightningErrorZ *val = (LDKCResult_boolLightningErrorZ*)(arg & ~1);
1060 CHECK(val->result_ok);
1061 return *val->contents.result;
1063 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolLightningErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
1064 LDKCResult_boolLightningErrorZ *val = (LDKCResult_boolLightningErrorZ*)(arg & ~1);
1065 CHECK(!val->result_ok);
1066 LDKLightningError err_var = (*val->contents.err);
1067 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1068 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1069 long err_ref = (long)err_var.inner & ~1;
1072 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) {
1073 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
1074 LDKChannelAnnouncement a_conv;
1075 a_conv.inner = (void*)(a & (~1));
1076 a_conv.is_owned = (a & 1) || (a == 0);
1077 a_conv = ChannelAnnouncement_clone(&a_conv);
1079 LDKChannelUpdate b_conv;
1080 b_conv.inner = (void*)(b & (~1));
1081 b_conv.is_owned = (b & 1) || (b == 0);
1082 b_conv = ChannelUpdate_clone(&b_conv);
1084 LDKChannelUpdate c_conv;
1085 c_conv.inner = (void*)(c & (~1));
1086 c_conv.is_owned = (c & 1) || (c == 0);
1087 c_conv = ChannelUpdate_clone(&c_conv);
1091 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1get_1a(JNIEnv *env, jclass clz, int64_t ptr) {
1092 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *tuple = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(ptr & ~1);
1093 LDKChannelAnnouncement a_var = tuple->a;
1094 CHECK((((long)a_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1095 CHECK((((long)&a_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1096 long a_ref = (long)a_var.inner & ~1;
1099 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1get_1b(JNIEnv *env, jclass clz, int64_t ptr) {
1100 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *tuple = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(ptr & ~1);
1101 LDKChannelUpdate b_var = tuple->b;
1102 CHECK((((long)b_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1103 CHECK((((long)&b_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1104 long b_ref = (long)b_var.inner & ~1;
1107 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1get_1c(JNIEnv *env, jclass clz, int64_t ptr) {
1108 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *tuple = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(ptr & ~1);
1109 LDKChannelUpdate c_var = tuple->c;
1110 CHECK((((long)c_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1111 CHECK((((long)&c_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1112 long c_ref = (long)c_var.inner & ~1;
1115 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
1116 LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret = MALLOC(sizeof(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
1117 ret->datalen = (*env)->GetArrayLength(env, elems);
1118 if (ret->datalen == 0) {
1121 ret->data = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ) * ret->datalen, "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ Data");
1122 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
1123 for (size_t i = 0; i < ret->datalen; i++) {
1124 int64_t arr_elem = java_elems[i];
1125 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ arr_elem_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)arr_elem) & ~1);
1126 FREE((void*)arr_elem);
1127 ret->data[i] = arr_elem_conv;
1129 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
1133 static inline LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(const LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *orig) {
1134 LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret = { .data = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ) * orig->datalen, "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ clone bytes"), .datalen = orig->datalen };
1135 for (size_t i = 0; i < ret.datalen; i++) {
1136 ret.data[i] = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(&orig->data[i]);
1140 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1NodeAnnouncementZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
1141 LDKCVec_NodeAnnouncementZ *ret = MALLOC(sizeof(LDKCVec_NodeAnnouncementZ), "LDKCVec_NodeAnnouncementZ");
1142 ret->datalen = (*env)->GetArrayLength(env, elems);
1143 if (ret->datalen == 0) {
1146 ret->data = MALLOC(sizeof(LDKNodeAnnouncement) * ret->datalen, "LDKCVec_NodeAnnouncementZ Data");
1147 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
1148 for (size_t i = 0; i < ret->datalen; i++) {
1149 int64_t arr_elem = java_elems[i];
1150 LDKNodeAnnouncement arr_elem_conv;
1151 arr_elem_conv.inner = (void*)(arr_elem & (~1));
1152 arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
1153 arr_elem_conv = NodeAnnouncement_clone(&arr_elem_conv);
1154 ret->data[i] = arr_elem_conv;
1156 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
1160 static inline LDKCVec_NodeAnnouncementZ CVec_NodeAnnouncementZ_clone(const LDKCVec_NodeAnnouncementZ *orig) {
1161 LDKCVec_NodeAnnouncementZ ret = { .data = MALLOC(sizeof(LDKNodeAnnouncement) * orig->datalen, "LDKCVec_NodeAnnouncementZ clone bytes"), .datalen = orig->datalen };
1162 for (size_t i = 0; i < ret.datalen; i++) {
1163 ret.data[i] = NodeAnnouncement_clone(&orig->data[i]);
1167 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneLightningErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1168 return ((LDKCResult_NoneLightningErrorZ*)arg)->result_ok;
1170 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneLightningErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1171 LDKCResult_NoneLightningErrorZ *val = (LDKCResult_NoneLightningErrorZ*)(arg & ~1);
1172 CHECK(val->result_ok);
1173 return *val->contents.result;
1175 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneLightningErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
1176 LDKCResult_NoneLightningErrorZ *val = (LDKCResult_NoneLightningErrorZ*)(arg & ~1);
1177 CHECK(!val->result_ok);
1178 LDKLightningError err_var = (*val->contents.err);
1179 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1180 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1181 long err_ref = (long)err_var.inner & ~1;
1184 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1u8ZPeerHandleErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1185 return ((LDKCResult_CVec_u8ZPeerHandleErrorZ*)arg)->result_ok;
1187 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1u8ZPeerHandleErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1188 LDKCResult_CVec_u8ZPeerHandleErrorZ *val = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(arg & ~1);
1189 CHECK(val->result_ok);
1190 LDKCVec_u8Z res_var = (*val->contents.result);
1191 int8_tArray res_arr = (*env)->NewByteArray(env, res_var.datalen);
1192 (*env)->SetByteArrayRegion(env, res_arr, 0, res_var.datalen, res_var.data);
1195 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1u8ZPeerHandleErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
1196 LDKCResult_CVec_u8ZPeerHandleErrorZ *val = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(arg & ~1);
1197 CHECK(!val->result_ok);
1198 LDKPeerHandleError err_var = (*val->contents.err);
1199 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1200 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1201 long err_ref = (long)err_var.inner & ~1;
1204 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePeerHandleErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1205 return ((LDKCResult_NonePeerHandleErrorZ*)arg)->result_ok;
1207 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePeerHandleErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1208 LDKCResult_NonePeerHandleErrorZ *val = (LDKCResult_NonePeerHandleErrorZ*)(arg & ~1);
1209 CHECK(val->result_ok);
1210 return *val->contents.result;
1212 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePeerHandleErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
1213 LDKCResult_NonePeerHandleErrorZ *val = (LDKCResult_NonePeerHandleErrorZ*)(arg & ~1);
1214 CHECK(!val->result_ok);
1215 LDKPeerHandleError err_var = (*val->contents.err);
1216 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1217 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1218 long err_ref = (long)err_var.inner & ~1;
1221 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolPeerHandleErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1222 return ((LDKCResult_boolPeerHandleErrorZ*)arg)->result_ok;
1224 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolPeerHandleErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1225 LDKCResult_boolPeerHandleErrorZ *val = (LDKCResult_boolPeerHandleErrorZ*)(arg & ~1);
1226 CHECK(val->result_ok);
1227 return *val->contents.result;
1229 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolPeerHandleErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
1230 LDKCResult_boolPeerHandleErrorZ *val = (LDKCResult_boolPeerHandleErrorZ*)(arg & ~1);
1231 CHECK(!val->result_ok);
1232 LDKPeerHandleError err_var = (*val->contents.err);
1233 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1234 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1235 long err_ref = (long)err_var.inner & ~1;
1238 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitFeaturesDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1239 return ((LDKCResult_InitFeaturesDecodeErrorZ*)arg)->result_ok;
1241 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitFeaturesDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1242 LDKCResult_InitFeaturesDecodeErrorZ *val = (LDKCResult_InitFeaturesDecodeErrorZ*)(arg & ~1);
1243 CHECK(val->result_ok);
1244 LDKInitFeatures res_var = (*val->contents.result);
1245 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1246 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1247 long res_ref = (long)res_var.inner & ~1;
1250 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitFeaturesDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
1251 LDKCResult_InitFeaturesDecodeErrorZ *val = (LDKCResult_InitFeaturesDecodeErrorZ*)(arg & ~1);
1252 CHECK(!val->result_ok);
1253 LDKDecodeError err_var = (*val->contents.err);
1254 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1255 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1256 long err_ref = (long)err_var.inner & ~1;
1259 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeFeaturesDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1260 return ((LDKCResult_NodeFeaturesDecodeErrorZ*)arg)->result_ok;
1262 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeFeaturesDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1263 LDKCResult_NodeFeaturesDecodeErrorZ *val = (LDKCResult_NodeFeaturesDecodeErrorZ*)(arg & ~1);
1264 CHECK(val->result_ok);
1265 LDKNodeFeatures res_var = (*val->contents.result);
1266 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1267 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1268 long res_ref = (long)res_var.inner & ~1;
1271 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeFeaturesDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
1272 LDKCResult_NodeFeaturesDecodeErrorZ *val = (LDKCResult_NodeFeaturesDecodeErrorZ*)(arg & ~1);
1273 CHECK(!val->result_ok);
1274 LDKDecodeError err_var = (*val->contents.err);
1275 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1276 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1277 long err_ref = (long)err_var.inner & ~1;
1280 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelFeaturesDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1281 return ((LDKCResult_ChannelFeaturesDecodeErrorZ*)arg)->result_ok;
1283 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelFeaturesDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1284 LDKCResult_ChannelFeaturesDecodeErrorZ *val = (LDKCResult_ChannelFeaturesDecodeErrorZ*)(arg & ~1);
1285 CHECK(val->result_ok);
1286 LDKChannelFeatures res_var = (*val->contents.result);
1287 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1288 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1289 long res_ref = (long)res_var.inner & ~1;
1292 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelFeaturesDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
1293 LDKCResult_ChannelFeaturesDecodeErrorZ *val = (LDKCResult_ChannelFeaturesDecodeErrorZ*)(arg & ~1);
1294 CHECK(!val->result_ok);
1295 LDKDecodeError err_var = (*val->contents.err);
1296 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1297 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1298 long err_ref = (long)err_var.inner & ~1;
1301 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelConfigDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1302 return ((LDKCResult_ChannelConfigDecodeErrorZ*)arg)->result_ok;
1304 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelConfigDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1305 LDKCResult_ChannelConfigDecodeErrorZ *val = (LDKCResult_ChannelConfigDecodeErrorZ*)(arg & ~1);
1306 CHECK(val->result_ok);
1307 LDKChannelConfig res_var = (*val->contents.result);
1308 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1309 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1310 long res_ref = (long)res_var.inner & ~1;
1313 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelConfigDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
1314 LDKCResult_ChannelConfigDecodeErrorZ *val = (LDKCResult_ChannelConfigDecodeErrorZ*)(arg & ~1);
1315 CHECK(!val->result_ok);
1316 LDKDecodeError err_var = (*val->contents.err);
1317 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1318 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1319 long err_ref = (long)err_var.inner & ~1;
1322 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1DirectionalChannelInfoDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1323 return ((LDKCResult_DirectionalChannelInfoDecodeErrorZ*)arg)->result_ok;
1325 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1DirectionalChannelInfoDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1326 LDKCResult_DirectionalChannelInfoDecodeErrorZ *val = (LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(arg & ~1);
1327 CHECK(val->result_ok);
1328 LDKDirectionalChannelInfo res_var = (*val->contents.result);
1329 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1330 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1331 long res_ref = (long)res_var.inner & ~1;
1334 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1DirectionalChannelInfoDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
1335 LDKCResult_DirectionalChannelInfoDecodeErrorZ *val = (LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(arg & ~1);
1336 CHECK(!val->result_ok);
1337 LDKDecodeError err_var = (*val->contents.err);
1338 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1339 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1340 long err_ref = (long)err_var.inner & ~1;
1343 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelInfoDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1344 return ((LDKCResult_ChannelInfoDecodeErrorZ*)arg)->result_ok;
1346 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelInfoDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1347 LDKCResult_ChannelInfoDecodeErrorZ *val = (LDKCResult_ChannelInfoDecodeErrorZ*)(arg & ~1);
1348 CHECK(val->result_ok);
1349 LDKChannelInfo res_var = (*val->contents.result);
1350 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1351 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1352 long res_ref = (long)res_var.inner & ~1;
1355 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelInfoDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
1356 LDKCResult_ChannelInfoDecodeErrorZ *val = (LDKCResult_ChannelInfoDecodeErrorZ*)(arg & ~1);
1357 CHECK(!val->result_ok);
1358 LDKDecodeError err_var = (*val->contents.err);
1359 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1360 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1361 long err_ref = (long)err_var.inner & ~1;
1364 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RoutingFeesDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1365 return ((LDKCResult_RoutingFeesDecodeErrorZ*)arg)->result_ok;
1367 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RoutingFeesDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1368 LDKCResult_RoutingFeesDecodeErrorZ *val = (LDKCResult_RoutingFeesDecodeErrorZ*)(arg & ~1);
1369 CHECK(val->result_ok);
1370 LDKRoutingFees res_var = (*val->contents.result);
1371 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1372 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1373 long res_ref = (long)res_var.inner & ~1;
1376 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RoutingFeesDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
1377 LDKCResult_RoutingFeesDecodeErrorZ *val = (LDKCResult_RoutingFeesDecodeErrorZ*)(arg & ~1);
1378 CHECK(!val->result_ok);
1379 LDKDecodeError err_var = (*val->contents.err);
1380 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1381 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1382 long err_ref = (long)err_var.inner & ~1;
1385 static jclass LDKNetAddress_IPv4_class = NULL;
1386 static jmethodID LDKNetAddress_IPv4_meth = NULL;
1387 static jclass LDKNetAddress_IPv6_class = NULL;
1388 static jmethodID LDKNetAddress_IPv6_meth = NULL;
1389 static jclass LDKNetAddress_OnionV2_class = NULL;
1390 static jmethodID LDKNetAddress_OnionV2_meth = NULL;
1391 static jclass LDKNetAddress_OnionV3_class = NULL;
1392 static jmethodID LDKNetAddress_OnionV3_meth = NULL;
1393 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKNetAddress_init (JNIEnv *env, jclass clz) {
1394 LDKNetAddress_IPv4_class =
1395 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKNetAddress$IPv4;"));
1396 CHECK(LDKNetAddress_IPv4_class != NULL);
1397 LDKNetAddress_IPv4_meth = (*env)->GetMethodID(env, LDKNetAddress_IPv4_class, "<init>", "([BS)V");
1398 CHECK(LDKNetAddress_IPv4_meth != NULL);
1399 LDKNetAddress_IPv6_class =
1400 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKNetAddress$IPv6;"));
1401 CHECK(LDKNetAddress_IPv6_class != NULL);
1402 LDKNetAddress_IPv6_meth = (*env)->GetMethodID(env, LDKNetAddress_IPv6_class, "<init>", "([BS)V");
1403 CHECK(LDKNetAddress_IPv6_meth != NULL);
1404 LDKNetAddress_OnionV2_class =
1405 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKNetAddress$OnionV2;"));
1406 CHECK(LDKNetAddress_OnionV2_class != NULL);
1407 LDKNetAddress_OnionV2_meth = (*env)->GetMethodID(env, LDKNetAddress_OnionV2_class, "<init>", "([BS)V");
1408 CHECK(LDKNetAddress_OnionV2_meth != NULL);
1409 LDKNetAddress_OnionV3_class =
1410 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKNetAddress$OnionV3;"));
1411 CHECK(LDKNetAddress_OnionV3_class != NULL);
1412 LDKNetAddress_OnionV3_meth = (*env)->GetMethodID(env, LDKNetAddress_OnionV3_class, "<init>", "([BSBS)V");
1413 CHECK(LDKNetAddress_OnionV3_meth != NULL);
1415 JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKNetAddress_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
1416 LDKNetAddress *obj = (LDKNetAddress*)ptr;
1418 case LDKNetAddress_IPv4: {
1419 int8_tArray addr_arr = (*env)->NewByteArray(env, 4);
1420 (*env)->SetByteArrayRegion(env, addr_arr, 0, 4, obj->i_pv4.addr.data);
1421 return (*env)->NewObject(env, LDKNetAddress_IPv4_class, LDKNetAddress_IPv4_meth, addr_arr, obj->i_pv4.port);
1423 case LDKNetAddress_IPv6: {
1424 int8_tArray addr_arr = (*env)->NewByteArray(env, 16);
1425 (*env)->SetByteArrayRegion(env, addr_arr, 0, 16, obj->i_pv6.addr.data);
1426 return (*env)->NewObject(env, LDKNetAddress_IPv6_class, LDKNetAddress_IPv6_meth, addr_arr, obj->i_pv6.port);
1428 case LDKNetAddress_OnionV2: {
1429 int8_tArray addr_arr = (*env)->NewByteArray(env, 10);
1430 (*env)->SetByteArrayRegion(env, addr_arr, 0, 10, obj->onion_v2.addr.data);
1431 return (*env)->NewObject(env, LDKNetAddress_OnionV2_class, LDKNetAddress_OnionV2_meth, addr_arr, obj->onion_v2.port);
1433 case LDKNetAddress_OnionV3: {
1434 int8_tArray ed25519_pubkey_arr = (*env)->NewByteArray(env, 32);
1435 (*env)->SetByteArrayRegion(env, ed25519_pubkey_arr, 0, 32, obj->onion_v3.ed25519_pubkey.data);
1436 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);
1441 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1NetAddressZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
1442 LDKCVec_NetAddressZ *ret = MALLOC(sizeof(LDKCVec_NetAddressZ), "LDKCVec_NetAddressZ");
1443 ret->datalen = (*env)->GetArrayLength(env, elems);
1444 if (ret->datalen == 0) {
1447 ret->data = MALLOC(sizeof(LDKNetAddress) * ret->datalen, "LDKCVec_NetAddressZ Data");
1448 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
1449 for (size_t i = 0; i < ret->datalen; i++) {
1450 int64_t arr_elem = java_elems[i];
1451 LDKNetAddress arr_elem_conv = *(LDKNetAddress*)(((uint64_t)arr_elem) & ~1);
1452 FREE((void*)arr_elem);
1453 ret->data[i] = arr_elem_conv;
1455 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
1459 static inline LDKCVec_NetAddressZ CVec_NetAddressZ_clone(const LDKCVec_NetAddressZ *orig) {
1460 LDKCVec_NetAddressZ ret = { .data = MALLOC(sizeof(LDKNetAddress) * orig->datalen, "LDKCVec_NetAddressZ clone bytes"), .datalen = orig->datalen };
1461 for (size_t i = 0; i < ret.datalen; i++) {
1462 ret.data[i] = NetAddress_clone(&orig->data[i]);
1466 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeAnnouncementInfoDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1467 return ((LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)arg)->result_ok;
1469 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeAnnouncementInfoDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1470 LDKCResult_NodeAnnouncementInfoDecodeErrorZ *val = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(arg & ~1);
1471 CHECK(val->result_ok);
1472 LDKNodeAnnouncementInfo res_var = (*val->contents.result);
1473 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1474 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1475 long res_ref = (long)res_var.inner & ~1;
1478 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeAnnouncementInfoDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
1479 LDKCResult_NodeAnnouncementInfoDecodeErrorZ *val = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(arg & ~1);
1480 CHECK(!val->result_ok);
1481 LDKDecodeError err_var = (*val->contents.err);
1482 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1483 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1484 long err_ref = (long)err_var.inner & ~1;
1487 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1u64Z_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
1488 LDKCVec_u64Z *ret = MALLOC(sizeof(LDKCVec_u64Z), "LDKCVec_u64Z");
1489 ret->datalen = (*env)->GetArrayLength(env, elems);
1490 if (ret->datalen == 0) {
1493 ret->data = MALLOC(sizeof(uint64_t) * ret->datalen, "LDKCVec_u64Z Data");
1494 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
1495 for (size_t i = 0; i < ret->datalen; i++) {
1496 ret->data[i] = java_elems[i];
1498 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
1502 static inline LDKCVec_u64Z CVec_u64Z_clone(const LDKCVec_u64Z *orig) {
1503 LDKCVec_u64Z ret = { .data = MALLOC(sizeof(int64_t) * orig->datalen, "LDKCVec_u64Z clone bytes"), .datalen = orig->datalen };
1504 memcpy(ret.data, orig->data, sizeof(int64_t) * ret.datalen);
1507 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeInfoDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1508 return ((LDKCResult_NodeInfoDecodeErrorZ*)arg)->result_ok;
1510 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeInfoDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1511 LDKCResult_NodeInfoDecodeErrorZ *val = (LDKCResult_NodeInfoDecodeErrorZ*)(arg & ~1);
1512 CHECK(val->result_ok);
1513 LDKNodeInfo res_var = (*val->contents.result);
1514 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1515 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1516 long res_ref = (long)res_var.inner & ~1;
1519 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeInfoDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
1520 LDKCResult_NodeInfoDecodeErrorZ *val = (LDKCResult_NodeInfoDecodeErrorZ*)(arg & ~1);
1521 CHECK(!val->result_ok);
1522 LDKDecodeError err_var = (*val->contents.err);
1523 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1524 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1525 long err_ref = (long)err_var.inner & ~1;
1528 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NetworkGraphDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1529 return ((LDKCResult_NetworkGraphDecodeErrorZ*)arg)->result_ok;
1531 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NetworkGraphDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1532 LDKCResult_NetworkGraphDecodeErrorZ *val = (LDKCResult_NetworkGraphDecodeErrorZ*)(arg & ~1);
1533 CHECK(val->result_ok);
1534 LDKNetworkGraph res_var = (*val->contents.result);
1535 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1536 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1537 long res_ref = (long)res_var.inner & ~1;
1540 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NetworkGraphDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
1541 LDKCResult_NetworkGraphDecodeErrorZ *val = (LDKCResult_NetworkGraphDecodeErrorZ*)(arg & ~1);
1542 CHECK(!val->result_ok);
1543 LDKDecodeError err_var = (*val->contents.err);
1544 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1545 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1546 long err_ref = (long)err_var.inner & ~1;
1549 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1usizeTransactionZ_1new(JNIEnv *env, jclass clz, int64_t a, int8_tArray b) {
1550 LDKC2Tuple_usizeTransactionZ* ret = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
1552 LDKTransaction b_ref;
1553 b_ref.datalen = (*env)->GetArrayLength(env, b);
1554 b_ref.data = MALLOC(b_ref.datalen, "LDKTransaction Bytes");
1555 (*env)->GetByteArrayRegion(env, b, 0, b_ref.datalen, b_ref.data);
1556 b_ref.data_is_owned = false;
1560 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1usizeTransactionZ_1get_1a(JNIEnv *env, jclass clz, int64_t ptr) {
1561 LDKC2Tuple_usizeTransactionZ *tuple = (LDKC2Tuple_usizeTransactionZ*)(ptr & ~1);
1564 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1usizeTransactionZ_1get_1b(JNIEnv *env, jclass clz, int64_t ptr) {
1565 LDKC2Tuple_usizeTransactionZ *tuple = (LDKC2Tuple_usizeTransactionZ*)(ptr & ~1);
1566 LDKTransaction b_var = tuple->b;
1567 int8_tArray b_arr = (*env)->NewByteArray(env, b_var.datalen);
1568 (*env)->SetByteArrayRegion(env, b_arr, 0, b_var.datalen, b_var.data);
1571 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C2Tuple_1usizeTransactionZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
1572 LDKCVec_C2Tuple_usizeTransactionZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_usizeTransactionZZ), "LDKCVec_C2Tuple_usizeTransactionZZ");
1573 ret->datalen = (*env)->GetArrayLength(env, elems);
1574 if (ret->datalen == 0) {
1577 ret->data = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ) * ret->datalen, "LDKCVec_C2Tuple_usizeTransactionZZ Data");
1578 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
1579 for (size_t i = 0; i < ret->datalen; i++) {
1580 int64_t arr_elem = java_elems[i];
1581 LDKC2Tuple_usizeTransactionZ arr_elem_conv = *(LDKC2Tuple_usizeTransactionZ*)(((uint64_t)arr_elem) & ~1);
1582 FREE((void*)arr_elem);
1583 ret->data[i] = arr_elem_conv;
1585 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
1589 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneChannelMonitorUpdateErrZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1590 return ((LDKCResult_NoneChannelMonitorUpdateErrZ*)arg)->result_ok;
1592 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneChannelMonitorUpdateErrZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1593 LDKCResult_NoneChannelMonitorUpdateErrZ *val = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(arg & ~1);
1594 CHECK(val->result_ok);
1595 return *val->contents.result;
1597 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneChannelMonitorUpdateErrZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
1598 LDKCResult_NoneChannelMonitorUpdateErrZ *val = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(arg & ~1);
1599 CHECK(!val->result_ok);
1600 jclass err_conv = LDKChannelMonitorUpdateErr_to_java(env, (*val->contents.err));
1603 static jclass LDKMonitorEvent_HTLCEvent_class = NULL;
1604 static jmethodID LDKMonitorEvent_HTLCEvent_meth = NULL;
1605 static jclass LDKMonitorEvent_CommitmentTxBroadcasted_class = NULL;
1606 static jmethodID LDKMonitorEvent_CommitmentTxBroadcasted_meth = NULL;
1607 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKMonitorEvent_init (JNIEnv *env, jclass clz) {
1608 LDKMonitorEvent_HTLCEvent_class =
1609 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMonitorEvent$HTLCEvent;"));
1610 CHECK(LDKMonitorEvent_HTLCEvent_class != NULL);
1611 LDKMonitorEvent_HTLCEvent_meth = (*env)->GetMethodID(env, LDKMonitorEvent_HTLCEvent_class, "<init>", "()V");
1612 CHECK(LDKMonitorEvent_HTLCEvent_meth != NULL);
1613 LDKMonitorEvent_CommitmentTxBroadcasted_class =
1614 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKMonitorEvent$CommitmentTxBroadcasted;"));
1615 CHECK(LDKMonitorEvent_CommitmentTxBroadcasted_class != NULL);
1616 LDKMonitorEvent_CommitmentTxBroadcasted_meth = (*env)->GetMethodID(env, LDKMonitorEvent_CommitmentTxBroadcasted_class, "<init>", "()V");
1617 CHECK(LDKMonitorEvent_CommitmentTxBroadcasted_meth != NULL);
1619 JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKMonitorEvent_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
1620 LDKMonitorEvent *obj = (LDKMonitorEvent*)ptr;
1622 case LDKMonitorEvent_HTLCEvent: {
1623 return (*env)->NewObject(env, LDKMonitorEvent_HTLCEvent_class, LDKMonitorEvent_HTLCEvent_meth);
1625 case LDKMonitorEvent_CommitmentTxBroadcasted: {
1626 return (*env)->NewObject(env, LDKMonitorEvent_CommitmentTxBroadcasted_class, LDKMonitorEvent_CommitmentTxBroadcasted_meth);
1631 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1MonitorEventZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
1632 LDKCVec_MonitorEventZ *ret = MALLOC(sizeof(LDKCVec_MonitorEventZ), "LDKCVec_MonitorEventZ");
1633 ret->datalen = (*env)->GetArrayLength(env, elems);
1634 if (ret->datalen == 0) {
1637 ret->data = MALLOC(sizeof(LDKMonitorEvent) * ret->datalen, "LDKCVec_MonitorEventZ Data");
1638 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
1639 for (size_t i = 0; i < ret->datalen; i++) {
1640 int64_t arr_elem = java_elems[i];
1641 LDKMonitorEvent arr_elem_conv = *(LDKMonitorEvent*)(((uint64_t)arr_elem) & ~1);
1642 FREE((void*)arr_elem);
1643 ret->data[i] = arr_elem_conv;
1645 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
1649 static inline LDKCVec_MonitorEventZ CVec_MonitorEventZ_clone(const LDKCVec_MonitorEventZ *orig) {
1650 LDKCVec_MonitorEventZ ret = { .data = MALLOC(sizeof(LDKMonitorEvent) * orig->datalen, "LDKCVec_MonitorEventZ clone bytes"), .datalen = orig->datalen };
1651 for (size_t i = 0; i < ret.datalen; i++) {
1652 ret.data[i] = MonitorEvent_clone(&orig->data[i]);
1656 static jclass LDKSpendableOutputDescriptor_StaticOutput_class = NULL;
1657 static jmethodID LDKSpendableOutputDescriptor_StaticOutput_meth = NULL;
1658 static jclass LDKSpendableOutputDescriptor_DelayedPaymentOutput_class = NULL;
1659 static jmethodID LDKSpendableOutputDescriptor_DelayedPaymentOutput_meth = NULL;
1660 static jclass LDKSpendableOutputDescriptor_StaticPaymentOutput_class = NULL;
1661 static jmethodID LDKSpendableOutputDescriptor_StaticPaymentOutput_meth = NULL;
1662 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKSpendableOutputDescriptor_init (JNIEnv *env, jclass clz) {
1663 LDKSpendableOutputDescriptor_StaticOutput_class =
1664 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKSpendableOutputDescriptor$StaticOutput;"));
1665 CHECK(LDKSpendableOutputDescriptor_StaticOutput_class != NULL);
1666 LDKSpendableOutputDescriptor_StaticOutput_meth = (*env)->GetMethodID(env, LDKSpendableOutputDescriptor_StaticOutput_class, "<init>", "(JJ)V");
1667 CHECK(LDKSpendableOutputDescriptor_StaticOutput_meth != NULL);
1668 LDKSpendableOutputDescriptor_DelayedPaymentOutput_class =
1669 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKSpendableOutputDescriptor$DelayedPaymentOutput;"));
1670 CHECK(LDKSpendableOutputDescriptor_DelayedPaymentOutput_class != NULL);
1671 LDKSpendableOutputDescriptor_DelayedPaymentOutput_meth = (*env)->GetMethodID(env, LDKSpendableOutputDescriptor_DelayedPaymentOutput_class, "<init>", "()V");
1672 CHECK(LDKSpendableOutputDescriptor_DelayedPaymentOutput_meth != NULL);
1673 LDKSpendableOutputDescriptor_StaticPaymentOutput_class =
1674 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKSpendableOutputDescriptor$StaticPaymentOutput;"));
1675 CHECK(LDKSpendableOutputDescriptor_StaticPaymentOutput_class != NULL);
1676 LDKSpendableOutputDescriptor_StaticPaymentOutput_meth = (*env)->GetMethodID(env, LDKSpendableOutputDescriptor_StaticPaymentOutput_class, "<init>", "()V");
1677 CHECK(LDKSpendableOutputDescriptor_StaticPaymentOutput_meth != NULL);
1679 JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKSpendableOutputDescriptor_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
1680 LDKSpendableOutputDescriptor *obj = (LDKSpendableOutputDescriptor*)ptr;
1682 case LDKSpendableOutputDescriptor_StaticOutput: {
1683 LDKOutPoint outpoint_var = obj->static_output.outpoint;
1684 CHECK((((long)outpoint_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1685 CHECK((((long)&outpoint_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1686 long outpoint_ref = (long)outpoint_var.inner & ~1;
1687 long output_ref = ((long)&obj->static_output.output) | 1;
1688 return (*env)->NewObject(env, LDKSpendableOutputDescriptor_StaticOutput_class, LDKSpendableOutputDescriptor_StaticOutput_meth, outpoint_ref, (long)output_ref);
1690 case LDKSpendableOutputDescriptor_DelayedPaymentOutput: {
1691 return (*env)->NewObject(env, LDKSpendableOutputDescriptor_DelayedPaymentOutput_class, LDKSpendableOutputDescriptor_DelayedPaymentOutput_meth);
1693 case LDKSpendableOutputDescriptor_StaticPaymentOutput: {
1694 return (*env)->NewObject(env, LDKSpendableOutputDescriptor_StaticPaymentOutput_class, LDKSpendableOutputDescriptor_StaticPaymentOutput_meth);
1699 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1SpendableOutputDescriptorZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
1700 LDKCVec_SpendableOutputDescriptorZ *ret = MALLOC(sizeof(LDKCVec_SpendableOutputDescriptorZ), "LDKCVec_SpendableOutputDescriptorZ");
1701 ret->datalen = (*env)->GetArrayLength(env, elems);
1702 if (ret->datalen == 0) {
1705 ret->data = MALLOC(sizeof(LDKSpendableOutputDescriptor) * ret->datalen, "LDKCVec_SpendableOutputDescriptorZ Data");
1706 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
1707 for (size_t i = 0; i < ret->datalen; i++) {
1708 int64_t arr_elem = java_elems[i];
1709 LDKSpendableOutputDescriptor arr_elem_conv = *(LDKSpendableOutputDescriptor*)(((uint64_t)arr_elem) & ~1);
1710 FREE((void*)arr_elem);
1711 ret->data[i] = arr_elem_conv;
1713 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
1717 static inline LDKCVec_SpendableOutputDescriptorZ CVec_SpendableOutputDescriptorZ_clone(const LDKCVec_SpendableOutputDescriptorZ *orig) {
1718 LDKCVec_SpendableOutputDescriptorZ ret = { .data = MALLOC(sizeof(LDKSpendableOutputDescriptor) * orig->datalen, "LDKCVec_SpendableOutputDescriptorZ clone bytes"), .datalen = orig->datalen };
1719 for (size_t i = 0; i < ret.datalen; i++) {
1720 ret.data[i] = SpendableOutputDescriptor_clone(&orig->data[i]);
1724 static jclass LDKEvent_FundingGenerationReady_class = NULL;
1725 static jmethodID LDKEvent_FundingGenerationReady_meth = NULL;
1726 static jclass LDKEvent_FundingBroadcastSafe_class = NULL;
1727 static jmethodID LDKEvent_FundingBroadcastSafe_meth = NULL;
1728 static jclass LDKEvent_PaymentReceived_class = NULL;
1729 static jmethodID LDKEvent_PaymentReceived_meth = NULL;
1730 static jclass LDKEvent_PaymentSent_class = NULL;
1731 static jmethodID LDKEvent_PaymentSent_meth = NULL;
1732 static jclass LDKEvent_PaymentFailed_class = NULL;
1733 static jmethodID LDKEvent_PaymentFailed_meth = NULL;
1734 static jclass LDKEvent_PendingHTLCsForwardable_class = NULL;
1735 static jmethodID LDKEvent_PendingHTLCsForwardable_meth = NULL;
1736 static jclass LDKEvent_SpendableOutputs_class = NULL;
1737 static jmethodID LDKEvent_SpendableOutputs_meth = NULL;
1738 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKEvent_init (JNIEnv *env, jclass clz) {
1739 LDKEvent_FundingGenerationReady_class =
1740 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$FundingGenerationReady;"));
1741 CHECK(LDKEvent_FundingGenerationReady_class != NULL);
1742 LDKEvent_FundingGenerationReady_meth = (*env)->GetMethodID(env, LDKEvent_FundingGenerationReady_class, "<init>", "([BJ[BJ)V");
1743 CHECK(LDKEvent_FundingGenerationReady_meth != NULL);
1744 LDKEvent_FundingBroadcastSafe_class =
1745 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$FundingBroadcastSafe;"));
1746 CHECK(LDKEvent_FundingBroadcastSafe_class != NULL);
1747 LDKEvent_FundingBroadcastSafe_meth = (*env)->GetMethodID(env, LDKEvent_FundingBroadcastSafe_class, "<init>", "(JJ)V");
1748 CHECK(LDKEvent_FundingBroadcastSafe_meth != NULL);
1749 LDKEvent_PaymentReceived_class =
1750 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$PaymentReceived;"));
1751 CHECK(LDKEvent_PaymentReceived_class != NULL);
1752 LDKEvent_PaymentReceived_meth = (*env)->GetMethodID(env, LDKEvent_PaymentReceived_class, "<init>", "([B[BJ)V");
1753 CHECK(LDKEvent_PaymentReceived_meth != NULL);
1754 LDKEvent_PaymentSent_class =
1755 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$PaymentSent;"));
1756 CHECK(LDKEvent_PaymentSent_class != NULL);
1757 LDKEvent_PaymentSent_meth = (*env)->GetMethodID(env, LDKEvent_PaymentSent_class, "<init>", "([B)V");
1758 CHECK(LDKEvent_PaymentSent_meth != NULL);
1759 LDKEvent_PaymentFailed_class =
1760 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$PaymentFailed;"));
1761 CHECK(LDKEvent_PaymentFailed_class != NULL);
1762 LDKEvent_PaymentFailed_meth = (*env)->GetMethodID(env, LDKEvent_PaymentFailed_class, "<init>", "([BZ)V");
1763 CHECK(LDKEvent_PaymentFailed_meth != NULL);
1764 LDKEvent_PendingHTLCsForwardable_class =
1765 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$PendingHTLCsForwardable;"));
1766 CHECK(LDKEvent_PendingHTLCsForwardable_class != NULL);
1767 LDKEvent_PendingHTLCsForwardable_meth = (*env)->GetMethodID(env, LDKEvent_PendingHTLCsForwardable_class, "<init>", "(J)V");
1768 CHECK(LDKEvent_PendingHTLCsForwardable_meth != NULL);
1769 LDKEvent_SpendableOutputs_class =
1770 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$SpendableOutputs;"));
1771 CHECK(LDKEvent_SpendableOutputs_class != NULL);
1772 LDKEvent_SpendableOutputs_meth = (*env)->GetMethodID(env, LDKEvent_SpendableOutputs_class, "<init>", "([J)V");
1773 CHECK(LDKEvent_SpendableOutputs_meth != NULL);
1775 JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKEvent_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
1776 LDKEvent *obj = (LDKEvent*)ptr;
1778 case LDKEvent_FundingGenerationReady: {
1779 int8_tArray temporary_channel_id_arr = (*env)->NewByteArray(env, 32);
1780 (*env)->SetByteArrayRegion(env, temporary_channel_id_arr, 0, 32, obj->funding_generation_ready.temporary_channel_id.data);
1781 LDKCVec_u8Z output_script_var = obj->funding_generation_ready.output_script;
1782 int8_tArray output_script_arr = (*env)->NewByteArray(env, output_script_var.datalen);
1783 (*env)->SetByteArrayRegion(env, output_script_arr, 0, output_script_var.datalen, output_script_var.data);
1784 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);
1786 case LDKEvent_FundingBroadcastSafe: {
1787 LDKOutPoint funding_txo_var = obj->funding_broadcast_safe.funding_txo;
1788 CHECK((((long)funding_txo_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1789 CHECK((((long)&funding_txo_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1790 long funding_txo_ref = (long)funding_txo_var.inner & ~1;
1791 return (*env)->NewObject(env, LDKEvent_FundingBroadcastSafe_class, LDKEvent_FundingBroadcastSafe_meth, funding_txo_ref, obj->funding_broadcast_safe.user_channel_id);
1793 case LDKEvent_PaymentReceived: {
1794 int8_tArray payment_hash_arr = (*env)->NewByteArray(env, 32);
1795 (*env)->SetByteArrayRegion(env, payment_hash_arr, 0, 32, obj->payment_received.payment_hash.data);
1796 int8_tArray payment_secret_arr = (*env)->NewByteArray(env, 32);
1797 (*env)->SetByteArrayRegion(env, payment_secret_arr, 0, 32, obj->payment_received.payment_secret.data);
1798 return (*env)->NewObject(env, LDKEvent_PaymentReceived_class, LDKEvent_PaymentReceived_meth, payment_hash_arr, payment_secret_arr, obj->payment_received.amt);
1800 case LDKEvent_PaymentSent: {
1801 int8_tArray payment_preimage_arr = (*env)->NewByteArray(env, 32);
1802 (*env)->SetByteArrayRegion(env, payment_preimage_arr, 0, 32, obj->payment_sent.payment_preimage.data);
1803 return (*env)->NewObject(env, LDKEvent_PaymentSent_class, LDKEvent_PaymentSent_meth, payment_preimage_arr);
1805 case LDKEvent_PaymentFailed: {
1806 int8_tArray payment_hash_arr = (*env)->NewByteArray(env, 32);
1807 (*env)->SetByteArrayRegion(env, payment_hash_arr, 0, 32, obj->payment_failed.payment_hash.data);
1808 return (*env)->NewObject(env, LDKEvent_PaymentFailed_class, LDKEvent_PaymentFailed_meth, payment_hash_arr, obj->payment_failed.rejected_by_dest);
1810 case LDKEvent_PendingHTLCsForwardable: {
1811 return (*env)->NewObject(env, LDKEvent_PendingHTLCsForwardable_class, LDKEvent_PendingHTLCsForwardable_meth, obj->pending_htl_cs_forwardable.time_forwardable);
1813 case LDKEvent_SpendableOutputs: {
1814 LDKCVec_SpendableOutputDescriptorZ outputs_var = obj->spendable_outputs.outputs;
1815 int64_tArray outputs_arr = (*env)->NewLongArray(env, outputs_var.datalen);
1816 int64_t *outputs_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, outputs_arr, NULL);
1817 for (size_t b = 0; b < outputs_var.datalen; b++) {
1818 long outputs_conv_27_ref = ((long)&outputs_var.data[b]) | 1;
1819 outputs_arr_ptr[b] = outputs_conv_27_ref;
1821 (*env)->ReleasePrimitiveArrayCritical(env, outputs_arr, outputs_arr_ptr, 0);
1822 return (*env)->NewObject(env, LDKEvent_SpendableOutputs_class, LDKEvent_SpendableOutputs_meth, outputs_arr);
1827 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1EventZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
1828 LDKCVec_EventZ *ret = MALLOC(sizeof(LDKCVec_EventZ), "LDKCVec_EventZ");
1829 ret->datalen = (*env)->GetArrayLength(env, elems);
1830 if (ret->datalen == 0) {
1833 ret->data = MALLOC(sizeof(LDKEvent) * ret->datalen, "LDKCVec_EventZ Data");
1834 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
1835 for (size_t i = 0; i < ret->datalen; i++) {
1836 int64_t arr_elem = java_elems[i];
1837 LDKEvent arr_elem_conv = *(LDKEvent*)(((uint64_t)arr_elem) & ~1);
1838 FREE((void*)arr_elem);
1839 ret->data[i] = arr_elem_conv;
1841 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
1845 static inline LDKCVec_EventZ CVec_EventZ_clone(const LDKCVec_EventZ *orig) {
1846 LDKCVec_EventZ ret = { .data = MALLOC(sizeof(LDKEvent) * orig->datalen, "LDKCVec_EventZ clone bytes"), .datalen = orig->datalen };
1847 for (size_t i = 0; i < ret.datalen; i++) {
1848 ret.data[i] = Event_clone(&orig->data[i]);
1852 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1OutPointDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1853 return ((LDKCResult_OutPointDecodeErrorZ*)arg)->result_ok;
1855 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1OutPointDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1856 LDKCResult_OutPointDecodeErrorZ *val = (LDKCResult_OutPointDecodeErrorZ*)(arg & ~1);
1857 CHECK(val->result_ok);
1858 LDKOutPoint res_var = (*val->contents.result);
1859 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1860 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1861 long res_ref = (long)res_var.inner & ~1;
1864 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1OutPointDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
1865 LDKCResult_OutPointDecodeErrorZ *val = (LDKCResult_OutPointDecodeErrorZ*)(arg & ~1);
1866 CHECK(!val->result_ok);
1867 LDKDecodeError err_var = (*val->contents.err);
1868 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1869 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1870 long err_ref = (long)err_var.inner & ~1;
1873 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelMonitorUpdateDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1874 return ((LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)arg)->result_ok;
1876 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelMonitorUpdateDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1877 LDKCResult_ChannelMonitorUpdateDecodeErrorZ *val = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(arg & ~1);
1878 CHECK(val->result_ok);
1879 LDKChannelMonitorUpdate res_var = (*val->contents.result);
1880 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1881 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1882 long res_ref = (long)res_var.inner & ~1;
1885 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelMonitorUpdateDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
1886 LDKCResult_ChannelMonitorUpdateDecodeErrorZ *val = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(arg & ~1);
1887 CHECK(!val->result_ok);
1888 LDKDecodeError err_var = (*val->contents.err);
1889 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1890 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1891 long err_ref = (long)err_var.inner & ~1;
1894 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HTLCUpdateDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1895 return ((LDKCResult_HTLCUpdateDecodeErrorZ*)arg)->result_ok;
1897 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HTLCUpdateDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1898 LDKCResult_HTLCUpdateDecodeErrorZ *val = (LDKCResult_HTLCUpdateDecodeErrorZ*)(arg & ~1);
1899 CHECK(val->result_ok);
1900 LDKHTLCUpdate res_var = (*val->contents.result);
1901 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1902 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1903 long res_ref = (long)res_var.inner & ~1;
1906 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HTLCUpdateDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
1907 LDKCResult_HTLCUpdateDecodeErrorZ *val = (LDKCResult_HTLCUpdateDecodeErrorZ*)(arg & ~1);
1908 CHECK(!val->result_ok);
1909 LDKDecodeError err_var = (*val->contents.err);
1910 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1911 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1912 long err_ref = (long)err_var.inner & ~1;
1915 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneMonitorUpdateErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1916 return ((LDKCResult_NoneMonitorUpdateErrorZ*)arg)->result_ok;
1918 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneMonitorUpdateErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
1919 LDKCResult_NoneMonitorUpdateErrorZ *val = (LDKCResult_NoneMonitorUpdateErrorZ*)(arg & ~1);
1920 CHECK(val->result_ok);
1921 return *val->contents.result;
1923 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneMonitorUpdateErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
1924 LDKCResult_NoneMonitorUpdateErrorZ *val = (LDKCResult_NoneMonitorUpdateErrorZ*)(arg & ~1);
1925 CHECK(!val->result_ok);
1926 LDKMonitorUpdateError err_var = (*val->contents.err);
1927 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1928 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1929 long err_ref = (long)err_var.inner & ~1;
1932 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1OutPointScriptZ_1new(JNIEnv *env, jclass clz, int64_t a, int8_tArray b) {
1933 LDKC2Tuple_OutPointScriptZ* ret = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
1935 a_conv.inner = (void*)(a & (~1));
1936 a_conv.is_owned = (a & 1) || (a == 0);
1937 a_conv = OutPoint_clone(&a_conv);
1940 b_ref.datalen = (*env)->GetArrayLength(env, b);
1941 b_ref.data = MALLOC(b_ref.datalen, "LDKCVec_u8Z Bytes");
1942 (*env)->GetByteArrayRegion(env, b, 0, b_ref.datalen, b_ref.data);
1946 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1OutPointScriptZ_1get_1a(JNIEnv *env, jclass clz, int64_t ptr) {
1947 LDKC2Tuple_OutPointScriptZ *tuple = (LDKC2Tuple_OutPointScriptZ*)(ptr & ~1);
1948 LDKOutPoint a_var = tuple->a;
1949 CHECK((((long)a_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1950 CHECK((((long)&a_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1951 long a_ref = (long)a_var.inner & ~1;
1954 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1OutPointScriptZ_1get_1b(JNIEnv *env, jclass clz, int64_t ptr) {
1955 LDKC2Tuple_OutPointScriptZ *tuple = (LDKC2Tuple_OutPointScriptZ*)(ptr & ~1);
1956 LDKCVec_u8Z b_var = tuple->b;
1957 int8_tArray b_arr = (*env)->NewByteArray(env, b_var.datalen);
1958 (*env)->SetByteArrayRegion(env, b_arr, 0, b_var.datalen, b_var.data);
1961 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1u32ScriptZ_1new(JNIEnv *env, jclass clz, int32_t a, int8_tArray b) {
1962 LDKC2Tuple_u32ScriptZ* ret = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
1965 b_ref.datalen = (*env)->GetArrayLength(env, b);
1966 b_ref.data = MALLOC(b_ref.datalen, "LDKCVec_u8Z Bytes");
1967 (*env)->GetByteArrayRegion(env, b, 0, b_ref.datalen, b_ref.data);
1971 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1u32ScriptZ_1get_1a(JNIEnv *env, jclass clz, int64_t ptr) {
1972 LDKC2Tuple_u32ScriptZ *tuple = (LDKC2Tuple_u32ScriptZ*)(ptr & ~1);
1975 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1u32ScriptZ_1get_1b(JNIEnv *env, jclass clz, int64_t ptr) {
1976 LDKC2Tuple_u32ScriptZ *tuple = (LDKC2Tuple_u32ScriptZ*)(ptr & ~1);
1977 LDKCVec_u8Z b_var = tuple->b;
1978 int8_tArray b_arr = (*env)->NewByteArray(env, b_var.datalen);
1979 (*env)->SetByteArrayRegion(env, b_arr, 0, b_var.datalen, b_var.data);
1982 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C2Tuple_1u32ScriptZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
1983 LDKCVec_C2Tuple_u32ScriptZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_u32ScriptZZ), "LDKCVec_C2Tuple_u32ScriptZZ");
1984 ret->datalen = (*env)->GetArrayLength(env, elems);
1985 if (ret->datalen == 0) {
1988 ret->data = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ) * ret->datalen, "LDKCVec_C2Tuple_u32ScriptZZ Data");
1989 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
1990 for (size_t i = 0; i < ret->datalen; i++) {
1991 int64_t arr_elem = java_elems[i];
1992 LDKC2Tuple_u32ScriptZ arr_elem_conv = *(LDKC2Tuple_u32ScriptZ*)(((uint64_t)arr_elem) & ~1);
1993 FREE((void*)arr_elem);
1994 ret->data[i] = arr_elem_conv;
1996 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
2000 static inline LDKCVec_C2Tuple_u32ScriptZZ CVec_C2Tuple_u32ScriptZZ_clone(const LDKCVec_C2Tuple_u32ScriptZZ *orig) {
2001 LDKCVec_C2Tuple_u32ScriptZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ) * orig->datalen, "LDKCVec_C2Tuple_u32ScriptZZ clone bytes"), .datalen = orig->datalen };
2002 for (size_t i = 0; i < ret.datalen; i++) {
2003 ret.data[i] = C2Tuple_u32ScriptZ_clone(&orig->data[i]);
2007 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1TxidCVec_1C2Tuple_1u32ScriptZZZ_1new(JNIEnv *env, jclass clz, int8_tArray a, int64_tArray b) {
2008 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
2009 LDKThirtyTwoBytes a_ref;
2010 CHECK((*env)->GetArrayLength(env, a) == 32);
2011 (*env)->GetByteArrayRegion(env, a, 0, 32, a_ref.data);
2013 LDKCVec_C2Tuple_u32ScriptZZ b_constr;
2014 b_constr.datalen = (*env)->GetArrayLength(env, b);
2015 if (b_constr.datalen > 0)
2016 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKC2Tuple_u32ScriptZ), "LDKCVec_C2Tuple_u32ScriptZZ Elements");
2018 b_constr.data = NULL;
2019 int64_t* b_vals = (*env)->GetLongArrayElements (env, b, NULL);
2020 for (size_t b = 0; b < b_constr.datalen; b++) {
2021 int64_t b_conv_27 = b_vals[b];
2022 LDKC2Tuple_u32ScriptZ b_conv_27_conv = *(LDKC2Tuple_u32ScriptZ*)(((uint64_t)b_conv_27) & ~1);
2023 FREE((void*)b_conv_27);
2024 b_constr.data[b] = b_conv_27_conv;
2026 (*env)->ReleaseLongArrayElements(env, b, b_vals, 0);
2030 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1TxidCVec_1C2Tuple_1u32ScriptZZZ_1get_1a(JNIEnv *env, jclass clz, int64_t ptr) {
2031 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *tuple = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(ptr & ~1);
2032 int8_tArray a_arr = (*env)->NewByteArray(env, 32);
2033 (*env)->SetByteArrayRegion(env, a_arr, 0, 32, tuple->a.data);
2036 JNIEXPORT int64_tArray JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1TxidCVec_1C2Tuple_1u32ScriptZZZ_1get_1b(JNIEnv *env, jclass clz, int64_t ptr) {
2037 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *tuple = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(ptr & ~1);
2038 LDKCVec_C2Tuple_u32ScriptZZ b_var = tuple->b;
2039 int64_tArray b_arr = (*env)->NewLongArray(env, b_var.datalen);
2040 int64_t *b_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, b_arr, NULL);
2041 for (size_t b = 0; b < b_var.datalen; b++) {
2042 long b_conv_27_ref = (long)(&b_var.data[b]) | 1;
2043 b_arr_ptr[b] = b_conv_27_ref;
2045 (*env)->ReleasePrimitiveArrayCritical(env, b_arr, b_arr_ptr, 0);
2048 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C2Tuple_1TxidCVec_1C2Tuple_1u32ScriptZZZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
2049 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ), "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ");
2050 ret->datalen = (*env)->GetArrayLength(env, elems);
2051 if (ret->datalen == 0) {
2054 ret->data = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ) * ret->datalen, "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ Data");
2055 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
2056 for (size_t i = 0; i < ret->datalen; i++) {
2057 int64_t arr_elem = java_elems[i];
2058 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ arr_elem_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(((uint64_t)arr_elem) & ~1);
2059 FREE((void*)arr_elem);
2060 ret->data[i] = arr_elem_conv;
2062 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
2066 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1u32TxOutZ_1new(JNIEnv *env, jclass clz, int32_t a, int64_t b) {
2067 LDKC2Tuple_u32TxOutZ* ret = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
2069 LDKTxOut b_conv = *(LDKTxOut*)(((uint64_t)b) & ~1);
2074 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1u32TxOutZ_1get_1a(JNIEnv *env, jclass clz, int64_t ptr) {
2075 LDKC2Tuple_u32TxOutZ *tuple = (LDKC2Tuple_u32TxOutZ*)(ptr & ~1);
2078 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1u32TxOutZ_1get_1b(JNIEnv *env, jclass clz, int64_t ptr) {
2079 LDKC2Tuple_u32TxOutZ *tuple = (LDKC2Tuple_u32TxOutZ*)(ptr & ~1);
2080 long b_ref = ((long)&tuple->b) | 1;
2083 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C2Tuple_1u32TxOutZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
2084 LDKCVec_C2Tuple_u32TxOutZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_u32TxOutZZ), "LDKCVec_C2Tuple_u32TxOutZZ");
2085 ret->datalen = (*env)->GetArrayLength(env, elems);
2086 if (ret->datalen == 0) {
2089 ret->data = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ) * ret->datalen, "LDKCVec_C2Tuple_u32TxOutZZ Data");
2090 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
2091 for (size_t i = 0; i < ret->datalen; i++) {
2092 int64_t arr_elem = java_elems[i];
2093 LDKC2Tuple_u32TxOutZ arr_elem_conv = *(LDKC2Tuple_u32TxOutZ*)(((uint64_t)arr_elem) & ~1);
2094 FREE((void*)arr_elem);
2095 ret->data[i] = arr_elem_conv;
2097 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
2101 static inline LDKCVec_C2Tuple_u32TxOutZZ CVec_C2Tuple_u32TxOutZZ_clone(const LDKCVec_C2Tuple_u32TxOutZZ *orig) {
2102 LDKCVec_C2Tuple_u32TxOutZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ) * orig->datalen, "LDKCVec_C2Tuple_u32TxOutZZ clone bytes"), .datalen = orig->datalen };
2103 for (size_t i = 0; i < ret.datalen; i++) {
2104 ret.data[i] = C2Tuple_u32TxOutZ_clone(&orig->data[i]);
2108 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1TxidCVec_1C2Tuple_1u32TxOutZZZ_1new(JNIEnv *env, jclass clz, int8_tArray a, int64_tArray b) {
2109 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
2110 LDKThirtyTwoBytes a_ref;
2111 CHECK((*env)->GetArrayLength(env, a) == 32);
2112 (*env)->GetByteArrayRegion(env, a, 0, 32, a_ref.data);
2114 LDKCVec_C2Tuple_u32TxOutZZ b_constr;
2115 b_constr.datalen = (*env)->GetArrayLength(env, b);
2116 if (b_constr.datalen > 0)
2117 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKC2Tuple_u32TxOutZ), "LDKCVec_C2Tuple_u32TxOutZZ Elements");
2119 b_constr.data = NULL;
2120 int64_t* b_vals = (*env)->GetLongArrayElements (env, b, NULL);
2121 for (size_t a = 0; a < b_constr.datalen; a++) {
2122 int64_t b_conv_26 = b_vals[a];
2123 LDKC2Tuple_u32TxOutZ b_conv_26_conv = *(LDKC2Tuple_u32TxOutZ*)(((uint64_t)b_conv_26) & ~1);
2124 FREE((void*)b_conv_26);
2125 b_constr.data[a] = b_conv_26_conv;
2127 (*env)->ReleaseLongArrayElements(env, b, b_vals, 0);
2131 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1TxidCVec_1C2Tuple_1u32TxOutZZZ_1get_1a(JNIEnv *env, jclass clz, int64_t ptr) {
2132 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *tuple = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(ptr & ~1);
2133 int8_tArray a_arr = (*env)->NewByteArray(env, 32);
2134 (*env)->SetByteArrayRegion(env, a_arr, 0, 32, tuple->a.data);
2137 JNIEXPORT int64_tArray JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1TxidCVec_1C2Tuple_1u32TxOutZZZ_1get_1b(JNIEnv *env, jclass clz, int64_t ptr) {
2138 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *tuple = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(ptr & ~1);
2139 LDKCVec_C2Tuple_u32TxOutZZ b_var = tuple->b;
2140 int64_tArray b_arr = (*env)->NewLongArray(env, b_var.datalen);
2141 int64_t *b_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, b_arr, NULL);
2142 for (size_t a = 0; a < b_var.datalen; a++) {
2143 long b_conv_26_ref = (long)(&b_var.data[a]) | 1;
2144 b_arr_ptr[a] = b_conv_26_ref;
2146 (*env)->ReleasePrimitiveArrayCritical(env, b_arr, b_arr_ptr, 0);
2149 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C2Tuple_1TxidCVec_1C2Tuple_1u32TxOutZZZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
2150 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ), "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ");
2151 ret->datalen = (*env)->GetArrayLength(env, elems);
2152 if (ret->datalen == 0) {
2155 ret->data = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ) * ret->datalen, "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ Data");
2156 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
2157 for (size_t i = 0; i < ret->datalen; i++) {
2158 int64_t arr_elem = java_elems[i];
2159 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ arr_elem_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(((uint64_t)arr_elem) & ~1);
2160 FREE((void*)arr_elem);
2161 ret->data[i] = arr_elem_conv;
2163 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
2167 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1SignatureCVec_1SignatureZZ_1new(JNIEnv *env, jclass clz, int8_tArray a, jobjectArray b) {
2168 LDKC2Tuple_SignatureCVec_SignatureZZ* ret = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
2170 CHECK((*env)->GetArrayLength(env, a) == 64);
2171 (*env)->GetByteArrayRegion(env, a, 0, 64, a_ref.compact_form);
2173 LDKCVec_SignatureZ b_constr;
2174 b_constr.datalen = (*env)->GetArrayLength(env, b);
2175 if (b_constr.datalen > 0)
2176 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
2178 b_constr.data = NULL;
2179 for (size_t i = 0; i < b_constr.datalen; i++) {
2180 int8_tArray b_conv_8 = (*env)->GetObjectArrayElement(env, b, i);
2181 LDKSignature b_conv_8_ref;
2182 CHECK((*env)->GetArrayLength(env, b_conv_8) == 64);
2183 (*env)->GetByteArrayRegion(env, b_conv_8, 0, 64, b_conv_8_ref.compact_form);
2184 b_constr.data[i] = b_conv_8_ref;
2189 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1SignatureCVec_1SignatureZZ_1get_1a(JNIEnv *env, jclass clz, int64_t ptr) {
2190 LDKC2Tuple_SignatureCVec_SignatureZZ *tuple = (LDKC2Tuple_SignatureCVec_SignatureZZ*)(ptr & ~1);
2191 int8_tArray a_arr = (*env)->NewByteArray(env, 64);
2192 (*env)->SetByteArrayRegion(env, a_arr, 0, 64, tuple->a.compact_form);
2195 JNIEXPORT jobjectArray JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1SignatureCVec_1SignatureZZ_1get_1b(JNIEnv *env, jclass clz, int64_t ptr) {
2196 LDKC2Tuple_SignatureCVec_SignatureZZ *tuple = (LDKC2Tuple_SignatureCVec_SignatureZZ*)(ptr & ~1);
2197 LDKCVec_SignatureZ b_var = tuple->b;
2198 jobjectArray b_arr = (*env)->NewObjectArray(env, b_var.datalen, arr_of_B_clz, NULL);
2200 for (size_t i = 0; i < b_var.datalen; i++) {
2201 int8_tArray b_conv_8_arr = (*env)->NewByteArray(env, 64);
2202 (*env)->SetByteArrayRegion(env, b_conv_8_arr, 0, 64, b_var.data[i].compact_form);
2203 (*env)->SetObjectArrayElement(env, b_arr, i, b_conv_8_arr);
2207 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1SignatureCVec_1SignatureZZNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
2208 return ((LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)arg)->result_ok;
2210 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1SignatureCVec_1SignatureZZNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
2211 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *val = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(arg & ~1);
2212 CHECK(val->result_ok);
2213 long res_ref = (long)(&(*val->contents.result)) | 1;
2216 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1SignatureCVec_1SignatureZZNoneZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
2217 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *val = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(arg & ~1);
2218 CHECK(!val->result_ok);
2219 return *val->contents.err;
2221 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SignatureNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
2222 return ((LDKCResult_SignatureNoneZ*)arg)->result_ok;
2224 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SignatureNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
2225 LDKCResult_SignatureNoneZ *val = (LDKCResult_SignatureNoneZ*)(arg & ~1);
2226 CHECK(val->result_ok);
2227 int8_tArray res_arr = (*env)->NewByteArray(env, 64);
2228 (*env)->SetByteArrayRegion(env, res_arr, 0, 64, (*val->contents.result).compact_form);
2231 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SignatureNoneZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
2232 LDKCResult_SignatureNoneZ *val = (LDKCResult_SignatureNoneZ*)(arg & ~1);
2233 CHECK(!val->result_ok);
2234 return *val->contents.err;
2236 typedef struct LDKSign_JCalls {
2237 atomic_size_t refcnt;
2240 jmethodID get_per_commitment_point_meth;
2241 jmethodID release_commitment_secret_meth;
2242 jmethodID channel_keys_id_meth;
2243 jmethodID sign_counterparty_commitment_meth;
2244 jmethodID sign_holder_commitment_and_htlcs_meth;
2245 jmethodID sign_justice_transaction_meth;
2246 jmethodID sign_counterparty_htlc_transaction_meth;
2247 jmethodID sign_closing_transaction_meth;
2248 jmethodID sign_channel_announcement_meth;
2249 jmethodID ready_channel_meth;
2250 jmethodID write_meth;
2252 static void LDKSign_JCalls_free(void* this_arg) {
2253 LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
2254 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
2256 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
2257 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
2261 LDKPublicKey get_per_commitment_point_jcall(const void* this_arg, uint64_t idx) {
2262 LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
2264 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
2265 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
2267 int8_tArray ret = (*env)->CallObjectMethod(env, obj, j_calls->get_per_commitment_point_meth, idx);
2268 LDKPublicKey ret_ref;
2269 CHECK((*env)->GetArrayLength(env, ret) == 33);
2270 (*env)->GetByteArrayRegion(env, ret, 0, 33, ret_ref.compressed_form);
2273 LDKThirtyTwoBytes release_commitment_secret_jcall(const void* this_arg, uint64_t idx) {
2274 LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
2276 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
2277 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
2279 int8_tArray ret = (*env)->CallObjectMethod(env, obj, j_calls->release_commitment_secret_meth, idx);
2280 LDKThirtyTwoBytes ret_ref;
2281 CHECK((*env)->GetArrayLength(env, ret) == 32);
2282 (*env)->GetByteArrayRegion(env, ret, 0, 32, ret_ref.data);
2285 LDKThirtyTwoBytes channel_keys_id_jcall(const void* this_arg) {
2286 LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
2288 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
2289 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
2291 int8_tArray ret = (*env)->CallObjectMethod(env, obj, j_calls->channel_keys_id_meth);
2292 LDKThirtyTwoBytes ret_ref;
2293 CHECK((*env)->GetArrayLength(env, ret) == 32);
2294 (*env)->GetByteArrayRegion(env, ret, 0, 32, ret_ref.data);
2297 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_counterparty_commitment_jcall(const void* this_arg, const LDKCommitmentTransaction * commitment_tx) {
2298 LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
2300 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
2301 LDKCommitmentTransaction commitment_tx_var = *commitment_tx;
2302 commitment_tx_var = CommitmentTransaction_clone(commitment_tx);
2303 CHECK((((long)commitment_tx_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2304 CHECK((((long)&commitment_tx_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2305 long commitment_tx_ref = (long)commitment_tx_var.inner;
2306 if (commitment_tx_var.is_owned) {
2307 commitment_tx_ref |= 1;
2309 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
2311 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(*env)->CallLongMethod(env, obj, j_calls->sign_counterparty_commitment_meth, commitment_tx_ref);
2312 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ret_conv = *(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(((uint64_t)ret) & ~1);
2313 ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone((LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)ret);
2316 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_holder_commitment_and_htlcs_jcall(const void* this_arg, const LDKHolderCommitmentTransaction * commitment_tx) {
2317 LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
2319 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
2320 LDKHolderCommitmentTransaction commitment_tx_var = *commitment_tx;
2321 commitment_tx_var = HolderCommitmentTransaction_clone(commitment_tx);
2322 CHECK((((long)commitment_tx_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2323 CHECK((((long)&commitment_tx_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2324 long commitment_tx_ref = (long)commitment_tx_var.inner;
2325 if (commitment_tx_var.is_owned) {
2326 commitment_tx_ref |= 1;
2328 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
2330 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(*env)->CallLongMethod(env, obj, j_calls->sign_holder_commitment_and_htlcs_meth, commitment_tx_ref);
2331 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ret_conv = *(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(((uint64_t)ret) & ~1);
2332 ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone((LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)ret);
2335 LDKCResult_SignatureNoneZ sign_justice_transaction_jcall(const void* this_arg, LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (* per_commitment_key)[32], const LDKHTLCOutputInCommitment * htlc) {
2336 LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
2338 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
2339 LDKTransaction justice_tx_var = justice_tx;
2340 int8_tArray justice_tx_arr = (*env)->NewByteArray(env, justice_tx_var.datalen);
2341 (*env)->SetByteArrayRegion(env, justice_tx_arr, 0, justice_tx_var.datalen, justice_tx_var.data);
2342 Transaction_free(justice_tx_var);
2343 int8_tArray per_commitment_key_arr = (*env)->NewByteArray(env, 32);
2344 (*env)->SetByteArrayRegion(env, per_commitment_key_arr, 0, 32, *per_commitment_key);
2345 LDKHTLCOutputInCommitment htlc_var = *htlc;
2346 htlc_var = HTLCOutputInCommitment_clone(htlc);
2347 CHECK((((long)htlc_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2348 CHECK((((long)&htlc_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2349 long htlc_ref = (long)htlc_var.inner;
2350 if (htlc_var.is_owned) {
2353 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
2355 LDKCResult_SignatureNoneZ* ret = (LDKCResult_SignatureNoneZ*)(*env)->CallLongMethod(env, obj, j_calls->sign_justice_transaction_meth, justice_tx_arr, input, amount, per_commitment_key_arr, htlc_ref);
2356 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1);
2357 ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)ret);
2360 LDKCResult_SignatureNoneZ sign_counterparty_htlc_transaction_jcall(const void* this_arg, LDKTransaction htlc_tx, uintptr_t input, uint64_t amount, LDKPublicKey per_commitment_point, const LDKHTLCOutputInCommitment * htlc) {
2361 LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
2363 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
2364 LDKTransaction htlc_tx_var = htlc_tx;
2365 int8_tArray htlc_tx_arr = (*env)->NewByteArray(env, htlc_tx_var.datalen);
2366 (*env)->SetByteArrayRegion(env, htlc_tx_arr, 0, htlc_tx_var.datalen, htlc_tx_var.data);
2367 Transaction_free(htlc_tx_var);
2368 int8_tArray per_commitment_point_arr = (*env)->NewByteArray(env, 33);
2369 (*env)->SetByteArrayRegion(env, per_commitment_point_arr, 0, 33, per_commitment_point.compressed_form);
2370 LDKHTLCOutputInCommitment htlc_var = *htlc;
2371 htlc_var = HTLCOutputInCommitment_clone(htlc);
2372 CHECK((((long)htlc_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2373 CHECK((((long)&htlc_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2374 long htlc_ref = (long)htlc_var.inner;
2375 if (htlc_var.is_owned) {
2378 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
2380 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);
2381 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1);
2382 ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)ret);
2385 LDKCResult_SignatureNoneZ sign_closing_transaction_jcall(const void* this_arg, LDKTransaction closing_tx) {
2386 LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
2388 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
2389 LDKTransaction closing_tx_var = closing_tx;
2390 int8_tArray closing_tx_arr = (*env)->NewByteArray(env, closing_tx_var.datalen);
2391 (*env)->SetByteArrayRegion(env, closing_tx_arr, 0, closing_tx_var.datalen, closing_tx_var.data);
2392 Transaction_free(closing_tx_var);
2393 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
2395 LDKCResult_SignatureNoneZ* ret = (LDKCResult_SignatureNoneZ*)(*env)->CallLongMethod(env, obj, j_calls->sign_closing_transaction_meth, closing_tx_arr);
2396 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1);
2397 ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)ret);
2400 LDKCResult_SignatureNoneZ sign_channel_announcement_jcall(const void* this_arg, const LDKUnsignedChannelAnnouncement * msg) {
2401 LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
2403 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
2404 LDKUnsignedChannelAnnouncement msg_var = *msg;
2405 msg_var = UnsignedChannelAnnouncement_clone(msg);
2406 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2407 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2408 long msg_ref = (long)msg_var.inner;
2409 if (msg_var.is_owned) {
2412 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
2414 LDKCResult_SignatureNoneZ* ret = (LDKCResult_SignatureNoneZ*)(*env)->CallLongMethod(env, obj, j_calls->sign_channel_announcement_meth, msg_ref);
2415 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1);
2416 ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)ret);
2419 void ready_channel_jcall(void* this_arg, const LDKChannelTransactionParameters * channel_parameters) {
2420 LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
2422 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
2423 LDKChannelTransactionParameters channel_parameters_var = *channel_parameters;
2424 channel_parameters_var = ChannelTransactionParameters_clone(channel_parameters);
2425 CHECK((((long)channel_parameters_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2426 CHECK((((long)&channel_parameters_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2427 long channel_parameters_ref = (long)channel_parameters_var.inner;
2428 if (channel_parameters_var.is_owned) {
2429 channel_parameters_ref |= 1;
2431 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
2433 return (*env)->CallVoidMethod(env, obj, j_calls->ready_channel_meth, channel_parameters_ref);
2435 LDKCVec_u8Z write_jcall(const void* this_arg) {
2436 LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
2438 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
2439 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
2441 int8_tArray ret = (*env)->CallObjectMethod(env, obj, j_calls->write_meth);
2442 LDKCVec_u8Z ret_ref;
2443 ret_ref.datalen = (*env)->GetArrayLength(env, ret);
2444 ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
2445 (*env)->GetByteArrayRegion(env, ret, 0, ret_ref.datalen, ret_ref.data);
2448 static void* LDKSign_JCalls_clone(const void* this_arg) {
2449 LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
2450 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
2451 return (void*) this_arg;
2453 static inline LDKSign LDKSign_init (JNIEnv *env, jclass clz, jobject o, int64_t pubkeys) {
2454 jclass c = (*env)->GetObjectClass(env, o);
2456 LDKSign_JCalls *calls = MALLOC(sizeof(LDKSign_JCalls), "LDKSign_JCalls");
2457 atomic_init(&calls->refcnt, 1);
2458 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
2459 calls->o = (*env)->NewWeakGlobalRef(env, o);
2460 calls->get_per_commitment_point_meth = (*env)->GetMethodID(env, c, "get_per_commitment_point", "(J)[B");
2461 CHECK(calls->get_per_commitment_point_meth != NULL);
2462 calls->release_commitment_secret_meth = (*env)->GetMethodID(env, c, "release_commitment_secret", "(J)[B");
2463 CHECK(calls->release_commitment_secret_meth != NULL);
2464 calls->channel_keys_id_meth = (*env)->GetMethodID(env, c, "channel_keys_id", "()[B");
2465 CHECK(calls->channel_keys_id_meth != NULL);
2466 calls->sign_counterparty_commitment_meth = (*env)->GetMethodID(env, c, "sign_counterparty_commitment", "(J)J");
2467 CHECK(calls->sign_counterparty_commitment_meth != NULL);
2468 calls->sign_holder_commitment_and_htlcs_meth = (*env)->GetMethodID(env, c, "sign_holder_commitment_and_htlcs", "(J)J");
2469 CHECK(calls->sign_holder_commitment_and_htlcs_meth != NULL);
2470 calls->sign_justice_transaction_meth = (*env)->GetMethodID(env, c, "sign_justice_transaction", "([BJJ[BJ)J");
2471 CHECK(calls->sign_justice_transaction_meth != NULL);
2472 calls->sign_counterparty_htlc_transaction_meth = (*env)->GetMethodID(env, c, "sign_counterparty_htlc_transaction", "([BJJ[BJ)J");
2473 CHECK(calls->sign_counterparty_htlc_transaction_meth != NULL);
2474 calls->sign_closing_transaction_meth = (*env)->GetMethodID(env, c, "sign_closing_transaction", "([B)J");
2475 CHECK(calls->sign_closing_transaction_meth != NULL);
2476 calls->sign_channel_announcement_meth = (*env)->GetMethodID(env, c, "sign_channel_announcement", "(J)J");
2477 CHECK(calls->sign_channel_announcement_meth != NULL);
2478 calls->ready_channel_meth = (*env)->GetMethodID(env, c, "ready_channel", "(J)V");
2479 CHECK(calls->ready_channel_meth != NULL);
2480 calls->write_meth = (*env)->GetMethodID(env, c, "write", "()[B");
2481 CHECK(calls->write_meth != NULL);
2483 LDKChannelPublicKeys pubkeys_conv;
2484 pubkeys_conv.inner = (void*)(pubkeys & (~1));
2485 pubkeys_conv.is_owned = (pubkeys & 1) || (pubkeys == 0);
2486 pubkeys_conv = ChannelPublicKeys_clone(&pubkeys_conv);
2489 .this_arg = (void*) calls,
2490 .get_per_commitment_point = get_per_commitment_point_jcall,
2491 .release_commitment_secret = release_commitment_secret_jcall,
2492 .channel_keys_id = channel_keys_id_jcall,
2493 .sign_counterparty_commitment = sign_counterparty_commitment_jcall,
2494 .sign_holder_commitment_and_htlcs = sign_holder_commitment_and_htlcs_jcall,
2495 .sign_justice_transaction = sign_justice_transaction_jcall,
2496 .sign_counterparty_htlc_transaction = sign_counterparty_htlc_transaction_jcall,
2497 .sign_closing_transaction = sign_closing_transaction_jcall,
2498 .sign_channel_announcement = sign_channel_announcement_jcall,
2499 .ready_channel = ready_channel_jcall,
2500 .clone = LDKSign_JCalls_clone,
2501 .write = write_jcall,
2502 .free = LDKSign_JCalls_free,
2503 .pubkeys = pubkeys_conv,
2504 .set_pubkeys = NULL,
2508 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKSign_1new(JNIEnv *env, jclass clz, jobject o, int64_t pubkeys) {
2509 LDKSign *res_ptr = MALLOC(sizeof(LDKSign), "LDKSign");
2510 *res_ptr = LDKSign_init(env, clz, o, pubkeys);
2511 return (long)res_ptr;
2513 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_Sign_1get_1per_1commitment_1point(JNIEnv *env, jclass clz, int64_t this_arg, int64_t idx) {
2514 LDKSign* this_arg_conv = (LDKSign*)(((uint64_t)this_arg) & ~1);
2515 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
2516 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, (this_arg_conv->get_per_commitment_point)(this_arg_conv->this_arg, idx).compressed_form);
2520 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_Sign_1release_1commitment_1secret(JNIEnv *env, jclass clz, int64_t this_arg, int64_t idx) {
2521 LDKSign* this_arg_conv = (LDKSign*)(((uint64_t)this_arg) & ~1);
2522 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
2523 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, (this_arg_conv->release_commitment_secret)(this_arg_conv->this_arg, idx).data);
2527 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_Sign_1channel_1keys_1id(JNIEnv *env, jclass clz, int64_t this_arg) {
2528 LDKSign* this_arg_conv = (LDKSign*)(((uint64_t)this_arg) & ~1);
2529 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
2530 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, (this_arg_conv->channel_keys_id)(this_arg_conv->this_arg).data);
2534 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Sign_1sign_1counterparty_1commitment(JNIEnv *env, jclass clz, int64_t this_arg, int64_t commitment_tx) {
2535 LDKSign* this_arg_conv = (LDKSign*)(((uint64_t)this_arg) & ~1);
2536 LDKCommitmentTransaction commitment_tx_conv;
2537 commitment_tx_conv.inner = (void*)(commitment_tx & (~1));
2538 commitment_tx_conv.is_owned = false;
2539 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
2540 *ret_conv = (this_arg_conv->sign_counterparty_commitment)(this_arg_conv->this_arg, &commitment_tx_conv);
2541 return (long)ret_conv;
2544 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Sign_1sign_1holder_1commitment_1and_1htlcs(JNIEnv *env, jclass clz, int64_t this_arg, int64_t commitment_tx) {
2545 LDKSign* this_arg_conv = (LDKSign*)(((uint64_t)this_arg) & ~1);
2546 LDKHolderCommitmentTransaction commitment_tx_conv;
2547 commitment_tx_conv.inner = (void*)(commitment_tx & (~1));
2548 commitment_tx_conv.is_owned = false;
2549 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
2550 *ret_conv = (this_arg_conv->sign_holder_commitment_and_htlcs)(this_arg_conv->this_arg, &commitment_tx_conv);
2551 return (long)ret_conv;
2554 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Sign_1sign_1justice_1transaction(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) {
2555 LDKSign* this_arg_conv = (LDKSign*)(((uint64_t)this_arg) & ~1);
2556 LDKTransaction justice_tx_ref;
2557 justice_tx_ref.datalen = (*env)->GetArrayLength(env, justice_tx);
2558 justice_tx_ref.data = MALLOC(justice_tx_ref.datalen, "LDKTransaction Bytes");
2559 (*env)->GetByteArrayRegion(env, justice_tx, 0, justice_tx_ref.datalen, justice_tx_ref.data);
2560 justice_tx_ref.data_is_owned = true;
2561 unsigned char per_commitment_key_arr[32];
2562 CHECK((*env)->GetArrayLength(env, per_commitment_key) == 32);
2563 (*env)->GetByteArrayRegion(env, per_commitment_key, 0, 32, per_commitment_key_arr);
2564 unsigned char (*per_commitment_key_ref)[32] = &per_commitment_key_arr;
2565 LDKHTLCOutputInCommitment htlc_conv;
2566 htlc_conv.inner = (void*)(htlc & (~1));
2567 htlc_conv.is_owned = false;
2568 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
2569 *ret_conv = (this_arg_conv->sign_justice_transaction)(this_arg_conv->this_arg, justice_tx_ref, input, amount, per_commitment_key_ref, &htlc_conv);
2570 return (long)ret_conv;
2573 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Sign_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) {
2574 LDKSign* this_arg_conv = (LDKSign*)(((uint64_t)this_arg) & ~1);
2575 LDKTransaction htlc_tx_ref;
2576 htlc_tx_ref.datalen = (*env)->GetArrayLength(env, htlc_tx);
2577 htlc_tx_ref.data = MALLOC(htlc_tx_ref.datalen, "LDKTransaction Bytes");
2578 (*env)->GetByteArrayRegion(env, htlc_tx, 0, htlc_tx_ref.datalen, htlc_tx_ref.data);
2579 htlc_tx_ref.data_is_owned = true;
2580 LDKPublicKey per_commitment_point_ref;
2581 CHECK((*env)->GetArrayLength(env, per_commitment_point) == 33);
2582 (*env)->GetByteArrayRegion(env, per_commitment_point, 0, 33, per_commitment_point_ref.compressed_form);
2583 LDKHTLCOutputInCommitment htlc_conv;
2584 htlc_conv.inner = (void*)(htlc & (~1));
2585 htlc_conv.is_owned = false;
2586 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
2587 *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);
2588 return (long)ret_conv;
2591 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Sign_1sign_1closing_1transaction(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray closing_tx) {
2592 LDKSign* this_arg_conv = (LDKSign*)(((uint64_t)this_arg) & ~1);
2593 LDKTransaction closing_tx_ref;
2594 closing_tx_ref.datalen = (*env)->GetArrayLength(env, closing_tx);
2595 closing_tx_ref.data = MALLOC(closing_tx_ref.datalen, "LDKTransaction Bytes");
2596 (*env)->GetByteArrayRegion(env, closing_tx, 0, closing_tx_ref.datalen, closing_tx_ref.data);
2597 closing_tx_ref.data_is_owned = true;
2598 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
2599 *ret_conv = (this_arg_conv->sign_closing_transaction)(this_arg_conv->this_arg, closing_tx_ref);
2600 return (long)ret_conv;
2603 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Sign_1sign_1channel_1announcement(JNIEnv *env, jclass clz, int64_t this_arg, int64_t msg) {
2604 LDKSign* this_arg_conv = (LDKSign*)(((uint64_t)this_arg) & ~1);
2605 LDKUnsignedChannelAnnouncement msg_conv;
2606 msg_conv.inner = (void*)(msg & (~1));
2607 msg_conv.is_owned = false;
2608 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
2609 *ret_conv = (this_arg_conv->sign_channel_announcement)(this_arg_conv->this_arg, &msg_conv);
2610 return (long)ret_conv;
2613 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Sign_1ready_1channel(JNIEnv *env, jclass clz, int64_t this_arg, int64_t channel_parameters) {
2614 LDKSign* this_arg_conv = (LDKSign*)(((uint64_t)this_arg) & ~1);
2615 LDKChannelTransactionParameters channel_parameters_conv;
2616 channel_parameters_conv.inner = (void*)(channel_parameters & (~1));
2617 channel_parameters_conv.is_owned = false;
2618 (this_arg_conv->ready_channel)(this_arg_conv->this_arg, &channel_parameters_conv);
2621 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_Sign_1write(JNIEnv *env, jclass clz, int64_t this_arg) {
2622 LDKSign* this_arg_conv = (LDKSign*)(((uint64_t)this_arg) & ~1);
2623 LDKCVec_u8Z ret_var = (this_arg_conv->write)(this_arg_conv->this_arg);
2624 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
2625 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
2626 CVec_u8Z_free(ret_var);
2630 LDKChannelPublicKeys LDKSign_set_get_pubkeys(LDKSign* this_arg) {
2631 if (this_arg->set_pubkeys != NULL)
2632 this_arg->set_pubkeys(this_arg);
2633 return this_arg->pubkeys;
2635 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Sign_1get_1pubkeys(JNIEnv *env, jclass clz, int64_t this_arg) {
2636 LDKSign* this_arg_conv = (LDKSign*)(((uint64_t)this_arg) & ~1);
2637 LDKChannelPublicKeys ret_var = LDKSign_set_get_pubkeys(this_arg_conv);
2638 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2639 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2640 long ret_ref = (long)ret_var.inner;
2641 if (ret_var.is_owned) {
2647 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1BlockHashChannelMonitorZ_1new(JNIEnv *env, jclass clz, int8_tArray a, int64_t b) {
2648 LDKC2Tuple_BlockHashChannelMonitorZ* ret = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
2649 LDKThirtyTwoBytes a_ref;
2650 CHECK((*env)->GetArrayLength(env, a) == 32);
2651 (*env)->GetByteArrayRegion(env, a, 0, 32, a_ref.data);
2653 LDKChannelMonitor b_conv;
2654 b_conv.inner = (void*)(b & (~1));
2655 b_conv.is_owned = (b & 1) || (b == 0);
2656 b_conv = ChannelMonitor_clone(&b_conv);
2660 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1BlockHashChannelMonitorZ_1get_1a(JNIEnv *env, jclass clz, int64_t ptr) {
2661 LDKC2Tuple_BlockHashChannelMonitorZ *tuple = (LDKC2Tuple_BlockHashChannelMonitorZ*)(ptr & ~1);
2662 int8_tArray a_arr = (*env)->NewByteArray(env, 32);
2663 (*env)->SetByteArrayRegion(env, a_arr, 0, 32, tuple->a.data);
2666 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1BlockHashChannelMonitorZ_1get_1b(JNIEnv *env, jclass clz, int64_t ptr) {
2667 LDKC2Tuple_BlockHashChannelMonitorZ *tuple = (LDKC2Tuple_BlockHashChannelMonitorZ*)(ptr & ~1);
2668 LDKChannelMonitor b_var = tuple->b;
2669 CHECK((((long)b_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2670 CHECK((((long)&b_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2671 long b_ref = (long)b_var.inner & ~1;
2674 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1BlockHashChannelMonitorZDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
2675 return ((LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)arg)->result_ok;
2677 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1BlockHashChannelMonitorZDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
2678 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *val = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(arg & ~1);
2679 CHECK(val->result_ok);
2680 long res_ref = (long)(&(*val->contents.result)) | 1;
2683 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1BlockHashChannelMonitorZDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
2684 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *val = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(arg & ~1);
2685 CHECK(!val->result_ok);
2686 LDKDecodeError err_var = (*val->contents.err);
2687 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2688 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2689 long err_ref = (long)err_var.inner & ~1;
2692 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxOutAccessErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
2693 return ((LDKCResult_TxOutAccessErrorZ*)arg)->result_ok;
2695 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxOutAccessErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
2696 LDKCResult_TxOutAccessErrorZ *val = (LDKCResult_TxOutAccessErrorZ*)(arg & ~1);
2697 CHECK(val->result_ok);
2698 long res_ref = ((long)&(*val->contents.result)) | 1;
2699 return (long)res_ref;
2701 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxOutAccessErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
2702 LDKCResult_TxOutAccessErrorZ *val = (LDKCResult_TxOutAccessErrorZ*)(arg & ~1);
2703 CHECK(!val->result_ok);
2704 jclass err_conv = LDKAccessError_to_java(env, (*val->contents.err));
2707 static jclass LDKAPIError_APIMisuseError_class = NULL;
2708 static jmethodID LDKAPIError_APIMisuseError_meth = NULL;
2709 static jclass LDKAPIError_FeeRateTooHigh_class = NULL;
2710 static jmethodID LDKAPIError_FeeRateTooHigh_meth = NULL;
2711 static jclass LDKAPIError_RouteError_class = NULL;
2712 static jmethodID LDKAPIError_RouteError_meth = NULL;
2713 static jclass LDKAPIError_ChannelUnavailable_class = NULL;
2714 static jmethodID LDKAPIError_ChannelUnavailable_meth = NULL;
2715 static jclass LDKAPIError_MonitorUpdateFailed_class = NULL;
2716 static jmethodID LDKAPIError_MonitorUpdateFailed_meth = NULL;
2717 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKAPIError_init (JNIEnv *env, jclass clz) {
2718 LDKAPIError_APIMisuseError_class =
2719 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKAPIError$APIMisuseError;"));
2720 CHECK(LDKAPIError_APIMisuseError_class != NULL);
2721 LDKAPIError_APIMisuseError_meth = (*env)->GetMethodID(env, LDKAPIError_APIMisuseError_class, "<init>", "([B)V");
2722 CHECK(LDKAPIError_APIMisuseError_meth != NULL);
2723 LDKAPIError_FeeRateTooHigh_class =
2724 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKAPIError$FeeRateTooHigh;"));
2725 CHECK(LDKAPIError_FeeRateTooHigh_class != NULL);
2726 LDKAPIError_FeeRateTooHigh_meth = (*env)->GetMethodID(env, LDKAPIError_FeeRateTooHigh_class, "<init>", "([BI)V");
2727 CHECK(LDKAPIError_FeeRateTooHigh_meth != NULL);
2728 LDKAPIError_RouteError_class =
2729 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKAPIError$RouteError;"));
2730 CHECK(LDKAPIError_RouteError_class != NULL);
2731 LDKAPIError_RouteError_meth = (*env)->GetMethodID(env, LDKAPIError_RouteError_class, "<init>", "(Ljava/lang/String;)V");
2732 CHECK(LDKAPIError_RouteError_meth != NULL);
2733 LDKAPIError_ChannelUnavailable_class =
2734 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKAPIError$ChannelUnavailable;"));
2735 CHECK(LDKAPIError_ChannelUnavailable_class != NULL);
2736 LDKAPIError_ChannelUnavailable_meth = (*env)->GetMethodID(env, LDKAPIError_ChannelUnavailable_class, "<init>", "([B)V");
2737 CHECK(LDKAPIError_ChannelUnavailable_meth != NULL);
2738 LDKAPIError_MonitorUpdateFailed_class =
2739 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKAPIError$MonitorUpdateFailed;"));
2740 CHECK(LDKAPIError_MonitorUpdateFailed_class != NULL);
2741 LDKAPIError_MonitorUpdateFailed_meth = (*env)->GetMethodID(env, LDKAPIError_MonitorUpdateFailed_class, "<init>", "()V");
2742 CHECK(LDKAPIError_MonitorUpdateFailed_meth != NULL);
2744 JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKAPIError_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
2745 LDKAPIError *obj = (LDKAPIError*)ptr;
2747 case LDKAPIError_APIMisuseError: {
2748 LDKCVec_u8Z err_var = obj->api_misuse_error.err;
2749 int8_tArray err_arr = (*env)->NewByteArray(env, err_var.datalen);
2750 (*env)->SetByteArrayRegion(env, err_arr, 0, err_var.datalen, err_var.data);
2751 return (*env)->NewObject(env, LDKAPIError_APIMisuseError_class, LDKAPIError_APIMisuseError_meth, err_arr);
2753 case LDKAPIError_FeeRateTooHigh: {
2754 LDKCVec_u8Z err_var = obj->fee_rate_too_high.err;
2755 int8_tArray err_arr = (*env)->NewByteArray(env, err_var.datalen);
2756 (*env)->SetByteArrayRegion(env, err_arr, 0, err_var.datalen, err_var.data);
2757 return (*env)->NewObject(env, LDKAPIError_FeeRateTooHigh_class, LDKAPIError_FeeRateTooHigh_meth, err_arr, obj->fee_rate_too_high.feerate);
2759 case LDKAPIError_RouteError: {
2760 LDKStr err_str = obj->route_error.err;
2761 jstring err_conv = str_ref_to_java(env, err_str.chars, err_str.len);
2762 return (*env)->NewObject(env, LDKAPIError_RouteError_class, LDKAPIError_RouteError_meth, err_conv);
2764 case LDKAPIError_ChannelUnavailable: {
2765 LDKCVec_u8Z err_var = obj->channel_unavailable.err;
2766 int8_tArray err_arr = (*env)->NewByteArray(env, err_var.datalen);
2767 (*env)->SetByteArrayRegion(env, err_arr, 0, err_var.datalen, err_var.data);
2768 return (*env)->NewObject(env, LDKAPIError_ChannelUnavailable_class, LDKAPIError_ChannelUnavailable_meth, err_arr);
2770 case LDKAPIError_MonitorUpdateFailed: {
2771 return (*env)->NewObject(env, LDKAPIError_MonitorUpdateFailed_class, LDKAPIError_MonitorUpdateFailed_meth);
2776 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneAPIErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
2777 return ((LDKCResult_NoneAPIErrorZ*)arg)->result_ok;
2779 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneAPIErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
2780 LDKCResult_NoneAPIErrorZ *val = (LDKCResult_NoneAPIErrorZ*)(arg & ~1);
2781 CHECK(val->result_ok);
2782 return *val->contents.result;
2784 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneAPIErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
2785 LDKCResult_NoneAPIErrorZ *val = (LDKCResult_NoneAPIErrorZ*)(arg & ~1);
2786 CHECK(!val->result_ok);
2787 long err_ref = ((long)&(*val->contents.err)) | 1;
2790 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1CResult_1NoneAPIErrorZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
2791 LDKCVec_CResult_NoneAPIErrorZZ *ret = MALLOC(sizeof(LDKCVec_CResult_NoneAPIErrorZZ), "LDKCVec_CResult_NoneAPIErrorZZ");
2792 ret->datalen = (*env)->GetArrayLength(env, elems);
2793 if (ret->datalen == 0) {
2796 ret->data = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ) * ret->datalen, "LDKCVec_CResult_NoneAPIErrorZZ Data");
2797 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
2798 for (size_t i = 0; i < ret->datalen; i++) {
2799 int64_t arr_elem = java_elems[i];
2800 LDKCResult_NoneAPIErrorZ arr_elem_conv = *(LDKCResult_NoneAPIErrorZ*)(((uint64_t)arr_elem) & ~1);
2801 FREE((void*)arr_elem);
2802 ret->data[i] = arr_elem_conv;
2804 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
2808 static inline LDKCVec_CResult_NoneAPIErrorZZ CVec_CResult_NoneAPIErrorZZ_clone(const LDKCVec_CResult_NoneAPIErrorZZ *orig) {
2809 LDKCVec_CResult_NoneAPIErrorZZ ret = { .data = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ) * orig->datalen, "LDKCVec_CResult_NoneAPIErrorZZ clone bytes"), .datalen = orig->datalen };
2810 for (size_t i = 0; i < ret.datalen; i++) {
2811 ret.data[i] = CResult_NoneAPIErrorZ_clone(&orig->data[i]);
2815 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1APIErrorZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
2816 LDKCVec_APIErrorZ *ret = MALLOC(sizeof(LDKCVec_APIErrorZ), "LDKCVec_APIErrorZ");
2817 ret->datalen = (*env)->GetArrayLength(env, elems);
2818 if (ret->datalen == 0) {
2821 ret->data = MALLOC(sizeof(LDKAPIError) * ret->datalen, "LDKCVec_APIErrorZ Data");
2822 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
2823 for (size_t i = 0; i < ret->datalen; i++) {
2824 int64_t arr_elem = java_elems[i];
2825 LDKAPIError arr_elem_conv = *(LDKAPIError*)(((uint64_t)arr_elem) & ~1);
2826 FREE((void*)arr_elem);
2827 ret->data[i] = arr_elem_conv;
2829 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
2833 static inline LDKCVec_APIErrorZ CVec_APIErrorZ_clone(const LDKCVec_APIErrorZ *orig) {
2834 LDKCVec_APIErrorZ ret = { .data = MALLOC(sizeof(LDKAPIError) * orig->datalen, "LDKCVec_APIErrorZ clone bytes"), .datalen = orig->datalen };
2835 for (size_t i = 0; i < ret.datalen; i++) {
2836 ret.data[i] = APIError_clone(&orig->data[i]);
2840 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1ChannelDetailsZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
2841 LDKCVec_ChannelDetailsZ *ret = MALLOC(sizeof(LDKCVec_ChannelDetailsZ), "LDKCVec_ChannelDetailsZ");
2842 ret->datalen = (*env)->GetArrayLength(env, elems);
2843 if (ret->datalen == 0) {
2846 ret->data = MALLOC(sizeof(LDKChannelDetails) * ret->datalen, "LDKCVec_ChannelDetailsZ Data");
2847 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
2848 for (size_t i = 0; i < ret->datalen; i++) {
2849 int64_t arr_elem = java_elems[i];
2850 LDKChannelDetails arr_elem_conv;
2851 arr_elem_conv.inner = (void*)(arr_elem & (~1));
2852 arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
2853 arr_elem_conv = ChannelDetails_clone(&arr_elem_conv);
2854 ret->data[i] = arr_elem_conv;
2856 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
2860 static inline LDKCVec_ChannelDetailsZ CVec_ChannelDetailsZ_clone(const LDKCVec_ChannelDetailsZ *orig) {
2861 LDKCVec_ChannelDetailsZ ret = { .data = MALLOC(sizeof(LDKChannelDetails) * orig->datalen, "LDKCVec_ChannelDetailsZ clone bytes"), .datalen = orig->datalen };
2862 for (size_t i = 0; i < ret.datalen; i++) {
2863 ret.data[i] = ChannelDetails_clone(&orig->data[i]);
2867 static jclass LDKPaymentSendFailure_ParameterError_class = NULL;
2868 static jmethodID LDKPaymentSendFailure_ParameterError_meth = NULL;
2869 static jclass LDKPaymentSendFailure_PathParameterError_class = NULL;
2870 static jmethodID LDKPaymentSendFailure_PathParameterError_meth = NULL;
2871 static jclass LDKPaymentSendFailure_AllFailedRetrySafe_class = NULL;
2872 static jmethodID LDKPaymentSendFailure_AllFailedRetrySafe_meth = NULL;
2873 static jclass LDKPaymentSendFailure_PartialFailure_class = NULL;
2874 static jmethodID LDKPaymentSendFailure_PartialFailure_meth = NULL;
2875 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKPaymentSendFailure_init (JNIEnv *env, jclass clz) {
2876 LDKPaymentSendFailure_ParameterError_class =
2877 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKPaymentSendFailure$ParameterError;"));
2878 CHECK(LDKPaymentSendFailure_ParameterError_class != NULL);
2879 LDKPaymentSendFailure_ParameterError_meth = (*env)->GetMethodID(env, LDKPaymentSendFailure_ParameterError_class, "<init>", "()V");
2880 CHECK(LDKPaymentSendFailure_ParameterError_meth != NULL);
2881 LDKPaymentSendFailure_PathParameterError_class =
2882 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKPaymentSendFailure$PathParameterError;"));
2883 CHECK(LDKPaymentSendFailure_PathParameterError_class != NULL);
2884 LDKPaymentSendFailure_PathParameterError_meth = (*env)->GetMethodID(env, LDKPaymentSendFailure_PathParameterError_class, "<init>", "()V");
2885 CHECK(LDKPaymentSendFailure_PathParameterError_meth != NULL);
2886 LDKPaymentSendFailure_AllFailedRetrySafe_class =
2887 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKPaymentSendFailure$AllFailedRetrySafe;"));
2888 CHECK(LDKPaymentSendFailure_AllFailedRetrySafe_class != NULL);
2889 LDKPaymentSendFailure_AllFailedRetrySafe_meth = (*env)->GetMethodID(env, LDKPaymentSendFailure_AllFailedRetrySafe_class, "<init>", "()V");
2890 CHECK(LDKPaymentSendFailure_AllFailedRetrySafe_meth != NULL);
2891 LDKPaymentSendFailure_PartialFailure_class =
2892 (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKPaymentSendFailure$PartialFailure;"));
2893 CHECK(LDKPaymentSendFailure_PartialFailure_class != NULL);
2894 LDKPaymentSendFailure_PartialFailure_meth = (*env)->GetMethodID(env, LDKPaymentSendFailure_PartialFailure_class, "<init>", "()V");
2895 CHECK(LDKPaymentSendFailure_PartialFailure_meth != NULL);
2897 JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKPaymentSendFailure_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
2898 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)ptr;
2900 case LDKPaymentSendFailure_ParameterError: {
2901 return (*env)->NewObject(env, LDKPaymentSendFailure_ParameterError_class, LDKPaymentSendFailure_ParameterError_meth);
2903 case LDKPaymentSendFailure_PathParameterError: {
2904 return (*env)->NewObject(env, LDKPaymentSendFailure_PathParameterError_class, LDKPaymentSendFailure_PathParameterError_meth);
2906 case LDKPaymentSendFailure_AllFailedRetrySafe: {
2907 return (*env)->NewObject(env, LDKPaymentSendFailure_AllFailedRetrySafe_class, LDKPaymentSendFailure_AllFailedRetrySafe_meth);
2909 case LDKPaymentSendFailure_PartialFailure: {
2910 return (*env)->NewObject(env, LDKPaymentSendFailure_PartialFailure_class, LDKPaymentSendFailure_PartialFailure_meth);
2915 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePaymentSendFailureZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
2916 return ((LDKCResult_NonePaymentSendFailureZ*)arg)->result_ok;
2918 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePaymentSendFailureZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
2919 LDKCResult_NonePaymentSendFailureZ *val = (LDKCResult_NonePaymentSendFailureZ*)(arg & ~1);
2920 CHECK(val->result_ok);
2921 return *val->contents.result;
2923 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePaymentSendFailureZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
2924 LDKCResult_NonePaymentSendFailureZ *val = (LDKCResult_NonePaymentSendFailureZ*)(arg & ~1);
2925 CHECK(!val->result_ok);
2926 long err_ref = ((long)&(*val->contents.err)) | 1;
2929 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1ChannelMonitorZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
2930 LDKCVec_ChannelMonitorZ *ret = MALLOC(sizeof(LDKCVec_ChannelMonitorZ), "LDKCVec_ChannelMonitorZ");
2931 ret->datalen = (*env)->GetArrayLength(env, elems);
2932 if (ret->datalen == 0) {
2935 ret->data = MALLOC(sizeof(LDKChannelMonitor) * ret->datalen, "LDKCVec_ChannelMonitorZ Data");
2936 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
2937 for (size_t i = 0; i < ret->datalen; i++) {
2938 int64_t arr_elem = java_elems[i];
2939 LDKChannelMonitor arr_elem_conv;
2940 arr_elem_conv.inner = (void*)(arr_elem & (~1));
2941 arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
2942 arr_elem_conv = ChannelMonitor_clone(&arr_elem_conv);
2943 ret->data[i] = arr_elem_conv;
2945 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
2949 static inline LDKCVec_ChannelMonitorZ CVec_ChannelMonitorZ_clone(const LDKCVec_ChannelMonitorZ *orig) {
2950 LDKCVec_ChannelMonitorZ ret = { .data = MALLOC(sizeof(LDKChannelMonitor) * orig->datalen, "LDKCVec_ChannelMonitorZ clone bytes"), .datalen = orig->datalen };
2951 for (size_t i = 0; i < ret.datalen; i++) {
2952 ret.data[i] = ChannelMonitor_clone(&orig->data[i]);
2956 typedef struct LDKWatch_JCalls {
2957 atomic_size_t refcnt;
2960 jmethodID watch_channel_meth;
2961 jmethodID update_channel_meth;
2962 jmethodID release_pending_monitor_events_meth;
2964 static void LDKWatch_JCalls_free(void* this_arg) {
2965 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
2966 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
2968 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
2969 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
2973 LDKCResult_NoneChannelMonitorUpdateErrZ watch_channel_jcall(const void* this_arg, LDKOutPoint funding_txo, LDKChannelMonitor monitor) {
2974 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
2976 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
2977 LDKOutPoint funding_txo_var = funding_txo;
2978 CHECK((((long)funding_txo_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2979 CHECK((((long)&funding_txo_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2980 long funding_txo_ref = (long)funding_txo_var.inner;
2981 if (funding_txo_var.is_owned) {
2982 funding_txo_ref |= 1;
2984 LDKChannelMonitor monitor_var = monitor;
2985 CHECK((((long)monitor_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2986 CHECK((((long)&monitor_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2987 long monitor_ref = (long)monitor_var.inner;
2988 if (monitor_var.is_owned) {
2991 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
2993 LDKCResult_NoneChannelMonitorUpdateErrZ* ret = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(*env)->CallLongMethod(env, obj, j_calls->watch_channel_meth, funding_txo_ref, monitor_ref);
2994 LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1);
2995 ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)ret);
2998 LDKCResult_NoneChannelMonitorUpdateErrZ update_channel_jcall(const void* this_arg, LDKOutPoint funding_txo, LDKChannelMonitorUpdate update) {
2999 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
3001 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
3002 LDKOutPoint funding_txo_var = funding_txo;
3003 CHECK((((long)funding_txo_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3004 CHECK((((long)&funding_txo_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3005 long funding_txo_ref = (long)funding_txo_var.inner;
3006 if (funding_txo_var.is_owned) {
3007 funding_txo_ref |= 1;
3009 LDKChannelMonitorUpdate update_var = update;
3010 CHECK((((long)update_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3011 CHECK((((long)&update_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3012 long update_ref = (long)update_var.inner;
3013 if (update_var.is_owned) {
3016 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
3018 LDKCResult_NoneChannelMonitorUpdateErrZ* ret = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(*env)->CallLongMethod(env, obj, j_calls->update_channel_meth, funding_txo_ref, update_ref);
3019 LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1);
3020 ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)ret);
3023 LDKCVec_MonitorEventZ release_pending_monitor_events_jcall(const void* this_arg) {
3024 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
3026 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
3027 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
3029 int64_tArray ret = (*env)->CallObjectMethod(env, obj, j_calls->release_pending_monitor_events_meth);
3030 LDKCVec_MonitorEventZ ret_constr;
3031 ret_constr.datalen = (*env)->GetArrayLength(env, ret);
3032 if (ret_constr.datalen > 0)
3033 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKMonitorEvent), "LDKCVec_MonitorEventZ Elements");
3035 ret_constr.data = NULL;
3036 int64_t* ret_vals = (*env)->GetLongArrayElements (env, ret, NULL);
3037 for (size_t o = 0; o < ret_constr.datalen; o++) {
3038 int64_t ret_conv_14 = ret_vals[o];
3039 LDKMonitorEvent ret_conv_14_conv = *(LDKMonitorEvent*)(((uint64_t)ret_conv_14) & ~1);
3040 ret_conv_14_conv = MonitorEvent_clone((LDKMonitorEvent*)ret_conv_14);
3041 ret_constr.data[o] = ret_conv_14_conv;
3043 (*env)->ReleaseLongArrayElements(env, ret, ret_vals, 0);
3046 static void* LDKWatch_JCalls_clone(const void* this_arg) {
3047 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
3048 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
3049 return (void*) this_arg;
3051 static inline LDKWatch LDKWatch_init (JNIEnv *env, jclass clz, jobject o) {
3052 jclass c = (*env)->GetObjectClass(env, o);
3054 LDKWatch_JCalls *calls = MALLOC(sizeof(LDKWatch_JCalls), "LDKWatch_JCalls");
3055 atomic_init(&calls->refcnt, 1);
3056 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
3057 calls->o = (*env)->NewWeakGlobalRef(env, o);
3058 calls->watch_channel_meth = (*env)->GetMethodID(env, c, "watch_channel", "(JJ)J");
3059 CHECK(calls->watch_channel_meth != NULL);
3060 calls->update_channel_meth = (*env)->GetMethodID(env, c, "update_channel", "(JJ)J");
3061 CHECK(calls->update_channel_meth != NULL);
3062 calls->release_pending_monitor_events_meth = (*env)->GetMethodID(env, c, "release_pending_monitor_events", "()[J");
3063 CHECK(calls->release_pending_monitor_events_meth != NULL);
3066 .this_arg = (void*) calls,
3067 .watch_channel = watch_channel_jcall,
3068 .update_channel = update_channel_jcall,
3069 .release_pending_monitor_events = release_pending_monitor_events_jcall,
3070 .free = LDKWatch_JCalls_free,
3074 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKWatch_1new(JNIEnv *env, jclass clz, jobject o) {
3075 LDKWatch *res_ptr = MALLOC(sizeof(LDKWatch), "LDKWatch");
3076 *res_ptr = LDKWatch_init(env, clz, o);
3077 return (long)res_ptr;
3079 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) {
3080 LDKWatch* this_arg_conv = (LDKWatch*)(((uint64_t)this_arg) & ~1);
3081 LDKOutPoint funding_txo_conv;
3082 funding_txo_conv.inner = (void*)(funding_txo & (~1));
3083 funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
3084 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
3085 LDKChannelMonitor monitor_conv;
3086 monitor_conv.inner = (void*)(monitor & (~1));
3087 monitor_conv.is_owned = (monitor & 1) || (monitor == 0);
3088 monitor_conv = ChannelMonitor_clone(&monitor_conv);
3089 LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
3090 *ret_conv = (this_arg_conv->watch_channel)(this_arg_conv->this_arg, funding_txo_conv, monitor_conv);
3091 return (long)ret_conv;
3094 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) {
3095 LDKWatch* this_arg_conv = (LDKWatch*)(((uint64_t)this_arg) & ~1);
3096 LDKOutPoint funding_txo_conv;
3097 funding_txo_conv.inner = (void*)(funding_txo & (~1));
3098 funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
3099 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
3100 LDKChannelMonitorUpdate update_conv;
3101 update_conv.inner = (void*)(update & (~1));
3102 update_conv.is_owned = (update & 1) || (update == 0);
3103 update_conv = ChannelMonitorUpdate_clone(&update_conv);
3104 LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
3105 *ret_conv = (this_arg_conv->update_channel)(this_arg_conv->this_arg, funding_txo_conv, update_conv);
3106 return (long)ret_conv;
3109 JNIEXPORT int64_tArray JNICALL Java_org_ldk_impl_bindings_Watch_1release_1pending_1monitor_1events(JNIEnv *env, jclass clz, int64_t this_arg) {
3110 LDKWatch* this_arg_conv = (LDKWatch*)(((uint64_t)this_arg) & ~1);
3111 LDKCVec_MonitorEventZ ret_var = (this_arg_conv->release_pending_monitor_events)(this_arg_conv->this_arg);
3112 int64_tArray ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
3113 int64_t *ret_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, ret_arr, NULL);
3114 for (size_t o = 0; o < ret_var.datalen; o++) {
3115 LDKMonitorEvent *ret_conv_14_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
3116 *ret_conv_14_copy = MonitorEvent_clone(&ret_var.data[o]);
3117 long ret_conv_14_ref = (long)ret_conv_14_copy;
3118 ret_arr_ptr[o] = ret_conv_14_ref;
3120 (*env)->ReleasePrimitiveArrayCritical(env, ret_arr, ret_arr_ptr, 0);
3125 typedef struct LDKBroadcasterInterface_JCalls {
3126 atomic_size_t refcnt;
3129 jmethodID broadcast_transaction_meth;
3130 } LDKBroadcasterInterface_JCalls;
3131 static void LDKBroadcasterInterface_JCalls_free(void* this_arg) {
3132 LDKBroadcasterInterface_JCalls *j_calls = (LDKBroadcasterInterface_JCalls*) this_arg;
3133 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
3135 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
3136 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
3140 void broadcast_transaction_jcall(const void* this_arg, LDKTransaction tx) {
3141 LDKBroadcasterInterface_JCalls *j_calls = (LDKBroadcasterInterface_JCalls*) this_arg;
3143 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
3144 LDKTransaction tx_var = tx;
3145 int8_tArray tx_arr = (*env)->NewByteArray(env, tx_var.datalen);
3146 (*env)->SetByteArrayRegion(env, tx_arr, 0, tx_var.datalen, tx_var.data);
3147 Transaction_free(tx_var);
3148 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
3150 return (*env)->CallVoidMethod(env, obj, j_calls->broadcast_transaction_meth, tx_arr);
3152 static void* LDKBroadcasterInterface_JCalls_clone(const void* this_arg) {
3153 LDKBroadcasterInterface_JCalls *j_calls = (LDKBroadcasterInterface_JCalls*) this_arg;
3154 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
3155 return (void*) this_arg;
3157 static inline LDKBroadcasterInterface LDKBroadcasterInterface_init (JNIEnv *env, jclass clz, jobject o) {
3158 jclass c = (*env)->GetObjectClass(env, o);
3160 LDKBroadcasterInterface_JCalls *calls = MALLOC(sizeof(LDKBroadcasterInterface_JCalls), "LDKBroadcasterInterface_JCalls");
3161 atomic_init(&calls->refcnt, 1);
3162 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
3163 calls->o = (*env)->NewWeakGlobalRef(env, o);
3164 calls->broadcast_transaction_meth = (*env)->GetMethodID(env, c, "broadcast_transaction", "([B)V");
3165 CHECK(calls->broadcast_transaction_meth != NULL);
3167 LDKBroadcasterInterface ret = {
3168 .this_arg = (void*) calls,
3169 .broadcast_transaction = broadcast_transaction_jcall,
3170 .free = LDKBroadcasterInterface_JCalls_free,
3174 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKBroadcasterInterface_1new(JNIEnv *env, jclass clz, jobject o) {
3175 LDKBroadcasterInterface *res_ptr = MALLOC(sizeof(LDKBroadcasterInterface), "LDKBroadcasterInterface");
3176 *res_ptr = LDKBroadcasterInterface_init(env, clz, o);
3177 return (long)res_ptr;
3179 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_BroadcasterInterface_1broadcast_1transaction(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray tx) {
3180 LDKBroadcasterInterface* this_arg_conv = (LDKBroadcasterInterface*)(((uint64_t)this_arg) & ~1);
3181 LDKTransaction tx_ref;
3182 tx_ref.datalen = (*env)->GetArrayLength(env, tx);
3183 tx_ref.data = MALLOC(tx_ref.datalen, "LDKTransaction Bytes");
3184 (*env)->GetByteArrayRegion(env, tx, 0, tx_ref.datalen, tx_ref.data);
3185 tx_ref.data_is_owned = true;
3186 (this_arg_conv->broadcast_transaction)(this_arg_conv->this_arg, tx_ref);
3189 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SignDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3190 return ((LDKCResult_SignDecodeErrorZ*)arg)->result_ok;
3192 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SignDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3193 LDKCResult_SignDecodeErrorZ *val = (LDKCResult_SignDecodeErrorZ*)(arg & ~1);
3194 CHECK(val->result_ok);
3195 LDKSign* ret = MALLOC(sizeof(LDKSign), "LDKSign");
3196 *ret = Sign_clone(&(*val->contents.result));
3199 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SignDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
3200 LDKCResult_SignDecodeErrorZ *val = (LDKCResult_SignDecodeErrorZ*)(arg & ~1);
3201 CHECK(!val->result_ok);
3202 LDKDecodeError err_var = (*val->contents.err);
3203 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3204 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3205 long err_ref = (long)err_var.inner & ~1;
3208 typedef struct LDKKeysInterface_JCalls {
3209 atomic_size_t refcnt;
3212 jmethodID get_node_secret_meth;
3213 jmethodID get_destination_script_meth;
3214 jmethodID get_shutdown_pubkey_meth;
3215 jmethodID get_channel_signer_meth;
3216 jmethodID get_secure_random_bytes_meth;
3217 jmethodID read_chan_signer_meth;
3218 } LDKKeysInterface_JCalls;
3219 static void LDKKeysInterface_JCalls_free(void* this_arg) {
3220 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
3221 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
3223 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
3224 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
3228 LDKSecretKey get_node_secret_jcall(const void* this_arg) {
3229 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
3231 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
3232 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
3234 int8_tArray ret = (*env)->CallObjectMethod(env, obj, j_calls->get_node_secret_meth);
3235 LDKSecretKey ret_ref;
3236 CHECK((*env)->GetArrayLength(env, ret) == 32);
3237 (*env)->GetByteArrayRegion(env, ret, 0, 32, ret_ref.bytes);
3240 LDKCVec_u8Z get_destination_script_jcall(const void* this_arg) {
3241 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
3243 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
3244 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
3246 int8_tArray ret = (*env)->CallObjectMethod(env, obj, j_calls->get_destination_script_meth);
3247 LDKCVec_u8Z ret_ref;
3248 ret_ref.datalen = (*env)->GetArrayLength(env, ret);
3249 ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
3250 (*env)->GetByteArrayRegion(env, ret, 0, ret_ref.datalen, ret_ref.data);
3253 LDKPublicKey get_shutdown_pubkey_jcall(const void* this_arg) {
3254 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
3256 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
3257 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
3259 int8_tArray ret = (*env)->CallObjectMethod(env, obj, j_calls->get_shutdown_pubkey_meth);
3260 LDKPublicKey ret_ref;
3261 CHECK((*env)->GetArrayLength(env, ret) == 33);
3262 (*env)->GetByteArrayRegion(env, ret, 0, 33, ret_ref.compressed_form);
3265 LDKSign get_channel_signer_jcall(const void* this_arg, bool inbound, uint64_t channel_value_satoshis) {
3266 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
3268 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
3269 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
3271 LDKSign* ret = (LDKSign*)(*env)->CallLongMethod(env, obj, j_calls->get_channel_signer_meth, inbound, channel_value_satoshis);
3272 LDKSign ret_conv = *(LDKSign*)(((uint64_t)ret) & ~1);
3273 ret_conv = Sign_clone(ret);
3276 LDKThirtyTwoBytes get_secure_random_bytes_jcall(const void* this_arg) {
3277 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
3279 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
3280 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
3282 int8_tArray ret = (*env)->CallObjectMethod(env, obj, j_calls->get_secure_random_bytes_meth);
3283 LDKThirtyTwoBytes ret_ref;
3284 CHECK((*env)->GetArrayLength(env, ret) == 32);
3285 (*env)->GetByteArrayRegion(env, ret, 0, 32, ret_ref.data);
3288 LDKCResult_SignDecodeErrorZ read_chan_signer_jcall(const void* this_arg, LDKu8slice reader) {
3289 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
3291 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
3292 LDKu8slice reader_var = reader;
3293 int8_tArray reader_arr = (*env)->NewByteArray(env, reader_var.datalen);
3294 (*env)->SetByteArrayRegion(env, reader_arr, 0, reader_var.datalen, reader_var.data);
3295 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
3297 LDKCResult_SignDecodeErrorZ* ret = (LDKCResult_SignDecodeErrorZ*)(*env)->CallLongMethod(env, obj, j_calls->read_chan_signer_meth, reader_arr);
3298 LDKCResult_SignDecodeErrorZ ret_conv = *(LDKCResult_SignDecodeErrorZ*)(((uint64_t)ret) & ~1);
3299 ret_conv = CResult_SignDecodeErrorZ_clone((LDKCResult_SignDecodeErrorZ*)ret);
3302 static void* LDKKeysInterface_JCalls_clone(const void* this_arg) {
3303 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
3304 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
3305 return (void*) this_arg;
3307 static inline LDKKeysInterface LDKKeysInterface_init (JNIEnv *env, jclass clz, jobject o) {
3308 jclass c = (*env)->GetObjectClass(env, o);
3310 LDKKeysInterface_JCalls *calls = MALLOC(sizeof(LDKKeysInterface_JCalls), "LDKKeysInterface_JCalls");
3311 atomic_init(&calls->refcnt, 1);
3312 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
3313 calls->o = (*env)->NewWeakGlobalRef(env, o);
3314 calls->get_node_secret_meth = (*env)->GetMethodID(env, c, "get_node_secret", "()[B");
3315 CHECK(calls->get_node_secret_meth != NULL);
3316 calls->get_destination_script_meth = (*env)->GetMethodID(env, c, "get_destination_script", "()[B");
3317 CHECK(calls->get_destination_script_meth != NULL);
3318 calls->get_shutdown_pubkey_meth = (*env)->GetMethodID(env, c, "get_shutdown_pubkey", "()[B");
3319 CHECK(calls->get_shutdown_pubkey_meth != NULL);
3320 calls->get_channel_signer_meth = (*env)->GetMethodID(env, c, "get_channel_signer", "(ZJ)J");
3321 CHECK(calls->get_channel_signer_meth != NULL);
3322 calls->get_secure_random_bytes_meth = (*env)->GetMethodID(env, c, "get_secure_random_bytes", "()[B");
3323 CHECK(calls->get_secure_random_bytes_meth != NULL);
3324 calls->read_chan_signer_meth = (*env)->GetMethodID(env, c, "read_chan_signer", "([B)J");
3325 CHECK(calls->read_chan_signer_meth != NULL);
3327 LDKKeysInterface ret = {
3328 .this_arg = (void*) calls,
3329 .get_node_secret = get_node_secret_jcall,
3330 .get_destination_script = get_destination_script_jcall,
3331 .get_shutdown_pubkey = get_shutdown_pubkey_jcall,
3332 .get_channel_signer = get_channel_signer_jcall,
3333 .get_secure_random_bytes = get_secure_random_bytes_jcall,
3334 .read_chan_signer = read_chan_signer_jcall,
3335 .free = LDKKeysInterface_JCalls_free,
3339 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKKeysInterface_1new(JNIEnv *env, jclass clz, jobject o) {
3340 LDKKeysInterface *res_ptr = MALLOC(sizeof(LDKKeysInterface), "LDKKeysInterface");
3341 *res_ptr = LDKKeysInterface_init(env, clz, o);
3342 return (long)res_ptr;
3344 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_KeysInterface_1get_1node_1secret(JNIEnv *env, jclass clz, int64_t this_arg) {
3345 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)(((uint64_t)this_arg) & ~1);
3346 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
3347 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, (this_arg_conv->get_node_secret)(this_arg_conv->this_arg).bytes);
3351 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_KeysInterface_1get_1destination_1script(JNIEnv *env, jclass clz, int64_t this_arg) {
3352 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)(((uint64_t)this_arg) & ~1);
3353 LDKCVec_u8Z ret_var = (this_arg_conv->get_destination_script)(this_arg_conv->this_arg);
3354 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
3355 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
3356 CVec_u8Z_free(ret_var);
3360 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_KeysInterface_1get_1shutdown_1pubkey(JNIEnv *env, jclass clz, int64_t this_arg) {
3361 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)(((uint64_t)this_arg) & ~1);
3362 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
3363 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, (this_arg_conv->get_shutdown_pubkey)(this_arg_conv->this_arg).compressed_form);
3367 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) {
3368 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)(((uint64_t)this_arg) & ~1);
3369 LDKSign* ret = MALLOC(sizeof(LDKSign), "LDKSign");
3370 *ret = (this_arg_conv->get_channel_signer)(this_arg_conv->this_arg, inbound, channel_value_satoshis);
3374 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_KeysInterface_1get_1secure_1random_1bytes(JNIEnv *env, jclass clz, int64_t this_arg) {
3375 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)(((uint64_t)this_arg) & ~1);
3376 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
3377 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, (this_arg_conv->get_secure_random_bytes)(this_arg_conv->this_arg).data);
3381 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_KeysInterface_1read_1chan_1signer(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray reader) {
3382 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)(((uint64_t)this_arg) & ~1);
3383 LDKu8slice reader_ref;
3384 reader_ref.datalen = (*env)->GetArrayLength(env, reader);
3385 reader_ref.data = (*env)->GetByteArrayElements (env, reader, NULL);
3386 LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
3387 *ret_conv = (this_arg_conv->read_chan_signer)(this_arg_conv->this_arg, reader_ref);
3388 (*env)->ReleaseByteArrayElements(env, reader, (int8_t*)reader_ref.data, 0);
3389 return (long)ret_conv;
3392 typedef struct LDKFeeEstimator_JCalls {
3393 atomic_size_t refcnt;
3396 jmethodID get_est_sat_per_1000_weight_meth;
3397 } LDKFeeEstimator_JCalls;
3398 static void LDKFeeEstimator_JCalls_free(void* this_arg) {
3399 LDKFeeEstimator_JCalls *j_calls = (LDKFeeEstimator_JCalls*) this_arg;
3400 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
3402 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
3403 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
3407 uint32_t get_est_sat_per_1000_weight_jcall(const void* this_arg, LDKConfirmationTarget confirmation_target) {
3408 LDKFeeEstimator_JCalls *j_calls = (LDKFeeEstimator_JCalls*) this_arg;
3410 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
3411 jclass confirmation_target_conv = LDKConfirmationTarget_to_java(env, confirmation_target);
3412 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
3414 return (*env)->CallIntMethod(env, obj, j_calls->get_est_sat_per_1000_weight_meth, confirmation_target_conv);
3416 static void* LDKFeeEstimator_JCalls_clone(const void* this_arg) {
3417 LDKFeeEstimator_JCalls *j_calls = (LDKFeeEstimator_JCalls*) this_arg;
3418 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
3419 return (void*) this_arg;
3421 static inline LDKFeeEstimator LDKFeeEstimator_init (JNIEnv *env, jclass clz, jobject o) {
3422 jclass c = (*env)->GetObjectClass(env, o);
3424 LDKFeeEstimator_JCalls *calls = MALLOC(sizeof(LDKFeeEstimator_JCalls), "LDKFeeEstimator_JCalls");
3425 atomic_init(&calls->refcnt, 1);
3426 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
3427 calls->o = (*env)->NewWeakGlobalRef(env, o);
3428 calls->get_est_sat_per_1000_weight_meth = (*env)->GetMethodID(env, c, "get_est_sat_per_1000_weight", "(Lorg/ldk/enums/LDKConfirmationTarget;)I");
3429 CHECK(calls->get_est_sat_per_1000_weight_meth != NULL);
3431 LDKFeeEstimator ret = {
3432 .this_arg = (void*) calls,
3433 .get_est_sat_per_1000_weight = get_est_sat_per_1000_weight_jcall,
3434 .free = LDKFeeEstimator_JCalls_free,
3438 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKFeeEstimator_1new(JNIEnv *env, jclass clz, jobject o) {
3439 LDKFeeEstimator *res_ptr = MALLOC(sizeof(LDKFeeEstimator), "LDKFeeEstimator");
3440 *res_ptr = LDKFeeEstimator_init(env, clz, o);
3441 return (long)res_ptr;
3443 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) {
3444 LDKFeeEstimator* this_arg_conv = (LDKFeeEstimator*)(((uint64_t)this_arg) & ~1);
3445 LDKConfirmationTarget confirmation_target_conv = LDKConfirmationTarget_from_java(env, confirmation_target);
3446 int32_t ret_val = (this_arg_conv->get_est_sat_per_1000_weight)(this_arg_conv->this_arg, confirmation_target_conv);
3450 typedef struct LDKLogger_JCalls {
3451 atomic_size_t refcnt;
3456 static void LDKLogger_JCalls_free(void* this_arg) {
3457 LDKLogger_JCalls *j_calls = (LDKLogger_JCalls*) this_arg;
3458 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
3460 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
3461 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
3465 void log_jcall(const void* this_arg, const char* record) {
3466 LDKLogger_JCalls *j_calls = (LDKLogger_JCalls*) this_arg;
3468 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
3469 const char* record_str = record;
3470 jstring record_conv = str_ref_to_java(env, record_str, strlen(record_str));
3471 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
3473 return (*env)->CallVoidMethod(env, obj, j_calls->log_meth, record_conv);
3475 static void* LDKLogger_JCalls_clone(const void* this_arg) {
3476 LDKLogger_JCalls *j_calls = (LDKLogger_JCalls*) this_arg;
3477 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
3478 return (void*) this_arg;
3480 static inline LDKLogger LDKLogger_init (JNIEnv *env, jclass clz, jobject o) {
3481 jclass c = (*env)->GetObjectClass(env, o);
3483 LDKLogger_JCalls *calls = MALLOC(sizeof(LDKLogger_JCalls), "LDKLogger_JCalls");
3484 atomic_init(&calls->refcnt, 1);
3485 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
3486 calls->o = (*env)->NewWeakGlobalRef(env, o);
3487 calls->log_meth = (*env)->GetMethodID(env, c, "log", "(Ljava/lang/String;)V");
3488 CHECK(calls->log_meth != NULL);
3491 .this_arg = (void*) calls,
3493 .free = LDKLogger_JCalls_free,
3497 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKLogger_1new(JNIEnv *env, jclass clz, jobject o) {
3498 LDKLogger *res_ptr = MALLOC(sizeof(LDKLogger), "LDKLogger");
3499 *res_ptr = LDKLogger_init(env, clz, o);
3500 return (long)res_ptr;
3502 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1BlockHashChannelManagerZ_1new(JNIEnv *env, jclass clz, int8_tArray a, int64_t b) {
3503 LDKC2Tuple_BlockHashChannelManagerZ* ret = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelManagerZ), "LDKC2Tuple_BlockHashChannelManagerZ");
3504 LDKThirtyTwoBytes a_ref;
3505 CHECK((*env)->GetArrayLength(env, a) == 32);
3506 (*env)->GetByteArrayRegion(env, a, 0, 32, a_ref.data);
3508 LDKChannelManager b_conv;
3509 b_conv.inner = (void*)(b & (~1));
3510 b_conv.is_owned = (b & 1) || (b == 0);
3511 // Warning: we need a move here but no clone is available for LDKChannelManager
3515 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1BlockHashChannelManagerZ_1get_1a(JNIEnv *env, jclass clz, int64_t ptr) {
3516 LDKC2Tuple_BlockHashChannelManagerZ *tuple = (LDKC2Tuple_BlockHashChannelManagerZ*)(ptr & ~1);
3517 int8_tArray a_arr = (*env)->NewByteArray(env, 32);
3518 (*env)->SetByteArrayRegion(env, a_arr, 0, 32, tuple->a.data);
3521 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKC2Tuple_1BlockHashChannelManagerZ_1get_1b(JNIEnv *env, jclass clz, int64_t ptr) {
3522 LDKC2Tuple_BlockHashChannelManagerZ *tuple = (LDKC2Tuple_BlockHashChannelManagerZ*)(ptr & ~1);
3523 LDKChannelManager b_var = tuple->b;
3524 CHECK((((long)b_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3525 CHECK((((long)&b_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3526 long b_ref = (long)b_var.inner & ~1;
3529 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1BlockHashChannelManagerZDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3530 return ((LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)arg)->result_ok;
3532 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1BlockHashChannelManagerZDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3533 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *val = (LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)(arg & ~1);
3534 CHECK(val->result_ok);
3535 long res_ref = (long)(&(*val->contents.result)) | 1;
3538 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1BlockHashChannelManagerZDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
3539 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *val = (LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)(arg & ~1);
3540 CHECK(!val->result_ok);
3541 LDKDecodeError err_var = (*val->contents.err);
3542 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3543 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3544 long err_ref = (long)err_var.inner & ~1;
3547 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SpendableOutputDescriptorDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3548 return ((LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)arg)->result_ok;
3550 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SpendableOutputDescriptorDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3551 LDKCResult_SpendableOutputDescriptorDecodeErrorZ *val = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(arg & ~1);
3552 CHECK(val->result_ok);
3553 long res_ref = ((long)&(*val->contents.result)) | 1;
3556 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SpendableOutputDescriptorDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
3557 LDKCResult_SpendableOutputDescriptorDecodeErrorZ *val = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(arg & ~1);
3558 CHECK(!val->result_ok);
3559 LDKDecodeError err_var = (*val->contents.err);
3560 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3561 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3562 long err_ref = (long)err_var.inner & ~1;
3565 static inline LDKCVec_CVec_u8ZZ CVec_CVec_u8ZZ_clone(const LDKCVec_CVec_u8ZZ *orig) {
3566 LDKCVec_CVec_u8ZZ ret = { .data = MALLOC(sizeof(LDKCVec_u8Z) * orig->datalen, "LDKCVec_CVec_u8ZZ clone bytes"), .datalen = orig->datalen };
3567 for (size_t i = 0; i < ret.datalen; i++) {
3568 ret.data[i] = CVec_u8Z_clone(&orig->data[i]);
3572 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1CVec_1u8ZZNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3573 return ((LDKCResult_CVec_CVec_u8ZZNoneZ*)arg)->result_ok;
3575 JNIEXPORT jobjectArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1CVec_1u8ZZNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3576 LDKCResult_CVec_CVec_u8ZZNoneZ *val = (LDKCResult_CVec_CVec_u8ZZNoneZ*)(arg & ~1);
3577 CHECK(val->result_ok);
3578 LDKCVec_CVec_u8ZZ res_var = (*val->contents.result);
3579 jobjectArray res_arr = (*env)->NewObjectArray(env, res_var.datalen, arr_of_B_clz, NULL);
3581 for (size_t i = 0; i < res_var.datalen; i++) {
3582 LDKCVec_u8Z res_conv_8_var = res_var.data[i];
3583 int8_tArray res_conv_8_arr = (*env)->NewByteArray(env, res_conv_8_var.datalen);
3584 (*env)->SetByteArrayRegion(env, res_conv_8_arr, 0, res_conv_8_var.datalen, res_conv_8_var.data);
3585 (*env)->SetObjectArrayElement(env, res_arr, i, res_conv_8_arr);
3589 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1CVec_1u8ZZNoneZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
3590 LDKCResult_CVec_CVec_u8ZZNoneZ *val = (LDKCResult_CVec_CVec_u8ZZNoneZ*)(arg & ~1);
3591 CHECK(!val->result_ok);
3592 return *val->contents.err;
3594 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InMemorySignerDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3595 return ((LDKCResult_InMemorySignerDecodeErrorZ*)arg)->result_ok;
3597 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InMemorySignerDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3598 LDKCResult_InMemorySignerDecodeErrorZ *val = (LDKCResult_InMemorySignerDecodeErrorZ*)(arg & ~1);
3599 CHECK(val->result_ok);
3600 LDKInMemorySigner res_var = (*val->contents.result);
3601 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3602 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3603 long res_ref = (long)res_var.inner & ~1;
3606 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InMemorySignerDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
3607 LDKCResult_InMemorySignerDecodeErrorZ *val = (LDKCResult_InMemorySignerDecodeErrorZ*)(arg & ~1);
3608 CHECK(!val->result_ok);
3609 LDKDecodeError err_var = (*val->contents.err);
3610 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3611 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3612 long err_ref = (long)err_var.inner & ~1;
3615 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1TxOutZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
3616 LDKCVec_TxOutZ *ret = MALLOC(sizeof(LDKCVec_TxOutZ), "LDKCVec_TxOutZ");
3617 ret->datalen = (*env)->GetArrayLength(env, elems);
3618 if (ret->datalen == 0) {
3621 ret->data = MALLOC(sizeof(LDKTxOut) * ret->datalen, "LDKCVec_TxOutZ Data");
3622 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
3623 for (size_t i = 0; i < ret->datalen; i++) {
3624 int64_t arr_elem = java_elems[i];
3625 LDKTxOut arr_elem_conv = *(LDKTxOut*)(((uint64_t)arr_elem) & ~1);
3626 FREE((void*)arr_elem);
3627 ret->data[i] = arr_elem_conv;
3629 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
3633 static inline LDKCVec_TxOutZ CVec_TxOutZ_clone(const LDKCVec_TxOutZ *orig) {
3634 LDKCVec_TxOutZ ret = { .data = MALLOC(sizeof(LDKTxOut) * orig->datalen, "LDKCVec_TxOutZ clone bytes"), .datalen = orig->datalen };
3635 for (size_t i = 0; i < ret.datalen; i++) {
3636 ret.data[i] = TxOut_clone(&orig->data[i]);
3640 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TransactionNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3641 return ((LDKCResult_TransactionNoneZ*)arg)->result_ok;
3643 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TransactionNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3644 LDKCResult_TransactionNoneZ *val = (LDKCResult_TransactionNoneZ*)(arg & ~1);
3645 CHECK(val->result_ok);
3646 LDKTransaction res_var = (*val->contents.result);
3647 int8_tArray res_arr = (*env)->NewByteArray(env, res_var.datalen);
3648 (*env)->SetByteArrayRegion(env, res_arr, 0, res_var.datalen, res_var.data);
3651 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TransactionNoneZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
3652 LDKCResult_TransactionNoneZ *val = (LDKCResult_TransactionNoneZ*)(arg & ~1);
3653 CHECK(!val->result_ok);
3654 return *val->contents.err;
3656 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1RouteHopZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
3657 LDKCVec_RouteHopZ *ret = MALLOC(sizeof(LDKCVec_RouteHopZ), "LDKCVec_RouteHopZ");
3658 ret->datalen = (*env)->GetArrayLength(env, elems);
3659 if (ret->datalen == 0) {
3662 ret->data = MALLOC(sizeof(LDKRouteHop) * ret->datalen, "LDKCVec_RouteHopZ Data");
3663 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
3664 for (size_t i = 0; i < ret->datalen; i++) {
3665 int64_t arr_elem = java_elems[i];
3666 LDKRouteHop arr_elem_conv;
3667 arr_elem_conv.inner = (void*)(arr_elem & (~1));
3668 arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
3669 arr_elem_conv = RouteHop_clone(&arr_elem_conv);
3670 ret->data[i] = arr_elem_conv;
3672 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
3676 static inline LDKCVec_RouteHopZ CVec_RouteHopZ_clone(const LDKCVec_RouteHopZ *orig) {
3677 LDKCVec_RouteHopZ ret = { .data = MALLOC(sizeof(LDKRouteHop) * orig->datalen, "LDKCVec_RouteHopZ clone bytes"), .datalen = orig->datalen };
3678 for (size_t i = 0; i < ret.datalen; i++) {
3679 ret.data[i] = RouteHop_clone(&orig->data[i]);
3683 static inline LDKCVec_CVec_RouteHopZZ CVec_CVec_RouteHopZZ_clone(const LDKCVec_CVec_RouteHopZZ *orig) {
3684 LDKCVec_CVec_RouteHopZZ ret = { .data = MALLOC(sizeof(LDKCVec_RouteHopZ) * orig->datalen, "LDKCVec_CVec_RouteHopZZ clone bytes"), .datalen = orig->datalen };
3685 for (size_t i = 0; i < ret.datalen; i++) {
3686 ret.data[i] = CVec_RouteHopZ_clone(&orig->data[i]);
3690 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3691 return ((LDKCResult_RouteDecodeErrorZ*)arg)->result_ok;
3693 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3694 LDKCResult_RouteDecodeErrorZ *val = (LDKCResult_RouteDecodeErrorZ*)(arg & ~1);
3695 CHECK(val->result_ok);
3696 LDKRoute res_var = (*val->contents.result);
3697 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3698 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3699 long res_ref = (long)res_var.inner & ~1;
3702 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
3703 LDKCResult_RouteDecodeErrorZ *val = (LDKCResult_RouteDecodeErrorZ*)(arg & ~1);
3704 CHECK(!val->result_ok);
3705 LDKDecodeError err_var = (*val->contents.err);
3706 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3707 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3708 long err_ref = (long)err_var.inner & ~1;
3711 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1RouteHintZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
3712 LDKCVec_RouteHintZ *ret = MALLOC(sizeof(LDKCVec_RouteHintZ), "LDKCVec_RouteHintZ");
3713 ret->datalen = (*env)->GetArrayLength(env, elems);
3714 if (ret->datalen == 0) {
3717 ret->data = MALLOC(sizeof(LDKRouteHint) * ret->datalen, "LDKCVec_RouteHintZ Data");
3718 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
3719 for (size_t i = 0; i < ret->datalen; i++) {
3720 int64_t arr_elem = java_elems[i];
3721 LDKRouteHint arr_elem_conv;
3722 arr_elem_conv.inner = (void*)(arr_elem & (~1));
3723 arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
3724 arr_elem_conv = RouteHint_clone(&arr_elem_conv);
3725 ret->data[i] = arr_elem_conv;
3727 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
3731 static inline LDKCVec_RouteHintZ CVec_RouteHintZ_clone(const LDKCVec_RouteHintZ *orig) {
3732 LDKCVec_RouteHintZ ret = { .data = MALLOC(sizeof(LDKRouteHint) * orig->datalen, "LDKCVec_RouteHintZ clone bytes"), .datalen = orig->datalen };
3733 for (size_t i = 0; i < ret.datalen; i++) {
3734 ret.data[i] = RouteHint_clone(&orig->data[i]);
3738 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteLightningErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3739 return ((LDKCResult_RouteLightningErrorZ*)arg)->result_ok;
3741 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteLightningErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3742 LDKCResult_RouteLightningErrorZ *val = (LDKCResult_RouteLightningErrorZ*)(arg & ~1);
3743 CHECK(val->result_ok);
3744 LDKRoute res_var = (*val->contents.result);
3745 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3746 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3747 long res_ref = (long)res_var.inner & ~1;
3750 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteLightningErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
3751 LDKCResult_RouteLightningErrorZ *val = (LDKCResult_RouteLightningErrorZ*)(arg & ~1);
3752 CHECK(!val->result_ok);
3753 LDKLightningError err_var = (*val->contents.err);
3754 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3755 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3756 long err_ref = (long)err_var.inner & ~1;
3759 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NetAddressu8Z_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3760 return ((LDKCResult_NetAddressu8Z*)arg)->result_ok;
3762 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NetAddressu8Z_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3763 LDKCResult_NetAddressu8Z *val = (LDKCResult_NetAddressu8Z*)(arg & ~1);
3764 CHECK(val->result_ok);
3765 long res_ref = ((long)&(*val->contents.result)) | 1;
3768 JNIEXPORT int8_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NetAddressu8Z_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
3769 LDKCResult_NetAddressu8Z *val = (LDKCResult_NetAddressu8Z*)(arg & ~1);
3770 CHECK(!val->result_ok);
3771 return *val->contents.err;
3773 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CResult_1NetAddressu8ZDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3774 return ((LDKCResult_CResult_NetAddressu8ZDecodeErrorZ*)arg)->result_ok;
3776 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CResult_1NetAddressu8ZDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3777 LDKCResult_CResult_NetAddressu8ZDecodeErrorZ *val = (LDKCResult_CResult_NetAddressu8ZDecodeErrorZ*)(arg & ~1);
3778 CHECK(val->result_ok);
3779 LDKCResult_NetAddressu8Z* res_conv = MALLOC(sizeof(LDKCResult_NetAddressu8Z), "LDKCResult_NetAddressu8Z");
3780 *res_conv = (*val->contents.result);
3781 *res_conv = CResult_NetAddressu8Z_clone(res_conv);
3782 return (long)res_conv;
3784 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CResult_1NetAddressu8ZDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
3785 LDKCResult_CResult_NetAddressu8ZDecodeErrorZ *val = (LDKCResult_CResult_NetAddressu8ZDecodeErrorZ*)(arg & ~1);
3786 CHECK(!val->result_ok);
3787 LDKDecodeError err_var = (*val->contents.err);
3788 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3789 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3790 long err_ref = (long)err_var.inner & ~1;
3793 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1UpdateAddHTLCZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
3794 LDKCVec_UpdateAddHTLCZ *ret = MALLOC(sizeof(LDKCVec_UpdateAddHTLCZ), "LDKCVec_UpdateAddHTLCZ");
3795 ret->datalen = (*env)->GetArrayLength(env, elems);
3796 if (ret->datalen == 0) {
3799 ret->data = MALLOC(sizeof(LDKUpdateAddHTLC) * ret->datalen, "LDKCVec_UpdateAddHTLCZ Data");
3800 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
3801 for (size_t i = 0; i < ret->datalen; i++) {
3802 int64_t arr_elem = java_elems[i];
3803 LDKUpdateAddHTLC arr_elem_conv;
3804 arr_elem_conv.inner = (void*)(arr_elem & (~1));
3805 arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
3806 arr_elem_conv = UpdateAddHTLC_clone(&arr_elem_conv);
3807 ret->data[i] = arr_elem_conv;
3809 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
3813 static inline LDKCVec_UpdateAddHTLCZ CVec_UpdateAddHTLCZ_clone(const LDKCVec_UpdateAddHTLCZ *orig) {
3814 LDKCVec_UpdateAddHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateAddHTLC) * orig->datalen, "LDKCVec_UpdateAddHTLCZ clone bytes"), .datalen = orig->datalen };
3815 for (size_t i = 0; i < ret.datalen; i++) {
3816 ret.data[i] = UpdateAddHTLC_clone(&orig->data[i]);
3820 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1UpdateFulfillHTLCZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
3821 LDKCVec_UpdateFulfillHTLCZ *ret = MALLOC(sizeof(LDKCVec_UpdateFulfillHTLCZ), "LDKCVec_UpdateFulfillHTLCZ");
3822 ret->datalen = (*env)->GetArrayLength(env, elems);
3823 if (ret->datalen == 0) {
3826 ret->data = MALLOC(sizeof(LDKUpdateFulfillHTLC) * ret->datalen, "LDKCVec_UpdateFulfillHTLCZ Data");
3827 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
3828 for (size_t i = 0; i < ret->datalen; i++) {
3829 int64_t arr_elem = java_elems[i];
3830 LDKUpdateFulfillHTLC arr_elem_conv;
3831 arr_elem_conv.inner = (void*)(arr_elem & (~1));
3832 arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
3833 arr_elem_conv = UpdateFulfillHTLC_clone(&arr_elem_conv);
3834 ret->data[i] = arr_elem_conv;
3836 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
3840 static inline LDKCVec_UpdateFulfillHTLCZ CVec_UpdateFulfillHTLCZ_clone(const LDKCVec_UpdateFulfillHTLCZ *orig) {
3841 LDKCVec_UpdateFulfillHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFulfillHTLC) * orig->datalen, "LDKCVec_UpdateFulfillHTLCZ clone bytes"), .datalen = orig->datalen };
3842 for (size_t i = 0; i < ret.datalen; i++) {
3843 ret.data[i] = UpdateFulfillHTLC_clone(&orig->data[i]);
3847 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1UpdateFailHTLCZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
3848 LDKCVec_UpdateFailHTLCZ *ret = MALLOC(sizeof(LDKCVec_UpdateFailHTLCZ), "LDKCVec_UpdateFailHTLCZ");
3849 ret->datalen = (*env)->GetArrayLength(env, elems);
3850 if (ret->datalen == 0) {
3853 ret->data = MALLOC(sizeof(LDKUpdateFailHTLC) * ret->datalen, "LDKCVec_UpdateFailHTLCZ Data");
3854 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
3855 for (size_t i = 0; i < ret->datalen; i++) {
3856 int64_t arr_elem = java_elems[i];
3857 LDKUpdateFailHTLC arr_elem_conv;
3858 arr_elem_conv.inner = (void*)(arr_elem & (~1));
3859 arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
3860 arr_elem_conv = UpdateFailHTLC_clone(&arr_elem_conv);
3861 ret->data[i] = arr_elem_conv;
3863 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
3867 static inline LDKCVec_UpdateFailHTLCZ CVec_UpdateFailHTLCZ_clone(const LDKCVec_UpdateFailHTLCZ *orig) {
3868 LDKCVec_UpdateFailHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFailHTLC) * orig->datalen, "LDKCVec_UpdateFailHTLCZ clone bytes"), .datalen = orig->datalen };
3869 for (size_t i = 0; i < ret.datalen; i++) {
3870 ret.data[i] = UpdateFailHTLC_clone(&orig->data[i]);
3874 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1UpdateFailMalformedHTLCZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
3875 LDKCVec_UpdateFailMalformedHTLCZ *ret = MALLOC(sizeof(LDKCVec_UpdateFailMalformedHTLCZ), "LDKCVec_UpdateFailMalformedHTLCZ");
3876 ret->datalen = (*env)->GetArrayLength(env, elems);
3877 if (ret->datalen == 0) {
3880 ret->data = MALLOC(sizeof(LDKUpdateFailMalformedHTLC) * ret->datalen, "LDKCVec_UpdateFailMalformedHTLCZ Data");
3881 int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
3882 for (size_t i = 0; i < ret->datalen; i++) {
3883 int64_t arr_elem = java_elems[i];
3884 LDKUpdateFailMalformedHTLC arr_elem_conv;
3885 arr_elem_conv.inner = (void*)(arr_elem & (~1));
3886 arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
3887 arr_elem_conv = UpdateFailMalformedHTLC_clone(&arr_elem_conv);
3888 ret->data[i] = arr_elem_conv;
3890 (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
3894 static inline LDKCVec_UpdateFailMalformedHTLCZ CVec_UpdateFailMalformedHTLCZ_clone(const LDKCVec_UpdateFailMalformedHTLCZ *orig) {
3895 LDKCVec_UpdateFailMalformedHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFailMalformedHTLC) * orig->datalen, "LDKCVec_UpdateFailMalformedHTLCZ clone bytes"), .datalen = orig->datalen };
3896 for (size_t i = 0; i < ret.datalen; i++) {
3897 ret.data[i] = UpdateFailMalformedHTLC_clone(&orig->data[i]);
3901 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1AcceptChannelDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3902 return ((LDKCResult_AcceptChannelDecodeErrorZ*)arg)->result_ok;
3904 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1AcceptChannelDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3905 LDKCResult_AcceptChannelDecodeErrorZ *val = (LDKCResult_AcceptChannelDecodeErrorZ*)(arg & ~1);
3906 CHECK(val->result_ok);
3907 LDKAcceptChannel res_var = (*val->contents.result);
3908 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3909 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3910 long res_ref = (long)res_var.inner & ~1;
3913 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1AcceptChannelDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
3914 LDKCResult_AcceptChannelDecodeErrorZ *val = (LDKCResult_AcceptChannelDecodeErrorZ*)(arg & ~1);
3915 CHECK(!val->result_ok);
3916 LDKDecodeError err_var = (*val->contents.err);
3917 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3918 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3919 long err_ref = (long)err_var.inner & ~1;
3922 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1AnnouncementSignaturesDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3923 return ((LDKCResult_AnnouncementSignaturesDecodeErrorZ*)arg)->result_ok;
3925 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1AnnouncementSignaturesDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3926 LDKCResult_AnnouncementSignaturesDecodeErrorZ *val = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(arg & ~1);
3927 CHECK(val->result_ok);
3928 LDKAnnouncementSignatures res_var = (*val->contents.result);
3929 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3930 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3931 long res_ref = (long)res_var.inner & ~1;
3934 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1AnnouncementSignaturesDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
3935 LDKCResult_AnnouncementSignaturesDecodeErrorZ *val = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(arg & ~1);
3936 CHECK(!val->result_ok);
3937 LDKDecodeError err_var = (*val->contents.err);
3938 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3939 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3940 long err_ref = (long)err_var.inner & ~1;
3943 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelReestablishDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3944 return ((LDKCResult_ChannelReestablishDecodeErrorZ*)arg)->result_ok;
3946 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelReestablishDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3947 LDKCResult_ChannelReestablishDecodeErrorZ *val = (LDKCResult_ChannelReestablishDecodeErrorZ*)(arg & ~1);
3948 CHECK(val->result_ok);
3949 LDKChannelReestablish res_var = (*val->contents.result);
3950 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3951 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3952 long res_ref = (long)res_var.inner & ~1;
3955 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelReestablishDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
3956 LDKCResult_ChannelReestablishDecodeErrorZ *val = (LDKCResult_ChannelReestablishDecodeErrorZ*)(arg & ~1);
3957 CHECK(!val->result_ok);
3958 LDKDecodeError err_var = (*val->contents.err);
3959 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3960 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3961 long err_ref = (long)err_var.inner & ~1;
3964 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ClosingSignedDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3965 return ((LDKCResult_ClosingSignedDecodeErrorZ*)arg)->result_ok;
3967 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ClosingSignedDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3968 LDKCResult_ClosingSignedDecodeErrorZ *val = (LDKCResult_ClosingSignedDecodeErrorZ*)(arg & ~1);
3969 CHECK(val->result_ok);
3970 LDKClosingSigned res_var = (*val->contents.result);
3971 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3972 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3973 long res_ref = (long)res_var.inner & ~1;
3976 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ClosingSignedDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
3977 LDKCResult_ClosingSignedDecodeErrorZ *val = (LDKCResult_ClosingSignedDecodeErrorZ*)(arg & ~1);
3978 CHECK(!val->result_ok);
3979 LDKDecodeError err_var = (*val->contents.err);
3980 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3981 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3982 long err_ref = (long)err_var.inner & ~1;
3985 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CommitmentSignedDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3986 return ((LDKCResult_CommitmentSignedDecodeErrorZ*)arg)->result_ok;
3988 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CommitmentSignedDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
3989 LDKCResult_CommitmentSignedDecodeErrorZ *val = (LDKCResult_CommitmentSignedDecodeErrorZ*)(arg & ~1);
3990 CHECK(val->result_ok);
3991 LDKCommitmentSigned res_var = (*val->contents.result);
3992 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3993 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3994 long res_ref = (long)res_var.inner & ~1;
3997 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CommitmentSignedDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
3998 LDKCResult_CommitmentSignedDecodeErrorZ *val = (LDKCResult_CommitmentSignedDecodeErrorZ*)(arg & ~1);
3999 CHECK(!val->result_ok);
4000 LDKDecodeError err_var = (*val->contents.err);
4001 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4002 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4003 long err_ref = (long)err_var.inner & ~1;
4006 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingCreatedDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4007 return ((LDKCResult_FundingCreatedDecodeErrorZ*)arg)->result_ok;
4009 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingCreatedDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4010 LDKCResult_FundingCreatedDecodeErrorZ *val = (LDKCResult_FundingCreatedDecodeErrorZ*)(arg & ~1);
4011 CHECK(val->result_ok);
4012 LDKFundingCreated res_var = (*val->contents.result);
4013 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4014 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4015 long res_ref = (long)res_var.inner & ~1;
4018 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingCreatedDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4019 LDKCResult_FundingCreatedDecodeErrorZ *val = (LDKCResult_FundingCreatedDecodeErrorZ*)(arg & ~1);
4020 CHECK(!val->result_ok);
4021 LDKDecodeError err_var = (*val->contents.err);
4022 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4023 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4024 long err_ref = (long)err_var.inner & ~1;
4027 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingSignedDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4028 return ((LDKCResult_FundingSignedDecodeErrorZ*)arg)->result_ok;
4030 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingSignedDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4031 LDKCResult_FundingSignedDecodeErrorZ *val = (LDKCResult_FundingSignedDecodeErrorZ*)(arg & ~1);
4032 CHECK(val->result_ok);
4033 LDKFundingSigned res_var = (*val->contents.result);
4034 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4035 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4036 long res_ref = (long)res_var.inner & ~1;
4039 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingSignedDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4040 LDKCResult_FundingSignedDecodeErrorZ *val = (LDKCResult_FundingSignedDecodeErrorZ*)(arg & ~1);
4041 CHECK(!val->result_ok);
4042 LDKDecodeError err_var = (*val->contents.err);
4043 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4044 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4045 long err_ref = (long)err_var.inner & ~1;
4048 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingLockedDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4049 return ((LDKCResult_FundingLockedDecodeErrorZ*)arg)->result_ok;
4051 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingLockedDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4052 LDKCResult_FundingLockedDecodeErrorZ *val = (LDKCResult_FundingLockedDecodeErrorZ*)(arg & ~1);
4053 CHECK(val->result_ok);
4054 LDKFundingLocked res_var = (*val->contents.result);
4055 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4056 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4057 long res_ref = (long)res_var.inner & ~1;
4060 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingLockedDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4061 LDKCResult_FundingLockedDecodeErrorZ *val = (LDKCResult_FundingLockedDecodeErrorZ*)(arg & ~1);
4062 CHECK(!val->result_ok);
4063 LDKDecodeError err_var = (*val->contents.err);
4064 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4065 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4066 long err_ref = (long)err_var.inner & ~1;
4069 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4070 return ((LDKCResult_InitDecodeErrorZ*)arg)->result_ok;
4072 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4073 LDKCResult_InitDecodeErrorZ *val = (LDKCResult_InitDecodeErrorZ*)(arg & ~1);
4074 CHECK(val->result_ok);
4075 LDKInit res_var = (*val->contents.result);
4076 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4077 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4078 long res_ref = (long)res_var.inner & ~1;
4081 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4082 LDKCResult_InitDecodeErrorZ *val = (LDKCResult_InitDecodeErrorZ*)(arg & ~1);
4083 CHECK(!val->result_ok);
4084 LDKDecodeError err_var = (*val->contents.err);
4085 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4086 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4087 long err_ref = (long)err_var.inner & ~1;
4090 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1OpenChannelDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4091 return ((LDKCResult_OpenChannelDecodeErrorZ*)arg)->result_ok;
4093 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1OpenChannelDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4094 LDKCResult_OpenChannelDecodeErrorZ *val = (LDKCResult_OpenChannelDecodeErrorZ*)(arg & ~1);
4095 CHECK(val->result_ok);
4096 LDKOpenChannel res_var = (*val->contents.result);
4097 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4098 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4099 long res_ref = (long)res_var.inner & ~1;
4102 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1OpenChannelDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4103 LDKCResult_OpenChannelDecodeErrorZ *val = (LDKCResult_OpenChannelDecodeErrorZ*)(arg & ~1);
4104 CHECK(!val->result_ok);
4105 LDKDecodeError err_var = (*val->contents.err);
4106 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4107 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4108 long err_ref = (long)err_var.inner & ~1;
4111 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RevokeAndACKDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4112 return ((LDKCResult_RevokeAndACKDecodeErrorZ*)arg)->result_ok;
4114 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RevokeAndACKDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4115 LDKCResult_RevokeAndACKDecodeErrorZ *val = (LDKCResult_RevokeAndACKDecodeErrorZ*)(arg & ~1);
4116 CHECK(val->result_ok);
4117 LDKRevokeAndACK res_var = (*val->contents.result);
4118 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4119 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4120 long res_ref = (long)res_var.inner & ~1;
4123 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RevokeAndACKDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4124 LDKCResult_RevokeAndACKDecodeErrorZ *val = (LDKCResult_RevokeAndACKDecodeErrorZ*)(arg & ~1);
4125 CHECK(!val->result_ok);
4126 LDKDecodeError err_var = (*val->contents.err);
4127 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4128 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4129 long err_ref = (long)err_var.inner & ~1;
4132 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ShutdownDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4133 return ((LDKCResult_ShutdownDecodeErrorZ*)arg)->result_ok;
4135 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ShutdownDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4136 LDKCResult_ShutdownDecodeErrorZ *val = (LDKCResult_ShutdownDecodeErrorZ*)(arg & ~1);
4137 CHECK(val->result_ok);
4138 LDKShutdown res_var = (*val->contents.result);
4139 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4140 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4141 long res_ref = (long)res_var.inner & ~1;
4144 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ShutdownDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4145 LDKCResult_ShutdownDecodeErrorZ *val = (LDKCResult_ShutdownDecodeErrorZ*)(arg & ~1);
4146 CHECK(!val->result_ok);
4147 LDKDecodeError err_var = (*val->contents.err);
4148 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4149 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4150 long err_ref = (long)err_var.inner & ~1;
4153 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFailHTLCDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4154 return ((LDKCResult_UpdateFailHTLCDecodeErrorZ*)arg)->result_ok;
4156 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFailHTLCDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4157 LDKCResult_UpdateFailHTLCDecodeErrorZ *val = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)(arg & ~1);
4158 CHECK(val->result_ok);
4159 LDKUpdateFailHTLC res_var = (*val->contents.result);
4160 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4161 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4162 long res_ref = (long)res_var.inner & ~1;
4165 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFailHTLCDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4166 LDKCResult_UpdateFailHTLCDecodeErrorZ *val = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)(arg & ~1);
4167 CHECK(!val->result_ok);
4168 LDKDecodeError err_var = (*val->contents.err);
4169 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4170 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4171 long err_ref = (long)err_var.inner & ~1;
4174 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFailMalformedHTLCDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4175 return ((LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)arg)->result_ok;
4177 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFailMalformedHTLCDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4178 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *val = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(arg & ~1);
4179 CHECK(val->result_ok);
4180 LDKUpdateFailMalformedHTLC res_var = (*val->contents.result);
4181 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4182 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4183 long res_ref = (long)res_var.inner & ~1;
4186 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFailMalformedHTLCDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4187 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *val = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(arg & ~1);
4188 CHECK(!val->result_ok);
4189 LDKDecodeError err_var = (*val->contents.err);
4190 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4191 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4192 long err_ref = (long)err_var.inner & ~1;
4195 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFeeDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4196 return ((LDKCResult_UpdateFeeDecodeErrorZ*)arg)->result_ok;
4198 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFeeDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4199 LDKCResult_UpdateFeeDecodeErrorZ *val = (LDKCResult_UpdateFeeDecodeErrorZ*)(arg & ~1);
4200 CHECK(val->result_ok);
4201 LDKUpdateFee res_var = (*val->contents.result);
4202 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4203 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4204 long res_ref = (long)res_var.inner & ~1;
4207 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFeeDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4208 LDKCResult_UpdateFeeDecodeErrorZ *val = (LDKCResult_UpdateFeeDecodeErrorZ*)(arg & ~1);
4209 CHECK(!val->result_ok);
4210 LDKDecodeError err_var = (*val->contents.err);
4211 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4212 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4213 long err_ref = (long)err_var.inner & ~1;
4216 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFulfillHTLCDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4217 return ((LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)arg)->result_ok;
4219 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFulfillHTLCDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4220 LDKCResult_UpdateFulfillHTLCDecodeErrorZ *val = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(arg & ~1);
4221 CHECK(val->result_ok);
4222 LDKUpdateFulfillHTLC res_var = (*val->contents.result);
4223 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4224 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4225 long res_ref = (long)res_var.inner & ~1;
4228 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFulfillHTLCDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4229 LDKCResult_UpdateFulfillHTLCDecodeErrorZ *val = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(arg & ~1);
4230 CHECK(!val->result_ok);
4231 LDKDecodeError err_var = (*val->contents.err);
4232 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4233 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4234 long err_ref = (long)err_var.inner & ~1;
4237 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateAddHTLCDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4238 return ((LDKCResult_UpdateAddHTLCDecodeErrorZ*)arg)->result_ok;
4240 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateAddHTLCDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4241 LDKCResult_UpdateAddHTLCDecodeErrorZ *val = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)(arg & ~1);
4242 CHECK(val->result_ok);
4243 LDKUpdateAddHTLC res_var = (*val->contents.result);
4244 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4245 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4246 long res_ref = (long)res_var.inner & ~1;
4249 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateAddHTLCDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4250 LDKCResult_UpdateAddHTLCDecodeErrorZ *val = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)(arg & ~1);
4251 CHECK(!val->result_ok);
4252 LDKDecodeError err_var = (*val->contents.err);
4253 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4254 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4255 long err_ref = (long)err_var.inner & ~1;
4258 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PingDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4259 return ((LDKCResult_PingDecodeErrorZ*)arg)->result_ok;
4261 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PingDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4262 LDKCResult_PingDecodeErrorZ *val = (LDKCResult_PingDecodeErrorZ*)(arg & ~1);
4263 CHECK(val->result_ok);
4264 LDKPing res_var = (*val->contents.result);
4265 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4266 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4267 long res_ref = (long)res_var.inner & ~1;
4270 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PingDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4271 LDKCResult_PingDecodeErrorZ *val = (LDKCResult_PingDecodeErrorZ*)(arg & ~1);
4272 CHECK(!val->result_ok);
4273 LDKDecodeError err_var = (*val->contents.err);
4274 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4275 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4276 long err_ref = (long)err_var.inner & ~1;
4279 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PongDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4280 return ((LDKCResult_PongDecodeErrorZ*)arg)->result_ok;
4282 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PongDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4283 LDKCResult_PongDecodeErrorZ *val = (LDKCResult_PongDecodeErrorZ*)(arg & ~1);
4284 CHECK(val->result_ok);
4285 LDKPong res_var = (*val->contents.result);
4286 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4287 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4288 long res_ref = (long)res_var.inner & ~1;
4291 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PongDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4292 LDKCResult_PongDecodeErrorZ *val = (LDKCResult_PongDecodeErrorZ*)(arg & ~1);
4293 CHECK(!val->result_ok);
4294 LDKDecodeError err_var = (*val->contents.err);
4295 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4296 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4297 long err_ref = (long)err_var.inner & ~1;
4300 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedChannelAnnouncementDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4301 return ((LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)arg)->result_ok;
4303 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedChannelAnnouncementDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4304 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *val = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(arg & ~1);
4305 CHECK(val->result_ok);
4306 LDKUnsignedChannelAnnouncement res_var = (*val->contents.result);
4307 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4308 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4309 long res_ref = (long)res_var.inner & ~1;
4312 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedChannelAnnouncementDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4313 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *val = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(arg & ~1);
4314 CHECK(!val->result_ok);
4315 LDKDecodeError err_var = (*val->contents.err);
4316 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4317 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4318 long err_ref = (long)err_var.inner & ~1;
4321 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelAnnouncementDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4322 return ((LDKCResult_ChannelAnnouncementDecodeErrorZ*)arg)->result_ok;
4324 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelAnnouncementDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4325 LDKCResult_ChannelAnnouncementDecodeErrorZ *val = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)(arg & ~1);
4326 CHECK(val->result_ok);
4327 LDKChannelAnnouncement res_var = (*val->contents.result);
4328 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4329 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4330 long res_ref = (long)res_var.inner & ~1;
4333 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelAnnouncementDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4334 LDKCResult_ChannelAnnouncementDecodeErrorZ *val = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)(arg & ~1);
4335 CHECK(!val->result_ok);
4336 LDKDecodeError err_var = (*val->contents.err);
4337 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4338 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4339 long err_ref = (long)err_var.inner & ~1;
4342 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedChannelUpdateDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4343 return ((LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)arg)->result_ok;
4345 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedChannelUpdateDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4346 LDKCResult_UnsignedChannelUpdateDecodeErrorZ *val = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(arg & ~1);
4347 CHECK(val->result_ok);
4348 LDKUnsignedChannelUpdate res_var = (*val->contents.result);
4349 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4350 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4351 long res_ref = (long)res_var.inner & ~1;
4354 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedChannelUpdateDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4355 LDKCResult_UnsignedChannelUpdateDecodeErrorZ *val = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(arg & ~1);
4356 CHECK(!val->result_ok);
4357 LDKDecodeError err_var = (*val->contents.err);
4358 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4359 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4360 long err_ref = (long)err_var.inner & ~1;
4363 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelUpdateDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4364 return ((LDKCResult_ChannelUpdateDecodeErrorZ*)arg)->result_ok;
4366 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelUpdateDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4367 LDKCResult_ChannelUpdateDecodeErrorZ *val = (LDKCResult_ChannelUpdateDecodeErrorZ*)(arg & ~1);
4368 CHECK(val->result_ok);
4369 LDKChannelUpdate res_var = (*val->contents.result);
4370 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4371 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4372 long res_ref = (long)res_var.inner & ~1;
4375 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelUpdateDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4376 LDKCResult_ChannelUpdateDecodeErrorZ *val = (LDKCResult_ChannelUpdateDecodeErrorZ*)(arg & ~1);
4377 CHECK(!val->result_ok);
4378 LDKDecodeError err_var = (*val->contents.err);
4379 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4380 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4381 long err_ref = (long)err_var.inner & ~1;
4384 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ErrorMessageDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4385 return ((LDKCResult_ErrorMessageDecodeErrorZ*)arg)->result_ok;
4387 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ErrorMessageDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4388 LDKCResult_ErrorMessageDecodeErrorZ *val = (LDKCResult_ErrorMessageDecodeErrorZ*)(arg & ~1);
4389 CHECK(val->result_ok);
4390 LDKErrorMessage res_var = (*val->contents.result);
4391 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4392 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4393 long res_ref = (long)res_var.inner & ~1;
4396 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ErrorMessageDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4397 LDKCResult_ErrorMessageDecodeErrorZ *val = (LDKCResult_ErrorMessageDecodeErrorZ*)(arg & ~1);
4398 CHECK(!val->result_ok);
4399 LDKDecodeError err_var = (*val->contents.err);
4400 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4401 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4402 long err_ref = (long)err_var.inner & ~1;
4405 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedNodeAnnouncementDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4406 return ((LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)arg)->result_ok;
4408 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedNodeAnnouncementDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4409 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *val = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(arg & ~1);
4410 CHECK(val->result_ok);
4411 LDKUnsignedNodeAnnouncement res_var = (*val->contents.result);
4412 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4413 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4414 long res_ref = (long)res_var.inner & ~1;
4417 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedNodeAnnouncementDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4418 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *val = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(arg & ~1);
4419 CHECK(!val->result_ok);
4420 LDKDecodeError err_var = (*val->contents.err);
4421 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4422 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4423 long err_ref = (long)err_var.inner & ~1;
4426 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeAnnouncementDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4427 return ((LDKCResult_NodeAnnouncementDecodeErrorZ*)arg)->result_ok;
4429 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeAnnouncementDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4430 LDKCResult_NodeAnnouncementDecodeErrorZ *val = (LDKCResult_NodeAnnouncementDecodeErrorZ*)(arg & ~1);
4431 CHECK(val->result_ok);
4432 LDKNodeAnnouncement res_var = (*val->contents.result);
4433 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4434 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4435 long res_ref = (long)res_var.inner & ~1;
4438 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeAnnouncementDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4439 LDKCResult_NodeAnnouncementDecodeErrorZ *val = (LDKCResult_NodeAnnouncementDecodeErrorZ*)(arg & ~1);
4440 CHECK(!val->result_ok);
4441 LDKDecodeError err_var = (*val->contents.err);
4442 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4443 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4444 long err_ref = (long)err_var.inner & ~1;
4447 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1QueryShortChannelIdsDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4448 return ((LDKCResult_QueryShortChannelIdsDecodeErrorZ*)arg)->result_ok;
4450 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1QueryShortChannelIdsDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4451 LDKCResult_QueryShortChannelIdsDecodeErrorZ *val = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(arg & ~1);
4452 CHECK(val->result_ok);
4453 LDKQueryShortChannelIds res_var = (*val->contents.result);
4454 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4455 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4456 long res_ref = (long)res_var.inner & ~1;
4459 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1QueryShortChannelIdsDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4460 LDKCResult_QueryShortChannelIdsDecodeErrorZ *val = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(arg & ~1);
4461 CHECK(!val->result_ok);
4462 LDKDecodeError err_var = (*val->contents.err);
4463 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4464 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4465 long err_ref = (long)err_var.inner & ~1;
4468 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ReplyShortChannelIdsEndDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4469 return ((LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)arg)->result_ok;
4471 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ReplyShortChannelIdsEndDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4472 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *val = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(arg & ~1);
4473 CHECK(val->result_ok);
4474 LDKReplyShortChannelIdsEnd res_var = (*val->contents.result);
4475 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4476 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4477 long res_ref = (long)res_var.inner & ~1;
4480 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ReplyShortChannelIdsEndDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4481 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *val = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(arg & ~1);
4482 CHECK(!val->result_ok);
4483 LDKDecodeError err_var = (*val->contents.err);
4484 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4485 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4486 long err_ref = (long)err_var.inner & ~1;
4489 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1QueryChannelRangeDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4490 return ((LDKCResult_QueryChannelRangeDecodeErrorZ*)arg)->result_ok;
4492 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1QueryChannelRangeDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4493 LDKCResult_QueryChannelRangeDecodeErrorZ *val = (LDKCResult_QueryChannelRangeDecodeErrorZ*)(arg & ~1);
4494 CHECK(val->result_ok);
4495 LDKQueryChannelRange res_var = (*val->contents.result);
4496 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4497 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4498 long res_ref = (long)res_var.inner & ~1;
4501 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1QueryChannelRangeDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4502 LDKCResult_QueryChannelRangeDecodeErrorZ *val = (LDKCResult_QueryChannelRangeDecodeErrorZ*)(arg & ~1);
4503 CHECK(!val->result_ok);
4504 LDKDecodeError err_var = (*val->contents.err);
4505 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4506 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4507 long err_ref = (long)err_var.inner & ~1;
4510 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ReplyChannelRangeDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4511 return ((LDKCResult_ReplyChannelRangeDecodeErrorZ*)arg)->result_ok;
4513 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ReplyChannelRangeDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4514 LDKCResult_ReplyChannelRangeDecodeErrorZ *val = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)(arg & ~1);
4515 CHECK(val->result_ok);
4516 LDKReplyChannelRange res_var = (*val->contents.result);
4517 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4518 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4519 long res_ref = (long)res_var.inner & ~1;
4522 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ReplyChannelRangeDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4523 LDKCResult_ReplyChannelRangeDecodeErrorZ *val = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)(arg & ~1);
4524 CHECK(!val->result_ok);
4525 LDKDecodeError err_var = (*val->contents.err);
4526 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4527 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4528 long err_ref = (long)err_var.inner & ~1;
4531 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1GossipTimestampFilterDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4532 return ((LDKCResult_GossipTimestampFilterDecodeErrorZ*)arg)->result_ok;
4534 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1GossipTimestampFilterDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
4535 LDKCResult_GossipTimestampFilterDecodeErrorZ *val = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)(arg & ~1);
4536 CHECK(val->result_ok);
4537 LDKGossipTimestampFilter res_var = (*val->contents.result);
4538 CHECK((((long)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4539 CHECK((((long)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4540 long res_ref = (long)res_var.inner & ~1;
4543 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1GossipTimestampFilterDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
4544 LDKCResult_GossipTimestampFilterDecodeErrorZ *val = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)(arg & ~1);
4545 CHECK(!val->result_ok);
4546 LDKDecodeError err_var = (*val->contents.err);
4547 CHECK((((long)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4548 CHECK((((long)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4549 long err_ref = (long)err_var.inner & ~1;
4552 typedef struct LDKMessageSendEventsProvider_JCalls {
4553 atomic_size_t refcnt;
4556 jmethodID get_and_clear_pending_msg_events_meth;
4557 } LDKMessageSendEventsProvider_JCalls;
4558 static void LDKMessageSendEventsProvider_JCalls_free(void* this_arg) {
4559 LDKMessageSendEventsProvider_JCalls *j_calls = (LDKMessageSendEventsProvider_JCalls*) this_arg;
4560 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
4562 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
4563 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
4567 LDKCVec_MessageSendEventZ get_and_clear_pending_msg_events_jcall(const void* this_arg) {
4568 LDKMessageSendEventsProvider_JCalls *j_calls = (LDKMessageSendEventsProvider_JCalls*) this_arg;
4570 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
4571 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
4573 int64_tArray ret = (*env)->CallObjectMethod(env, obj, j_calls->get_and_clear_pending_msg_events_meth);
4574 LDKCVec_MessageSendEventZ ret_constr;
4575 ret_constr.datalen = (*env)->GetArrayLength(env, ret);
4576 if (ret_constr.datalen > 0)
4577 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKMessageSendEvent), "LDKCVec_MessageSendEventZ Elements");
4579 ret_constr.data = NULL;
4580 int64_t* ret_vals = (*env)->GetLongArrayElements (env, ret, NULL);
4581 for (size_t s = 0; s < ret_constr.datalen; s++) {
4582 int64_t ret_conv_18 = ret_vals[s];
4583 LDKMessageSendEvent ret_conv_18_conv = *(LDKMessageSendEvent*)(((uint64_t)ret_conv_18) & ~1);
4584 ret_conv_18_conv = MessageSendEvent_clone((LDKMessageSendEvent*)ret_conv_18);
4585 ret_constr.data[s] = ret_conv_18_conv;
4587 (*env)->ReleaseLongArrayElements(env, ret, ret_vals, 0);
4590 static void* LDKMessageSendEventsProvider_JCalls_clone(const void* this_arg) {
4591 LDKMessageSendEventsProvider_JCalls *j_calls = (LDKMessageSendEventsProvider_JCalls*) this_arg;
4592 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
4593 return (void*) this_arg;
4595 static inline LDKMessageSendEventsProvider LDKMessageSendEventsProvider_init (JNIEnv *env, jclass clz, jobject o) {
4596 jclass c = (*env)->GetObjectClass(env, o);
4598 LDKMessageSendEventsProvider_JCalls *calls = MALLOC(sizeof(LDKMessageSendEventsProvider_JCalls), "LDKMessageSendEventsProvider_JCalls");
4599 atomic_init(&calls->refcnt, 1);
4600 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
4601 calls->o = (*env)->NewWeakGlobalRef(env, o);
4602 calls->get_and_clear_pending_msg_events_meth = (*env)->GetMethodID(env, c, "get_and_clear_pending_msg_events", "()[J");
4603 CHECK(calls->get_and_clear_pending_msg_events_meth != NULL);
4605 LDKMessageSendEventsProvider ret = {
4606 .this_arg = (void*) calls,
4607 .get_and_clear_pending_msg_events = get_and_clear_pending_msg_events_jcall,
4608 .free = LDKMessageSendEventsProvider_JCalls_free,
4612 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKMessageSendEventsProvider_1new(JNIEnv *env, jclass clz, jobject o) {
4613 LDKMessageSendEventsProvider *res_ptr = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
4614 *res_ptr = LDKMessageSendEventsProvider_init(env, clz, o);
4615 return (long)res_ptr;
4617 JNIEXPORT int64_tArray JNICALL Java_org_ldk_impl_bindings_MessageSendEventsProvider_1get_1and_1clear_1pending_1msg_1events(JNIEnv *env, jclass clz, int64_t this_arg) {
4618 LDKMessageSendEventsProvider* this_arg_conv = (LDKMessageSendEventsProvider*)(((uint64_t)this_arg) & ~1);
4619 LDKCVec_MessageSendEventZ ret_var = (this_arg_conv->get_and_clear_pending_msg_events)(this_arg_conv->this_arg);
4620 int64_tArray ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
4621 int64_t *ret_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, ret_arr, NULL);
4622 for (size_t s = 0; s < ret_var.datalen; s++) {
4623 LDKMessageSendEvent *ret_conv_18_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
4624 *ret_conv_18_copy = MessageSendEvent_clone(&ret_var.data[s]);
4625 long ret_conv_18_ref = (long)ret_conv_18_copy;
4626 ret_arr_ptr[s] = ret_conv_18_ref;
4628 (*env)->ReleasePrimitiveArrayCritical(env, ret_arr, ret_arr_ptr, 0);
4633 typedef struct LDKEventsProvider_JCalls {
4634 atomic_size_t refcnt;
4637 jmethodID get_and_clear_pending_events_meth;
4638 } LDKEventsProvider_JCalls;
4639 static void LDKEventsProvider_JCalls_free(void* this_arg) {
4640 LDKEventsProvider_JCalls *j_calls = (LDKEventsProvider_JCalls*) this_arg;
4641 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
4643 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
4644 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
4648 LDKCVec_EventZ get_and_clear_pending_events_jcall(const void* this_arg) {
4649 LDKEventsProvider_JCalls *j_calls = (LDKEventsProvider_JCalls*) this_arg;
4651 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
4652 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
4654 int64_tArray ret = (*env)->CallObjectMethod(env, obj, j_calls->get_and_clear_pending_events_meth);
4655 LDKCVec_EventZ ret_constr;
4656 ret_constr.datalen = (*env)->GetArrayLength(env, ret);
4657 if (ret_constr.datalen > 0)
4658 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKEvent), "LDKCVec_EventZ Elements");
4660 ret_constr.data = NULL;
4661 int64_t* ret_vals = (*env)->GetLongArrayElements (env, ret, NULL);
4662 for (size_t h = 0; h < ret_constr.datalen; h++) {
4663 int64_t ret_conv_7 = ret_vals[h];
4664 LDKEvent ret_conv_7_conv = *(LDKEvent*)(((uint64_t)ret_conv_7) & ~1);
4665 ret_conv_7_conv = Event_clone((LDKEvent*)ret_conv_7);
4666 ret_constr.data[h] = ret_conv_7_conv;
4668 (*env)->ReleaseLongArrayElements(env, ret, ret_vals, 0);
4671 static void* LDKEventsProvider_JCalls_clone(const void* this_arg) {
4672 LDKEventsProvider_JCalls *j_calls = (LDKEventsProvider_JCalls*) this_arg;
4673 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
4674 return (void*) this_arg;
4676 static inline LDKEventsProvider LDKEventsProvider_init (JNIEnv *env, jclass clz, jobject o) {
4677 jclass c = (*env)->GetObjectClass(env, o);
4679 LDKEventsProvider_JCalls *calls = MALLOC(sizeof(LDKEventsProvider_JCalls), "LDKEventsProvider_JCalls");
4680 atomic_init(&calls->refcnt, 1);
4681 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
4682 calls->o = (*env)->NewWeakGlobalRef(env, o);
4683 calls->get_and_clear_pending_events_meth = (*env)->GetMethodID(env, c, "get_and_clear_pending_events", "()[J");
4684 CHECK(calls->get_and_clear_pending_events_meth != NULL);
4686 LDKEventsProvider ret = {
4687 .this_arg = (void*) calls,
4688 .get_and_clear_pending_events = get_and_clear_pending_events_jcall,
4689 .free = LDKEventsProvider_JCalls_free,
4693 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKEventsProvider_1new(JNIEnv *env, jclass clz, jobject o) {
4694 LDKEventsProvider *res_ptr = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider");
4695 *res_ptr = LDKEventsProvider_init(env, clz, o);
4696 return (long)res_ptr;
4698 JNIEXPORT int64_tArray JNICALL Java_org_ldk_impl_bindings_EventsProvider_1get_1and_1clear_1pending_1events(JNIEnv *env, jclass clz, int64_t this_arg) {
4699 LDKEventsProvider* this_arg_conv = (LDKEventsProvider*)(((uint64_t)this_arg) & ~1);
4700 LDKCVec_EventZ ret_var = (this_arg_conv->get_and_clear_pending_events)(this_arg_conv->this_arg);
4701 int64_tArray ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
4702 int64_t *ret_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, ret_arr, NULL);
4703 for (size_t h = 0; h < ret_var.datalen; h++) {
4704 LDKEvent *ret_conv_7_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
4705 *ret_conv_7_copy = Event_clone(&ret_var.data[h]);
4706 long ret_conv_7_ref = (long)ret_conv_7_copy;
4707 ret_arr_ptr[h] = ret_conv_7_ref;
4709 (*env)->ReleasePrimitiveArrayCritical(env, ret_arr, ret_arr_ptr, 0);
4714 typedef struct LDKAccess_JCalls {
4715 atomic_size_t refcnt;
4718 jmethodID get_utxo_meth;
4720 static void LDKAccess_JCalls_free(void* this_arg) {
4721 LDKAccess_JCalls *j_calls = (LDKAccess_JCalls*) this_arg;
4722 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
4724 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
4725 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
4729 LDKCResult_TxOutAccessErrorZ get_utxo_jcall(const void* this_arg, const uint8_t (* genesis_hash)[32], uint64_t short_channel_id) {
4730 LDKAccess_JCalls *j_calls = (LDKAccess_JCalls*) this_arg;
4732 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
4733 int8_tArray genesis_hash_arr = (*env)->NewByteArray(env, 32);
4734 (*env)->SetByteArrayRegion(env, genesis_hash_arr, 0, 32, *genesis_hash);
4735 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
4737 LDKCResult_TxOutAccessErrorZ* ret = (LDKCResult_TxOutAccessErrorZ*)(*env)->CallLongMethod(env, obj, j_calls->get_utxo_meth, genesis_hash_arr, short_channel_id);
4738 LDKCResult_TxOutAccessErrorZ ret_conv = *(LDKCResult_TxOutAccessErrorZ*)(((uint64_t)ret) & ~1);
4739 ret_conv = CResult_TxOutAccessErrorZ_clone((LDKCResult_TxOutAccessErrorZ*)ret);
4742 static void* LDKAccess_JCalls_clone(const void* this_arg) {
4743 LDKAccess_JCalls *j_calls = (LDKAccess_JCalls*) this_arg;
4744 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
4745 return (void*) this_arg;
4747 static inline LDKAccess LDKAccess_init (JNIEnv *env, jclass clz, jobject o) {
4748 jclass c = (*env)->GetObjectClass(env, o);
4750 LDKAccess_JCalls *calls = MALLOC(sizeof(LDKAccess_JCalls), "LDKAccess_JCalls");
4751 atomic_init(&calls->refcnt, 1);
4752 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
4753 calls->o = (*env)->NewWeakGlobalRef(env, o);
4754 calls->get_utxo_meth = (*env)->GetMethodID(env, c, "get_utxo", "([BJ)J");
4755 CHECK(calls->get_utxo_meth != NULL);
4758 .this_arg = (void*) calls,
4759 .get_utxo = get_utxo_jcall,
4760 .free = LDKAccess_JCalls_free,
4764 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKAccess_1new(JNIEnv *env, jclass clz, jobject o) {
4765 LDKAccess *res_ptr = MALLOC(sizeof(LDKAccess), "LDKAccess");
4766 *res_ptr = LDKAccess_init(env, clz, o);
4767 return (long)res_ptr;
4769 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) {
4770 LDKAccess* this_arg_conv = (LDKAccess*)(((uint64_t)this_arg) & ~1);
4771 unsigned char genesis_hash_arr[32];
4772 CHECK((*env)->GetArrayLength(env, genesis_hash) == 32);
4773 (*env)->GetByteArrayRegion(env, genesis_hash, 0, 32, genesis_hash_arr);
4774 unsigned char (*genesis_hash_ref)[32] = &genesis_hash_arr;
4775 LDKCResult_TxOutAccessErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutAccessErrorZ), "LDKCResult_TxOutAccessErrorZ");
4776 *ret_conv = (this_arg_conv->get_utxo)(this_arg_conv->this_arg, genesis_hash_ref, short_channel_id);
4777 return (long)ret_conv;
4780 typedef struct LDKListen_JCalls {
4781 atomic_size_t refcnt;
4784 jmethodID block_connected_meth;
4785 jmethodID block_disconnected_meth;
4787 static void LDKListen_JCalls_free(void* this_arg) {
4788 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
4789 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
4791 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
4792 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
4796 void block_connected_jcall(const void* this_arg, LDKu8slice block, uint32_t height) {
4797 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
4799 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
4800 LDKu8slice block_var = block;
4801 int8_tArray block_arr = (*env)->NewByteArray(env, block_var.datalen);
4802 (*env)->SetByteArrayRegion(env, block_arr, 0, block_var.datalen, block_var.data);
4803 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
4805 return (*env)->CallVoidMethod(env, obj, j_calls->block_connected_meth, block_arr, height);
4807 void block_disconnected_jcall(const void* this_arg, const uint8_t (* header)[80], uint32_t height) {
4808 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
4810 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
4811 int8_tArray header_arr = (*env)->NewByteArray(env, 80);
4812 (*env)->SetByteArrayRegion(env, header_arr, 0, 80, *header);
4813 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
4815 return (*env)->CallVoidMethod(env, obj, j_calls->block_disconnected_meth, header_arr, height);
4817 static void* LDKListen_JCalls_clone(const void* this_arg) {
4818 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
4819 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
4820 return (void*) this_arg;
4822 static inline LDKListen LDKListen_init (JNIEnv *env, jclass clz, jobject o) {
4823 jclass c = (*env)->GetObjectClass(env, o);
4825 LDKListen_JCalls *calls = MALLOC(sizeof(LDKListen_JCalls), "LDKListen_JCalls");
4826 atomic_init(&calls->refcnt, 1);
4827 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
4828 calls->o = (*env)->NewWeakGlobalRef(env, o);
4829 calls->block_connected_meth = (*env)->GetMethodID(env, c, "block_connected", "([BI)V");
4830 CHECK(calls->block_connected_meth != NULL);
4831 calls->block_disconnected_meth = (*env)->GetMethodID(env, c, "block_disconnected", "([BI)V");
4832 CHECK(calls->block_disconnected_meth != NULL);
4835 .this_arg = (void*) calls,
4836 .block_connected = block_connected_jcall,
4837 .block_disconnected = block_disconnected_jcall,
4838 .free = LDKListen_JCalls_free,
4842 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKListen_1new(JNIEnv *env, jclass clz, jobject o) {
4843 LDKListen *res_ptr = MALLOC(sizeof(LDKListen), "LDKListen");
4844 *res_ptr = LDKListen_init(env, clz, o);
4845 return (long)res_ptr;
4847 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) {
4848 LDKListen* this_arg_conv = (LDKListen*)(((uint64_t)this_arg) & ~1);
4849 LDKu8slice block_ref;
4850 block_ref.datalen = (*env)->GetArrayLength(env, block);
4851 block_ref.data = (*env)->GetByteArrayElements (env, block, NULL);
4852 (this_arg_conv->block_connected)(this_arg_conv->this_arg, block_ref, height);
4853 (*env)->ReleaseByteArrayElements(env, block, (int8_t*)block_ref.data, 0);
4856 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) {
4857 LDKListen* this_arg_conv = (LDKListen*)(((uint64_t)this_arg) & ~1);
4858 unsigned char header_arr[80];
4859 CHECK((*env)->GetArrayLength(env, header) == 80);
4860 (*env)->GetByteArrayRegion(env, header, 0, 80, header_arr);
4861 unsigned char (*header_ref)[80] = &header_arr;
4862 (this_arg_conv->block_disconnected)(this_arg_conv->this_arg, header_ref, height);
4865 typedef struct LDKFilter_JCalls {
4866 atomic_size_t refcnt;
4869 jmethodID register_tx_meth;
4870 jmethodID register_output_meth;
4872 static void LDKFilter_JCalls_free(void* this_arg) {
4873 LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg;
4874 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
4876 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
4877 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
4881 void register_tx_jcall(const void* this_arg, const uint8_t (* txid)[32], LDKu8slice script_pubkey) {
4882 LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg;
4884 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
4885 int8_tArray txid_arr = (*env)->NewByteArray(env, 32);
4886 (*env)->SetByteArrayRegion(env, txid_arr, 0, 32, *txid);
4887 LDKu8slice script_pubkey_var = script_pubkey;
4888 int8_tArray script_pubkey_arr = (*env)->NewByteArray(env, script_pubkey_var.datalen);
4889 (*env)->SetByteArrayRegion(env, script_pubkey_arr, 0, script_pubkey_var.datalen, script_pubkey_var.data);
4890 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
4892 return (*env)->CallVoidMethod(env, obj, j_calls->register_tx_meth, txid_arr, script_pubkey_arr);
4894 void register_output_jcall(const void* this_arg, const LDKOutPoint * outpoint, LDKu8slice script_pubkey) {
4895 LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg;
4897 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
4898 LDKOutPoint outpoint_var = *outpoint;
4899 outpoint_var = OutPoint_clone(outpoint);
4900 CHECK((((long)outpoint_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4901 CHECK((((long)&outpoint_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4902 long outpoint_ref = (long)outpoint_var.inner;
4903 if (outpoint_var.is_owned) {
4906 LDKu8slice script_pubkey_var = script_pubkey;
4907 int8_tArray script_pubkey_arr = (*env)->NewByteArray(env, script_pubkey_var.datalen);
4908 (*env)->SetByteArrayRegion(env, script_pubkey_arr, 0, script_pubkey_var.datalen, script_pubkey_var.data);
4909 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
4911 return (*env)->CallVoidMethod(env, obj, j_calls->register_output_meth, outpoint_ref, script_pubkey_arr);
4913 static void* LDKFilter_JCalls_clone(const void* this_arg) {
4914 LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg;
4915 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
4916 return (void*) this_arg;
4918 static inline LDKFilter LDKFilter_init (JNIEnv *env, jclass clz, jobject o) {
4919 jclass c = (*env)->GetObjectClass(env, o);
4921 LDKFilter_JCalls *calls = MALLOC(sizeof(LDKFilter_JCalls), "LDKFilter_JCalls");
4922 atomic_init(&calls->refcnt, 1);
4923 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
4924 calls->o = (*env)->NewWeakGlobalRef(env, o);
4925 calls->register_tx_meth = (*env)->GetMethodID(env, c, "register_tx", "([B[B)V");
4926 CHECK(calls->register_tx_meth != NULL);
4927 calls->register_output_meth = (*env)->GetMethodID(env, c, "register_output", "(J[B)V");
4928 CHECK(calls->register_output_meth != NULL);
4931 .this_arg = (void*) calls,
4932 .register_tx = register_tx_jcall,
4933 .register_output = register_output_jcall,
4934 .free = LDKFilter_JCalls_free,
4938 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKFilter_1new(JNIEnv *env, jclass clz, jobject o) {
4939 LDKFilter *res_ptr = MALLOC(sizeof(LDKFilter), "LDKFilter");
4940 *res_ptr = LDKFilter_init(env, clz, o);
4941 return (long)res_ptr;
4943 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) {
4944 LDKFilter* this_arg_conv = (LDKFilter*)(((uint64_t)this_arg) & ~1);
4945 unsigned char txid_arr[32];
4946 CHECK((*env)->GetArrayLength(env, txid) == 32);
4947 (*env)->GetByteArrayRegion(env, txid, 0, 32, txid_arr);
4948 unsigned char (*txid_ref)[32] = &txid_arr;
4949 LDKu8slice script_pubkey_ref;
4950 script_pubkey_ref.datalen = (*env)->GetArrayLength(env, script_pubkey);
4951 script_pubkey_ref.data = (*env)->GetByteArrayElements (env, script_pubkey, NULL);
4952 (this_arg_conv->register_tx)(this_arg_conv->this_arg, txid_ref, script_pubkey_ref);
4953 (*env)->ReleaseByteArrayElements(env, script_pubkey, (int8_t*)script_pubkey_ref.data, 0);
4956 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Filter_1register_1output(JNIEnv *env, jclass clz, int64_t this_arg, int64_t outpoint, int8_tArray script_pubkey) {
4957 LDKFilter* this_arg_conv = (LDKFilter*)(((uint64_t)this_arg) & ~1);
4958 LDKOutPoint outpoint_conv;
4959 outpoint_conv.inner = (void*)(outpoint & (~1));
4960 outpoint_conv.is_owned = false;
4961 LDKu8slice script_pubkey_ref;
4962 script_pubkey_ref.datalen = (*env)->GetArrayLength(env, script_pubkey);
4963 script_pubkey_ref.data = (*env)->GetByteArrayElements (env, script_pubkey, NULL);
4964 (this_arg_conv->register_output)(this_arg_conv->this_arg, &outpoint_conv, script_pubkey_ref);
4965 (*env)->ReleaseByteArrayElements(env, script_pubkey, (int8_t*)script_pubkey_ref.data, 0);
4968 typedef struct LDKPersist_JCalls {
4969 atomic_size_t refcnt;
4972 jmethodID persist_new_channel_meth;
4973 jmethodID update_persisted_channel_meth;
4974 } LDKPersist_JCalls;
4975 static void LDKPersist_JCalls_free(void* this_arg) {
4976 LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) this_arg;
4977 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
4979 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
4980 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
4984 LDKCResult_NoneChannelMonitorUpdateErrZ persist_new_channel_jcall(const void* this_arg, LDKOutPoint id, const LDKChannelMonitor * data) {
4985 LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) this_arg;
4987 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
4988 LDKOutPoint id_var = id;
4989 CHECK((((long)id_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4990 CHECK((((long)&id_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4991 long id_ref = (long)id_var.inner;
4992 if (id_var.is_owned) {
4995 LDKChannelMonitor data_var = *data;
4996 data_var = ChannelMonitor_clone(data);
4997 CHECK((((long)data_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4998 CHECK((((long)&data_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4999 long data_ref = (long)data_var.inner;
5000 if (data_var.is_owned) {
5003 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
5005 LDKCResult_NoneChannelMonitorUpdateErrZ* ret = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(*env)->CallLongMethod(env, obj, j_calls->persist_new_channel_meth, id_ref, data_ref);
5006 LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1);
5007 ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)ret);
5010 LDKCResult_NoneChannelMonitorUpdateErrZ update_persisted_channel_jcall(const void* this_arg, LDKOutPoint id, const LDKChannelMonitorUpdate * update, const LDKChannelMonitor * data) {
5011 LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) this_arg;
5013 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
5014 LDKOutPoint id_var = id;
5015 CHECK((((long)id_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5016 CHECK((((long)&id_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5017 long id_ref = (long)id_var.inner;
5018 if (id_var.is_owned) {
5021 LDKChannelMonitorUpdate update_var = *update;
5022 update_var = ChannelMonitorUpdate_clone(update);
5023 CHECK((((long)update_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5024 CHECK((((long)&update_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5025 long update_ref = (long)update_var.inner;
5026 if (update_var.is_owned) {
5029 LDKChannelMonitor data_var = *data;
5030 data_var = ChannelMonitor_clone(data);
5031 CHECK((((long)data_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5032 CHECK((((long)&data_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5033 long data_ref = (long)data_var.inner;
5034 if (data_var.is_owned) {
5037 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
5039 LDKCResult_NoneChannelMonitorUpdateErrZ* ret = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(*env)->CallLongMethod(env, obj, j_calls->update_persisted_channel_meth, id_ref, update_ref, data_ref);
5040 LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1);
5041 ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)ret);
5044 static void* LDKPersist_JCalls_clone(const void* this_arg) {
5045 LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) this_arg;
5046 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
5047 return (void*) this_arg;
5049 static inline LDKPersist LDKPersist_init (JNIEnv *env, jclass clz, jobject o) {
5050 jclass c = (*env)->GetObjectClass(env, o);
5052 LDKPersist_JCalls *calls = MALLOC(sizeof(LDKPersist_JCalls), "LDKPersist_JCalls");
5053 atomic_init(&calls->refcnt, 1);
5054 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
5055 calls->o = (*env)->NewWeakGlobalRef(env, o);
5056 calls->persist_new_channel_meth = (*env)->GetMethodID(env, c, "persist_new_channel", "(JJ)J");
5057 CHECK(calls->persist_new_channel_meth != NULL);
5058 calls->update_persisted_channel_meth = (*env)->GetMethodID(env, c, "update_persisted_channel", "(JJJ)J");
5059 CHECK(calls->update_persisted_channel_meth != NULL);
5062 .this_arg = (void*) calls,
5063 .persist_new_channel = persist_new_channel_jcall,
5064 .update_persisted_channel = update_persisted_channel_jcall,
5065 .free = LDKPersist_JCalls_free,
5069 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKPersist_1new(JNIEnv *env, jclass clz, jobject o) {
5070 LDKPersist *res_ptr = MALLOC(sizeof(LDKPersist), "LDKPersist");
5071 *res_ptr = LDKPersist_init(env, clz, o);
5072 return (long)res_ptr;
5074 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) {
5075 LDKPersist* this_arg_conv = (LDKPersist*)(((uint64_t)this_arg) & ~1);
5076 LDKOutPoint id_conv;
5077 id_conv.inner = (void*)(id & (~1));
5078 id_conv.is_owned = (id & 1) || (id == 0);
5079 id_conv = OutPoint_clone(&id_conv);
5080 LDKChannelMonitor data_conv;
5081 data_conv.inner = (void*)(data & (~1));
5082 data_conv.is_owned = false;
5083 LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
5084 *ret_conv = (this_arg_conv->persist_new_channel)(this_arg_conv->this_arg, id_conv, &data_conv);
5085 return (long)ret_conv;
5088 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) {
5089 LDKPersist* this_arg_conv = (LDKPersist*)(((uint64_t)this_arg) & ~1);
5090 LDKOutPoint id_conv;
5091 id_conv.inner = (void*)(id & (~1));
5092 id_conv.is_owned = (id & 1) || (id == 0);
5093 id_conv = OutPoint_clone(&id_conv);
5094 LDKChannelMonitorUpdate update_conv;
5095 update_conv.inner = (void*)(update & (~1));
5096 update_conv.is_owned = false;
5097 LDKChannelMonitor data_conv;
5098 data_conv.inner = (void*)(data & (~1));
5099 data_conv.is_owned = false;
5100 LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
5101 *ret_conv = (this_arg_conv->update_persisted_channel)(this_arg_conv->this_arg, id_conv, &update_conv, &data_conv);
5102 return (long)ret_conv;
5105 typedef struct LDKChannelMessageHandler_JCalls {
5106 atomic_size_t refcnt;
5109 LDKMessageSendEventsProvider_JCalls* MessageSendEventsProvider;
5110 jmethodID handle_open_channel_meth;
5111 jmethodID handle_accept_channel_meth;
5112 jmethodID handle_funding_created_meth;
5113 jmethodID handle_funding_signed_meth;
5114 jmethodID handle_funding_locked_meth;
5115 jmethodID handle_shutdown_meth;
5116 jmethodID handle_closing_signed_meth;
5117 jmethodID handle_update_add_htlc_meth;
5118 jmethodID handle_update_fulfill_htlc_meth;
5119 jmethodID handle_update_fail_htlc_meth;
5120 jmethodID handle_update_fail_malformed_htlc_meth;
5121 jmethodID handle_commitment_signed_meth;
5122 jmethodID handle_revoke_and_ack_meth;
5123 jmethodID handle_update_fee_meth;
5124 jmethodID handle_announcement_signatures_meth;
5125 jmethodID peer_disconnected_meth;
5126 jmethodID peer_connected_meth;
5127 jmethodID handle_channel_reestablish_meth;
5128 jmethodID handle_error_meth;
5129 } LDKChannelMessageHandler_JCalls;
5130 static void LDKChannelMessageHandler_JCalls_free(void* this_arg) {
5131 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5132 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
5134 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
5135 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
5139 void handle_open_channel_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKInitFeatures their_features, const LDKOpenChannel * msg) {
5140 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5142 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
5143 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
5144 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
5145 LDKInitFeatures their_features_var = their_features;
5146 CHECK((((long)their_features_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5147 CHECK((((long)&their_features_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5148 long their_features_ref = (long)their_features_var.inner;
5149 if (their_features_var.is_owned) {
5150 their_features_ref |= 1;
5152 LDKOpenChannel msg_var = *msg;
5153 msg_var = OpenChannel_clone(msg);
5154 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5155 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5156 long msg_ref = (long)msg_var.inner;
5157 if (msg_var.is_owned) {
5160 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
5162 return (*env)->CallVoidMethod(env, obj, j_calls->handle_open_channel_meth, their_node_id_arr, their_features_ref, msg_ref);
5164 void handle_accept_channel_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKInitFeatures their_features, const LDKAcceptChannel * msg) {
5165 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5167 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
5168 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
5169 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
5170 LDKInitFeatures their_features_var = their_features;
5171 CHECK((((long)their_features_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5172 CHECK((((long)&their_features_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5173 long their_features_ref = (long)their_features_var.inner;
5174 if (their_features_var.is_owned) {
5175 their_features_ref |= 1;
5177 LDKAcceptChannel msg_var = *msg;
5178 msg_var = AcceptChannel_clone(msg);
5179 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5180 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5181 long msg_ref = (long)msg_var.inner;
5182 if (msg_var.is_owned) {
5185 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
5187 return (*env)->CallVoidMethod(env, obj, j_calls->handle_accept_channel_meth, their_node_id_arr, their_features_ref, msg_ref);
5189 void handle_funding_created_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKFundingCreated * msg) {
5190 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5192 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
5193 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
5194 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
5195 LDKFundingCreated msg_var = *msg;
5196 msg_var = FundingCreated_clone(msg);
5197 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5198 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5199 long msg_ref = (long)msg_var.inner;
5200 if (msg_var.is_owned) {
5203 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
5205 return (*env)->CallVoidMethod(env, obj, j_calls->handle_funding_created_meth, their_node_id_arr, msg_ref);
5207 void handle_funding_signed_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKFundingSigned * msg) {
5208 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5210 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
5211 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
5212 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
5213 LDKFundingSigned msg_var = *msg;
5214 msg_var = FundingSigned_clone(msg);
5215 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5216 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5217 long msg_ref = (long)msg_var.inner;
5218 if (msg_var.is_owned) {
5221 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
5223 return (*env)->CallVoidMethod(env, obj, j_calls->handle_funding_signed_meth, their_node_id_arr, msg_ref);
5225 void handle_funding_locked_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKFundingLocked * msg) {
5226 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5228 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
5229 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
5230 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
5231 LDKFundingLocked msg_var = *msg;
5232 msg_var = FundingLocked_clone(msg);
5233 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5234 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5235 long msg_ref = (long)msg_var.inner;
5236 if (msg_var.is_owned) {
5239 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
5241 return (*env)->CallVoidMethod(env, obj, j_calls->handle_funding_locked_meth, their_node_id_arr, msg_ref);
5243 void handle_shutdown_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInitFeatures * their_features, const LDKShutdown * msg) {
5244 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5246 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
5247 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
5248 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
5249 LDKInitFeatures their_features_var = *their_features;
5250 their_features_var = InitFeatures_clone(their_features);
5251 CHECK((((long)their_features_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5252 CHECK((((long)&their_features_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5253 long their_features_ref = (long)their_features_var.inner;
5254 if (their_features_var.is_owned) {
5255 their_features_ref |= 1;
5257 LDKShutdown msg_var = *msg;
5258 msg_var = Shutdown_clone(msg);
5259 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5260 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5261 long msg_ref = (long)msg_var.inner;
5262 if (msg_var.is_owned) {
5265 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
5267 return (*env)->CallVoidMethod(env, obj, j_calls->handle_shutdown_meth, their_node_id_arr, their_features_ref, msg_ref);
5269 void handle_closing_signed_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKClosingSigned * msg) {
5270 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5272 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
5273 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
5274 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
5275 LDKClosingSigned msg_var = *msg;
5276 msg_var = ClosingSigned_clone(msg);
5277 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5278 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5279 long msg_ref = (long)msg_var.inner;
5280 if (msg_var.is_owned) {
5283 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
5285 return (*env)->CallVoidMethod(env, obj, j_calls->handle_closing_signed_meth, their_node_id_arr, msg_ref);
5287 void handle_update_add_htlc_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateAddHTLC * msg) {
5288 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5290 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
5291 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
5292 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
5293 LDKUpdateAddHTLC msg_var = *msg;
5294 msg_var = UpdateAddHTLC_clone(msg);
5295 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5296 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5297 long msg_ref = (long)msg_var.inner;
5298 if (msg_var.is_owned) {
5301 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
5303 return (*env)->CallVoidMethod(env, obj, j_calls->handle_update_add_htlc_meth, their_node_id_arr, msg_ref);
5305 void handle_update_fulfill_htlc_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFulfillHTLC * msg) {
5306 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5308 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
5309 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
5310 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
5311 LDKUpdateFulfillHTLC msg_var = *msg;
5312 msg_var = UpdateFulfillHTLC_clone(msg);
5313 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5314 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5315 long msg_ref = (long)msg_var.inner;
5316 if (msg_var.is_owned) {
5319 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
5321 return (*env)->CallVoidMethod(env, obj, j_calls->handle_update_fulfill_htlc_meth, their_node_id_arr, msg_ref);
5323 void handle_update_fail_htlc_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFailHTLC * msg) {
5324 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5326 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
5327 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
5328 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
5329 LDKUpdateFailHTLC msg_var = *msg;
5330 msg_var = UpdateFailHTLC_clone(msg);
5331 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5332 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5333 long msg_ref = (long)msg_var.inner;
5334 if (msg_var.is_owned) {
5337 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
5339 return (*env)->CallVoidMethod(env, obj, j_calls->handle_update_fail_htlc_meth, their_node_id_arr, msg_ref);
5341 void handle_update_fail_malformed_htlc_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFailMalformedHTLC * msg) {
5342 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5344 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
5345 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
5346 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
5347 LDKUpdateFailMalformedHTLC msg_var = *msg;
5348 msg_var = UpdateFailMalformedHTLC_clone(msg);
5349 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5350 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5351 long msg_ref = (long)msg_var.inner;
5352 if (msg_var.is_owned) {
5355 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
5357 return (*env)->CallVoidMethod(env, obj, j_calls->handle_update_fail_malformed_htlc_meth, their_node_id_arr, msg_ref);
5359 void handle_commitment_signed_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKCommitmentSigned * msg) {
5360 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5362 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
5363 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
5364 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
5365 LDKCommitmentSigned msg_var = *msg;
5366 msg_var = CommitmentSigned_clone(msg);
5367 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5368 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5369 long msg_ref = (long)msg_var.inner;
5370 if (msg_var.is_owned) {
5373 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
5375 return (*env)->CallVoidMethod(env, obj, j_calls->handle_commitment_signed_meth, their_node_id_arr, msg_ref);
5377 void handle_revoke_and_ack_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKRevokeAndACK * msg) {
5378 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5380 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
5381 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
5382 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
5383 LDKRevokeAndACK msg_var = *msg;
5384 msg_var = RevokeAndACK_clone(msg);
5385 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5386 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5387 long msg_ref = (long)msg_var.inner;
5388 if (msg_var.is_owned) {
5391 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
5393 return (*env)->CallVoidMethod(env, obj, j_calls->handle_revoke_and_ack_meth, their_node_id_arr, msg_ref);
5395 void handle_update_fee_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFee * msg) {
5396 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5398 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
5399 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
5400 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
5401 LDKUpdateFee msg_var = *msg;
5402 msg_var = UpdateFee_clone(msg);
5403 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5404 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5405 long msg_ref = (long)msg_var.inner;
5406 if (msg_var.is_owned) {
5409 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
5411 return (*env)->CallVoidMethod(env, obj, j_calls->handle_update_fee_meth, their_node_id_arr, msg_ref);
5413 void handle_announcement_signatures_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKAnnouncementSignatures * msg) {
5414 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5416 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
5417 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
5418 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
5419 LDKAnnouncementSignatures msg_var = *msg;
5420 msg_var = AnnouncementSignatures_clone(msg);
5421 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5422 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5423 long msg_ref = (long)msg_var.inner;
5424 if (msg_var.is_owned) {
5427 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
5429 return (*env)->CallVoidMethod(env, obj, j_calls->handle_announcement_signatures_meth, their_node_id_arr, msg_ref);
5431 void peer_disconnected_jcall(const void* this_arg, LDKPublicKey their_node_id, bool no_connection_possible) {
5432 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5434 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
5435 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
5436 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
5437 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
5439 return (*env)->CallVoidMethod(env, obj, j_calls->peer_disconnected_meth, their_node_id_arr, no_connection_possible);
5441 void peer_connected_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInit * msg) {
5442 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5444 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
5445 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
5446 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
5447 LDKInit msg_var = *msg;
5448 msg_var = Init_clone(msg);
5449 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5450 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5451 long msg_ref = (long)msg_var.inner;
5452 if (msg_var.is_owned) {
5455 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
5457 return (*env)->CallVoidMethod(env, obj, j_calls->peer_connected_meth, their_node_id_arr, msg_ref);
5459 void handle_channel_reestablish_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKChannelReestablish * msg) {
5460 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5462 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
5463 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
5464 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
5465 LDKChannelReestablish msg_var = *msg;
5466 msg_var = ChannelReestablish_clone(msg);
5467 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5468 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5469 long msg_ref = (long)msg_var.inner;
5470 if (msg_var.is_owned) {
5473 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
5475 return (*env)->CallVoidMethod(env, obj, j_calls->handle_channel_reestablish_meth, their_node_id_arr, msg_ref);
5477 void handle_error_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKErrorMessage * msg) {
5478 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5480 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
5481 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
5482 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
5483 LDKErrorMessage msg_var = *msg;
5484 msg_var = ErrorMessage_clone(msg);
5485 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5486 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5487 long msg_ref = (long)msg_var.inner;
5488 if (msg_var.is_owned) {
5491 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
5493 return (*env)->CallVoidMethod(env, obj, j_calls->handle_error_meth, their_node_id_arr, msg_ref);
5495 static void* LDKChannelMessageHandler_JCalls_clone(const void* this_arg) {
5496 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5497 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
5498 atomic_fetch_add_explicit(&j_calls->MessageSendEventsProvider->refcnt, 1, memory_order_release);
5499 return (void*) this_arg;
5501 static inline LDKChannelMessageHandler LDKChannelMessageHandler_init (JNIEnv *env, jclass clz, jobject o, jobject MessageSendEventsProvider) {
5502 jclass c = (*env)->GetObjectClass(env, o);
5504 LDKChannelMessageHandler_JCalls *calls = MALLOC(sizeof(LDKChannelMessageHandler_JCalls), "LDKChannelMessageHandler_JCalls");
5505 atomic_init(&calls->refcnt, 1);
5506 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
5507 calls->o = (*env)->NewWeakGlobalRef(env, o);
5508 calls->handle_open_channel_meth = (*env)->GetMethodID(env, c, "handle_open_channel", "([BJJ)V");
5509 CHECK(calls->handle_open_channel_meth != NULL);
5510 calls->handle_accept_channel_meth = (*env)->GetMethodID(env, c, "handle_accept_channel", "([BJJ)V");
5511 CHECK(calls->handle_accept_channel_meth != NULL);
5512 calls->handle_funding_created_meth = (*env)->GetMethodID(env, c, "handle_funding_created", "([BJ)V");
5513 CHECK(calls->handle_funding_created_meth != NULL);
5514 calls->handle_funding_signed_meth = (*env)->GetMethodID(env, c, "handle_funding_signed", "([BJ)V");
5515 CHECK(calls->handle_funding_signed_meth != NULL);
5516 calls->handle_funding_locked_meth = (*env)->GetMethodID(env, c, "handle_funding_locked", "([BJ)V");
5517 CHECK(calls->handle_funding_locked_meth != NULL);
5518 calls->handle_shutdown_meth = (*env)->GetMethodID(env, c, "handle_shutdown", "([BJJ)V");
5519 CHECK(calls->handle_shutdown_meth != NULL);
5520 calls->handle_closing_signed_meth = (*env)->GetMethodID(env, c, "handle_closing_signed", "([BJ)V");
5521 CHECK(calls->handle_closing_signed_meth != NULL);
5522 calls->handle_update_add_htlc_meth = (*env)->GetMethodID(env, c, "handle_update_add_htlc", "([BJ)V");
5523 CHECK(calls->handle_update_add_htlc_meth != NULL);
5524 calls->handle_update_fulfill_htlc_meth = (*env)->GetMethodID(env, c, "handle_update_fulfill_htlc", "([BJ)V");
5525 CHECK(calls->handle_update_fulfill_htlc_meth != NULL);
5526 calls->handle_update_fail_htlc_meth = (*env)->GetMethodID(env, c, "handle_update_fail_htlc", "([BJ)V");
5527 CHECK(calls->handle_update_fail_htlc_meth != NULL);
5528 calls->handle_update_fail_malformed_htlc_meth = (*env)->GetMethodID(env, c, "handle_update_fail_malformed_htlc", "([BJ)V");
5529 CHECK(calls->handle_update_fail_malformed_htlc_meth != NULL);
5530 calls->handle_commitment_signed_meth = (*env)->GetMethodID(env, c, "handle_commitment_signed", "([BJ)V");
5531 CHECK(calls->handle_commitment_signed_meth != NULL);
5532 calls->handle_revoke_and_ack_meth = (*env)->GetMethodID(env, c, "handle_revoke_and_ack", "([BJ)V");
5533 CHECK(calls->handle_revoke_and_ack_meth != NULL);
5534 calls->handle_update_fee_meth = (*env)->GetMethodID(env, c, "handle_update_fee", "([BJ)V");
5535 CHECK(calls->handle_update_fee_meth != NULL);
5536 calls->handle_announcement_signatures_meth = (*env)->GetMethodID(env, c, "handle_announcement_signatures", "([BJ)V");
5537 CHECK(calls->handle_announcement_signatures_meth != NULL);
5538 calls->peer_disconnected_meth = (*env)->GetMethodID(env, c, "peer_disconnected", "([BZ)V");
5539 CHECK(calls->peer_disconnected_meth != NULL);
5540 calls->peer_connected_meth = (*env)->GetMethodID(env, c, "peer_connected", "([BJ)V");
5541 CHECK(calls->peer_connected_meth != NULL);
5542 calls->handle_channel_reestablish_meth = (*env)->GetMethodID(env, c, "handle_channel_reestablish", "([BJ)V");
5543 CHECK(calls->handle_channel_reestablish_meth != NULL);
5544 calls->handle_error_meth = (*env)->GetMethodID(env, c, "handle_error", "([BJ)V");
5545 CHECK(calls->handle_error_meth != NULL);
5547 LDKChannelMessageHandler ret = {
5548 .this_arg = (void*) calls,
5549 .handle_open_channel = handle_open_channel_jcall,
5550 .handle_accept_channel = handle_accept_channel_jcall,
5551 .handle_funding_created = handle_funding_created_jcall,
5552 .handle_funding_signed = handle_funding_signed_jcall,
5553 .handle_funding_locked = handle_funding_locked_jcall,
5554 .handle_shutdown = handle_shutdown_jcall,
5555 .handle_closing_signed = handle_closing_signed_jcall,
5556 .handle_update_add_htlc = handle_update_add_htlc_jcall,
5557 .handle_update_fulfill_htlc = handle_update_fulfill_htlc_jcall,
5558 .handle_update_fail_htlc = handle_update_fail_htlc_jcall,
5559 .handle_update_fail_malformed_htlc = handle_update_fail_malformed_htlc_jcall,
5560 .handle_commitment_signed = handle_commitment_signed_jcall,
5561 .handle_revoke_and_ack = handle_revoke_and_ack_jcall,
5562 .handle_update_fee = handle_update_fee_jcall,
5563 .handle_announcement_signatures = handle_announcement_signatures_jcall,
5564 .peer_disconnected = peer_disconnected_jcall,
5565 .peer_connected = peer_connected_jcall,
5566 .handle_channel_reestablish = handle_channel_reestablish_jcall,
5567 .handle_error = handle_error_jcall,
5568 .free = LDKChannelMessageHandler_JCalls_free,
5569 .MessageSendEventsProvider = LDKMessageSendEventsProvider_init(env, clz, MessageSendEventsProvider),
5571 calls->MessageSendEventsProvider = ret.MessageSendEventsProvider.this_arg;
5574 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKChannelMessageHandler_1new(JNIEnv *env, jclass clz, jobject o, jobject MessageSendEventsProvider) {
5575 LDKChannelMessageHandler *res_ptr = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
5576 *res_ptr = LDKChannelMessageHandler_init(env, clz, o, MessageSendEventsProvider);
5577 return (long)res_ptr;
5579 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) {
5580 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5581 LDKPublicKey their_node_id_ref;
5582 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
5583 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
5584 LDKInitFeatures their_features_conv;
5585 their_features_conv.inner = (void*)(their_features & (~1));
5586 their_features_conv.is_owned = (their_features & 1) || (their_features == 0);
5587 their_features_conv = InitFeatures_clone(&their_features_conv);
5588 LDKOpenChannel msg_conv;
5589 msg_conv.inner = (void*)(msg & (~1));
5590 msg_conv.is_owned = false;
5591 (this_arg_conv->handle_open_channel)(this_arg_conv->this_arg, their_node_id_ref, their_features_conv, &msg_conv);
5594 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) {
5595 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5596 LDKPublicKey their_node_id_ref;
5597 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
5598 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
5599 LDKInitFeatures their_features_conv;
5600 their_features_conv.inner = (void*)(their_features & (~1));
5601 their_features_conv.is_owned = (their_features & 1) || (their_features == 0);
5602 their_features_conv = InitFeatures_clone(&their_features_conv);
5603 LDKAcceptChannel msg_conv;
5604 msg_conv.inner = (void*)(msg & (~1));
5605 msg_conv.is_owned = false;
5606 (this_arg_conv->handle_accept_channel)(this_arg_conv->this_arg, their_node_id_ref, their_features_conv, &msg_conv);
5609 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) {
5610 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5611 LDKPublicKey their_node_id_ref;
5612 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
5613 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
5614 LDKFundingCreated msg_conv;
5615 msg_conv.inner = (void*)(msg & (~1));
5616 msg_conv.is_owned = false;
5617 (this_arg_conv->handle_funding_created)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
5620 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) {
5621 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5622 LDKPublicKey their_node_id_ref;
5623 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
5624 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
5625 LDKFundingSigned msg_conv;
5626 msg_conv.inner = (void*)(msg & (~1));
5627 msg_conv.is_owned = false;
5628 (this_arg_conv->handle_funding_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
5631 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) {
5632 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5633 LDKPublicKey their_node_id_ref;
5634 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
5635 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
5636 LDKFundingLocked msg_conv;
5637 msg_conv.inner = (void*)(msg & (~1));
5638 msg_conv.is_owned = false;
5639 (this_arg_conv->handle_funding_locked)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
5642 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) {
5643 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5644 LDKPublicKey their_node_id_ref;
5645 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
5646 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
5647 LDKInitFeatures their_features_conv;
5648 their_features_conv.inner = (void*)(their_features & (~1));
5649 their_features_conv.is_owned = false;
5650 LDKShutdown msg_conv;
5651 msg_conv.inner = (void*)(msg & (~1));
5652 msg_conv.is_owned = false;
5653 (this_arg_conv->handle_shutdown)(this_arg_conv->this_arg, their_node_id_ref, &their_features_conv, &msg_conv);
5656 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) {
5657 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5658 LDKPublicKey their_node_id_ref;
5659 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
5660 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
5661 LDKClosingSigned msg_conv;
5662 msg_conv.inner = (void*)(msg & (~1));
5663 msg_conv.is_owned = false;
5664 (this_arg_conv->handle_closing_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
5667 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) {
5668 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5669 LDKPublicKey their_node_id_ref;
5670 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
5671 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
5672 LDKUpdateAddHTLC msg_conv;
5673 msg_conv.inner = (void*)(msg & (~1));
5674 msg_conv.is_owned = false;
5675 (this_arg_conv->handle_update_add_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
5678 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) {
5679 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5680 LDKPublicKey their_node_id_ref;
5681 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
5682 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
5683 LDKUpdateFulfillHTLC msg_conv;
5684 msg_conv.inner = (void*)(msg & (~1));
5685 msg_conv.is_owned = false;
5686 (this_arg_conv->handle_update_fulfill_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
5689 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) {
5690 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5691 LDKPublicKey their_node_id_ref;
5692 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
5693 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
5694 LDKUpdateFailHTLC msg_conv;
5695 msg_conv.inner = (void*)(msg & (~1));
5696 msg_conv.is_owned = false;
5697 (this_arg_conv->handle_update_fail_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
5700 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) {
5701 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5702 LDKPublicKey their_node_id_ref;
5703 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
5704 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
5705 LDKUpdateFailMalformedHTLC msg_conv;
5706 msg_conv.inner = (void*)(msg & (~1));
5707 msg_conv.is_owned = false;
5708 (this_arg_conv->handle_update_fail_malformed_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
5711 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) {
5712 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5713 LDKPublicKey their_node_id_ref;
5714 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
5715 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
5716 LDKCommitmentSigned msg_conv;
5717 msg_conv.inner = (void*)(msg & (~1));
5718 msg_conv.is_owned = false;
5719 (this_arg_conv->handle_commitment_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
5722 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) {
5723 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5724 LDKPublicKey their_node_id_ref;
5725 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
5726 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
5727 LDKRevokeAndACK msg_conv;
5728 msg_conv.inner = (void*)(msg & (~1));
5729 msg_conv.is_owned = false;
5730 (this_arg_conv->handle_revoke_and_ack)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
5733 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) {
5734 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5735 LDKPublicKey their_node_id_ref;
5736 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
5737 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
5738 LDKUpdateFee msg_conv;
5739 msg_conv.inner = (void*)(msg & (~1));
5740 msg_conv.is_owned = false;
5741 (this_arg_conv->handle_update_fee)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
5744 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) {
5745 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5746 LDKPublicKey their_node_id_ref;
5747 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
5748 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
5749 LDKAnnouncementSignatures msg_conv;
5750 msg_conv.inner = (void*)(msg & (~1));
5751 msg_conv.is_owned = false;
5752 (this_arg_conv->handle_announcement_signatures)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
5755 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) {
5756 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5757 LDKPublicKey their_node_id_ref;
5758 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
5759 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
5760 (this_arg_conv->peer_disconnected)(this_arg_conv->this_arg, their_node_id_ref, no_connection_possible);
5763 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) {
5764 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5765 LDKPublicKey their_node_id_ref;
5766 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
5767 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
5769 msg_conv.inner = (void*)(msg & (~1));
5770 msg_conv.is_owned = false;
5771 (this_arg_conv->peer_connected)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
5774 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) {
5775 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5776 LDKPublicKey their_node_id_ref;
5777 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
5778 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
5779 LDKChannelReestablish msg_conv;
5780 msg_conv.inner = (void*)(msg & (~1));
5781 msg_conv.is_owned = false;
5782 (this_arg_conv->handle_channel_reestablish)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
5785 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) {
5786 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5787 LDKPublicKey their_node_id_ref;
5788 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
5789 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
5790 LDKErrorMessage msg_conv;
5791 msg_conv.inner = (void*)(msg & (~1));
5792 msg_conv.is_owned = false;
5793 (this_arg_conv->handle_error)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
5796 typedef struct LDKRoutingMessageHandler_JCalls {
5797 atomic_size_t refcnt;
5800 LDKMessageSendEventsProvider_JCalls* MessageSendEventsProvider;
5801 jmethodID handle_node_announcement_meth;
5802 jmethodID handle_channel_announcement_meth;
5803 jmethodID handle_channel_update_meth;
5804 jmethodID handle_htlc_fail_channel_update_meth;
5805 jmethodID get_next_channel_announcements_meth;
5806 jmethodID get_next_node_announcements_meth;
5807 jmethodID sync_routing_table_meth;
5808 jmethodID handle_reply_channel_range_meth;
5809 jmethodID handle_reply_short_channel_ids_end_meth;
5810 jmethodID handle_query_channel_range_meth;
5811 jmethodID handle_query_short_channel_ids_meth;
5812 } LDKRoutingMessageHandler_JCalls;
5813 static void LDKRoutingMessageHandler_JCalls_free(void* this_arg) {
5814 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
5815 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
5817 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
5818 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
5822 LDKCResult_boolLightningErrorZ handle_node_announcement_jcall(const void* this_arg, const LDKNodeAnnouncement * msg) {
5823 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
5825 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
5826 LDKNodeAnnouncement msg_var = *msg;
5827 msg_var = NodeAnnouncement_clone(msg);
5828 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5829 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5830 long msg_ref = (long)msg_var.inner;
5831 if (msg_var.is_owned) {
5834 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
5836 LDKCResult_boolLightningErrorZ* ret = (LDKCResult_boolLightningErrorZ*)(*env)->CallLongMethod(env, obj, j_calls->handle_node_announcement_meth, msg_ref);
5837 LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(((uint64_t)ret) & ~1);
5838 ret_conv = CResult_boolLightningErrorZ_clone((LDKCResult_boolLightningErrorZ*)ret);
5841 LDKCResult_boolLightningErrorZ handle_channel_announcement_jcall(const void* this_arg, const LDKChannelAnnouncement * msg) {
5842 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
5844 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
5845 LDKChannelAnnouncement msg_var = *msg;
5846 msg_var = ChannelAnnouncement_clone(msg);
5847 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5848 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5849 long msg_ref = (long)msg_var.inner;
5850 if (msg_var.is_owned) {
5853 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
5855 LDKCResult_boolLightningErrorZ* ret = (LDKCResult_boolLightningErrorZ*)(*env)->CallLongMethod(env, obj, j_calls->handle_channel_announcement_meth, msg_ref);
5856 LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(((uint64_t)ret) & ~1);
5857 ret_conv = CResult_boolLightningErrorZ_clone((LDKCResult_boolLightningErrorZ*)ret);
5860 LDKCResult_boolLightningErrorZ handle_channel_update_jcall(const void* this_arg, const LDKChannelUpdate * msg) {
5861 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
5863 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
5864 LDKChannelUpdate msg_var = *msg;
5865 msg_var = ChannelUpdate_clone(msg);
5866 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5867 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5868 long msg_ref = (long)msg_var.inner;
5869 if (msg_var.is_owned) {
5872 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
5874 LDKCResult_boolLightningErrorZ* ret = (LDKCResult_boolLightningErrorZ*)(*env)->CallLongMethod(env, obj, j_calls->handle_channel_update_meth, msg_ref);
5875 LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(((uint64_t)ret) & ~1);
5876 ret_conv = CResult_boolLightningErrorZ_clone((LDKCResult_boolLightningErrorZ*)ret);
5879 void handle_htlc_fail_channel_update_jcall(const void* this_arg, const LDKHTLCFailChannelUpdate * update) {
5880 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
5882 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
5883 long ret_update = (long)update;
5884 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
5886 return (*env)->CallVoidMethod(env, obj, j_calls->handle_htlc_fail_channel_update_meth, ret_update);
5888 LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ get_next_channel_announcements_jcall(const void* this_arg, uint64_t starting_point, uint8_t batch_amount) {
5889 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
5891 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
5892 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
5894 int64_tArray ret = (*env)->CallObjectMethod(env, obj, j_calls->get_next_channel_announcements_meth, starting_point, batch_amount);
5895 LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret_constr;
5896 ret_constr.datalen = (*env)->GetArrayLength(env, ret);
5897 if (ret_constr.datalen > 0)
5898 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ Elements");
5900 ret_constr.data = NULL;
5901 int64_t* ret_vals = (*env)->GetLongArrayElements (env, ret, NULL);
5902 for (size_t l = 0; l < ret_constr.datalen; l++) {
5903 int64_t ret_conv_63 = ret_vals[l];
5904 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ ret_conv_63_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)ret_conv_63) & ~1);
5905 ret_conv_63_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone((LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)ret_conv_63);
5906 ret_constr.data[l] = ret_conv_63_conv;
5908 (*env)->ReleaseLongArrayElements(env, ret, ret_vals, 0);
5911 LDKCVec_NodeAnnouncementZ get_next_node_announcements_jcall(const void* this_arg, LDKPublicKey starting_point, uint8_t batch_amount) {
5912 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
5914 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
5915 int8_tArray starting_point_arr = (*env)->NewByteArray(env, 33);
5916 (*env)->SetByteArrayRegion(env, starting_point_arr, 0, 33, starting_point.compressed_form);
5917 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
5919 int64_tArray ret = (*env)->CallObjectMethod(env, obj, j_calls->get_next_node_announcements_meth, starting_point_arr, batch_amount);
5920 LDKCVec_NodeAnnouncementZ ret_constr;
5921 ret_constr.datalen = (*env)->GetArrayLength(env, ret);
5922 if (ret_constr.datalen > 0)
5923 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKNodeAnnouncement), "LDKCVec_NodeAnnouncementZ Elements");
5925 ret_constr.data = NULL;
5926 int64_t* ret_vals = (*env)->GetLongArrayElements (env, ret, NULL);
5927 for (size_t s = 0; s < ret_constr.datalen; s++) {
5928 int64_t ret_conv_18 = ret_vals[s];
5929 LDKNodeAnnouncement ret_conv_18_conv;
5930 ret_conv_18_conv.inner = (void*)(ret_conv_18 & (~1));
5931 ret_conv_18_conv.is_owned = (ret_conv_18 & 1) || (ret_conv_18 == 0);
5932 ret_conv_18_conv = NodeAnnouncement_clone(&ret_conv_18_conv);
5933 ret_constr.data[s] = ret_conv_18_conv;
5935 (*env)->ReleaseLongArrayElements(env, ret, ret_vals, 0);
5938 void sync_routing_table_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInit * init) {
5939 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
5941 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
5942 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
5943 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
5944 LDKInit init_var = *init;
5945 init_var = Init_clone(init);
5946 CHECK((((long)init_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5947 CHECK((((long)&init_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5948 long init_ref = (long)init_var.inner;
5949 if (init_var.is_owned) {
5952 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
5954 return (*env)->CallVoidMethod(env, obj, j_calls->sync_routing_table_meth, their_node_id_arr, init_ref);
5956 LDKCResult_NoneLightningErrorZ handle_reply_channel_range_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKReplyChannelRange msg) {
5957 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
5959 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
5960 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
5961 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
5962 LDKReplyChannelRange msg_var = msg;
5963 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5964 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5965 long msg_ref = (long)msg_var.inner;
5966 if (msg_var.is_owned) {
5969 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
5971 LDKCResult_NoneLightningErrorZ* ret = (LDKCResult_NoneLightningErrorZ*)(*env)->CallLongMethod(env, obj, j_calls->handle_reply_channel_range_meth, their_node_id_arr, msg_ref);
5972 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1);
5973 ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)ret);
5976 LDKCResult_NoneLightningErrorZ handle_reply_short_channel_ids_end_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKReplyShortChannelIdsEnd msg) {
5977 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
5979 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
5980 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
5981 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
5982 LDKReplyShortChannelIdsEnd msg_var = msg;
5983 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5984 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5985 long msg_ref = (long)msg_var.inner;
5986 if (msg_var.is_owned) {
5989 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
5991 LDKCResult_NoneLightningErrorZ* ret = (LDKCResult_NoneLightningErrorZ*)(*env)->CallLongMethod(env, obj, j_calls->handle_reply_short_channel_ids_end_meth, their_node_id_arr, msg_ref);
5992 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1);
5993 ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)ret);
5996 LDKCResult_NoneLightningErrorZ handle_query_channel_range_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKQueryChannelRange msg) {
5997 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
5999 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
6000 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
6001 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
6002 LDKQueryChannelRange msg_var = msg;
6003 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6004 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6005 long msg_ref = (long)msg_var.inner;
6006 if (msg_var.is_owned) {
6009 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
6011 LDKCResult_NoneLightningErrorZ* ret = (LDKCResult_NoneLightningErrorZ*)(*env)->CallLongMethod(env, obj, j_calls->handle_query_channel_range_meth, their_node_id_arr, msg_ref);
6012 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1);
6013 ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)ret);
6016 LDKCResult_NoneLightningErrorZ handle_query_short_channel_ids_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKQueryShortChannelIds msg) {
6017 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
6019 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
6020 int8_tArray their_node_id_arr = (*env)->NewByteArray(env, 33);
6021 (*env)->SetByteArrayRegion(env, their_node_id_arr, 0, 33, their_node_id.compressed_form);
6022 LDKQueryShortChannelIds msg_var = msg;
6023 CHECK((((long)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6024 CHECK((((long)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6025 long msg_ref = (long)msg_var.inner;
6026 if (msg_var.is_owned) {
6029 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
6031 LDKCResult_NoneLightningErrorZ* ret = (LDKCResult_NoneLightningErrorZ*)(*env)->CallLongMethod(env, obj, j_calls->handle_query_short_channel_ids_meth, their_node_id_arr, msg_ref);
6032 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1);
6033 ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)ret);
6036 static void* LDKRoutingMessageHandler_JCalls_clone(const void* this_arg) {
6037 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
6038 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
6039 atomic_fetch_add_explicit(&j_calls->MessageSendEventsProvider->refcnt, 1, memory_order_release);
6040 return (void*) this_arg;
6042 static inline LDKRoutingMessageHandler LDKRoutingMessageHandler_init (JNIEnv *env, jclass clz, jobject o, jobject MessageSendEventsProvider) {
6043 jclass c = (*env)->GetObjectClass(env, o);
6045 LDKRoutingMessageHandler_JCalls *calls = MALLOC(sizeof(LDKRoutingMessageHandler_JCalls), "LDKRoutingMessageHandler_JCalls");
6046 atomic_init(&calls->refcnt, 1);
6047 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
6048 calls->o = (*env)->NewWeakGlobalRef(env, o);
6049 calls->handle_node_announcement_meth = (*env)->GetMethodID(env, c, "handle_node_announcement", "(J)J");
6050 CHECK(calls->handle_node_announcement_meth != NULL);
6051 calls->handle_channel_announcement_meth = (*env)->GetMethodID(env, c, "handle_channel_announcement", "(J)J");
6052 CHECK(calls->handle_channel_announcement_meth != NULL);
6053 calls->handle_channel_update_meth = (*env)->GetMethodID(env, c, "handle_channel_update", "(J)J");
6054 CHECK(calls->handle_channel_update_meth != NULL);
6055 calls->handle_htlc_fail_channel_update_meth = (*env)->GetMethodID(env, c, "handle_htlc_fail_channel_update", "(J)V");
6056 CHECK(calls->handle_htlc_fail_channel_update_meth != NULL);
6057 calls->get_next_channel_announcements_meth = (*env)->GetMethodID(env, c, "get_next_channel_announcements", "(JB)[J");
6058 CHECK(calls->get_next_channel_announcements_meth != NULL);
6059 calls->get_next_node_announcements_meth = (*env)->GetMethodID(env, c, "get_next_node_announcements", "([BB)[J");
6060 CHECK(calls->get_next_node_announcements_meth != NULL);
6061 calls->sync_routing_table_meth = (*env)->GetMethodID(env, c, "sync_routing_table", "([BJ)V");
6062 CHECK(calls->sync_routing_table_meth != NULL);
6063 calls->handle_reply_channel_range_meth = (*env)->GetMethodID(env, c, "handle_reply_channel_range", "([BJ)J");
6064 CHECK(calls->handle_reply_channel_range_meth != NULL);
6065 calls->handle_reply_short_channel_ids_end_meth = (*env)->GetMethodID(env, c, "handle_reply_short_channel_ids_end", "([BJ)J");
6066 CHECK(calls->handle_reply_short_channel_ids_end_meth != NULL);
6067 calls->handle_query_channel_range_meth = (*env)->GetMethodID(env, c, "handle_query_channel_range", "([BJ)J");
6068 CHECK(calls->handle_query_channel_range_meth != NULL);
6069 calls->handle_query_short_channel_ids_meth = (*env)->GetMethodID(env, c, "handle_query_short_channel_ids", "([BJ)J");
6070 CHECK(calls->handle_query_short_channel_ids_meth != NULL);
6072 LDKRoutingMessageHandler ret = {
6073 .this_arg = (void*) calls,
6074 .handle_node_announcement = handle_node_announcement_jcall,
6075 .handle_channel_announcement = handle_channel_announcement_jcall,
6076 .handle_channel_update = handle_channel_update_jcall,
6077 .handle_htlc_fail_channel_update = handle_htlc_fail_channel_update_jcall,
6078 .get_next_channel_announcements = get_next_channel_announcements_jcall,
6079 .get_next_node_announcements = get_next_node_announcements_jcall,
6080 .sync_routing_table = sync_routing_table_jcall,
6081 .handle_reply_channel_range = handle_reply_channel_range_jcall,
6082 .handle_reply_short_channel_ids_end = handle_reply_short_channel_ids_end_jcall,
6083 .handle_query_channel_range = handle_query_channel_range_jcall,
6084 .handle_query_short_channel_ids = handle_query_short_channel_ids_jcall,
6085 .free = LDKRoutingMessageHandler_JCalls_free,
6086 .MessageSendEventsProvider = LDKMessageSendEventsProvider_init(env, clz, MessageSendEventsProvider),
6088 calls->MessageSendEventsProvider = ret.MessageSendEventsProvider.this_arg;
6091 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKRoutingMessageHandler_1new(JNIEnv *env, jclass clz, jobject o, jobject MessageSendEventsProvider) {
6092 LDKRoutingMessageHandler *res_ptr = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
6093 *res_ptr = LDKRoutingMessageHandler_init(env, clz, o, MessageSendEventsProvider);
6094 return (long)res_ptr;
6096 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RoutingMessageHandler_1handle_1node_1announcement(JNIEnv *env, jclass clz, int64_t this_arg, int64_t msg) {
6097 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1);
6098 LDKNodeAnnouncement msg_conv;
6099 msg_conv.inner = (void*)(msg & (~1));
6100 msg_conv.is_owned = false;
6101 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
6102 *ret_conv = (this_arg_conv->handle_node_announcement)(this_arg_conv->this_arg, &msg_conv);
6103 return (long)ret_conv;
6106 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RoutingMessageHandler_1handle_1channel_1announcement(JNIEnv *env, jclass clz, int64_t this_arg, int64_t msg) {
6107 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1);
6108 LDKChannelAnnouncement msg_conv;
6109 msg_conv.inner = (void*)(msg & (~1));
6110 msg_conv.is_owned = false;
6111 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
6112 *ret_conv = (this_arg_conv->handle_channel_announcement)(this_arg_conv->this_arg, &msg_conv);
6113 return (long)ret_conv;
6116 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RoutingMessageHandler_1handle_1channel_1update(JNIEnv *env, jclass clz, int64_t this_arg, int64_t msg) {
6117 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1);
6118 LDKChannelUpdate msg_conv;
6119 msg_conv.inner = (void*)(msg & (~1));
6120 msg_conv.is_owned = false;
6121 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
6122 *ret_conv = (this_arg_conv->handle_channel_update)(this_arg_conv->this_arg, &msg_conv);
6123 return (long)ret_conv;
6126 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) {
6127 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1);
6128 LDKHTLCFailChannelUpdate* update_conv = (LDKHTLCFailChannelUpdate*)update;
6129 (this_arg_conv->handle_htlc_fail_channel_update)(this_arg_conv->this_arg, update_conv);
6132 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) {
6133 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1);
6134 LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret_var = (this_arg_conv->get_next_channel_announcements)(this_arg_conv->this_arg, starting_point, batch_amount);
6135 int64_tArray ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
6136 int64_t *ret_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, ret_arr, NULL);
6137 for (size_t l = 0; l < ret_var.datalen; l++) {
6138 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv_63_ref = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
6139 *ret_conv_63_ref = ret_var.data[l];
6140 ret_arr_ptr[l] = (long)ret_conv_63_ref;
6142 (*env)->ReleasePrimitiveArrayCritical(env, ret_arr, ret_arr_ptr, 0);
6147 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) {
6148 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1);
6149 LDKPublicKey starting_point_ref;
6150 CHECK((*env)->GetArrayLength(env, starting_point) == 33);
6151 (*env)->GetByteArrayRegion(env, starting_point, 0, 33, starting_point_ref.compressed_form);
6152 LDKCVec_NodeAnnouncementZ ret_var = (this_arg_conv->get_next_node_announcements)(this_arg_conv->this_arg, starting_point_ref, batch_amount);
6153 int64_tArray ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
6154 int64_t *ret_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, ret_arr, NULL);
6155 for (size_t s = 0; s < ret_var.datalen; s++) {
6156 LDKNodeAnnouncement ret_conv_18_var = ret_var.data[s];
6157 CHECK((((long)ret_conv_18_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6158 CHECK((((long)&ret_conv_18_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6159 long ret_conv_18_ref = (long)ret_conv_18_var.inner;
6160 if (ret_conv_18_var.is_owned) {
6161 ret_conv_18_ref |= 1;
6163 ret_arr_ptr[s] = ret_conv_18_ref;
6165 (*env)->ReleasePrimitiveArrayCritical(env, ret_arr, ret_arr_ptr, 0);
6170 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) {
6171 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1);
6172 LDKPublicKey their_node_id_ref;
6173 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
6174 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
6176 init_conv.inner = (void*)(init & (~1));
6177 init_conv.is_owned = false;
6178 (this_arg_conv->sync_routing_table)(this_arg_conv->this_arg, their_node_id_ref, &init_conv);
6181 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) {
6182 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1);
6183 LDKPublicKey their_node_id_ref;
6184 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
6185 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
6186 LDKReplyChannelRange msg_conv;
6187 msg_conv.inner = (void*)(msg & (~1));
6188 msg_conv.is_owned = (msg & 1) || (msg == 0);
6189 msg_conv = ReplyChannelRange_clone(&msg_conv);
6190 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
6191 *ret_conv = (this_arg_conv->handle_reply_channel_range)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
6192 return (long)ret_conv;
6195 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) {
6196 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1);
6197 LDKPublicKey their_node_id_ref;
6198 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
6199 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
6200 LDKReplyShortChannelIdsEnd msg_conv;
6201 msg_conv.inner = (void*)(msg & (~1));
6202 msg_conv.is_owned = (msg & 1) || (msg == 0);
6203 msg_conv = ReplyShortChannelIdsEnd_clone(&msg_conv);
6204 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
6205 *ret_conv = (this_arg_conv->handle_reply_short_channel_ids_end)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
6206 return (long)ret_conv;
6209 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) {
6210 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1);
6211 LDKPublicKey their_node_id_ref;
6212 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
6213 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
6214 LDKQueryChannelRange msg_conv;
6215 msg_conv.inner = (void*)(msg & (~1));
6216 msg_conv.is_owned = (msg & 1) || (msg == 0);
6217 msg_conv = QueryChannelRange_clone(&msg_conv);
6218 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
6219 *ret_conv = (this_arg_conv->handle_query_channel_range)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
6220 return (long)ret_conv;
6223 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) {
6224 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1);
6225 LDKPublicKey their_node_id_ref;
6226 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
6227 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
6228 LDKQueryShortChannelIds msg_conv;
6229 msg_conv.inner = (void*)(msg & (~1));
6230 msg_conv.is_owned = (msg & 1) || (msg == 0);
6231 msg_conv = QueryShortChannelIds_clone(&msg_conv);
6232 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
6233 *ret_conv = (this_arg_conv->handle_query_short_channel_ids)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
6234 return (long)ret_conv;
6237 typedef struct LDKSocketDescriptor_JCalls {
6238 atomic_size_t refcnt;
6241 jmethodID send_data_meth;
6242 jmethodID disconnect_socket_meth;
6244 jmethodID hash_meth;
6245 } LDKSocketDescriptor_JCalls;
6246 static void LDKSocketDescriptor_JCalls_free(void* this_arg) {
6247 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
6248 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
6250 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
6251 (*env)->DeleteWeakGlobalRef(env, j_calls->o);
6255 uintptr_t send_data_jcall(void* this_arg, LDKu8slice data, bool resume_read) {
6256 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
6258 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
6259 LDKu8slice data_var = data;
6260 int8_tArray data_arr = (*env)->NewByteArray(env, data_var.datalen);
6261 (*env)->SetByteArrayRegion(env, data_arr, 0, data_var.datalen, data_var.data);
6262 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
6264 return (*env)->CallLongMethod(env, obj, j_calls->send_data_meth, data_arr, resume_read);
6266 void disconnect_socket_jcall(void* this_arg) {
6267 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
6269 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
6270 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
6272 return (*env)->CallVoidMethod(env, obj, j_calls->disconnect_socket_meth);
6274 bool eq_jcall(const void* this_arg, const LDKSocketDescriptor * other_arg) {
6275 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
6277 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
6278 LDKSocketDescriptor *other_arg_clone = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
6279 *other_arg_clone = SocketDescriptor_clone(other_arg);
6280 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
6282 return (*env)->CallBooleanMethod(env, obj, j_calls->eq_meth, (long)other_arg_clone);
6284 uint64_t hash_jcall(const void* this_arg) {
6285 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
6287 DO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);
6288 jobject obj = (*env)->NewLocalRef(env, j_calls->o);
6290 return (*env)->CallLongMethod(env, obj, j_calls->hash_meth);
6292 static void* LDKSocketDescriptor_JCalls_clone(const void* this_arg) {
6293 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
6294 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
6295 return (void*) this_arg;
6297 static inline LDKSocketDescriptor LDKSocketDescriptor_init (JNIEnv *env, jclass clz, jobject o) {
6298 jclass c = (*env)->GetObjectClass(env, o);
6300 LDKSocketDescriptor_JCalls *calls = MALLOC(sizeof(LDKSocketDescriptor_JCalls), "LDKSocketDescriptor_JCalls");
6301 atomic_init(&calls->refcnt, 1);
6302 DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
6303 calls->o = (*env)->NewWeakGlobalRef(env, o);
6304 calls->send_data_meth = (*env)->GetMethodID(env, c, "send_data", "([BZ)J");
6305 CHECK(calls->send_data_meth != NULL);
6306 calls->disconnect_socket_meth = (*env)->GetMethodID(env, c, "disconnect_socket", "()V");
6307 CHECK(calls->disconnect_socket_meth != NULL);
6308 calls->eq_meth = (*env)->GetMethodID(env, c, "eq", "(J)Z");
6309 CHECK(calls->eq_meth != NULL);
6310 calls->hash_meth = (*env)->GetMethodID(env, c, "hash", "()J");
6311 CHECK(calls->hash_meth != NULL);
6313 LDKSocketDescriptor ret = {
6314 .this_arg = (void*) calls,
6315 .send_data = send_data_jcall,
6316 .disconnect_socket = disconnect_socket_jcall,
6319 .clone = LDKSocketDescriptor_JCalls_clone,
6320 .free = LDKSocketDescriptor_JCalls_free,
6324 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKSocketDescriptor_1new(JNIEnv *env, jclass clz, jobject o) {
6325 LDKSocketDescriptor *res_ptr = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
6326 *res_ptr = LDKSocketDescriptor_init(env, clz, o);
6327 return (long)res_ptr;
6329 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) {
6330 LDKSocketDescriptor* this_arg_conv = (LDKSocketDescriptor*)(((uint64_t)this_arg) & ~1);
6331 LDKu8slice data_ref;
6332 data_ref.datalen = (*env)->GetArrayLength(env, data);
6333 data_ref.data = (*env)->GetByteArrayElements (env, data, NULL);
6334 int64_t ret_val = (this_arg_conv->send_data)(this_arg_conv->this_arg, data_ref, resume_read);
6335 (*env)->ReleaseByteArrayElements(env, data, (int8_t*)data_ref.data, 0);
6339 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_SocketDescriptor_1disconnect_1socket(JNIEnv *env, jclass clz, int64_t this_arg) {
6340 LDKSocketDescriptor* this_arg_conv = (LDKSocketDescriptor*)(((uint64_t)this_arg) & ~1);
6341 (this_arg_conv->disconnect_socket)(this_arg_conv->this_arg);
6344 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SocketDescriptor_1hash(JNIEnv *env, jclass clz, int64_t this_arg) {
6345 LDKSocketDescriptor* this_arg_conv = (LDKSocketDescriptor*)(((uint64_t)this_arg) & ~1);
6346 int64_t ret_val = (this_arg_conv->hash)(this_arg_conv->this_arg);
6350 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Transaction_1free(JNIEnv *env, jclass clz, int8_tArray _res) {
6351 LDKTransaction _res_ref;
6352 _res_ref.datalen = (*env)->GetArrayLength(env, _res);
6353 _res_ref.data = MALLOC(_res_ref.datalen, "LDKTransaction Bytes");
6354 (*env)->GetByteArrayRegion(env, _res, 0, _res_ref.datalen, _res_ref.data);
6355 _res_ref.data_is_owned = true;
6356 Transaction_free(_res_ref);
6359 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_TxOut_1free(JNIEnv *env, jclass clz, int64_t _res) {
6360 if ((_res & 1) != 0) return;
6361 LDKTxOut _res_conv = *(LDKTxOut*)(((uint64_t)_res) & ~1);
6363 TxOut_free(_res_conv);
6366 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_TxOut_1clone(JNIEnv *env, jclass clz, int64_t orig) {
6367 LDKTxOut* orig_conv = (LDKTxOut*)(orig & ~1);
6368 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
6369 *ret_ref = TxOut_clone(orig_conv);
6370 return (long)ret_ref;
6373 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SecretKeyErrorZ_1ok(JNIEnv *env, jclass clz, int8_tArray o) {
6375 CHECK((*env)->GetArrayLength(env, o) == 32);
6376 (*env)->GetByteArrayRegion(env, o, 0, 32, o_ref.bytes);
6377 LDKCResult_SecretKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SecretKeyErrorZ), "LDKCResult_SecretKeyErrorZ");
6378 *ret_conv = CResult_SecretKeyErrorZ_ok(o_ref);
6379 return (long)ret_conv;
6382 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SecretKeyErrorZ_1err(JNIEnv *env, jclass clz, jclass e) {
6383 LDKSecp256k1Error e_conv = LDKSecp256k1Error_from_java(env, e);
6384 LDKCResult_SecretKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SecretKeyErrorZ), "LDKCResult_SecretKeyErrorZ");
6385 *ret_conv = CResult_SecretKeyErrorZ_err(e_conv);
6386 return (long)ret_conv;
6389 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1SecretKeyErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
6390 if ((_res & 1) != 0) return;
6391 LDKCResult_SecretKeyErrorZ _res_conv = *(LDKCResult_SecretKeyErrorZ*)(((uint64_t)_res) & ~1);
6393 CResult_SecretKeyErrorZ_free(_res_conv);
6396 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PublicKeyErrorZ_1ok(JNIEnv *env, jclass clz, int8_tArray o) {
6398 CHECK((*env)->GetArrayLength(env, o) == 33);
6399 (*env)->GetByteArrayRegion(env, o, 0, 33, o_ref.compressed_form);
6400 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
6401 *ret_conv = CResult_PublicKeyErrorZ_ok(o_ref);
6402 return (long)ret_conv;
6405 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PublicKeyErrorZ_1err(JNIEnv *env, jclass clz, jclass e) {
6406 LDKSecp256k1Error e_conv = LDKSecp256k1Error_from_java(env, e);
6407 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
6408 *ret_conv = CResult_PublicKeyErrorZ_err(e_conv);
6409 return (long)ret_conv;
6412 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PublicKeyErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
6413 if ((_res & 1) != 0) return;
6414 LDKCResult_PublicKeyErrorZ _res_conv = *(LDKCResult_PublicKeyErrorZ*)(((uint64_t)_res) & ~1);
6416 CResult_PublicKeyErrorZ_free(_res_conv);
6419 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
6420 LDKTxCreationKeys o_conv;
6421 o_conv.inner = (void*)(o & (~1));
6422 o_conv.is_owned = (o & 1) || (o == 0);
6423 o_conv = TxCreationKeys_clone(&o_conv);
6424 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
6425 *ret_conv = CResult_TxCreationKeysDecodeErrorZ_ok(o_conv);
6426 return (long)ret_conv;
6429 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
6430 LDKDecodeError e_conv;
6431 e_conv.inner = (void*)(e & (~1));
6432 e_conv.is_owned = (e & 1) || (e == 0);
6433 e_conv = DecodeError_clone(&e_conv);
6434 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
6435 *ret_conv = CResult_TxCreationKeysDecodeErrorZ_err(e_conv);
6436 return (long)ret_conv;
6439 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
6440 if ((_res & 1) != 0) return;
6441 LDKCResult_TxCreationKeysDecodeErrorZ _res_conv = *(LDKCResult_TxCreationKeysDecodeErrorZ*)(((uint64_t)_res) & ~1);
6443 CResult_TxCreationKeysDecodeErrorZ_free(_res_conv);
6446 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
6447 LDKCResult_TxCreationKeysDecodeErrorZ* orig_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)(orig & ~1);
6448 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
6449 *ret_conv = CResult_TxCreationKeysDecodeErrorZ_clone(orig_conv);
6450 return (long)ret_conv;
6453 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelPublicKeysDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
6454 LDKChannelPublicKeys o_conv;
6455 o_conv.inner = (void*)(o & (~1));
6456 o_conv.is_owned = (o & 1) || (o == 0);
6457 o_conv = ChannelPublicKeys_clone(&o_conv);
6458 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
6459 *ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_ok(o_conv);
6460 return (long)ret_conv;
6463 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelPublicKeysDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
6464 LDKDecodeError e_conv;
6465 e_conv.inner = (void*)(e & (~1));
6466 e_conv.is_owned = (e & 1) || (e == 0);
6467 e_conv = DecodeError_clone(&e_conv);
6468 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
6469 *ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_err(e_conv);
6470 return (long)ret_conv;
6473 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelPublicKeysDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
6474 if ((_res & 1) != 0) return;
6475 LDKCResult_ChannelPublicKeysDecodeErrorZ _res_conv = *(LDKCResult_ChannelPublicKeysDecodeErrorZ*)(((uint64_t)_res) & ~1);
6477 CResult_ChannelPublicKeysDecodeErrorZ_free(_res_conv);
6480 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelPublicKeysDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
6481 LDKCResult_ChannelPublicKeysDecodeErrorZ* orig_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)(orig & ~1);
6482 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
6483 *ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_clone(orig_conv);
6484 return (long)ret_conv;
6487 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
6488 LDKTxCreationKeys o_conv;
6489 o_conv.inner = (void*)(o & (~1));
6490 o_conv.is_owned = (o & 1) || (o == 0);
6491 o_conv = TxCreationKeys_clone(&o_conv);
6492 LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
6493 *ret_conv = CResult_TxCreationKeysErrorZ_ok(o_conv);
6494 return (long)ret_conv;
6497 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysErrorZ_1err(JNIEnv *env, jclass clz, jclass e) {
6498 LDKSecp256k1Error e_conv = LDKSecp256k1Error_from_java(env, e);
6499 LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
6500 *ret_conv = CResult_TxCreationKeysErrorZ_err(e_conv);
6501 return (long)ret_conv;
6504 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
6505 if ((_res & 1) != 0) return;
6506 LDKCResult_TxCreationKeysErrorZ _res_conv = *(LDKCResult_TxCreationKeysErrorZ*)(((uint64_t)_res) & ~1);
6508 CResult_TxCreationKeysErrorZ_free(_res_conv);
6511 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCOutputInCommitmentDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
6512 LDKHTLCOutputInCommitment o_conv;
6513 o_conv.inner = (void*)(o & (~1));
6514 o_conv.is_owned = (o & 1) || (o == 0);
6515 o_conv = HTLCOutputInCommitment_clone(&o_conv);
6516 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
6517 *ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o_conv);
6518 return (long)ret_conv;
6521 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCOutputInCommitmentDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
6522 LDKDecodeError e_conv;
6523 e_conv.inner = (void*)(e & (~1));
6524 e_conv.is_owned = (e & 1) || (e == 0);
6525 e_conv = DecodeError_clone(&e_conv);
6526 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
6527 *ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e_conv);
6528 return (long)ret_conv;
6531 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCOutputInCommitmentDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
6532 if ((_res & 1) != 0) return;
6533 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ _res_conv = *(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(((uint64_t)_res) & ~1);
6535 CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res_conv);
6538 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCOutputInCommitmentDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
6539 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* orig_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(orig & ~1);
6540 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
6541 *ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig_conv);
6542 return (long)ret_conv;
6545 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CounterpartyChannelTransactionParametersDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
6546 LDKCounterpartyChannelTransactionParameters o_conv;
6547 o_conv.inner = (void*)(o & (~1));
6548 o_conv.is_owned = (o & 1) || (o == 0);
6549 o_conv = CounterpartyChannelTransactionParameters_clone(&o_conv);
6550 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
6551 *ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o_conv);
6552 return (long)ret_conv;
6555 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CounterpartyChannelTransactionParametersDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
6556 LDKDecodeError e_conv;
6557 e_conv.inner = (void*)(e & (~1));
6558 e_conv.is_owned = (e & 1) || (e == 0);
6559 e_conv = DecodeError_clone(&e_conv);
6560 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
6561 *ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e_conv);
6562 return (long)ret_conv;
6565 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CounterpartyChannelTransactionParametersDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
6566 if ((_res & 1) != 0) return;
6567 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ _res_conv = *(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(((uint64_t)_res) & ~1);
6569 CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res_conv);
6572 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CounterpartyChannelTransactionParametersDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
6573 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* orig_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(orig & ~1);
6574 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
6575 *ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig_conv);
6576 return (long)ret_conv;
6579 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelTransactionParametersDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
6580 LDKChannelTransactionParameters o_conv;
6581 o_conv.inner = (void*)(o & (~1));
6582 o_conv.is_owned = (o & 1) || (o == 0);
6583 o_conv = ChannelTransactionParameters_clone(&o_conv);
6584 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
6585 *ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_ok(o_conv);
6586 return (long)ret_conv;
6589 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelTransactionParametersDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
6590 LDKDecodeError e_conv;
6591 e_conv.inner = (void*)(e & (~1));
6592 e_conv.is_owned = (e & 1) || (e == 0);
6593 e_conv = DecodeError_clone(&e_conv);
6594 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
6595 *ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_err(e_conv);
6596 return (long)ret_conv;
6599 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelTransactionParametersDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
6600 if ((_res & 1) != 0) return;
6601 LDKCResult_ChannelTransactionParametersDecodeErrorZ _res_conv = *(LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(((uint64_t)_res) & ~1);
6603 CResult_ChannelTransactionParametersDecodeErrorZ_free(_res_conv);
6606 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelTransactionParametersDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
6607 LDKCResult_ChannelTransactionParametersDecodeErrorZ* orig_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(orig & ~1);
6608 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
6609 *ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig_conv);
6610 return (long)ret_conv;
6613 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1SignatureZ_1free(JNIEnv *env, jclass clz, jobjectArray _res) {
6614 LDKCVec_SignatureZ _res_constr;
6615 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
6616 if (_res_constr.datalen > 0)
6617 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
6619 _res_constr.data = NULL;
6620 for (size_t i = 0; i < _res_constr.datalen; i++) {
6621 int8_tArray _res_conv_8 = (*env)->GetObjectArrayElement(env, _res, i);
6622 LDKSignature _res_conv_8_ref;
6623 CHECK((*env)->GetArrayLength(env, _res_conv_8) == 64);
6624 (*env)->GetByteArrayRegion(env, _res_conv_8, 0, 64, _res_conv_8_ref.compact_form);
6625 _res_constr.data[i] = _res_conv_8_ref;
6627 CVec_SignatureZ_free(_res_constr);
6630 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1HolderCommitmentTransactionDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
6631 LDKHolderCommitmentTransaction o_conv;
6632 o_conv.inner = (void*)(o & (~1));
6633 o_conv.is_owned = (o & 1) || (o == 0);
6634 o_conv = HolderCommitmentTransaction_clone(&o_conv);
6635 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
6636 *ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o_conv);
6637 return (long)ret_conv;
6640 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1HolderCommitmentTransactionDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
6641 LDKDecodeError e_conv;
6642 e_conv.inner = (void*)(e & (~1));
6643 e_conv.is_owned = (e & 1) || (e == 0);
6644 e_conv = DecodeError_clone(&e_conv);
6645 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
6646 *ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_err(e_conv);
6647 return (long)ret_conv;
6650 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1HolderCommitmentTransactionDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
6651 if ((_res & 1) != 0) return;
6652 LDKCResult_HolderCommitmentTransactionDecodeErrorZ _res_conv = *(LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(((uint64_t)_res) & ~1);
6654 CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res_conv);
6657 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1HolderCommitmentTransactionDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
6658 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(orig & ~1);
6659 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
6660 *ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig_conv);
6661 return (long)ret_conv;
6664 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1BuiltCommitmentTransactionDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
6665 LDKBuiltCommitmentTransaction o_conv;
6666 o_conv.inner = (void*)(o & (~1));
6667 o_conv.is_owned = (o & 1) || (o == 0);
6668 o_conv = BuiltCommitmentTransaction_clone(&o_conv);
6669 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
6670 *ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o_conv);
6671 return (long)ret_conv;
6674 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1BuiltCommitmentTransactionDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
6675 LDKDecodeError e_conv;
6676 e_conv.inner = (void*)(e & (~1));
6677 e_conv.is_owned = (e & 1) || (e == 0);
6678 e_conv = DecodeError_clone(&e_conv);
6679 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
6680 *ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e_conv);
6681 return (long)ret_conv;
6684 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1BuiltCommitmentTransactionDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
6685 if ((_res & 1) != 0) return;
6686 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ _res_conv = *(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(((uint64_t)_res) & ~1);
6688 CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res_conv);
6691 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1BuiltCommitmentTransactionDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
6692 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(orig & ~1);
6693 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
6694 *ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig_conv);
6695 return (long)ret_conv;
6698 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentTransactionDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
6699 LDKCommitmentTransaction o_conv;
6700 o_conv.inner = (void*)(o & (~1));
6701 o_conv.is_owned = (o & 1) || (o == 0);
6702 o_conv = CommitmentTransaction_clone(&o_conv);
6703 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
6704 *ret_conv = CResult_CommitmentTransactionDecodeErrorZ_ok(o_conv);
6705 return (long)ret_conv;
6708 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentTransactionDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
6709 LDKDecodeError e_conv;
6710 e_conv.inner = (void*)(e & (~1));
6711 e_conv.is_owned = (e & 1) || (e == 0);
6712 e_conv = DecodeError_clone(&e_conv);
6713 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
6714 *ret_conv = CResult_CommitmentTransactionDecodeErrorZ_err(e_conv);
6715 return (long)ret_conv;
6718 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentTransactionDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
6719 if ((_res & 1) != 0) return;
6720 LDKCResult_CommitmentTransactionDecodeErrorZ _res_conv = *(LDKCResult_CommitmentTransactionDecodeErrorZ*)(((uint64_t)_res) & ~1);
6722 CResult_CommitmentTransactionDecodeErrorZ_free(_res_conv);
6725 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentTransactionDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
6726 LDKCResult_CommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)(orig & ~1);
6727 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
6728 *ret_conv = CResult_CommitmentTransactionDecodeErrorZ_clone(orig_conv);
6729 return (long)ret_conv;
6732 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TrustedCommitmentTransactionNoneZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
6733 LDKTrustedCommitmentTransaction o_conv;
6734 o_conv.inner = (void*)(o & (~1));
6735 o_conv.is_owned = (o & 1) || (o == 0);
6736 // Warning: we need a move here but no clone is available for LDKTrustedCommitmentTransaction
6737 LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
6738 *ret_conv = CResult_TrustedCommitmentTransactionNoneZ_ok(o_conv);
6739 return (long)ret_conv;
6742 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TrustedCommitmentTransactionNoneZ_1err(JNIEnv *env, jclass clz) {
6743 LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
6744 *ret_conv = CResult_TrustedCommitmentTransactionNoneZ_err();
6745 return (long)ret_conv;
6748 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1TrustedCommitmentTransactionNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
6749 if ((_res & 1) != 0) return;
6750 LDKCResult_TrustedCommitmentTransactionNoneZ _res_conv = *(LDKCResult_TrustedCommitmentTransactionNoneZ*)(((uint64_t)_res) & ~1);
6752 CResult_TrustedCommitmentTransactionNoneZ_free(_res_conv);
6755 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1ok(JNIEnv *env, jclass clz, jobjectArray o) {
6756 LDKCVec_SignatureZ o_constr;
6757 o_constr.datalen = (*env)->GetArrayLength(env, o);
6758 if (o_constr.datalen > 0)
6759 o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
6761 o_constr.data = NULL;
6762 for (size_t i = 0; i < o_constr.datalen; i++) {
6763 int8_tArray o_conv_8 = (*env)->GetObjectArrayElement(env, o, i);
6764 LDKSignature o_conv_8_ref;
6765 CHECK((*env)->GetArrayLength(env, o_conv_8) == 64);
6766 (*env)->GetByteArrayRegion(env, o_conv_8, 0, 64, o_conv_8_ref.compact_form);
6767 o_constr.data[i] = o_conv_8_ref;
6769 LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
6770 *ret_conv = CResult_CVec_SignatureZNoneZ_ok(o_constr);
6771 return (long)ret_conv;
6774 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1err(JNIEnv *env, jclass clz) {
6775 LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
6776 *ret_conv = CResult_CVec_SignatureZNoneZ_err();
6777 return (long)ret_conv;
6780 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
6781 if ((_res & 1) != 0) return;
6782 LDKCResult_CVec_SignatureZNoneZ _res_conv = *(LDKCResult_CVec_SignatureZNoneZ*)(((uint64_t)_res) & ~1);
6784 CResult_CVec_SignatureZNoneZ_free(_res_conv);
6787 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
6788 LDKCResult_CVec_SignatureZNoneZ* orig_conv = (LDKCResult_CVec_SignatureZNoneZ*)(orig & ~1);
6789 LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
6790 *ret_conv = CResult_CVec_SignatureZNoneZ_clone(orig_conv);
6791 return (long)ret_conv;
6794 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1MessageSendEventZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
6795 LDKCVec_MessageSendEventZ _res_constr;
6796 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
6797 if (_res_constr.datalen > 0)
6798 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKMessageSendEvent), "LDKCVec_MessageSendEventZ Elements");
6800 _res_constr.data = NULL;
6801 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
6802 for (size_t s = 0; s < _res_constr.datalen; s++) {
6803 int64_t _res_conv_18 = _res_vals[s];
6804 LDKMessageSendEvent _res_conv_18_conv = *(LDKMessageSendEvent*)(((uint64_t)_res_conv_18) & ~1);
6805 FREE((void*)_res_conv_18);
6806 _res_constr.data[s] = _res_conv_18_conv;
6808 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
6809 CVec_MessageSendEventZ_free(_res_constr);
6812 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1ok(JNIEnv *env, jclass clz, jboolean o) {
6813 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
6814 *ret_conv = CResult_boolLightningErrorZ_ok(o);
6815 return (long)ret_conv;
6818 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
6819 LDKLightningError e_conv;
6820 e_conv.inner = (void*)(e & (~1));
6821 e_conv.is_owned = (e & 1) || (e == 0);
6822 e_conv = LightningError_clone(&e_conv);
6823 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
6824 *ret_conv = CResult_boolLightningErrorZ_err(e_conv);
6825 return (long)ret_conv;
6828 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
6829 if ((_res & 1) != 0) return;
6830 LDKCResult_boolLightningErrorZ _res_conv = *(LDKCResult_boolLightningErrorZ*)(((uint64_t)_res) & ~1);
6832 CResult_boolLightningErrorZ_free(_res_conv);
6835 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
6836 LDKCResult_boolLightningErrorZ* orig_conv = (LDKCResult_boolLightningErrorZ*)(orig & ~1);
6837 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
6838 *ret_conv = CResult_boolLightningErrorZ_clone(orig_conv);
6839 return (long)ret_conv;
6842 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
6843 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* orig_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(orig & ~1);
6844 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_ref = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
6845 *ret_ref = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig_conv);
6846 return (long)ret_ref;
6849 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) {
6850 LDKChannelAnnouncement a_conv;
6851 a_conv.inner = (void*)(a & (~1));
6852 a_conv.is_owned = (a & 1) || (a == 0);
6853 a_conv = ChannelAnnouncement_clone(&a_conv);
6854 LDKChannelUpdate b_conv;
6855 b_conv.inner = (void*)(b & (~1));
6856 b_conv.is_owned = (b & 1) || (b == 0);
6857 b_conv = ChannelUpdate_clone(&b_conv);
6858 LDKChannelUpdate c_conv;
6859 c_conv.inner = (void*)(c & (~1));
6860 c_conv.is_owned = (c & 1) || (c == 0);
6861 c_conv = ChannelUpdate_clone(&c_conv);
6862 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_ref = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
6863 *ret_ref = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a_conv, b_conv, c_conv);
6864 return (long)ret_ref;
6867 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
6868 if ((_res & 1) != 0) return;
6869 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)_res) & ~1);
6871 C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res_conv);
6874 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
6875 LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res_constr;
6876 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
6877 if (_res_constr.datalen > 0)
6878 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ Elements");
6880 _res_constr.data = NULL;
6881 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
6882 for (size_t l = 0; l < _res_constr.datalen; l++) {
6883 int64_t _res_conv_63 = _res_vals[l];
6884 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res_conv_63_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)_res_conv_63) & ~1);
6885 FREE((void*)_res_conv_63);
6886 _res_constr.data[l] = _res_conv_63_conv;
6888 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
6889 CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res_constr);
6892 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1NodeAnnouncementZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
6893 LDKCVec_NodeAnnouncementZ _res_constr;
6894 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
6895 if (_res_constr.datalen > 0)
6896 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKNodeAnnouncement), "LDKCVec_NodeAnnouncementZ Elements");
6898 _res_constr.data = NULL;
6899 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
6900 for (size_t s = 0; s < _res_constr.datalen; s++) {
6901 int64_t _res_conv_18 = _res_vals[s];
6902 LDKNodeAnnouncement _res_conv_18_conv;
6903 _res_conv_18_conv.inner = (void*)(_res_conv_18 & (~1));
6904 _res_conv_18_conv.is_owned = (_res_conv_18 & 1) || (_res_conv_18 == 0);
6905 _res_constr.data[s] = _res_conv_18_conv;
6907 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
6908 CVec_NodeAnnouncementZ_free(_res_constr);
6911 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1ok(JNIEnv *env, jclass clz) {
6912 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
6913 *ret_conv = CResult_NoneLightningErrorZ_ok();
6914 return (long)ret_conv;
6917 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
6918 LDKLightningError e_conv;
6919 e_conv.inner = (void*)(e & (~1));
6920 e_conv.is_owned = (e & 1) || (e == 0);
6921 e_conv = LightningError_clone(&e_conv);
6922 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
6923 *ret_conv = CResult_NoneLightningErrorZ_err(e_conv);
6924 return (long)ret_conv;
6927 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
6928 if ((_res & 1) != 0) return;
6929 LDKCResult_NoneLightningErrorZ _res_conv = *(LDKCResult_NoneLightningErrorZ*)(((uint64_t)_res) & ~1);
6931 CResult_NoneLightningErrorZ_free(_res_conv);
6934 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
6935 LDKCResult_NoneLightningErrorZ* orig_conv = (LDKCResult_NoneLightningErrorZ*)(orig & ~1);
6936 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
6937 *ret_conv = CResult_NoneLightningErrorZ_clone(orig_conv);
6938 return (long)ret_conv;
6941 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1PublicKeyZ_1free(JNIEnv *env, jclass clz, jobjectArray _res) {
6942 LDKCVec_PublicKeyZ _res_constr;
6943 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
6944 if (_res_constr.datalen > 0)
6945 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKPublicKey), "LDKCVec_PublicKeyZ Elements");
6947 _res_constr.data = NULL;
6948 for (size_t i = 0; i < _res_constr.datalen; i++) {
6949 int8_tArray _res_conv_8 = (*env)->GetObjectArrayElement(env, _res, i);
6950 LDKPublicKey _res_conv_8_ref;
6951 CHECK((*env)->GetArrayLength(env, _res_conv_8) == 33);
6952 (*env)->GetByteArrayRegion(env, _res_conv_8, 0, 33, _res_conv_8_ref.compressed_form);
6953 _res_constr.data[i] = _res_conv_8_ref;
6955 CVec_PublicKeyZ_free(_res_constr);
6958 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1u8Z_1free(JNIEnv *env, jclass clz, int8_tArray _res) {
6959 LDKCVec_u8Z _res_ref;
6960 _res_ref.datalen = (*env)->GetArrayLength(env, _res);
6961 _res_ref.data = MALLOC(_res_ref.datalen, "LDKCVec_u8Z Bytes");
6962 (*env)->GetByteArrayRegion(env, _res, 0, _res_ref.datalen, _res_ref.data);
6963 CVec_u8Z_free(_res_ref);
6966 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1u8ZPeerHandleErrorZ_1ok(JNIEnv *env, jclass clz, int8_tArray o) {
6968 o_ref.datalen = (*env)->GetArrayLength(env, o);
6969 o_ref.data = MALLOC(o_ref.datalen, "LDKCVec_u8Z Bytes");
6970 (*env)->GetByteArrayRegion(env, o, 0, o_ref.datalen, o_ref.data);
6971 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
6972 *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_ok(o_ref);
6973 return (long)ret_conv;
6976 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1u8ZPeerHandleErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
6977 LDKPeerHandleError e_conv;
6978 e_conv.inner = (void*)(e & (~1));
6979 e_conv.is_owned = (e & 1) || (e == 0);
6980 e_conv = PeerHandleError_clone(&e_conv);
6981 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
6982 *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_err(e_conv);
6983 return (long)ret_conv;
6986 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1u8ZPeerHandleErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
6987 if ((_res & 1) != 0) return;
6988 LDKCResult_CVec_u8ZPeerHandleErrorZ _res_conv = *(LDKCResult_CVec_u8ZPeerHandleErrorZ*)(((uint64_t)_res) & ~1);
6990 CResult_CVec_u8ZPeerHandleErrorZ_free(_res_conv);
6993 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1u8ZPeerHandleErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
6994 LDKCResult_CVec_u8ZPeerHandleErrorZ* orig_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(orig & ~1);
6995 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
6996 *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_clone(orig_conv);
6997 return (long)ret_conv;
7000 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NonePeerHandleErrorZ_1ok(JNIEnv *env, jclass clz) {
7001 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
7002 *ret_conv = CResult_NonePeerHandleErrorZ_ok();
7003 return (long)ret_conv;
7006 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NonePeerHandleErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
7007 LDKPeerHandleError e_conv;
7008 e_conv.inner = (void*)(e & (~1));
7009 e_conv.is_owned = (e & 1) || (e == 0);
7010 e_conv = PeerHandleError_clone(&e_conv);
7011 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
7012 *ret_conv = CResult_NonePeerHandleErrorZ_err(e_conv);
7013 return (long)ret_conv;
7016 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NonePeerHandleErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
7017 if ((_res & 1) != 0) return;
7018 LDKCResult_NonePeerHandleErrorZ _res_conv = *(LDKCResult_NonePeerHandleErrorZ*)(((uint64_t)_res) & ~1);
7020 CResult_NonePeerHandleErrorZ_free(_res_conv);
7023 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NonePeerHandleErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
7024 LDKCResult_NonePeerHandleErrorZ* orig_conv = (LDKCResult_NonePeerHandleErrorZ*)(orig & ~1);
7025 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
7026 *ret_conv = CResult_NonePeerHandleErrorZ_clone(orig_conv);
7027 return (long)ret_conv;
7030 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1boolPeerHandleErrorZ_1ok(JNIEnv *env, jclass clz, jboolean o) {
7031 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
7032 *ret_conv = CResult_boolPeerHandleErrorZ_ok(o);
7033 return (long)ret_conv;
7036 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1boolPeerHandleErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
7037 LDKPeerHandleError e_conv;
7038 e_conv.inner = (void*)(e & (~1));
7039 e_conv.is_owned = (e & 1) || (e == 0);
7040 e_conv = PeerHandleError_clone(&e_conv);
7041 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
7042 *ret_conv = CResult_boolPeerHandleErrorZ_err(e_conv);
7043 return (long)ret_conv;
7046 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1boolPeerHandleErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
7047 if ((_res & 1) != 0) return;
7048 LDKCResult_boolPeerHandleErrorZ _res_conv = *(LDKCResult_boolPeerHandleErrorZ*)(((uint64_t)_res) & ~1);
7050 CResult_boolPeerHandleErrorZ_free(_res_conv);
7053 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1boolPeerHandleErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
7054 LDKCResult_boolPeerHandleErrorZ* orig_conv = (LDKCResult_boolPeerHandleErrorZ*)(orig & ~1);
7055 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
7056 *ret_conv = CResult_boolPeerHandleErrorZ_clone(orig_conv);
7057 return (long)ret_conv;
7060 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InitFeaturesDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
7061 LDKInitFeatures o_conv;
7062 o_conv.inner = (void*)(o & (~1));
7063 o_conv.is_owned = (o & 1) || (o == 0);
7064 o_conv = InitFeatures_clone(&o_conv);
7065 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
7066 *ret_conv = CResult_InitFeaturesDecodeErrorZ_ok(o_conv);
7067 return (long)ret_conv;
7070 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InitFeaturesDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
7071 LDKDecodeError e_conv;
7072 e_conv.inner = (void*)(e & (~1));
7073 e_conv.is_owned = (e & 1) || (e == 0);
7074 e_conv = DecodeError_clone(&e_conv);
7075 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
7076 *ret_conv = CResult_InitFeaturesDecodeErrorZ_err(e_conv);
7077 return (long)ret_conv;
7080 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1InitFeaturesDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
7081 if ((_res & 1) != 0) return;
7082 LDKCResult_InitFeaturesDecodeErrorZ _res_conv = *(LDKCResult_InitFeaturesDecodeErrorZ*)(((uint64_t)_res) & ~1);
7084 CResult_InitFeaturesDecodeErrorZ_free(_res_conv);
7087 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeFeaturesDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
7088 LDKNodeFeatures o_conv;
7089 o_conv.inner = (void*)(o & (~1));
7090 o_conv.is_owned = (o & 1) || (o == 0);
7091 o_conv = NodeFeatures_clone(&o_conv);
7092 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
7093 *ret_conv = CResult_NodeFeaturesDecodeErrorZ_ok(o_conv);
7094 return (long)ret_conv;
7097 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeFeaturesDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
7098 LDKDecodeError e_conv;
7099 e_conv.inner = (void*)(e & (~1));
7100 e_conv.is_owned = (e & 1) || (e == 0);
7101 e_conv = DecodeError_clone(&e_conv);
7102 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
7103 *ret_conv = CResult_NodeFeaturesDecodeErrorZ_err(e_conv);
7104 return (long)ret_conv;
7107 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NodeFeaturesDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
7108 if ((_res & 1) != 0) return;
7109 LDKCResult_NodeFeaturesDecodeErrorZ _res_conv = *(LDKCResult_NodeFeaturesDecodeErrorZ*)(((uint64_t)_res) & ~1);
7111 CResult_NodeFeaturesDecodeErrorZ_free(_res_conv);
7114 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelFeaturesDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
7115 LDKChannelFeatures o_conv;
7116 o_conv.inner = (void*)(o & (~1));
7117 o_conv.is_owned = (o & 1) || (o == 0);
7118 o_conv = ChannelFeatures_clone(&o_conv);
7119 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
7120 *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_ok(o_conv);
7121 return (long)ret_conv;
7124 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelFeaturesDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
7125 LDKDecodeError e_conv;
7126 e_conv.inner = (void*)(e & (~1));
7127 e_conv.is_owned = (e & 1) || (e == 0);
7128 e_conv = DecodeError_clone(&e_conv);
7129 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
7130 *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_err(e_conv);
7131 return (long)ret_conv;
7134 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelFeaturesDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
7135 if ((_res & 1) != 0) return;
7136 LDKCResult_ChannelFeaturesDecodeErrorZ _res_conv = *(LDKCResult_ChannelFeaturesDecodeErrorZ*)(((uint64_t)_res) & ~1);
7138 CResult_ChannelFeaturesDecodeErrorZ_free(_res_conv);
7141 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelConfigDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
7142 LDKChannelConfig o_conv;
7143 o_conv.inner = (void*)(o & (~1));
7144 o_conv.is_owned = (o & 1) || (o == 0);
7145 o_conv = ChannelConfig_clone(&o_conv);
7146 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
7147 *ret_conv = CResult_ChannelConfigDecodeErrorZ_ok(o_conv);
7148 return (long)ret_conv;
7151 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelConfigDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
7152 LDKDecodeError e_conv;
7153 e_conv.inner = (void*)(e & (~1));
7154 e_conv.is_owned = (e & 1) || (e == 0);
7155 e_conv = DecodeError_clone(&e_conv);
7156 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
7157 *ret_conv = CResult_ChannelConfigDecodeErrorZ_err(e_conv);
7158 return (long)ret_conv;
7161 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelConfigDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
7162 if ((_res & 1) != 0) return;
7163 LDKCResult_ChannelConfigDecodeErrorZ _res_conv = *(LDKCResult_ChannelConfigDecodeErrorZ*)(((uint64_t)_res) & ~1);
7165 CResult_ChannelConfigDecodeErrorZ_free(_res_conv);
7168 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelConfigDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
7169 LDKCResult_ChannelConfigDecodeErrorZ* orig_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)(orig & ~1);
7170 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
7171 *ret_conv = CResult_ChannelConfigDecodeErrorZ_clone(orig_conv);
7172 return (long)ret_conv;
7175 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1DirectionalChannelInfoDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
7176 LDKDirectionalChannelInfo o_conv;
7177 o_conv.inner = (void*)(o & (~1));
7178 o_conv.is_owned = (o & 1) || (o == 0);
7179 o_conv = DirectionalChannelInfo_clone(&o_conv);
7180 LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ");
7181 *ret_conv = CResult_DirectionalChannelInfoDecodeErrorZ_ok(o_conv);
7182 return (long)ret_conv;
7185 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1DirectionalChannelInfoDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
7186 LDKDecodeError e_conv;
7187 e_conv.inner = (void*)(e & (~1));
7188 e_conv.is_owned = (e & 1) || (e == 0);
7189 e_conv = DecodeError_clone(&e_conv);
7190 LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ");
7191 *ret_conv = CResult_DirectionalChannelInfoDecodeErrorZ_err(e_conv);
7192 return (long)ret_conv;
7195 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1DirectionalChannelInfoDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
7196 if ((_res & 1) != 0) return;
7197 LDKCResult_DirectionalChannelInfoDecodeErrorZ _res_conv = *(LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(((uint64_t)_res) & ~1);
7199 CResult_DirectionalChannelInfoDecodeErrorZ_free(_res_conv);
7202 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1DirectionalChannelInfoDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
7203 LDKCResult_DirectionalChannelInfoDecodeErrorZ* orig_conv = (LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(orig & ~1);
7204 LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ");
7205 *ret_conv = CResult_DirectionalChannelInfoDecodeErrorZ_clone(orig_conv);
7206 return (long)ret_conv;
7209 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelInfoDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
7210 LDKChannelInfo o_conv;
7211 o_conv.inner = (void*)(o & (~1));
7212 o_conv.is_owned = (o & 1) || (o == 0);
7213 o_conv = ChannelInfo_clone(&o_conv);
7214 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
7215 *ret_conv = CResult_ChannelInfoDecodeErrorZ_ok(o_conv);
7216 return (long)ret_conv;
7219 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelInfoDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
7220 LDKDecodeError e_conv;
7221 e_conv.inner = (void*)(e & (~1));
7222 e_conv.is_owned = (e & 1) || (e == 0);
7223 e_conv = DecodeError_clone(&e_conv);
7224 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
7225 *ret_conv = CResult_ChannelInfoDecodeErrorZ_err(e_conv);
7226 return (long)ret_conv;
7229 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelInfoDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
7230 if ((_res & 1) != 0) return;
7231 LDKCResult_ChannelInfoDecodeErrorZ _res_conv = *(LDKCResult_ChannelInfoDecodeErrorZ*)(((uint64_t)_res) & ~1);
7233 CResult_ChannelInfoDecodeErrorZ_free(_res_conv);
7236 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelInfoDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
7237 LDKCResult_ChannelInfoDecodeErrorZ* orig_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)(orig & ~1);
7238 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
7239 *ret_conv = CResult_ChannelInfoDecodeErrorZ_clone(orig_conv);
7240 return (long)ret_conv;
7243 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RoutingFeesDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
7244 LDKRoutingFees o_conv;
7245 o_conv.inner = (void*)(o & (~1));
7246 o_conv.is_owned = (o & 1) || (o == 0);
7247 o_conv = RoutingFees_clone(&o_conv);
7248 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
7249 *ret_conv = CResult_RoutingFeesDecodeErrorZ_ok(o_conv);
7250 return (long)ret_conv;
7253 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RoutingFeesDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
7254 LDKDecodeError e_conv;
7255 e_conv.inner = (void*)(e & (~1));
7256 e_conv.is_owned = (e & 1) || (e == 0);
7257 e_conv = DecodeError_clone(&e_conv);
7258 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
7259 *ret_conv = CResult_RoutingFeesDecodeErrorZ_err(e_conv);
7260 return (long)ret_conv;
7263 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RoutingFeesDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
7264 if ((_res & 1) != 0) return;
7265 LDKCResult_RoutingFeesDecodeErrorZ _res_conv = *(LDKCResult_RoutingFeesDecodeErrorZ*)(((uint64_t)_res) & ~1);
7267 CResult_RoutingFeesDecodeErrorZ_free(_res_conv);
7270 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RoutingFeesDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
7271 LDKCResult_RoutingFeesDecodeErrorZ* orig_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)(orig & ~1);
7272 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
7273 *ret_conv = CResult_RoutingFeesDecodeErrorZ_clone(orig_conv);
7274 return (long)ret_conv;
7277 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1NetAddressZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
7278 LDKCVec_NetAddressZ _res_constr;
7279 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
7280 if (_res_constr.datalen > 0)
7281 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
7283 _res_constr.data = NULL;
7284 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
7285 for (size_t m = 0; m < _res_constr.datalen; m++) {
7286 int64_t _res_conv_12 = _res_vals[m];
7287 LDKNetAddress _res_conv_12_conv = *(LDKNetAddress*)(((uint64_t)_res_conv_12) & ~1);
7288 FREE((void*)_res_conv_12);
7289 _res_constr.data[m] = _res_conv_12_conv;
7291 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
7292 CVec_NetAddressZ_free(_res_constr);
7295 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementInfoDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
7296 LDKNodeAnnouncementInfo o_conv;
7297 o_conv.inner = (void*)(o & (~1));
7298 o_conv.is_owned = (o & 1) || (o == 0);
7299 o_conv = NodeAnnouncementInfo_clone(&o_conv);
7300 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
7301 *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o_conv);
7302 return (long)ret_conv;
7305 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementInfoDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
7306 LDKDecodeError e_conv;
7307 e_conv.inner = (void*)(e & (~1));
7308 e_conv.is_owned = (e & 1) || (e == 0);
7309 e_conv = DecodeError_clone(&e_conv);
7310 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
7311 *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_err(e_conv);
7312 return (long)ret_conv;
7315 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementInfoDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
7316 if ((_res & 1) != 0) return;
7317 LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res_conv = *(LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(((uint64_t)_res) & ~1);
7319 CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res_conv);
7322 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementInfoDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
7323 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* orig_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(orig & ~1);
7324 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
7325 *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig_conv);
7326 return (long)ret_conv;
7329 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1u64Z_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
7330 LDKCVec_u64Z _res_constr;
7331 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
7332 if (_res_constr.datalen > 0)
7333 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
7335 _res_constr.data = NULL;
7336 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
7337 for (size_t g = 0; g < _res_constr.datalen; g++) {
7338 int64_t _res_conv_6 = _res_vals[g];
7339 _res_constr.data[g] = _res_conv_6;
7341 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
7342 CVec_u64Z_free(_res_constr);
7345 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeInfoDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
7347 o_conv.inner = (void*)(o & (~1));
7348 o_conv.is_owned = (o & 1) || (o == 0);
7349 o_conv = NodeInfo_clone(&o_conv);
7350 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
7351 *ret_conv = CResult_NodeInfoDecodeErrorZ_ok(o_conv);
7352 return (long)ret_conv;
7355 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeInfoDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
7356 LDKDecodeError e_conv;
7357 e_conv.inner = (void*)(e & (~1));
7358 e_conv.is_owned = (e & 1) || (e == 0);
7359 e_conv = DecodeError_clone(&e_conv);
7360 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
7361 *ret_conv = CResult_NodeInfoDecodeErrorZ_err(e_conv);
7362 return (long)ret_conv;
7365 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NodeInfoDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
7366 if ((_res & 1) != 0) return;
7367 LDKCResult_NodeInfoDecodeErrorZ _res_conv = *(LDKCResult_NodeInfoDecodeErrorZ*)(((uint64_t)_res) & ~1);
7369 CResult_NodeInfoDecodeErrorZ_free(_res_conv);
7372 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeInfoDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
7373 LDKCResult_NodeInfoDecodeErrorZ* orig_conv = (LDKCResult_NodeInfoDecodeErrorZ*)(orig & ~1);
7374 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
7375 *ret_conv = CResult_NodeInfoDecodeErrorZ_clone(orig_conv);
7376 return (long)ret_conv;
7379 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NetworkGraphDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
7380 LDKNetworkGraph o_conv;
7381 o_conv.inner = (void*)(o & (~1));
7382 o_conv.is_owned = (o & 1) || (o == 0);
7383 o_conv = NetworkGraph_clone(&o_conv);
7384 LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
7385 *ret_conv = CResult_NetworkGraphDecodeErrorZ_ok(o_conv);
7386 return (long)ret_conv;
7389 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NetworkGraphDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
7390 LDKDecodeError e_conv;
7391 e_conv.inner = (void*)(e & (~1));
7392 e_conv.is_owned = (e & 1) || (e == 0);
7393 e_conv = DecodeError_clone(&e_conv);
7394 LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
7395 *ret_conv = CResult_NetworkGraphDecodeErrorZ_err(e_conv);
7396 return (long)ret_conv;
7399 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NetworkGraphDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
7400 if ((_res & 1) != 0) return;
7401 LDKCResult_NetworkGraphDecodeErrorZ _res_conv = *(LDKCResult_NetworkGraphDecodeErrorZ*)(((uint64_t)_res) & ~1);
7403 CResult_NetworkGraphDecodeErrorZ_free(_res_conv);
7406 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NetworkGraphDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
7407 LDKCResult_NetworkGraphDecodeErrorZ* orig_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)(orig & ~1);
7408 LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
7409 *ret_conv = CResult_NetworkGraphDecodeErrorZ_clone(orig_conv);
7410 return (long)ret_conv;
7413 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1usizeTransactionZ_1new(JNIEnv *env, jclass clz, int64_t a, int8_tArray b) {
7414 LDKTransaction b_ref;
7415 b_ref.datalen = (*env)->GetArrayLength(env, b);
7416 b_ref.data = MALLOC(b_ref.datalen, "LDKTransaction Bytes");
7417 (*env)->GetByteArrayRegion(env, b, 0, b_ref.datalen, b_ref.data);
7418 b_ref.data_is_owned = true;
7419 LDKC2Tuple_usizeTransactionZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
7420 *ret_ref = C2Tuple_usizeTransactionZ_new(a, b_ref);
7421 return (long)ret_ref;
7424 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_C2Tuple_1usizeTransactionZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
7425 if ((_res & 1) != 0) return;
7426 LDKC2Tuple_usizeTransactionZ _res_conv = *(LDKC2Tuple_usizeTransactionZ*)(((uint64_t)_res) & ~1);
7428 C2Tuple_usizeTransactionZ_free(_res_conv);
7431 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1C2Tuple_1usizeTransactionZZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
7432 LDKCVec_C2Tuple_usizeTransactionZZ _res_constr;
7433 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
7434 if (_res_constr.datalen > 0)
7435 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
7437 _res_constr.data = NULL;
7438 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
7439 for (size_t y = 0; y < _res_constr.datalen; y++) {
7440 int64_t _res_conv_24 = _res_vals[y];
7441 LDKC2Tuple_usizeTransactionZ _res_conv_24_conv = *(LDKC2Tuple_usizeTransactionZ*)(((uint64_t)_res_conv_24) & ~1);
7442 FREE((void*)_res_conv_24);
7443 _res_constr.data[y] = _res_conv_24_conv;
7445 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
7446 CVec_C2Tuple_usizeTransactionZZ_free(_res_constr);
7449 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneChannelMonitorUpdateErrZ_1ok(JNIEnv *env, jclass clz) {
7450 LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
7451 *ret_conv = CResult_NoneChannelMonitorUpdateErrZ_ok();
7452 return (long)ret_conv;
7455 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneChannelMonitorUpdateErrZ_1err(JNIEnv *env, jclass clz, jclass e) {
7456 LDKChannelMonitorUpdateErr e_conv = LDKChannelMonitorUpdateErr_from_java(env, e);
7457 LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
7458 *ret_conv = CResult_NoneChannelMonitorUpdateErrZ_err(e_conv);
7459 return (long)ret_conv;
7462 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneChannelMonitorUpdateErrZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
7463 if ((_res & 1) != 0) return;
7464 LDKCResult_NoneChannelMonitorUpdateErrZ _res_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)_res) & ~1);
7466 CResult_NoneChannelMonitorUpdateErrZ_free(_res_conv);
7469 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneChannelMonitorUpdateErrZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
7470 LDKCResult_NoneChannelMonitorUpdateErrZ* orig_conv = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(orig & ~1);
7471 LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
7472 *ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone(orig_conv);
7473 return (long)ret_conv;
7476 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1MonitorEventZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
7477 LDKCVec_MonitorEventZ _res_constr;
7478 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
7479 if (_res_constr.datalen > 0)
7480 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKMonitorEvent), "LDKCVec_MonitorEventZ Elements");
7482 _res_constr.data = NULL;
7483 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
7484 for (size_t o = 0; o < _res_constr.datalen; o++) {
7485 int64_t _res_conv_14 = _res_vals[o];
7486 LDKMonitorEvent _res_conv_14_conv = *(LDKMonitorEvent*)(((uint64_t)_res_conv_14) & ~1);
7487 FREE((void*)_res_conv_14);
7488 _res_constr.data[o] = _res_conv_14_conv;
7490 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
7491 CVec_MonitorEventZ_free(_res_constr);
7494 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1EventZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
7495 LDKCVec_EventZ _res_constr;
7496 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
7497 if (_res_constr.datalen > 0)
7498 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKEvent), "LDKCVec_EventZ Elements");
7500 _res_constr.data = NULL;
7501 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
7502 for (size_t h = 0; h < _res_constr.datalen; h++) {
7503 int64_t _res_conv_7 = _res_vals[h];
7504 LDKEvent _res_conv_7_conv = *(LDKEvent*)(((uint64_t)_res_conv_7) & ~1);
7505 FREE((void*)_res_conv_7);
7506 _res_constr.data[h] = _res_conv_7_conv;
7508 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
7509 CVec_EventZ_free(_res_constr);
7512 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1OutPointDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
7514 o_conv.inner = (void*)(o & (~1));
7515 o_conv.is_owned = (o & 1) || (o == 0);
7516 o_conv = OutPoint_clone(&o_conv);
7517 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
7518 *ret_conv = CResult_OutPointDecodeErrorZ_ok(o_conv);
7519 return (long)ret_conv;
7522 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1OutPointDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
7523 LDKDecodeError e_conv;
7524 e_conv.inner = (void*)(e & (~1));
7525 e_conv.is_owned = (e & 1) || (e == 0);
7526 e_conv = DecodeError_clone(&e_conv);
7527 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
7528 *ret_conv = CResult_OutPointDecodeErrorZ_err(e_conv);
7529 return (long)ret_conv;
7532 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1OutPointDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
7533 if ((_res & 1) != 0) return;
7534 LDKCResult_OutPointDecodeErrorZ _res_conv = *(LDKCResult_OutPointDecodeErrorZ*)(((uint64_t)_res) & ~1);
7536 CResult_OutPointDecodeErrorZ_free(_res_conv);
7539 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1OutPointDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
7540 LDKCResult_OutPointDecodeErrorZ* orig_conv = (LDKCResult_OutPointDecodeErrorZ*)(orig & ~1);
7541 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
7542 *ret_conv = CResult_OutPointDecodeErrorZ_clone(orig_conv);
7543 return (long)ret_conv;
7546 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelMonitorUpdateDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
7547 LDKChannelMonitorUpdate o_conv;
7548 o_conv.inner = (void*)(o & (~1));
7549 o_conv.is_owned = (o & 1) || (o == 0);
7550 o_conv = ChannelMonitorUpdate_clone(&o_conv);
7551 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
7552 *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o_conv);
7553 return (long)ret_conv;
7556 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelMonitorUpdateDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
7557 LDKDecodeError e_conv;
7558 e_conv.inner = (void*)(e & (~1));
7559 e_conv.is_owned = (e & 1) || (e == 0);
7560 e_conv = DecodeError_clone(&e_conv);
7561 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
7562 *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_err(e_conv);
7563 return (long)ret_conv;
7566 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelMonitorUpdateDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
7567 if ((_res & 1) != 0) return;
7568 LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res_conv = *(LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(((uint64_t)_res) & ~1);
7570 CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res_conv);
7573 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelMonitorUpdateDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
7574 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* orig_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(orig & ~1);
7575 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
7576 *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig_conv);
7577 return (long)ret_conv;
7580 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCUpdateDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
7581 LDKHTLCUpdate o_conv;
7582 o_conv.inner = (void*)(o & (~1));
7583 o_conv.is_owned = (o & 1) || (o == 0);
7584 o_conv = HTLCUpdate_clone(&o_conv);
7585 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
7586 *ret_conv = CResult_HTLCUpdateDecodeErrorZ_ok(o_conv);
7587 return (long)ret_conv;
7590 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCUpdateDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
7591 LDKDecodeError e_conv;
7592 e_conv.inner = (void*)(e & (~1));
7593 e_conv.is_owned = (e & 1) || (e == 0);
7594 e_conv = DecodeError_clone(&e_conv);
7595 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
7596 *ret_conv = CResult_HTLCUpdateDecodeErrorZ_err(e_conv);
7597 return (long)ret_conv;
7600 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCUpdateDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
7601 if ((_res & 1) != 0) return;
7602 LDKCResult_HTLCUpdateDecodeErrorZ _res_conv = *(LDKCResult_HTLCUpdateDecodeErrorZ*)(((uint64_t)_res) & ~1);
7604 CResult_HTLCUpdateDecodeErrorZ_free(_res_conv);
7607 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCUpdateDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
7608 LDKCResult_HTLCUpdateDecodeErrorZ* orig_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)(orig & ~1);
7609 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
7610 *ret_conv = CResult_HTLCUpdateDecodeErrorZ_clone(orig_conv);
7611 return (long)ret_conv;
7614 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneMonitorUpdateErrorZ_1ok(JNIEnv *env, jclass clz) {
7615 LDKCResult_NoneMonitorUpdateErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneMonitorUpdateErrorZ), "LDKCResult_NoneMonitorUpdateErrorZ");
7616 *ret_conv = CResult_NoneMonitorUpdateErrorZ_ok();
7617 return (long)ret_conv;
7620 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneMonitorUpdateErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
7621 LDKMonitorUpdateError e_conv;
7622 e_conv.inner = (void*)(e & (~1));
7623 e_conv.is_owned = (e & 1) || (e == 0);
7624 e_conv = MonitorUpdateError_clone(&e_conv);
7625 LDKCResult_NoneMonitorUpdateErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneMonitorUpdateErrorZ), "LDKCResult_NoneMonitorUpdateErrorZ");
7626 *ret_conv = CResult_NoneMonitorUpdateErrorZ_err(e_conv);
7627 return (long)ret_conv;
7630 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneMonitorUpdateErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
7631 if ((_res & 1) != 0) return;
7632 LDKCResult_NoneMonitorUpdateErrorZ _res_conv = *(LDKCResult_NoneMonitorUpdateErrorZ*)(((uint64_t)_res) & ~1);
7634 CResult_NoneMonitorUpdateErrorZ_free(_res_conv);
7637 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneMonitorUpdateErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
7638 LDKCResult_NoneMonitorUpdateErrorZ* orig_conv = (LDKCResult_NoneMonitorUpdateErrorZ*)(orig & ~1);
7639 LDKCResult_NoneMonitorUpdateErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneMonitorUpdateErrorZ), "LDKCResult_NoneMonitorUpdateErrorZ");
7640 *ret_conv = CResult_NoneMonitorUpdateErrorZ_clone(orig_conv);
7641 return (long)ret_conv;
7644 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1OutPointScriptZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
7645 LDKC2Tuple_OutPointScriptZ* orig_conv = (LDKC2Tuple_OutPointScriptZ*)(orig & ~1);
7646 LDKC2Tuple_OutPointScriptZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
7647 *ret_ref = C2Tuple_OutPointScriptZ_clone(orig_conv);
7648 return (long)ret_ref;
7651 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1OutPointScriptZ_1new(JNIEnv *env, jclass clz, int64_t a, int8_tArray b) {
7653 a_conv.inner = (void*)(a & (~1));
7654 a_conv.is_owned = (a & 1) || (a == 0);
7655 a_conv = OutPoint_clone(&a_conv);
7657 b_ref.datalen = (*env)->GetArrayLength(env, b);
7658 b_ref.data = MALLOC(b_ref.datalen, "LDKCVec_u8Z Bytes");
7659 (*env)->GetByteArrayRegion(env, b, 0, b_ref.datalen, b_ref.data);
7660 LDKC2Tuple_OutPointScriptZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
7661 *ret_ref = C2Tuple_OutPointScriptZ_new(a_conv, b_ref);
7662 return (long)ret_ref;
7665 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_C2Tuple_1OutPointScriptZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
7666 if ((_res & 1) != 0) return;
7667 LDKC2Tuple_OutPointScriptZ _res_conv = *(LDKC2Tuple_OutPointScriptZ*)(((uint64_t)_res) & ~1);
7669 C2Tuple_OutPointScriptZ_free(_res_conv);
7672 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1u32ScriptZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
7673 LDKC2Tuple_u32ScriptZ* orig_conv = (LDKC2Tuple_u32ScriptZ*)(orig & ~1);
7674 LDKC2Tuple_u32ScriptZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
7675 *ret_ref = C2Tuple_u32ScriptZ_clone(orig_conv);
7676 return (long)ret_ref;
7679 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1u32ScriptZ_1new(JNIEnv *env, jclass clz, int32_t a, int8_tArray b) {
7681 b_ref.datalen = (*env)->GetArrayLength(env, b);
7682 b_ref.data = MALLOC(b_ref.datalen, "LDKCVec_u8Z Bytes");
7683 (*env)->GetByteArrayRegion(env, b, 0, b_ref.datalen, b_ref.data);
7684 LDKC2Tuple_u32ScriptZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
7685 *ret_ref = C2Tuple_u32ScriptZ_new(a, b_ref);
7686 return (long)ret_ref;
7689 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_C2Tuple_1u32ScriptZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
7690 if ((_res & 1) != 0) return;
7691 LDKC2Tuple_u32ScriptZ _res_conv = *(LDKC2Tuple_u32ScriptZ*)(((uint64_t)_res) & ~1);
7693 C2Tuple_u32ScriptZ_free(_res_conv);
7696 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1C2Tuple_1u32ScriptZZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
7697 LDKCVec_C2Tuple_u32ScriptZZ _res_constr;
7698 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
7699 if (_res_constr.datalen > 0)
7700 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_u32ScriptZ), "LDKCVec_C2Tuple_u32ScriptZZ Elements");
7702 _res_constr.data = NULL;
7703 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
7704 for (size_t b = 0; b < _res_constr.datalen; b++) {
7705 int64_t _res_conv_27 = _res_vals[b];
7706 LDKC2Tuple_u32ScriptZ _res_conv_27_conv = *(LDKC2Tuple_u32ScriptZ*)(((uint64_t)_res_conv_27) & ~1);
7707 FREE((void*)_res_conv_27);
7708 _res_constr.data[b] = _res_conv_27_conv;
7710 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
7711 CVec_C2Tuple_u32ScriptZZ_free(_res_constr);
7714 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1TxidCVec_1C2Tuple_1u32ScriptZZZ_1new(JNIEnv *env, jclass clz, int8_tArray a, int64_tArray b) {
7715 LDKThirtyTwoBytes a_ref;
7716 CHECK((*env)->GetArrayLength(env, a) == 32);
7717 (*env)->GetByteArrayRegion(env, a, 0, 32, a_ref.data);
7718 LDKCVec_C2Tuple_u32ScriptZZ b_constr;
7719 b_constr.datalen = (*env)->GetArrayLength(env, b);
7720 if (b_constr.datalen > 0)
7721 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKC2Tuple_u32ScriptZ), "LDKCVec_C2Tuple_u32ScriptZZ Elements");
7723 b_constr.data = NULL;
7724 int64_t* b_vals = (*env)->GetLongArrayElements (env, b, NULL);
7725 for (size_t b = 0; b < b_constr.datalen; b++) {
7726 int64_t b_conv_27 = b_vals[b];
7727 LDKC2Tuple_u32ScriptZ b_conv_27_conv = *(LDKC2Tuple_u32ScriptZ*)(((uint64_t)b_conv_27) & ~1);
7728 FREE((void*)b_conv_27);
7729 b_constr.data[b] = b_conv_27_conv;
7731 (*env)->ReleaseLongArrayElements(env, b, b_vals, 0);
7732 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
7733 *ret_ref = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a_ref, b_constr);
7734 return (long)ret_ref;
7737 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_C2Tuple_1TxidCVec_1C2Tuple_1u32ScriptZZZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
7738 if ((_res & 1) != 0) return;
7739 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(((uint64_t)_res) & ~1);
7741 C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res_conv);
7744 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1C2Tuple_1TxidCVec_1C2Tuple_1u32ScriptZZZZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
7745 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ _res_constr;
7746 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
7747 if (_res_constr.datalen > 0)
7748 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ Elements");
7750 _res_constr.data = NULL;
7751 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
7752 for (size_t v = 0; v < _res_constr.datalen; v++) {
7753 int64_t _res_conv_47 = _res_vals[v];
7754 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res_conv_47_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(((uint64_t)_res_conv_47) & ~1);
7755 FREE((void*)_res_conv_47);
7756 _res_constr.data[v] = _res_conv_47_conv;
7758 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
7759 CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res_constr);
7762 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1TransactionZ_1free(JNIEnv *env, jclass clz, jobjectArray _res) {
7763 LDKCVec_TransactionZ _res_constr;
7764 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
7765 if (_res_constr.datalen > 0)
7766 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKTransaction), "LDKCVec_TransactionZ Elements");
7768 _res_constr.data = NULL;
7769 for (size_t i = 0; i < _res_constr.datalen; i++) {
7770 int8_tArray _res_conv_8 = (*env)->GetObjectArrayElement(env, _res, i);
7771 LDKTransaction _res_conv_8_ref;
7772 _res_conv_8_ref.datalen = (*env)->GetArrayLength(env, _res_conv_8);
7773 _res_conv_8_ref.data = MALLOC(_res_conv_8_ref.datalen, "LDKTransaction Bytes");
7774 (*env)->GetByteArrayRegion(env, _res_conv_8, 0, _res_conv_8_ref.datalen, _res_conv_8_ref.data);
7775 _res_conv_8_ref.data_is_owned = true;
7776 _res_constr.data[i] = _res_conv_8_ref;
7778 CVec_TransactionZ_free(_res_constr);
7781 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1u32TxOutZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
7782 LDKC2Tuple_u32TxOutZ* orig_conv = (LDKC2Tuple_u32TxOutZ*)(orig & ~1);
7783 LDKC2Tuple_u32TxOutZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
7784 *ret_ref = C2Tuple_u32TxOutZ_clone(orig_conv);
7785 return (long)ret_ref;
7788 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1u32TxOutZ_1new(JNIEnv *env, jclass clz, int32_t a, int64_t b) {
7789 LDKTxOut b_conv = *(LDKTxOut*)(((uint64_t)b) & ~1);
7791 LDKC2Tuple_u32TxOutZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
7792 *ret_ref = C2Tuple_u32TxOutZ_new(a, b_conv);
7793 return (long)ret_ref;
7796 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_C2Tuple_1u32TxOutZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
7797 if ((_res & 1) != 0) return;
7798 LDKC2Tuple_u32TxOutZ _res_conv = *(LDKC2Tuple_u32TxOutZ*)(((uint64_t)_res) & ~1);
7800 C2Tuple_u32TxOutZ_free(_res_conv);
7803 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1C2Tuple_1u32TxOutZZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
7804 LDKCVec_C2Tuple_u32TxOutZZ _res_constr;
7805 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
7806 if (_res_constr.datalen > 0)
7807 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_u32TxOutZ), "LDKCVec_C2Tuple_u32TxOutZZ Elements");
7809 _res_constr.data = NULL;
7810 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
7811 for (size_t a = 0; a < _res_constr.datalen; a++) {
7812 int64_t _res_conv_26 = _res_vals[a];
7813 LDKC2Tuple_u32TxOutZ _res_conv_26_conv = *(LDKC2Tuple_u32TxOutZ*)(((uint64_t)_res_conv_26) & ~1);
7814 FREE((void*)_res_conv_26);
7815 _res_constr.data[a] = _res_conv_26_conv;
7817 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
7818 CVec_C2Tuple_u32TxOutZZ_free(_res_constr);
7821 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1TxidCVec_1C2Tuple_1u32TxOutZZZ_1new(JNIEnv *env, jclass clz, int8_tArray a, int64_tArray b) {
7822 LDKThirtyTwoBytes a_ref;
7823 CHECK((*env)->GetArrayLength(env, a) == 32);
7824 (*env)->GetByteArrayRegion(env, a, 0, 32, a_ref.data);
7825 LDKCVec_C2Tuple_u32TxOutZZ b_constr;
7826 b_constr.datalen = (*env)->GetArrayLength(env, b);
7827 if (b_constr.datalen > 0)
7828 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKC2Tuple_u32TxOutZ), "LDKCVec_C2Tuple_u32TxOutZZ Elements");
7830 b_constr.data = NULL;
7831 int64_t* b_vals = (*env)->GetLongArrayElements (env, b, NULL);
7832 for (size_t a = 0; a < b_constr.datalen; a++) {
7833 int64_t b_conv_26 = b_vals[a];
7834 LDKC2Tuple_u32TxOutZ b_conv_26_conv = *(LDKC2Tuple_u32TxOutZ*)(((uint64_t)b_conv_26) & ~1);
7835 FREE((void*)b_conv_26);
7836 b_constr.data[a] = b_conv_26_conv;
7838 (*env)->ReleaseLongArrayElements(env, b, b_vals, 0);
7839 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
7840 *ret_ref = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a_ref, b_constr);
7841 return (long)ret_ref;
7844 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_C2Tuple_1TxidCVec_1C2Tuple_1u32TxOutZZZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
7845 if ((_res & 1) != 0) return;
7846 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(((uint64_t)_res) & ~1);
7848 C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res_conv);
7851 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1C2Tuple_1TxidCVec_1C2Tuple_1u32TxOutZZZZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
7852 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ _res_constr;
7853 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
7854 if (_res_constr.datalen > 0)
7855 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ Elements");
7857 _res_constr.data = NULL;
7858 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
7859 for (size_t u = 0; u < _res_constr.datalen; u++) {
7860 int64_t _res_conv_46 = _res_vals[u];
7861 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res_conv_46_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(((uint64_t)_res_conv_46) & ~1);
7862 FREE((void*)_res_conv_46);
7863 _res_constr.data[u] = _res_conv_46_conv;
7865 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
7866 CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res_constr);
7869 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1BlockHashChannelMonitorZ_1new(JNIEnv *env, jclass clz, int8_tArray a, int64_t b) {
7870 LDKThirtyTwoBytes a_ref;
7871 CHECK((*env)->GetArrayLength(env, a) == 32);
7872 (*env)->GetByteArrayRegion(env, a, 0, 32, a_ref.data);
7873 LDKChannelMonitor b_conv;
7874 b_conv.inner = (void*)(b & (~1));
7875 b_conv.is_owned = (b & 1) || (b == 0);
7876 b_conv = ChannelMonitor_clone(&b_conv);
7877 LDKC2Tuple_BlockHashChannelMonitorZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
7878 *ret_ref = C2Tuple_BlockHashChannelMonitorZ_new(a_ref, b_conv);
7879 return (long)ret_ref;
7882 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_C2Tuple_1BlockHashChannelMonitorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
7883 if ((_res & 1) != 0) return;
7884 LDKC2Tuple_BlockHashChannelMonitorZ _res_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(((uint64_t)_res) & ~1);
7886 C2Tuple_BlockHashChannelMonitorZ_free(_res_conv);
7889 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1BlockHashChannelMonitorZDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
7890 LDKC2Tuple_BlockHashChannelMonitorZ o_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(((uint64_t)o) & ~1);
7892 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
7893 *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o_conv);
7894 return (long)ret_conv;
7897 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1BlockHashChannelMonitorZDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
7898 LDKDecodeError e_conv;
7899 e_conv.inner = (void*)(e & (~1));
7900 e_conv.is_owned = (e & 1) || (e == 0);
7901 e_conv = DecodeError_clone(&e_conv);
7902 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
7903 *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e_conv);
7904 return (long)ret_conv;
7907 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1BlockHashChannelMonitorZDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
7908 if ((_res & 1) != 0) return;
7909 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ _res_conv = *(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(((uint64_t)_res) & ~1);
7911 CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res_conv);
7914 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1SpendableOutputDescriptorZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
7915 LDKCVec_SpendableOutputDescriptorZ _res_constr;
7916 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
7917 if (_res_constr.datalen > 0)
7918 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKSpendableOutputDescriptor), "LDKCVec_SpendableOutputDescriptorZ Elements");
7920 _res_constr.data = NULL;
7921 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
7922 for (size_t b = 0; b < _res_constr.datalen; b++) {
7923 int64_t _res_conv_27 = _res_vals[b];
7924 LDKSpendableOutputDescriptor _res_conv_27_conv = *(LDKSpendableOutputDescriptor*)(((uint64_t)_res_conv_27) & ~1);
7925 FREE((void*)_res_conv_27);
7926 _res_constr.data[b] = _res_conv_27_conv;
7928 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
7929 CVec_SpendableOutputDescriptorZ_free(_res_constr);
7932 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TxOutAccessErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
7933 LDKTxOut o_conv = *(LDKTxOut*)(((uint64_t)o) & ~1);
7935 LDKCResult_TxOutAccessErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutAccessErrorZ), "LDKCResult_TxOutAccessErrorZ");
7936 *ret_conv = CResult_TxOutAccessErrorZ_ok(o_conv);
7937 return (long)ret_conv;
7940 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TxOutAccessErrorZ_1err(JNIEnv *env, jclass clz, jclass e) {
7941 LDKAccessError e_conv = LDKAccessError_from_java(env, e);
7942 LDKCResult_TxOutAccessErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutAccessErrorZ), "LDKCResult_TxOutAccessErrorZ");
7943 *ret_conv = CResult_TxOutAccessErrorZ_err(e_conv);
7944 return (long)ret_conv;
7947 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1TxOutAccessErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
7948 if ((_res & 1) != 0) return;
7949 LDKCResult_TxOutAccessErrorZ _res_conv = *(LDKCResult_TxOutAccessErrorZ*)(((uint64_t)_res) & ~1);
7951 CResult_TxOutAccessErrorZ_free(_res_conv);
7954 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TxOutAccessErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
7955 LDKCResult_TxOutAccessErrorZ* orig_conv = (LDKCResult_TxOutAccessErrorZ*)(orig & ~1);
7956 LDKCResult_TxOutAccessErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutAccessErrorZ), "LDKCResult_TxOutAccessErrorZ");
7957 *ret_conv = CResult_TxOutAccessErrorZ_clone(orig_conv);
7958 return (long)ret_conv;
7961 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneAPIErrorZ_1ok(JNIEnv *env, jclass clz) {
7962 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
7963 *ret_conv = CResult_NoneAPIErrorZ_ok();
7964 return (long)ret_conv;
7967 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneAPIErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
7968 LDKAPIError e_conv = *(LDKAPIError*)(((uint64_t)e) & ~1);
7970 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
7971 *ret_conv = CResult_NoneAPIErrorZ_err(e_conv);
7972 return (long)ret_conv;
7975 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneAPIErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
7976 if ((_res & 1) != 0) return;
7977 LDKCResult_NoneAPIErrorZ _res_conv = *(LDKCResult_NoneAPIErrorZ*)(((uint64_t)_res) & ~1);
7979 CResult_NoneAPIErrorZ_free(_res_conv);
7982 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneAPIErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
7983 LDKCResult_NoneAPIErrorZ* orig_conv = (LDKCResult_NoneAPIErrorZ*)(orig & ~1);
7984 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
7985 *ret_conv = CResult_NoneAPIErrorZ_clone(orig_conv);
7986 return (long)ret_conv;
7989 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1CResult_1NoneAPIErrorZZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
7990 LDKCVec_CResult_NoneAPIErrorZZ _res_constr;
7991 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
7992 if (_res_constr.datalen > 0)
7993 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKCResult_NoneAPIErrorZ), "LDKCVec_CResult_NoneAPIErrorZZ Elements");
7995 _res_constr.data = NULL;
7996 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
7997 for (size_t w = 0; w < _res_constr.datalen; w++) {
7998 int64_t _res_conv_22 = _res_vals[w];
7999 LDKCResult_NoneAPIErrorZ _res_conv_22_conv = *(LDKCResult_NoneAPIErrorZ*)(((uint64_t)_res_conv_22) & ~1);
8000 FREE((void*)_res_conv_22);
8001 _res_constr.data[w] = _res_conv_22_conv;
8003 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
8004 CVec_CResult_NoneAPIErrorZZ_free(_res_constr);
8007 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1APIErrorZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
8008 LDKCVec_APIErrorZ _res_constr;
8009 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
8010 if (_res_constr.datalen > 0)
8011 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKAPIError), "LDKCVec_APIErrorZ Elements");
8013 _res_constr.data = NULL;
8014 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
8015 for (size_t k = 0; k < _res_constr.datalen; k++) {
8016 int64_t _res_conv_10 = _res_vals[k];
8017 LDKAPIError _res_conv_10_conv = *(LDKAPIError*)(((uint64_t)_res_conv_10) & ~1);
8018 FREE((void*)_res_conv_10);
8019 _res_constr.data[k] = _res_conv_10_conv;
8021 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
8022 CVec_APIErrorZ_free(_res_constr);
8025 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1ChannelDetailsZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
8026 LDKCVec_ChannelDetailsZ _res_constr;
8027 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
8028 if (_res_constr.datalen > 0)
8029 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
8031 _res_constr.data = NULL;
8032 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
8033 for (size_t q = 0; q < _res_constr.datalen; q++) {
8034 int64_t _res_conv_16 = _res_vals[q];
8035 LDKChannelDetails _res_conv_16_conv;
8036 _res_conv_16_conv.inner = (void*)(_res_conv_16 & (~1));
8037 _res_conv_16_conv.is_owned = (_res_conv_16 & 1) || (_res_conv_16 == 0);
8038 _res_constr.data[q] = _res_conv_16_conv;
8040 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
8041 CVec_ChannelDetailsZ_free(_res_constr);
8044 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NonePaymentSendFailureZ_1ok(JNIEnv *env, jclass clz) {
8045 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
8046 *ret_conv = CResult_NonePaymentSendFailureZ_ok();
8047 return (long)ret_conv;
8050 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NonePaymentSendFailureZ_1err(JNIEnv *env, jclass clz, int64_t e) {
8051 LDKPaymentSendFailure e_conv = *(LDKPaymentSendFailure*)(((uint64_t)e) & ~1);
8053 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
8054 *ret_conv = CResult_NonePaymentSendFailureZ_err(e_conv);
8055 return (long)ret_conv;
8058 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NonePaymentSendFailureZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
8059 if ((_res & 1) != 0) return;
8060 LDKCResult_NonePaymentSendFailureZ _res_conv = *(LDKCResult_NonePaymentSendFailureZ*)(((uint64_t)_res) & ~1);
8062 CResult_NonePaymentSendFailureZ_free(_res_conv);
8065 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NonePaymentSendFailureZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
8066 LDKCResult_NonePaymentSendFailureZ* orig_conv = (LDKCResult_NonePaymentSendFailureZ*)(orig & ~1);
8067 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
8068 *ret_conv = CResult_NonePaymentSendFailureZ_clone(orig_conv);
8069 return (long)ret_conv;
8072 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1ChannelMonitorZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
8073 LDKCVec_ChannelMonitorZ _res_constr;
8074 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
8075 if (_res_constr.datalen > 0)
8076 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKChannelMonitor), "LDKCVec_ChannelMonitorZ Elements");
8078 _res_constr.data = NULL;
8079 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
8080 for (size_t q = 0; q < _res_constr.datalen; q++) {
8081 int64_t _res_conv_16 = _res_vals[q];
8082 LDKChannelMonitor _res_conv_16_conv;
8083 _res_conv_16_conv.inner = (void*)(_res_conv_16 & (~1));
8084 _res_conv_16_conv.is_owned = (_res_conv_16 & 1) || (_res_conv_16 == 0);
8085 _res_constr.data[q] = _res_conv_16_conv;
8087 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
8088 CVec_ChannelMonitorZ_free(_res_constr);
8091 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1BlockHashChannelManagerZ_1new(JNIEnv *env, jclass clz, int8_tArray a, int64_t b) {
8092 LDKThirtyTwoBytes a_ref;
8093 CHECK((*env)->GetArrayLength(env, a) == 32);
8094 (*env)->GetByteArrayRegion(env, a, 0, 32, a_ref.data);
8095 LDKChannelManager b_conv;
8096 b_conv.inner = (void*)(b & (~1));
8097 b_conv.is_owned = (b & 1) || (b == 0);
8098 // Warning: we need a move here but no clone is available for LDKChannelManager
8099 LDKC2Tuple_BlockHashChannelManagerZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelManagerZ), "LDKC2Tuple_BlockHashChannelManagerZ");
8100 *ret_ref = C2Tuple_BlockHashChannelManagerZ_new(a_ref, b_conv);
8101 return (long)ret_ref;
8104 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_C2Tuple_1BlockHashChannelManagerZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
8105 if ((_res & 1) != 0) return;
8106 LDKC2Tuple_BlockHashChannelManagerZ _res_conv = *(LDKC2Tuple_BlockHashChannelManagerZ*)(((uint64_t)_res) & ~1);
8108 C2Tuple_BlockHashChannelManagerZ_free(_res_conv);
8111 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1BlockHashChannelManagerZDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
8112 LDKC2Tuple_BlockHashChannelManagerZ o_conv = *(LDKC2Tuple_BlockHashChannelManagerZ*)(((uint64_t)o) & ~1);
8114 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ");
8115 *ret_conv = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o_conv);
8116 return (long)ret_conv;
8119 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1BlockHashChannelManagerZDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
8120 LDKDecodeError e_conv;
8121 e_conv.inner = (void*)(e & (~1));
8122 e_conv.is_owned = (e & 1) || (e == 0);
8123 e_conv = DecodeError_clone(&e_conv);
8124 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ");
8125 *ret_conv = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e_conv);
8126 return (long)ret_conv;
8129 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1BlockHashChannelManagerZDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
8130 if ((_res & 1) != 0) return;
8131 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res_conv = *(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)(((uint64_t)_res) & ~1);
8133 CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res_conv);
8136 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SpendableOutputDescriptorDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
8137 LDKSpendableOutputDescriptor o_conv = *(LDKSpendableOutputDescriptor*)(((uint64_t)o) & ~1);
8139 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
8140 *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o_conv);
8141 return (long)ret_conv;
8144 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SpendableOutputDescriptorDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
8145 LDKDecodeError e_conv;
8146 e_conv.inner = (void*)(e & (~1));
8147 e_conv.is_owned = (e & 1) || (e == 0);
8148 e_conv = DecodeError_clone(&e_conv);
8149 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
8150 *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_err(e_conv);
8151 return (long)ret_conv;
8154 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1SpendableOutputDescriptorDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
8155 if ((_res & 1) != 0) return;
8156 LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res_conv = *(LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(((uint64_t)_res) & ~1);
8158 CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res_conv);
8161 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SpendableOutputDescriptorDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
8162 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(orig & ~1);
8163 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
8164 *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig_conv);
8165 return (long)ret_conv;
8168 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1SignatureCVec_1SignatureZZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
8169 LDKC2Tuple_SignatureCVec_SignatureZZ* orig_conv = (LDKC2Tuple_SignatureCVec_SignatureZZ*)(orig & ~1);
8170 LDKC2Tuple_SignatureCVec_SignatureZZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
8171 *ret_ref = C2Tuple_SignatureCVec_SignatureZZ_clone(orig_conv);
8172 return (long)ret_ref;
8175 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1SignatureCVec_1SignatureZZ_1new(JNIEnv *env, jclass clz, int8_tArray a, jobjectArray b) {
8177 CHECK((*env)->GetArrayLength(env, a) == 64);
8178 (*env)->GetByteArrayRegion(env, a, 0, 64, a_ref.compact_form);
8179 LDKCVec_SignatureZ b_constr;
8180 b_constr.datalen = (*env)->GetArrayLength(env, b);
8181 if (b_constr.datalen > 0)
8182 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
8184 b_constr.data = NULL;
8185 for (size_t i = 0; i < b_constr.datalen; i++) {
8186 int8_tArray b_conv_8 = (*env)->GetObjectArrayElement(env, b, i);
8187 LDKSignature b_conv_8_ref;
8188 CHECK((*env)->GetArrayLength(env, b_conv_8) == 64);
8189 (*env)->GetByteArrayRegion(env, b_conv_8, 0, 64, b_conv_8_ref.compact_form);
8190 b_constr.data[i] = b_conv_8_ref;
8192 LDKC2Tuple_SignatureCVec_SignatureZZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
8193 *ret_ref = C2Tuple_SignatureCVec_SignatureZZ_new(a_ref, b_constr);
8194 return (long)ret_ref;
8197 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_C2Tuple_1SignatureCVec_1SignatureZZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
8198 if ((_res & 1) != 0) return;
8199 LDKC2Tuple_SignatureCVec_SignatureZZ _res_conv = *(LDKC2Tuple_SignatureCVec_SignatureZZ*)(((uint64_t)_res) & ~1);
8201 C2Tuple_SignatureCVec_SignatureZZ_free(_res_conv);
8204 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1SignatureCVec_1SignatureZZNoneZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
8205 LDKC2Tuple_SignatureCVec_SignatureZZ o_conv = *(LDKC2Tuple_SignatureCVec_SignatureZZ*)(((uint64_t)o) & ~1);
8207 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
8208 *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o_conv);
8209 return (long)ret_conv;
8212 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1SignatureCVec_1SignatureZZNoneZ_1err(JNIEnv *env, jclass clz) {
8213 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
8214 *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err();
8215 return (long)ret_conv;
8218 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1SignatureCVec_1SignatureZZNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
8219 if ((_res & 1) != 0) return;
8220 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ _res_conv = *(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(((uint64_t)_res) & ~1);
8222 CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res_conv);
8225 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1SignatureCVec_1SignatureZZNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
8226 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* orig_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(orig & ~1);
8227 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
8228 *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig_conv);
8229 return (long)ret_conv;
8232 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SignatureNoneZ_1ok(JNIEnv *env, jclass clz, int8_tArray o) {
8234 CHECK((*env)->GetArrayLength(env, o) == 64);
8235 (*env)->GetByteArrayRegion(env, o, 0, 64, o_ref.compact_form);
8236 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
8237 *ret_conv = CResult_SignatureNoneZ_ok(o_ref);
8238 return (long)ret_conv;
8241 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SignatureNoneZ_1err(JNIEnv *env, jclass clz) {
8242 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
8243 *ret_conv = CResult_SignatureNoneZ_err();
8244 return (long)ret_conv;
8247 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1SignatureNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
8248 if ((_res & 1) != 0) return;
8249 LDKCResult_SignatureNoneZ _res_conv = *(LDKCResult_SignatureNoneZ*)(((uint64_t)_res) & ~1);
8251 CResult_SignatureNoneZ_free(_res_conv);
8254 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SignatureNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
8255 LDKCResult_SignatureNoneZ* orig_conv = (LDKCResult_SignatureNoneZ*)(orig & ~1);
8256 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
8257 *ret_conv = CResult_SignatureNoneZ_clone(orig_conv);
8258 return (long)ret_conv;
8261 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SignDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
8262 LDKSign o_conv = *(LDKSign*)(((uint64_t)o) & ~1);
8263 if (o_conv.free == LDKSign_JCalls_free) {
8264 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
8265 LDKSign_JCalls_clone(o_conv.this_arg);
8267 LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
8268 *ret_conv = CResult_SignDecodeErrorZ_ok(o_conv);
8269 return (long)ret_conv;
8272 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SignDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
8273 LDKDecodeError e_conv;
8274 e_conv.inner = (void*)(e & (~1));
8275 e_conv.is_owned = (e & 1) || (e == 0);
8276 e_conv = DecodeError_clone(&e_conv);
8277 LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
8278 *ret_conv = CResult_SignDecodeErrorZ_err(e_conv);
8279 return (long)ret_conv;
8282 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1SignDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
8283 if ((_res & 1) != 0) return;
8284 LDKCResult_SignDecodeErrorZ _res_conv = *(LDKCResult_SignDecodeErrorZ*)(((uint64_t)_res) & ~1);
8286 CResult_SignDecodeErrorZ_free(_res_conv);
8289 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SignDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
8290 LDKCResult_SignDecodeErrorZ* orig_conv = (LDKCResult_SignDecodeErrorZ*)(orig & ~1);
8291 LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
8292 *ret_conv = CResult_SignDecodeErrorZ_clone(orig_conv);
8293 return (long)ret_conv;
8296 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1CVec_1u8ZZ_1free(JNIEnv *env, jclass clz, jobjectArray _res) {
8297 LDKCVec_CVec_u8ZZ _res_constr;
8298 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
8299 if (_res_constr.datalen > 0)
8300 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKCVec_u8Z), "LDKCVec_CVec_u8ZZ Elements");
8302 _res_constr.data = NULL;
8303 for (size_t i = 0; i < _res_constr.datalen; i++) {
8304 int8_tArray _res_conv_8 = (*env)->GetObjectArrayElement(env, _res, i);
8305 LDKCVec_u8Z _res_conv_8_ref;
8306 _res_conv_8_ref.datalen = (*env)->GetArrayLength(env, _res_conv_8);
8307 _res_conv_8_ref.data = MALLOC(_res_conv_8_ref.datalen, "LDKCVec_u8Z Bytes");
8308 (*env)->GetByteArrayRegion(env, _res_conv_8, 0, _res_conv_8_ref.datalen, _res_conv_8_ref.data);
8309 _res_constr.data[i] = _res_conv_8_ref;
8311 CVec_CVec_u8ZZ_free(_res_constr);
8314 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1CVec_1u8ZZNoneZ_1ok(JNIEnv *env, jclass clz, jobjectArray o) {
8315 LDKCVec_CVec_u8ZZ o_constr;
8316 o_constr.datalen = (*env)->GetArrayLength(env, o);
8317 if (o_constr.datalen > 0)
8318 o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKCVec_u8Z), "LDKCVec_CVec_u8ZZ Elements");
8320 o_constr.data = NULL;
8321 for (size_t i = 0; i < o_constr.datalen; i++) {
8322 int8_tArray o_conv_8 = (*env)->GetObjectArrayElement(env, o, i);
8323 LDKCVec_u8Z o_conv_8_ref;
8324 o_conv_8_ref.datalen = (*env)->GetArrayLength(env, o_conv_8);
8325 o_conv_8_ref.data = MALLOC(o_conv_8_ref.datalen, "LDKCVec_u8Z Bytes");
8326 (*env)->GetByteArrayRegion(env, o_conv_8, 0, o_conv_8_ref.datalen, o_conv_8_ref.data);
8327 o_constr.data[i] = o_conv_8_ref;
8329 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
8330 *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_ok(o_constr);
8331 return (long)ret_conv;
8334 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1CVec_1u8ZZNoneZ_1err(JNIEnv *env, jclass clz) {
8335 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
8336 *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_err();
8337 return (long)ret_conv;
8340 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1CVec_1u8ZZNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
8341 if ((_res & 1) != 0) return;
8342 LDKCResult_CVec_CVec_u8ZZNoneZ _res_conv = *(LDKCResult_CVec_CVec_u8ZZNoneZ*)(((uint64_t)_res) & ~1);
8344 CResult_CVec_CVec_u8ZZNoneZ_free(_res_conv);
8347 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1CVec_1u8ZZNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
8348 LDKCResult_CVec_CVec_u8ZZNoneZ* orig_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)(orig & ~1);
8349 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
8350 *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_clone(orig_conv);
8351 return (long)ret_conv;
8354 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InMemorySignerDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
8355 LDKInMemorySigner o_conv;
8356 o_conv.inner = (void*)(o & (~1));
8357 o_conv.is_owned = (o & 1) || (o == 0);
8358 o_conv = InMemorySigner_clone(&o_conv);
8359 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
8360 *ret_conv = CResult_InMemorySignerDecodeErrorZ_ok(o_conv);
8361 return (long)ret_conv;
8364 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InMemorySignerDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
8365 LDKDecodeError e_conv;
8366 e_conv.inner = (void*)(e & (~1));
8367 e_conv.is_owned = (e & 1) || (e == 0);
8368 e_conv = DecodeError_clone(&e_conv);
8369 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
8370 *ret_conv = CResult_InMemorySignerDecodeErrorZ_err(e_conv);
8371 return (long)ret_conv;
8374 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1InMemorySignerDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
8375 if ((_res & 1) != 0) return;
8376 LDKCResult_InMemorySignerDecodeErrorZ _res_conv = *(LDKCResult_InMemorySignerDecodeErrorZ*)(((uint64_t)_res) & ~1);
8378 CResult_InMemorySignerDecodeErrorZ_free(_res_conv);
8381 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InMemorySignerDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
8382 LDKCResult_InMemorySignerDecodeErrorZ* orig_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)(orig & ~1);
8383 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
8384 *ret_conv = CResult_InMemorySignerDecodeErrorZ_clone(orig_conv);
8385 return (long)ret_conv;
8388 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1TxOutZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
8389 LDKCVec_TxOutZ _res_constr;
8390 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
8391 if (_res_constr.datalen > 0)
8392 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKTxOut), "LDKCVec_TxOutZ Elements");
8394 _res_constr.data = NULL;
8395 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
8396 for (size_t h = 0; h < _res_constr.datalen; h++) {
8397 int64_t _res_conv_7 = _res_vals[h];
8398 LDKTxOut _res_conv_7_conv = *(LDKTxOut*)(((uint64_t)_res_conv_7) & ~1);
8399 FREE((void*)_res_conv_7);
8400 _res_constr.data[h] = _res_conv_7_conv;
8402 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
8403 CVec_TxOutZ_free(_res_constr);
8406 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TransactionNoneZ_1ok(JNIEnv *env, jclass clz, int8_tArray o) {
8407 LDKTransaction o_ref;
8408 o_ref.datalen = (*env)->GetArrayLength(env, o);
8409 o_ref.data = MALLOC(o_ref.datalen, "LDKTransaction Bytes");
8410 (*env)->GetByteArrayRegion(env, o, 0, o_ref.datalen, o_ref.data);
8411 o_ref.data_is_owned = true;
8412 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
8413 *ret_conv = CResult_TransactionNoneZ_ok(o_ref);
8414 return (long)ret_conv;
8417 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TransactionNoneZ_1err(JNIEnv *env, jclass clz) {
8418 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
8419 *ret_conv = CResult_TransactionNoneZ_err();
8420 return (long)ret_conv;
8423 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1TransactionNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
8424 if ((_res & 1) != 0) return;
8425 LDKCResult_TransactionNoneZ _res_conv = *(LDKCResult_TransactionNoneZ*)(((uint64_t)_res) & ~1);
8427 CResult_TransactionNoneZ_free(_res_conv);
8430 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1RouteHopZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
8431 LDKCVec_RouteHopZ _res_constr;
8432 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
8433 if (_res_constr.datalen > 0)
8434 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
8436 _res_constr.data = NULL;
8437 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
8438 for (size_t k = 0; k < _res_constr.datalen; k++) {
8439 int64_t _res_conv_10 = _res_vals[k];
8440 LDKRouteHop _res_conv_10_conv;
8441 _res_conv_10_conv.inner = (void*)(_res_conv_10 & (~1));
8442 _res_conv_10_conv.is_owned = (_res_conv_10 & 1) || (_res_conv_10 == 0);
8443 _res_constr.data[k] = _res_conv_10_conv;
8445 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
8446 CVec_RouteHopZ_free(_res_constr);
8449 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1CVec_1RouteHopZZ_1free(JNIEnv *env, jclass clz, jobjectArray _res) {
8450 LDKCVec_CVec_RouteHopZZ _res_constr;
8451 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
8452 if (_res_constr.datalen > 0)
8453 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKCVec_RouteHopZ), "LDKCVec_CVec_RouteHopZZ Elements");
8455 _res_constr.data = NULL;
8456 for (size_t m = 0; m < _res_constr.datalen; m++) {
8457 int64_tArray _res_conv_12 = (*env)->GetObjectArrayElement(env, _res, m);
8458 LDKCVec_RouteHopZ _res_conv_12_constr;
8459 _res_conv_12_constr.datalen = (*env)->GetArrayLength(env, _res_conv_12);
8460 if (_res_conv_12_constr.datalen > 0)
8461 _res_conv_12_constr.data = MALLOC(_res_conv_12_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
8463 _res_conv_12_constr.data = NULL;
8464 int64_t* _res_conv_12_vals = (*env)->GetLongArrayElements (env, _res_conv_12, NULL);
8465 for (size_t k = 0; k < _res_conv_12_constr.datalen; k++) {
8466 int64_t _res_conv_12_conv_10 = _res_conv_12_vals[k];
8467 LDKRouteHop _res_conv_12_conv_10_conv;
8468 _res_conv_12_conv_10_conv.inner = (void*)(_res_conv_12_conv_10 & (~1));
8469 _res_conv_12_conv_10_conv.is_owned = (_res_conv_12_conv_10 & 1) || (_res_conv_12_conv_10 == 0);
8470 _res_conv_12_constr.data[k] = _res_conv_12_conv_10_conv;
8472 (*env)->ReleaseLongArrayElements(env, _res_conv_12, _res_conv_12_vals, 0);
8473 _res_constr.data[m] = _res_conv_12_constr;
8475 CVec_CVec_RouteHopZZ_free(_res_constr);
8478 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
8480 o_conv.inner = (void*)(o & (~1));
8481 o_conv.is_owned = (o & 1) || (o == 0);
8482 o_conv = Route_clone(&o_conv);
8483 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
8484 *ret_conv = CResult_RouteDecodeErrorZ_ok(o_conv);
8485 return (long)ret_conv;
8488 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
8489 LDKDecodeError e_conv;
8490 e_conv.inner = (void*)(e & (~1));
8491 e_conv.is_owned = (e & 1) || (e == 0);
8492 e_conv = DecodeError_clone(&e_conv);
8493 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
8494 *ret_conv = CResult_RouteDecodeErrorZ_err(e_conv);
8495 return (long)ret_conv;
8498 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RouteDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
8499 if ((_res & 1) != 0) return;
8500 LDKCResult_RouteDecodeErrorZ _res_conv = *(LDKCResult_RouteDecodeErrorZ*)(((uint64_t)_res) & ~1);
8502 CResult_RouteDecodeErrorZ_free(_res_conv);
8505 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
8506 LDKCResult_RouteDecodeErrorZ* orig_conv = (LDKCResult_RouteDecodeErrorZ*)(orig & ~1);
8507 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
8508 *ret_conv = CResult_RouteDecodeErrorZ_clone(orig_conv);
8509 return (long)ret_conv;
8512 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1RouteHintZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
8513 LDKCVec_RouteHintZ _res_constr;
8514 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
8515 if (_res_constr.datalen > 0)
8516 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKRouteHint), "LDKCVec_RouteHintZ Elements");
8518 _res_constr.data = NULL;
8519 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
8520 for (size_t l = 0; l < _res_constr.datalen; l++) {
8521 int64_t _res_conv_11 = _res_vals[l];
8522 LDKRouteHint _res_conv_11_conv;
8523 _res_conv_11_conv.inner = (void*)(_res_conv_11 & (~1));
8524 _res_conv_11_conv.is_owned = (_res_conv_11 & 1) || (_res_conv_11 == 0);
8525 _res_constr.data[l] = _res_conv_11_conv;
8527 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
8528 CVec_RouteHintZ_free(_res_constr);
8531 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteLightningErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
8533 o_conv.inner = (void*)(o & (~1));
8534 o_conv.is_owned = (o & 1) || (o == 0);
8535 o_conv = Route_clone(&o_conv);
8536 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
8537 *ret_conv = CResult_RouteLightningErrorZ_ok(o_conv);
8538 return (long)ret_conv;
8541 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteLightningErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
8542 LDKLightningError e_conv;
8543 e_conv.inner = (void*)(e & (~1));
8544 e_conv.is_owned = (e & 1) || (e == 0);
8545 e_conv = LightningError_clone(&e_conv);
8546 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
8547 *ret_conv = CResult_RouteLightningErrorZ_err(e_conv);
8548 return (long)ret_conv;
8551 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RouteLightningErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
8552 if ((_res & 1) != 0) return;
8553 LDKCResult_RouteLightningErrorZ _res_conv = *(LDKCResult_RouteLightningErrorZ*)(((uint64_t)_res) & ~1);
8555 CResult_RouteLightningErrorZ_free(_res_conv);
8558 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteLightningErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
8559 LDKCResult_RouteLightningErrorZ* orig_conv = (LDKCResult_RouteLightningErrorZ*)(orig & ~1);
8560 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
8561 *ret_conv = CResult_RouteLightningErrorZ_clone(orig_conv);
8562 return (long)ret_conv;
8565 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NetAddressu8Z_1ok(JNIEnv *env, jclass clz, int64_t o) {
8566 LDKNetAddress o_conv = *(LDKNetAddress*)(((uint64_t)o) & ~1);
8568 LDKCResult_NetAddressu8Z* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressu8Z), "LDKCResult_NetAddressu8Z");
8569 *ret_conv = CResult_NetAddressu8Z_ok(o_conv);
8570 return (long)ret_conv;
8573 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NetAddressu8Z_1err(JNIEnv *env, jclass clz, int8_t e) {
8574 LDKCResult_NetAddressu8Z* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressu8Z), "LDKCResult_NetAddressu8Z");
8575 *ret_conv = CResult_NetAddressu8Z_err(e);
8576 return (long)ret_conv;
8579 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NetAddressu8Z_1free(JNIEnv *env, jclass clz, int64_t _res) {
8580 if ((_res & 1) != 0) return;
8581 LDKCResult_NetAddressu8Z _res_conv = *(LDKCResult_NetAddressu8Z*)(((uint64_t)_res) & ~1);
8583 CResult_NetAddressu8Z_free(_res_conv);
8586 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NetAddressu8Z_1clone(JNIEnv *env, jclass clz, int64_t orig) {
8587 LDKCResult_NetAddressu8Z* orig_conv = (LDKCResult_NetAddressu8Z*)(orig & ~1);
8588 LDKCResult_NetAddressu8Z* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressu8Z), "LDKCResult_NetAddressu8Z");
8589 *ret_conv = CResult_NetAddressu8Z_clone(orig_conv);
8590 return (long)ret_conv;
8593 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CResult_1NetAddressu8ZDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
8594 LDKCResult_NetAddressu8Z o_conv = *(LDKCResult_NetAddressu8Z*)(((uint64_t)o) & ~1);
8596 LDKCResult_CResult_NetAddressu8ZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CResult_NetAddressu8ZDecodeErrorZ), "LDKCResult_CResult_NetAddressu8ZDecodeErrorZ");
8597 *ret_conv = CResult_CResult_NetAddressu8ZDecodeErrorZ_ok(o_conv);
8598 return (long)ret_conv;
8601 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CResult_1NetAddressu8ZDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
8602 LDKDecodeError e_conv;
8603 e_conv.inner = (void*)(e & (~1));
8604 e_conv.is_owned = (e & 1) || (e == 0);
8605 e_conv = DecodeError_clone(&e_conv);
8606 LDKCResult_CResult_NetAddressu8ZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CResult_NetAddressu8ZDecodeErrorZ), "LDKCResult_CResult_NetAddressu8ZDecodeErrorZ");
8607 *ret_conv = CResult_CResult_NetAddressu8ZDecodeErrorZ_err(e_conv);
8608 return (long)ret_conv;
8611 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CResult_1NetAddressu8ZDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
8612 if ((_res & 1) != 0) return;
8613 LDKCResult_CResult_NetAddressu8ZDecodeErrorZ _res_conv = *(LDKCResult_CResult_NetAddressu8ZDecodeErrorZ*)(((uint64_t)_res) & ~1);
8615 CResult_CResult_NetAddressu8ZDecodeErrorZ_free(_res_conv);
8618 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CResult_1NetAddressu8ZDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
8619 LDKCResult_CResult_NetAddressu8ZDecodeErrorZ* orig_conv = (LDKCResult_CResult_NetAddressu8ZDecodeErrorZ*)(orig & ~1);
8620 LDKCResult_CResult_NetAddressu8ZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CResult_NetAddressu8ZDecodeErrorZ), "LDKCResult_CResult_NetAddressu8ZDecodeErrorZ");
8621 *ret_conv = CResult_CResult_NetAddressu8ZDecodeErrorZ_clone(orig_conv);
8622 return (long)ret_conv;
8625 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1UpdateAddHTLCZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
8626 LDKCVec_UpdateAddHTLCZ _res_constr;
8627 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
8628 if (_res_constr.datalen > 0)
8629 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateAddHTLC), "LDKCVec_UpdateAddHTLCZ Elements");
8631 _res_constr.data = NULL;
8632 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
8633 for (size_t p = 0; p < _res_constr.datalen; p++) {
8634 int64_t _res_conv_15 = _res_vals[p];
8635 LDKUpdateAddHTLC _res_conv_15_conv;
8636 _res_conv_15_conv.inner = (void*)(_res_conv_15 & (~1));
8637 _res_conv_15_conv.is_owned = (_res_conv_15 & 1) || (_res_conv_15 == 0);
8638 _res_constr.data[p] = _res_conv_15_conv;
8640 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
8641 CVec_UpdateAddHTLCZ_free(_res_constr);
8644 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1UpdateFulfillHTLCZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
8645 LDKCVec_UpdateFulfillHTLCZ _res_constr;
8646 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
8647 if (_res_constr.datalen > 0)
8648 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateFulfillHTLC), "LDKCVec_UpdateFulfillHTLCZ Elements");
8650 _res_constr.data = NULL;
8651 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
8652 for (size_t t = 0; t < _res_constr.datalen; t++) {
8653 int64_t _res_conv_19 = _res_vals[t];
8654 LDKUpdateFulfillHTLC _res_conv_19_conv;
8655 _res_conv_19_conv.inner = (void*)(_res_conv_19 & (~1));
8656 _res_conv_19_conv.is_owned = (_res_conv_19 & 1) || (_res_conv_19 == 0);
8657 _res_constr.data[t] = _res_conv_19_conv;
8659 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
8660 CVec_UpdateFulfillHTLCZ_free(_res_constr);
8663 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1UpdateFailHTLCZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
8664 LDKCVec_UpdateFailHTLCZ _res_constr;
8665 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
8666 if (_res_constr.datalen > 0)
8667 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateFailHTLC), "LDKCVec_UpdateFailHTLCZ Elements");
8669 _res_constr.data = NULL;
8670 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
8671 for (size_t q = 0; q < _res_constr.datalen; q++) {
8672 int64_t _res_conv_16 = _res_vals[q];
8673 LDKUpdateFailHTLC _res_conv_16_conv;
8674 _res_conv_16_conv.inner = (void*)(_res_conv_16 & (~1));
8675 _res_conv_16_conv.is_owned = (_res_conv_16 & 1) || (_res_conv_16 == 0);
8676 _res_constr.data[q] = _res_conv_16_conv;
8678 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
8679 CVec_UpdateFailHTLCZ_free(_res_constr);
8682 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1UpdateFailMalformedHTLCZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
8683 LDKCVec_UpdateFailMalformedHTLCZ _res_constr;
8684 _res_constr.datalen = (*env)->GetArrayLength(env, _res);
8685 if (_res_constr.datalen > 0)
8686 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateFailMalformedHTLC), "LDKCVec_UpdateFailMalformedHTLCZ Elements");
8688 _res_constr.data = NULL;
8689 int64_t* _res_vals = (*env)->GetLongArrayElements (env, _res, NULL);
8690 for (size_t z = 0; z < _res_constr.datalen; z++) {
8691 int64_t _res_conv_25 = _res_vals[z];
8692 LDKUpdateFailMalformedHTLC _res_conv_25_conv;
8693 _res_conv_25_conv.inner = (void*)(_res_conv_25 & (~1));
8694 _res_conv_25_conv.is_owned = (_res_conv_25 & 1) || (_res_conv_25 == 0);
8695 _res_constr.data[z] = _res_conv_25_conv;
8697 (*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
8698 CVec_UpdateFailMalformedHTLCZ_free(_res_constr);
8701 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1AcceptChannelDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
8702 LDKAcceptChannel o_conv;
8703 o_conv.inner = (void*)(o & (~1));
8704 o_conv.is_owned = (o & 1) || (o == 0);
8705 o_conv = AcceptChannel_clone(&o_conv);
8706 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
8707 *ret_conv = CResult_AcceptChannelDecodeErrorZ_ok(o_conv);
8708 return (long)ret_conv;
8711 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1AcceptChannelDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
8712 LDKDecodeError e_conv;
8713 e_conv.inner = (void*)(e & (~1));
8714 e_conv.is_owned = (e & 1) || (e == 0);
8715 e_conv = DecodeError_clone(&e_conv);
8716 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
8717 *ret_conv = CResult_AcceptChannelDecodeErrorZ_err(e_conv);
8718 return (long)ret_conv;
8721 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1AcceptChannelDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
8722 if ((_res & 1) != 0) return;
8723 LDKCResult_AcceptChannelDecodeErrorZ _res_conv = *(LDKCResult_AcceptChannelDecodeErrorZ*)(((uint64_t)_res) & ~1);
8725 CResult_AcceptChannelDecodeErrorZ_free(_res_conv);
8728 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1AcceptChannelDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
8729 LDKCResult_AcceptChannelDecodeErrorZ* orig_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)(orig & ~1);
8730 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
8731 *ret_conv = CResult_AcceptChannelDecodeErrorZ_clone(orig_conv);
8732 return (long)ret_conv;
8735 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1AnnouncementSignaturesDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
8736 LDKAnnouncementSignatures o_conv;
8737 o_conv.inner = (void*)(o & (~1));
8738 o_conv.is_owned = (o & 1) || (o == 0);
8739 o_conv = AnnouncementSignatures_clone(&o_conv);
8740 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
8741 *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_ok(o_conv);
8742 return (long)ret_conv;
8745 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1AnnouncementSignaturesDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
8746 LDKDecodeError e_conv;
8747 e_conv.inner = (void*)(e & (~1));
8748 e_conv.is_owned = (e & 1) || (e == 0);
8749 e_conv = DecodeError_clone(&e_conv);
8750 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
8751 *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_err(e_conv);
8752 return (long)ret_conv;
8755 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1AnnouncementSignaturesDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
8756 if ((_res & 1) != 0) return;
8757 LDKCResult_AnnouncementSignaturesDecodeErrorZ _res_conv = *(LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(((uint64_t)_res) & ~1);
8759 CResult_AnnouncementSignaturesDecodeErrorZ_free(_res_conv);
8762 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1AnnouncementSignaturesDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
8763 LDKCResult_AnnouncementSignaturesDecodeErrorZ* orig_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(orig & ~1);
8764 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
8765 *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig_conv);
8766 return (long)ret_conv;
8769 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelReestablishDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
8770 LDKChannelReestablish o_conv;
8771 o_conv.inner = (void*)(o & (~1));
8772 o_conv.is_owned = (o & 1) || (o == 0);
8773 o_conv = ChannelReestablish_clone(&o_conv);
8774 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
8775 *ret_conv = CResult_ChannelReestablishDecodeErrorZ_ok(o_conv);
8776 return (long)ret_conv;
8779 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelReestablishDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
8780 LDKDecodeError e_conv;
8781 e_conv.inner = (void*)(e & (~1));
8782 e_conv.is_owned = (e & 1) || (e == 0);
8783 e_conv = DecodeError_clone(&e_conv);
8784 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
8785 *ret_conv = CResult_ChannelReestablishDecodeErrorZ_err(e_conv);
8786 return (long)ret_conv;
8789 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelReestablishDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
8790 if ((_res & 1) != 0) return;
8791 LDKCResult_ChannelReestablishDecodeErrorZ _res_conv = *(LDKCResult_ChannelReestablishDecodeErrorZ*)(((uint64_t)_res) & ~1);
8793 CResult_ChannelReestablishDecodeErrorZ_free(_res_conv);
8796 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelReestablishDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
8797 LDKCResult_ChannelReestablishDecodeErrorZ* orig_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)(orig & ~1);
8798 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
8799 *ret_conv = CResult_ChannelReestablishDecodeErrorZ_clone(orig_conv);
8800 return (long)ret_conv;
8803 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ClosingSignedDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
8804 LDKClosingSigned o_conv;
8805 o_conv.inner = (void*)(o & (~1));
8806 o_conv.is_owned = (o & 1) || (o == 0);
8807 o_conv = ClosingSigned_clone(&o_conv);
8808 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
8809 *ret_conv = CResult_ClosingSignedDecodeErrorZ_ok(o_conv);
8810 return (long)ret_conv;
8813 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ClosingSignedDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
8814 LDKDecodeError e_conv;
8815 e_conv.inner = (void*)(e & (~1));
8816 e_conv.is_owned = (e & 1) || (e == 0);
8817 e_conv = DecodeError_clone(&e_conv);
8818 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
8819 *ret_conv = CResult_ClosingSignedDecodeErrorZ_err(e_conv);
8820 return (long)ret_conv;
8823 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ClosingSignedDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
8824 if ((_res & 1) != 0) return;
8825 LDKCResult_ClosingSignedDecodeErrorZ _res_conv = *(LDKCResult_ClosingSignedDecodeErrorZ*)(((uint64_t)_res) & ~1);
8827 CResult_ClosingSignedDecodeErrorZ_free(_res_conv);
8830 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ClosingSignedDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
8831 LDKCResult_ClosingSignedDecodeErrorZ* orig_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)(orig & ~1);
8832 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
8833 *ret_conv = CResult_ClosingSignedDecodeErrorZ_clone(orig_conv);
8834 return (long)ret_conv;
8837 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentSignedDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
8838 LDKCommitmentSigned o_conv;
8839 o_conv.inner = (void*)(o & (~1));
8840 o_conv.is_owned = (o & 1) || (o == 0);
8841 o_conv = CommitmentSigned_clone(&o_conv);
8842 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
8843 *ret_conv = CResult_CommitmentSignedDecodeErrorZ_ok(o_conv);
8844 return (long)ret_conv;
8847 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentSignedDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
8848 LDKDecodeError e_conv;
8849 e_conv.inner = (void*)(e & (~1));
8850 e_conv.is_owned = (e & 1) || (e == 0);
8851 e_conv = DecodeError_clone(&e_conv);
8852 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
8853 *ret_conv = CResult_CommitmentSignedDecodeErrorZ_err(e_conv);
8854 return (long)ret_conv;
8857 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentSignedDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
8858 if ((_res & 1) != 0) return;
8859 LDKCResult_CommitmentSignedDecodeErrorZ _res_conv = *(LDKCResult_CommitmentSignedDecodeErrorZ*)(((uint64_t)_res) & ~1);
8861 CResult_CommitmentSignedDecodeErrorZ_free(_res_conv);
8864 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentSignedDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
8865 LDKCResult_CommitmentSignedDecodeErrorZ* orig_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)(orig & ~1);
8866 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
8867 *ret_conv = CResult_CommitmentSignedDecodeErrorZ_clone(orig_conv);
8868 return (long)ret_conv;
8871 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1FundingCreatedDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
8872 LDKFundingCreated o_conv;
8873 o_conv.inner = (void*)(o & (~1));
8874 o_conv.is_owned = (o & 1) || (o == 0);
8875 o_conv = FundingCreated_clone(&o_conv);
8876 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
8877 *ret_conv = CResult_FundingCreatedDecodeErrorZ_ok(o_conv);
8878 return (long)ret_conv;
8881 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1FundingCreatedDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
8882 LDKDecodeError e_conv;
8883 e_conv.inner = (void*)(e & (~1));
8884 e_conv.is_owned = (e & 1) || (e == 0);
8885 e_conv = DecodeError_clone(&e_conv);
8886 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
8887 *ret_conv = CResult_FundingCreatedDecodeErrorZ_err(e_conv);
8888 return (long)ret_conv;
8891 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1FundingCreatedDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
8892 if ((_res & 1) != 0) return;
8893 LDKCResult_FundingCreatedDecodeErrorZ _res_conv = *(LDKCResult_FundingCreatedDecodeErrorZ*)(((uint64_t)_res) & ~1);
8895 CResult_FundingCreatedDecodeErrorZ_free(_res_conv);
8898 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1FundingCreatedDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
8899 LDKCResult_FundingCreatedDecodeErrorZ* orig_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)(orig & ~1);
8900 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
8901 *ret_conv = CResult_FundingCreatedDecodeErrorZ_clone(orig_conv);
8902 return (long)ret_conv;
8905 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1FundingSignedDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
8906 LDKFundingSigned o_conv;
8907 o_conv.inner = (void*)(o & (~1));
8908 o_conv.is_owned = (o & 1) || (o == 0);
8909 o_conv = FundingSigned_clone(&o_conv);
8910 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
8911 *ret_conv = CResult_FundingSignedDecodeErrorZ_ok(o_conv);
8912 return (long)ret_conv;
8915 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1FundingSignedDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
8916 LDKDecodeError e_conv;
8917 e_conv.inner = (void*)(e & (~1));
8918 e_conv.is_owned = (e & 1) || (e == 0);
8919 e_conv = DecodeError_clone(&e_conv);
8920 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
8921 *ret_conv = CResult_FundingSignedDecodeErrorZ_err(e_conv);
8922 return (long)ret_conv;
8925 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1FundingSignedDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
8926 if ((_res & 1) != 0) return;
8927 LDKCResult_FundingSignedDecodeErrorZ _res_conv = *(LDKCResult_FundingSignedDecodeErrorZ*)(((uint64_t)_res) & ~1);
8929 CResult_FundingSignedDecodeErrorZ_free(_res_conv);
8932 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1FundingSignedDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
8933 LDKCResult_FundingSignedDecodeErrorZ* orig_conv = (LDKCResult_FundingSignedDecodeErrorZ*)(orig & ~1);
8934 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
8935 *ret_conv = CResult_FundingSignedDecodeErrorZ_clone(orig_conv);
8936 return (long)ret_conv;
8939 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1FundingLockedDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
8940 LDKFundingLocked o_conv;
8941 o_conv.inner = (void*)(o & (~1));
8942 o_conv.is_owned = (o & 1) || (o == 0);
8943 o_conv = FundingLocked_clone(&o_conv);
8944 LDKCResult_FundingLockedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingLockedDecodeErrorZ), "LDKCResult_FundingLockedDecodeErrorZ");
8945 *ret_conv = CResult_FundingLockedDecodeErrorZ_ok(o_conv);
8946 return (long)ret_conv;
8949 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1FundingLockedDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
8950 LDKDecodeError e_conv;
8951 e_conv.inner = (void*)(e & (~1));
8952 e_conv.is_owned = (e & 1) || (e == 0);
8953 e_conv = DecodeError_clone(&e_conv);
8954 LDKCResult_FundingLockedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingLockedDecodeErrorZ), "LDKCResult_FundingLockedDecodeErrorZ");
8955 *ret_conv = CResult_FundingLockedDecodeErrorZ_err(e_conv);
8956 return (long)ret_conv;
8959 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1FundingLockedDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
8960 if ((_res & 1) != 0) return;
8961 LDKCResult_FundingLockedDecodeErrorZ _res_conv = *(LDKCResult_FundingLockedDecodeErrorZ*)(((uint64_t)_res) & ~1);
8963 CResult_FundingLockedDecodeErrorZ_free(_res_conv);
8966 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1FundingLockedDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
8967 LDKCResult_FundingLockedDecodeErrorZ* orig_conv = (LDKCResult_FundingLockedDecodeErrorZ*)(orig & ~1);
8968 LDKCResult_FundingLockedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingLockedDecodeErrorZ), "LDKCResult_FundingLockedDecodeErrorZ");
8969 *ret_conv = CResult_FundingLockedDecodeErrorZ_clone(orig_conv);
8970 return (long)ret_conv;
8973 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InitDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
8975 o_conv.inner = (void*)(o & (~1));
8976 o_conv.is_owned = (o & 1) || (o == 0);
8977 o_conv = Init_clone(&o_conv);
8978 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
8979 *ret_conv = CResult_InitDecodeErrorZ_ok(o_conv);
8980 return (long)ret_conv;
8983 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InitDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
8984 LDKDecodeError e_conv;
8985 e_conv.inner = (void*)(e & (~1));
8986 e_conv.is_owned = (e & 1) || (e == 0);
8987 e_conv = DecodeError_clone(&e_conv);
8988 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
8989 *ret_conv = CResult_InitDecodeErrorZ_err(e_conv);
8990 return (long)ret_conv;
8993 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1InitDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
8994 if ((_res & 1) != 0) return;
8995 LDKCResult_InitDecodeErrorZ _res_conv = *(LDKCResult_InitDecodeErrorZ*)(((uint64_t)_res) & ~1);
8997 CResult_InitDecodeErrorZ_free(_res_conv);
9000 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InitDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9001 LDKCResult_InitDecodeErrorZ* orig_conv = (LDKCResult_InitDecodeErrorZ*)(orig & ~1);
9002 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
9003 *ret_conv = CResult_InitDecodeErrorZ_clone(orig_conv);
9004 return (long)ret_conv;
9007 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1OpenChannelDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9008 LDKOpenChannel o_conv;
9009 o_conv.inner = (void*)(o & (~1));
9010 o_conv.is_owned = (o & 1) || (o == 0);
9011 o_conv = OpenChannel_clone(&o_conv);
9012 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
9013 *ret_conv = CResult_OpenChannelDecodeErrorZ_ok(o_conv);
9014 return (long)ret_conv;
9017 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1OpenChannelDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9018 LDKDecodeError e_conv;
9019 e_conv.inner = (void*)(e & (~1));
9020 e_conv.is_owned = (e & 1) || (e == 0);
9021 e_conv = DecodeError_clone(&e_conv);
9022 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
9023 *ret_conv = CResult_OpenChannelDecodeErrorZ_err(e_conv);
9024 return (long)ret_conv;
9027 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1OpenChannelDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9028 if ((_res & 1) != 0) return;
9029 LDKCResult_OpenChannelDecodeErrorZ _res_conv = *(LDKCResult_OpenChannelDecodeErrorZ*)(((uint64_t)_res) & ~1);
9031 CResult_OpenChannelDecodeErrorZ_free(_res_conv);
9034 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1OpenChannelDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9035 LDKCResult_OpenChannelDecodeErrorZ* orig_conv = (LDKCResult_OpenChannelDecodeErrorZ*)(orig & ~1);
9036 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
9037 *ret_conv = CResult_OpenChannelDecodeErrorZ_clone(orig_conv);
9038 return (long)ret_conv;
9041 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RevokeAndACKDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9042 LDKRevokeAndACK o_conv;
9043 o_conv.inner = (void*)(o & (~1));
9044 o_conv.is_owned = (o & 1) || (o == 0);
9045 o_conv = RevokeAndACK_clone(&o_conv);
9046 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
9047 *ret_conv = CResult_RevokeAndACKDecodeErrorZ_ok(o_conv);
9048 return (long)ret_conv;
9051 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RevokeAndACKDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9052 LDKDecodeError e_conv;
9053 e_conv.inner = (void*)(e & (~1));
9054 e_conv.is_owned = (e & 1) || (e == 0);
9055 e_conv = DecodeError_clone(&e_conv);
9056 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
9057 *ret_conv = CResult_RevokeAndACKDecodeErrorZ_err(e_conv);
9058 return (long)ret_conv;
9061 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RevokeAndACKDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9062 if ((_res & 1) != 0) return;
9063 LDKCResult_RevokeAndACKDecodeErrorZ _res_conv = *(LDKCResult_RevokeAndACKDecodeErrorZ*)(((uint64_t)_res) & ~1);
9065 CResult_RevokeAndACKDecodeErrorZ_free(_res_conv);
9068 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RevokeAndACKDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9069 LDKCResult_RevokeAndACKDecodeErrorZ* orig_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)(orig & ~1);
9070 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
9071 *ret_conv = CResult_RevokeAndACKDecodeErrorZ_clone(orig_conv);
9072 return (long)ret_conv;
9075 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9077 o_conv.inner = (void*)(o & (~1));
9078 o_conv.is_owned = (o & 1) || (o == 0);
9079 o_conv = Shutdown_clone(&o_conv);
9080 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
9081 *ret_conv = CResult_ShutdownDecodeErrorZ_ok(o_conv);
9082 return (long)ret_conv;
9085 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9086 LDKDecodeError e_conv;
9087 e_conv.inner = (void*)(e & (~1));
9088 e_conv.is_owned = (e & 1) || (e == 0);
9089 e_conv = DecodeError_clone(&e_conv);
9090 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
9091 *ret_conv = CResult_ShutdownDecodeErrorZ_err(e_conv);
9092 return (long)ret_conv;
9095 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9096 if ((_res & 1) != 0) return;
9097 LDKCResult_ShutdownDecodeErrorZ _res_conv = *(LDKCResult_ShutdownDecodeErrorZ*)(((uint64_t)_res) & ~1);
9099 CResult_ShutdownDecodeErrorZ_free(_res_conv);
9102 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9103 LDKCResult_ShutdownDecodeErrorZ* orig_conv = (LDKCResult_ShutdownDecodeErrorZ*)(orig & ~1);
9104 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
9105 *ret_conv = CResult_ShutdownDecodeErrorZ_clone(orig_conv);
9106 return (long)ret_conv;
9109 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailHTLCDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9110 LDKUpdateFailHTLC o_conv;
9111 o_conv.inner = (void*)(o & (~1));
9112 o_conv.is_owned = (o & 1) || (o == 0);
9113 o_conv = UpdateFailHTLC_clone(&o_conv);
9114 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
9115 *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_ok(o_conv);
9116 return (long)ret_conv;
9119 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailHTLCDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9120 LDKDecodeError e_conv;
9121 e_conv.inner = (void*)(e & (~1));
9122 e_conv.is_owned = (e & 1) || (e == 0);
9123 e_conv = DecodeError_clone(&e_conv);
9124 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
9125 *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_err(e_conv);
9126 return (long)ret_conv;
9129 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailHTLCDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9130 if ((_res & 1) != 0) return;
9131 LDKCResult_UpdateFailHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateFailHTLCDecodeErrorZ*)(((uint64_t)_res) & ~1);
9133 CResult_UpdateFailHTLCDecodeErrorZ_free(_res_conv);
9136 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailHTLCDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9137 LDKCResult_UpdateFailHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)(orig & ~1);
9138 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
9139 *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_clone(orig_conv);
9140 return (long)ret_conv;
9143 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailMalformedHTLCDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9144 LDKUpdateFailMalformedHTLC o_conv;
9145 o_conv.inner = (void*)(o & (~1));
9146 o_conv.is_owned = (o & 1) || (o == 0);
9147 o_conv = UpdateFailMalformedHTLC_clone(&o_conv);
9148 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
9149 *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o_conv);
9150 return (long)ret_conv;
9153 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailMalformedHTLCDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9154 LDKDecodeError e_conv;
9155 e_conv.inner = (void*)(e & (~1));
9156 e_conv.is_owned = (e & 1) || (e == 0);
9157 e_conv = DecodeError_clone(&e_conv);
9158 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
9159 *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e_conv);
9160 return (long)ret_conv;
9163 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailMalformedHTLCDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9164 if ((_res & 1) != 0) return;
9165 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(((uint64_t)_res) & ~1);
9167 CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res_conv);
9170 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailMalformedHTLCDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9171 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(orig & ~1);
9172 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
9173 *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig_conv);
9174 return (long)ret_conv;
9177 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFeeDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9178 LDKUpdateFee o_conv;
9179 o_conv.inner = (void*)(o & (~1));
9180 o_conv.is_owned = (o & 1) || (o == 0);
9181 o_conv = UpdateFee_clone(&o_conv);
9182 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
9183 *ret_conv = CResult_UpdateFeeDecodeErrorZ_ok(o_conv);
9184 return (long)ret_conv;
9187 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFeeDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9188 LDKDecodeError e_conv;
9189 e_conv.inner = (void*)(e & (~1));
9190 e_conv.is_owned = (e & 1) || (e == 0);
9191 e_conv = DecodeError_clone(&e_conv);
9192 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
9193 *ret_conv = CResult_UpdateFeeDecodeErrorZ_err(e_conv);
9194 return (long)ret_conv;
9197 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFeeDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9198 if ((_res & 1) != 0) return;
9199 LDKCResult_UpdateFeeDecodeErrorZ _res_conv = *(LDKCResult_UpdateFeeDecodeErrorZ*)(((uint64_t)_res) & ~1);
9201 CResult_UpdateFeeDecodeErrorZ_free(_res_conv);
9204 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFeeDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9205 LDKCResult_UpdateFeeDecodeErrorZ* orig_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)(orig & ~1);
9206 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
9207 *ret_conv = CResult_UpdateFeeDecodeErrorZ_clone(orig_conv);
9208 return (long)ret_conv;
9211 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFulfillHTLCDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9212 LDKUpdateFulfillHTLC o_conv;
9213 o_conv.inner = (void*)(o & (~1));
9214 o_conv.is_owned = (o & 1) || (o == 0);
9215 o_conv = UpdateFulfillHTLC_clone(&o_conv);
9216 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
9217 *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o_conv);
9218 return (long)ret_conv;
9221 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFulfillHTLCDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9222 LDKDecodeError e_conv;
9223 e_conv.inner = (void*)(e & (~1));
9224 e_conv.is_owned = (e & 1) || (e == 0);
9225 e_conv = DecodeError_clone(&e_conv);
9226 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
9227 *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_err(e_conv);
9228 return (long)ret_conv;
9231 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFulfillHTLCDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9232 if ((_res & 1) != 0) return;
9233 LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(((uint64_t)_res) & ~1);
9235 CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res_conv);
9238 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFulfillHTLCDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9239 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(orig & ~1);
9240 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
9241 *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig_conv);
9242 return (long)ret_conv;
9245 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateAddHTLCDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9246 LDKUpdateAddHTLC o_conv;
9247 o_conv.inner = (void*)(o & (~1));
9248 o_conv.is_owned = (o & 1) || (o == 0);
9249 o_conv = UpdateAddHTLC_clone(&o_conv);
9250 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
9251 *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_ok(o_conv);
9252 return (long)ret_conv;
9255 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateAddHTLCDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9256 LDKDecodeError e_conv;
9257 e_conv.inner = (void*)(e & (~1));
9258 e_conv.is_owned = (e & 1) || (e == 0);
9259 e_conv = DecodeError_clone(&e_conv);
9260 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
9261 *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_err(e_conv);
9262 return (long)ret_conv;
9265 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateAddHTLCDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9266 if ((_res & 1) != 0) return;
9267 LDKCResult_UpdateAddHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateAddHTLCDecodeErrorZ*)(((uint64_t)_res) & ~1);
9269 CResult_UpdateAddHTLCDecodeErrorZ_free(_res_conv);
9272 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateAddHTLCDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9273 LDKCResult_UpdateAddHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)(orig & ~1);
9274 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
9275 *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_clone(orig_conv);
9276 return (long)ret_conv;
9279 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PingDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9281 o_conv.inner = (void*)(o & (~1));
9282 o_conv.is_owned = (o & 1) || (o == 0);
9283 o_conv = Ping_clone(&o_conv);
9284 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
9285 *ret_conv = CResult_PingDecodeErrorZ_ok(o_conv);
9286 return (long)ret_conv;
9289 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PingDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9290 LDKDecodeError e_conv;
9291 e_conv.inner = (void*)(e & (~1));
9292 e_conv.is_owned = (e & 1) || (e == 0);
9293 e_conv = DecodeError_clone(&e_conv);
9294 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
9295 *ret_conv = CResult_PingDecodeErrorZ_err(e_conv);
9296 return (long)ret_conv;
9299 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PingDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9300 if ((_res & 1) != 0) return;
9301 LDKCResult_PingDecodeErrorZ _res_conv = *(LDKCResult_PingDecodeErrorZ*)(((uint64_t)_res) & ~1);
9303 CResult_PingDecodeErrorZ_free(_res_conv);
9306 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PingDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9307 LDKCResult_PingDecodeErrorZ* orig_conv = (LDKCResult_PingDecodeErrorZ*)(orig & ~1);
9308 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
9309 *ret_conv = CResult_PingDecodeErrorZ_clone(orig_conv);
9310 return (long)ret_conv;
9313 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PongDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9315 o_conv.inner = (void*)(o & (~1));
9316 o_conv.is_owned = (o & 1) || (o == 0);
9317 o_conv = Pong_clone(&o_conv);
9318 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
9319 *ret_conv = CResult_PongDecodeErrorZ_ok(o_conv);
9320 return (long)ret_conv;
9323 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PongDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9324 LDKDecodeError e_conv;
9325 e_conv.inner = (void*)(e & (~1));
9326 e_conv.is_owned = (e & 1) || (e == 0);
9327 e_conv = DecodeError_clone(&e_conv);
9328 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
9329 *ret_conv = CResult_PongDecodeErrorZ_err(e_conv);
9330 return (long)ret_conv;
9333 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PongDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9334 if ((_res & 1) != 0) return;
9335 LDKCResult_PongDecodeErrorZ _res_conv = *(LDKCResult_PongDecodeErrorZ*)(((uint64_t)_res) & ~1);
9337 CResult_PongDecodeErrorZ_free(_res_conv);
9340 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PongDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9341 LDKCResult_PongDecodeErrorZ* orig_conv = (LDKCResult_PongDecodeErrorZ*)(orig & ~1);
9342 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
9343 *ret_conv = CResult_PongDecodeErrorZ_clone(orig_conv);
9344 return (long)ret_conv;
9347 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelAnnouncementDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9348 LDKUnsignedChannelAnnouncement o_conv;
9349 o_conv.inner = (void*)(o & (~1));
9350 o_conv.is_owned = (o & 1) || (o == 0);
9351 o_conv = UnsignedChannelAnnouncement_clone(&o_conv);
9352 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
9353 *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o_conv);
9354 return (long)ret_conv;
9357 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelAnnouncementDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9358 LDKDecodeError e_conv;
9359 e_conv.inner = (void*)(e & (~1));
9360 e_conv.is_owned = (e & 1) || (e == 0);
9361 e_conv = DecodeError_clone(&e_conv);
9362 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
9363 *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e_conv);
9364 return (long)ret_conv;
9367 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelAnnouncementDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9368 if ((_res & 1) != 0) return;
9369 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(((uint64_t)_res) & ~1);
9371 CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res_conv);
9374 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelAnnouncementDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9375 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(orig & ~1);
9376 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
9377 *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig_conv);
9378 return (long)ret_conv;
9381 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelAnnouncementDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9382 LDKChannelAnnouncement o_conv;
9383 o_conv.inner = (void*)(o & (~1));
9384 o_conv.is_owned = (o & 1) || (o == 0);
9385 o_conv = ChannelAnnouncement_clone(&o_conv);
9386 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
9387 *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_ok(o_conv);
9388 return (long)ret_conv;
9391 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelAnnouncementDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9392 LDKDecodeError e_conv;
9393 e_conv.inner = (void*)(e & (~1));
9394 e_conv.is_owned = (e & 1) || (e == 0);
9395 e_conv = DecodeError_clone(&e_conv);
9396 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
9397 *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_err(e_conv);
9398 return (long)ret_conv;
9401 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelAnnouncementDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9402 if ((_res & 1) != 0) return;
9403 LDKCResult_ChannelAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_ChannelAnnouncementDecodeErrorZ*)(((uint64_t)_res) & ~1);
9405 CResult_ChannelAnnouncementDecodeErrorZ_free(_res_conv);
9408 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelAnnouncementDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9409 LDKCResult_ChannelAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)(orig & ~1);
9410 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
9411 *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_clone(orig_conv);
9412 return (long)ret_conv;
9415 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelUpdateDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9416 LDKUnsignedChannelUpdate o_conv;
9417 o_conv.inner = (void*)(o & (~1));
9418 o_conv.is_owned = (o & 1) || (o == 0);
9419 o_conv = UnsignedChannelUpdate_clone(&o_conv);
9420 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
9421 *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o_conv);
9422 return (long)ret_conv;
9425 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelUpdateDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9426 LDKDecodeError e_conv;
9427 e_conv.inner = (void*)(e & (~1));
9428 e_conv.is_owned = (e & 1) || (e == 0);
9429 e_conv = DecodeError_clone(&e_conv);
9430 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
9431 *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_err(e_conv);
9432 return (long)ret_conv;
9435 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelUpdateDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9436 if ((_res & 1) != 0) return;
9437 LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res_conv = *(LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(((uint64_t)_res) & ~1);
9439 CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res_conv);
9442 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelUpdateDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9443 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* orig_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(orig & ~1);
9444 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
9445 *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig_conv);
9446 return (long)ret_conv;
9449 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelUpdateDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9450 LDKChannelUpdate o_conv;
9451 o_conv.inner = (void*)(o & (~1));
9452 o_conv.is_owned = (o & 1) || (o == 0);
9453 o_conv = ChannelUpdate_clone(&o_conv);
9454 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
9455 *ret_conv = CResult_ChannelUpdateDecodeErrorZ_ok(o_conv);
9456 return (long)ret_conv;
9459 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelUpdateDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9460 LDKDecodeError e_conv;
9461 e_conv.inner = (void*)(e & (~1));
9462 e_conv.is_owned = (e & 1) || (e == 0);
9463 e_conv = DecodeError_clone(&e_conv);
9464 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
9465 *ret_conv = CResult_ChannelUpdateDecodeErrorZ_err(e_conv);
9466 return (long)ret_conv;
9469 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelUpdateDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9470 if ((_res & 1) != 0) return;
9471 LDKCResult_ChannelUpdateDecodeErrorZ _res_conv = *(LDKCResult_ChannelUpdateDecodeErrorZ*)(((uint64_t)_res) & ~1);
9473 CResult_ChannelUpdateDecodeErrorZ_free(_res_conv);
9476 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelUpdateDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9477 LDKCResult_ChannelUpdateDecodeErrorZ* orig_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)(orig & ~1);
9478 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
9479 *ret_conv = CResult_ChannelUpdateDecodeErrorZ_clone(orig_conv);
9480 return (long)ret_conv;
9483 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ErrorMessageDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9484 LDKErrorMessage o_conv;
9485 o_conv.inner = (void*)(o & (~1));
9486 o_conv.is_owned = (o & 1) || (o == 0);
9487 o_conv = ErrorMessage_clone(&o_conv);
9488 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
9489 *ret_conv = CResult_ErrorMessageDecodeErrorZ_ok(o_conv);
9490 return (long)ret_conv;
9493 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ErrorMessageDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9494 LDKDecodeError e_conv;
9495 e_conv.inner = (void*)(e & (~1));
9496 e_conv.is_owned = (e & 1) || (e == 0);
9497 e_conv = DecodeError_clone(&e_conv);
9498 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
9499 *ret_conv = CResult_ErrorMessageDecodeErrorZ_err(e_conv);
9500 return (long)ret_conv;
9503 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ErrorMessageDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9504 if ((_res & 1) != 0) return;
9505 LDKCResult_ErrorMessageDecodeErrorZ _res_conv = *(LDKCResult_ErrorMessageDecodeErrorZ*)(((uint64_t)_res) & ~1);
9507 CResult_ErrorMessageDecodeErrorZ_free(_res_conv);
9510 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ErrorMessageDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9511 LDKCResult_ErrorMessageDecodeErrorZ* orig_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)(orig & ~1);
9512 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
9513 *ret_conv = CResult_ErrorMessageDecodeErrorZ_clone(orig_conv);
9514 return (long)ret_conv;
9517 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedNodeAnnouncementDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9518 LDKUnsignedNodeAnnouncement o_conv;
9519 o_conv.inner = (void*)(o & (~1));
9520 o_conv.is_owned = (o & 1) || (o == 0);
9521 o_conv = UnsignedNodeAnnouncement_clone(&o_conv);
9522 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
9523 *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o_conv);
9524 return (long)ret_conv;
9527 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedNodeAnnouncementDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9528 LDKDecodeError e_conv;
9529 e_conv.inner = (void*)(e & (~1));
9530 e_conv.is_owned = (e & 1) || (e == 0);
9531 e_conv = DecodeError_clone(&e_conv);
9532 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
9533 *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e_conv);
9534 return (long)ret_conv;
9537 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedNodeAnnouncementDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9538 if ((_res & 1) != 0) return;
9539 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(((uint64_t)_res) & ~1);
9541 CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res_conv);
9544 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedNodeAnnouncementDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9545 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(orig & ~1);
9546 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
9547 *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig_conv);
9548 return (long)ret_conv;
9551 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9552 LDKNodeAnnouncement o_conv;
9553 o_conv.inner = (void*)(o & (~1));
9554 o_conv.is_owned = (o & 1) || (o == 0);
9555 o_conv = NodeAnnouncement_clone(&o_conv);
9556 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
9557 *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_ok(o_conv);
9558 return (long)ret_conv;
9561 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9562 LDKDecodeError e_conv;
9563 e_conv.inner = (void*)(e & (~1));
9564 e_conv.is_owned = (e & 1) || (e == 0);
9565 e_conv = DecodeError_clone(&e_conv);
9566 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
9567 *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_err(e_conv);
9568 return (long)ret_conv;
9571 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9572 if ((_res & 1) != 0) return;
9573 LDKCResult_NodeAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_NodeAnnouncementDecodeErrorZ*)(((uint64_t)_res) & ~1);
9575 CResult_NodeAnnouncementDecodeErrorZ_free(_res_conv);
9578 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9579 LDKCResult_NodeAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)(orig & ~1);
9580 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
9581 *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_clone(orig_conv);
9582 return (long)ret_conv;
9585 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1QueryShortChannelIdsDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9586 LDKQueryShortChannelIds o_conv;
9587 o_conv.inner = (void*)(o & (~1));
9588 o_conv.is_owned = (o & 1) || (o == 0);
9589 o_conv = QueryShortChannelIds_clone(&o_conv);
9590 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
9591 *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_ok(o_conv);
9592 return (long)ret_conv;
9595 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1QueryShortChannelIdsDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9596 LDKDecodeError e_conv;
9597 e_conv.inner = (void*)(e & (~1));
9598 e_conv.is_owned = (e & 1) || (e == 0);
9599 e_conv = DecodeError_clone(&e_conv);
9600 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
9601 *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_err(e_conv);
9602 return (long)ret_conv;
9605 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1QueryShortChannelIdsDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9606 if ((_res & 1) != 0) return;
9607 LDKCResult_QueryShortChannelIdsDecodeErrorZ _res_conv = *(LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(((uint64_t)_res) & ~1);
9609 CResult_QueryShortChannelIdsDecodeErrorZ_free(_res_conv);
9612 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1QueryShortChannelIdsDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9613 LDKCResult_QueryShortChannelIdsDecodeErrorZ* orig_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(orig & ~1);
9614 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
9615 *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig_conv);
9616 return (long)ret_conv;
9619 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyShortChannelIdsEndDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9620 LDKReplyShortChannelIdsEnd o_conv;
9621 o_conv.inner = (void*)(o & (~1));
9622 o_conv.is_owned = (o & 1) || (o == 0);
9623 o_conv = ReplyShortChannelIdsEnd_clone(&o_conv);
9624 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
9625 *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o_conv);
9626 return (long)ret_conv;
9629 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyShortChannelIdsEndDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9630 LDKDecodeError e_conv;
9631 e_conv.inner = (void*)(e & (~1));
9632 e_conv.is_owned = (e & 1) || (e == 0);
9633 e_conv = DecodeError_clone(&e_conv);
9634 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
9635 *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e_conv);
9636 return (long)ret_conv;
9639 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyShortChannelIdsEndDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9640 if ((_res & 1) != 0) return;
9641 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res_conv = *(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(((uint64_t)_res) & ~1);
9643 CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res_conv);
9646 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyShortChannelIdsEndDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9647 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* orig_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(orig & ~1);
9648 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
9649 *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig_conv);
9650 return (long)ret_conv;
9653 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1QueryChannelRangeDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9654 LDKQueryChannelRange o_conv;
9655 o_conv.inner = (void*)(o & (~1));
9656 o_conv.is_owned = (o & 1) || (o == 0);
9657 o_conv = QueryChannelRange_clone(&o_conv);
9658 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
9659 *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_ok(o_conv);
9660 return (long)ret_conv;
9663 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1QueryChannelRangeDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9664 LDKDecodeError e_conv;
9665 e_conv.inner = (void*)(e & (~1));
9666 e_conv.is_owned = (e & 1) || (e == 0);
9667 e_conv = DecodeError_clone(&e_conv);
9668 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
9669 *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_err(e_conv);
9670 return (long)ret_conv;
9673 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1QueryChannelRangeDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9674 if ((_res & 1) != 0) return;
9675 LDKCResult_QueryChannelRangeDecodeErrorZ _res_conv = *(LDKCResult_QueryChannelRangeDecodeErrorZ*)(((uint64_t)_res) & ~1);
9677 CResult_QueryChannelRangeDecodeErrorZ_free(_res_conv);
9680 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1QueryChannelRangeDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9681 LDKCResult_QueryChannelRangeDecodeErrorZ* orig_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)(orig & ~1);
9682 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
9683 *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_clone(orig_conv);
9684 return (long)ret_conv;
9687 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyChannelRangeDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9688 LDKReplyChannelRange o_conv;
9689 o_conv.inner = (void*)(o & (~1));
9690 o_conv.is_owned = (o & 1) || (o == 0);
9691 o_conv = ReplyChannelRange_clone(&o_conv);
9692 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
9693 *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_ok(o_conv);
9694 return (long)ret_conv;
9697 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyChannelRangeDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9698 LDKDecodeError e_conv;
9699 e_conv.inner = (void*)(e & (~1));
9700 e_conv.is_owned = (e & 1) || (e == 0);
9701 e_conv = DecodeError_clone(&e_conv);
9702 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
9703 *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_err(e_conv);
9704 return (long)ret_conv;
9707 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyChannelRangeDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9708 if ((_res & 1) != 0) return;
9709 LDKCResult_ReplyChannelRangeDecodeErrorZ _res_conv = *(LDKCResult_ReplyChannelRangeDecodeErrorZ*)(((uint64_t)_res) & ~1);
9711 CResult_ReplyChannelRangeDecodeErrorZ_free(_res_conv);
9714 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyChannelRangeDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9715 LDKCResult_ReplyChannelRangeDecodeErrorZ* orig_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)(orig & ~1);
9716 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
9717 *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_clone(orig_conv);
9718 return (long)ret_conv;
9721 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1GossipTimestampFilterDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
9722 LDKGossipTimestampFilter o_conv;
9723 o_conv.inner = (void*)(o & (~1));
9724 o_conv.is_owned = (o & 1) || (o == 0);
9725 o_conv = GossipTimestampFilter_clone(&o_conv);
9726 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
9727 *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_ok(o_conv);
9728 return (long)ret_conv;
9731 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1GossipTimestampFilterDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
9732 LDKDecodeError e_conv;
9733 e_conv.inner = (void*)(e & (~1));
9734 e_conv.is_owned = (e & 1) || (e == 0);
9735 e_conv = DecodeError_clone(&e_conv);
9736 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
9737 *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_err(e_conv);
9738 return (long)ret_conv;
9741 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1GossipTimestampFilterDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
9742 if ((_res & 1) != 0) return;
9743 LDKCResult_GossipTimestampFilterDecodeErrorZ _res_conv = *(LDKCResult_GossipTimestampFilterDecodeErrorZ*)(((uint64_t)_res) & ~1);
9745 CResult_GossipTimestampFilterDecodeErrorZ_free(_res_conv);
9748 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1GossipTimestampFilterDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9749 LDKCResult_GossipTimestampFilterDecodeErrorZ* orig_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)(orig & ~1);
9750 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
9751 *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_clone(orig_conv);
9752 return (long)ret_conv;
9755 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Event_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
9756 if ((this_ptr & 1) != 0) return;
9757 LDKEvent this_ptr_conv = *(LDKEvent*)(((uint64_t)this_ptr) & ~1);
9758 FREE((void*)this_ptr);
9759 Event_free(this_ptr_conv);
9762 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Event_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9763 LDKEvent* orig_conv = (LDKEvent*)orig;
9764 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
9765 *ret_copy = Event_clone(orig_conv);
9766 long ret_ref = (long)ret_copy;
9770 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_Event_1write(JNIEnv *env, jclass clz, int64_t obj) {
9771 LDKEvent* obj_conv = (LDKEvent*)obj;
9772 LDKCVec_u8Z ret_var = Event_write(obj_conv);
9773 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
9774 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
9775 CVec_u8Z_free(ret_var);
9779 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_MessageSendEvent_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
9780 if ((this_ptr & 1) != 0) return;
9781 LDKMessageSendEvent this_ptr_conv = *(LDKMessageSendEvent*)(((uint64_t)this_ptr) & ~1);
9782 FREE((void*)this_ptr);
9783 MessageSendEvent_free(this_ptr_conv);
9786 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MessageSendEvent_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9787 LDKMessageSendEvent* orig_conv = (LDKMessageSendEvent*)orig;
9788 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
9789 *ret_copy = MessageSendEvent_clone(orig_conv);
9790 long ret_ref = (long)ret_copy;
9794 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_MessageSendEventsProvider_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
9795 if ((this_ptr & 1) != 0) return;
9796 LDKMessageSendEventsProvider this_ptr_conv = *(LDKMessageSendEventsProvider*)(((uint64_t)this_ptr) & ~1);
9797 FREE((void*)this_ptr);
9798 MessageSendEventsProvider_free(this_ptr_conv);
9801 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_EventsProvider_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
9802 if ((this_ptr & 1) != 0) return;
9803 LDKEventsProvider this_ptr_conv = *(LDKEventsProvider*)(((uint64_t)this_ptr) & ~1);
9804 FREE((void*)this_ptr);
9805 EventsProvider_free(this_ptr_conv);
9808 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_APIError_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
9809 if ((this_ptr & 1) != 0) return;
9810 LDKAPIError this_ptr_conv = *(LDKAPIError*)(((uint64_t)this_ptr) & ~1);
9811 FREE((void*)this_ptr);
9812 APIError_free(this_ptr_conv);
9815 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_APIError_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9816 LDKAPIError* orig_conv = (LDKAPIError*)orig;
9817 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
9818 *ret_copy = APIError_clone(orig_conv);
9819 long ret_ref = (long)ret_copy;
9823 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_Level_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9824 LDKLevel* orig_conv = (LDKLevel*)(orig & ~1);
9825 jclass ret_conv = LDKLevel_to_java(env, Level_clone(orig_conv));
9829 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_Level_1max(JNIEnv *env, jclass clz) {
9830 jclass ret_conv = LDKLevel_to_java(env, Level_max());
9834 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Logger_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
9835 if ((this_ptr & 1) != 0) return;
9836 LDKLogger this_ptr_conv = *(LDKLogger*)(((uint64_t)this_ptr) & ~1);
9837 FREE((void*)this_ptr);
9838 Logger_free(this_ptr_conv);
9841 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeConfig_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
9842 LDKChannelHandshakeConfig this_obj_conv;
9843 this_obj_conv.inner = (void*)(this_obj & (~1));
9844 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
9845 ChannelHandshakeConfig_free(this_obj_conv);
9848 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeConfig_1get_1minimum_1depth(JNIEnv *env, jclass clz, int64_t this_ptr) {
9849 LDKChannelHandshakeConfig this_ptr_conv;
9850 this_ptr_conv.inner = (void*)(this_ptr & (~1));
9851 this_ptr_conv.is_owned = false;
9852 int32_t ret_val = ChannelHandshakeConfig_get_minimum_depth(&this_ptr_conv);
9856 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeConfig_1set_1minimum_1depth(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
9857 LDKChannelHandshakeConfig this_ptr_conv;
9858 this_ptr_conv.inner = (void*)(this_ptr & (~1));
9859 this_ptr_conv.is_owned = false;
9860 ChannelHandshakeConfig_set_minimum_depth(&this_ptr_conv, val);
9863 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeConfig_1get_1our_1to_1self_1delay(JNIEnv *env, jclass clz, int64_t this_ptr) {
9864 LDKChannelHandshakeConfig this_ptr_conv;
9865 this_ptr_conv.inner = (void*)(this_ptr & (~1));
9866 this_ptr_conv.is_owned = false;
9867 int16_t ret_val = ChannelHandshakeConfig_get_our_to_self_delay(&this_ptr_conv);
9871 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) {
9872 LDKChannelHandshakeConfig this_ptr_conv;
9873 this_ptr_conv.inner = (void*)(this_ptr & (~1));
9874 this_ptr_conv.is_owned = false;
9875 ChannelHandshakeConfig_set_our_to_self_delay(&this_ptr_conv, val);
9878 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeConfig_1get_1our_1htlc_1minimum_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
9879 LDKChannelHandshakeConfig this_ptr_conv;
9880 this_ptr_conv.inner = (void*)(this_ptr & (~1));
9881 this_ptr_conv.is_owned = false;
9882 int64_t ret_val = ChannelHandshakeConfig_get_our_htlc_minimum_msat(&this_ptr_conv);
9886 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) {
9887 LDKChannelHandshakeConfig this_ptr_conv;
9888 this_ptr_conv.inner = (void*)(this_ptr & (~1));
9889 this_ptr_conv.is_owned = false;
9890 ChannelHandshakeConfig_set_our_htlc_minimum_msat(&this_ptr_conv, val);
9893 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) {
9894 LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_new(minimum_depth_arg, our_to_self_delay_arg, our_htlc_minimum_msat_arg);
9895 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
9896 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
9897 long ret_ref = (long)ret_var.inner;
9898 if (ret_var.is_owned) {
9904 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeConfig_1clone(JNIEnv *env, jclass clz, int64_t orig) {
9905 LDKChannelHandshakeConfig orig_conv;
9906 orig_conv.inner = (void*)(orig & (~1));
9907 orig_conv.is_owned = false;
9908 LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_clone(&orig_conv);
9909 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
9910 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
9911 long ret_ref = (long)ret_var.inner;
9912 if (ret_var.is_owned) {
9918 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeConfig_1default(JNIEnv *env, jclass clz) {
9919 LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_default();
9920 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
9921 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
9922 long ret_ref = (long)ret_var.inner;
9923 if (ret_var.is_owned) {
9929 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
9930 LDKChannelHandshakeLimits this_obj_conv;
9931 this_obj_conv.inner = (void*)(this_obj & (~1));
9932 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
9933 ChannelHandshakeLimits_free(this_obj_conv);
9936 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1get_1min_1funding_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr) {
9937 LDKChannelHandshakeLimits this_ptr_conv;
9938 this_ptr_conv.inner = (void*)(this_ptr & (~1));
9939 this_ptr_conv.is_owned = false;
9940 int64_t ret_val = ChannelHandshakeLimits_get_min_funding_satoshis(&this_ptr_conv);
9944 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1set_1min_1funding_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
9945 LDKChannelHandshakeLimits this_ptr_conv;
9946 this_ptr_conv.inner = (void*)(this_ptr & (~1));
9947 this_ptr_conv.is_owned = false;
9948 ChannelHandshakeLimits_set_min_funding_satoshis(&this_ptr_conv, val);
9951 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1get_1max_1htlc_1minimum_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
9952 LDKChannelHandshakeLimits this_ptr_conv;
9953 this_ptr_conv.inner = (void*)(this_ptr & (~1));
9954 this_ptr_conv.is_owned = false;
9955 int64_t ret_val = ChannelHandshakeLimits_get_max_htlc_minimum_msat(&this_ptr_conv);
9959 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) {
9960 LDKChannelHandshakeLimits this_ptr_conv;
9961 this_ptr_conv.inner = (void*)(this_ptr & (~1));
9962 this_ptr_conv.is_owned = false;
9963 ChannelHandshakeLimits_set_max_htlc_minimum_msat(&this_ptr_conv, val);
9966 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) {
9967 LDKChannelHandshakeLimits this_ptr_conv;
9968 this_ptr_conv.inner = (void*)(this_ptr & (~1));
9969 this_ptr_conv.is_owned = false;
9970 int64_t ret_val = ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(&this_ptr_conv);
9974 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) {
9975 LDKChannelHandshakeLimits this_ptr_conv;
9976 this_ptr_conv.inner = (void*)(this_ptr & (~1));
9977 this_ptr_conv.is_owned = false;
9978 ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
9981 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1get_1max_1channel_1reserve_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr) {
9982 LDKChannelHandshakeLimits this_ptr_conv;
9983 this_ptr_conv.inner = (void*)(this_ptr & (~1));
9984 this_ptr_conv.is_owned = false;
9985 int64_t ret_val = ChannelHandshakeLimits_get_max_channel_reserve_satoshis(&this_ptr_conv);
9989 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) {
9990 LDKChannelHandshakeLimits this_ptr_conv;
9991 this_ptr_conv.inner = (void*)(this_ptr & (~1));
9992 this_ptr_conv.is_owned = false;
9993 ChannelHandshakeLimits_set_max_channel_reserve_satoshis(&this_ptr_conv, val);
9996 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1get_1min_1max_1accepted_1htlcs(JNIEnv *env, jclass clz, int64_t this_ptr) {
9997 LDKChannelHandshakeLimits this_ptr_conv;
9998 this_ptr_conv.inner = (void*)(this_ptr & (~1));
9999 this_ptr_conv.is_owned = false;
10000 int16_t ret_val = ChannelHandshakeLimits_get_min_max_accepted_htlcs(&this_ptr_conv);
10004 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) {
10005 LDKChannelHandshakeLimits this_ptr_conv;
10006 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10007 this_ptr_conv.is_owned = false;
10008 ChannelHandshakeLimits_set_min_max_accepted_htlcs(&this_ptr_conv, val);
10011 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1get_1min_1dust_1limit_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr) {
10012 LDKChannelHandshakeLimits this_ptr_conv;
10013 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10014 this_ptr_conv.is_owned = false;
10015 int64_t ret_val = ChannelHandshakeLimits_get_min_dust_limit_satoshis(&this_ptr_conv);
10019 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1set_1min_1dust_1limit_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
10020 LDKChannelHandshakeLimits this_ptr_conv;
10021 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10022 this_ptr_conv.is_owned = false;
10023 ChannelHandshakeLimits_set_min_dust_limit_satoshis(&this_ptr_conv, val);
10026 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1get_1max_1dust_1limit_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr) {
10027 LDKChannelHandshakeLimits this_ptr_conv;
10028 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10029 this_ptr_conv.is_owned = false;
10030 int64_t ret_val = ChannelHandshakeLimits_get_max_dust_limit_satoshis(&this_ptr_conv);
10034 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1set_1max_1dust_1limit_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
10035 LDKChannelHandshakeLimits this_ptr_conv;
10036 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10037 this_ptr_conv.is_owned = false;
10038 ChannelHandshakeLimits_set_max_dust_limit_satoshis(&this_ptr_conv, val);
10041 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1get_1max_1minimum_1depth(JNIEnv *env, jclass clz, int64_t this_ptr) {
10042 LDKChannelHandshakeLimits this_ptr_conv;
10043 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10044 this_ptr_conv.is_owned = false;
10045 int32_t ret_val = ChannelHandshakeLimits_get_max_minimum_depth(&this_ptr_conv);
10049 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1set_1max_1minimum_1depth(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
10050 LDKChannelHandshakeLimits this_ptr_conv;
10051 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10052 this_ptr_conv.is_owned = false;
10053 ChannelHandshakeLimits_set_max_minimum_depth(&this_ptr_conv, val);
10056 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1get_1force_1announced_1channel_1preference(JNIEnv *env, jclass clz, int64_t this_ptr) {
10057 LDKChannelHandshakeLimits this_ptr_conv;
10058 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10059 this_ptr_conv.is_owned = false;
10060 jboolean ret_val = ChannelHandshakeLimits_get_force_announced_channel_preference(&this_ptr_conv);
10064 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1set_1force_1announced_1channel_1preference(JNIEnv *env, jclass clz, int64_t this_ptr, jboolean val) {
10065 LDKChannelHandshakeLimits this_ptr_conv;
10066 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10067 this_ptr_conv.is_owned = false;
10068 ChannelHandshakeLimits_set_force_announced_channel_preference(&this_ptr_conv, val);
10071 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1get_1their_1to_1self_1delay(JNIEnv *env, jclass clz, int64_t this_ptr) {
10072 LDKChannelHandshakeLimits this_ptr_conv;
10073 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10074 this_ptr_conv.is_owned = false;
10075 int16_t ret_val = ChannelHandshakeLimits_get_their_to_self_delay(&this_ptr_conv);
10079 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) {
10080 LDKChannelHandshakeLimits this_ptr_conv;
10081 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10082 this_ptr_conv.is_owned = false;
10083 ChannelHandshakeLimits_set_their_to_self_delay(&this_ptr_conv, val);
10086 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, int64_t min_dust_limit_satoshis_arg, int64_t max_dust_limit_satoshis_arg, int32_t max_minimum_depth_arg, jboolean force_announced_channel_preference_arg, int16_t their_to_self_delay_arg) {
10087 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, min_dust_limit_satoshis_arg, max_dust_limit_satoshis_arg, max_minimum_depth_arg, force_announced_channel_preference_arg, their_to_self_delay_arg);
10088 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
10089 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
10090 long ret_ref = (long)ret_var.inner;
10091 if (ret_var.is_owned) {
10097 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10098 LDKChannelHandshakeLimits orig_conv;
10099 orig_conv.inner = (void*)(orig & (~1));
10100 orig_conv.is_owned = false;
10101 LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_clone(&orig_conv);
10102 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
10103 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
10104 long ret_ref = (long)ret_var.inner;
10105 if (ret_var.is_owned) {
10111 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1default(JNIEnv *env, jclass clz) {
10112 LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_default();
10113 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
10114 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
10115 long ret_ref = (long)ret_var.inner;
10116 if (ret_var.is_owned) {
10122 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
10123 LDKChannelConfig this_obj_conv;
10124 this_obj_conv.inner = (void*)(this_obj & (~1));
10125 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
10126 ChannelConfig_free(this_obj_conv);
10129 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1get_1fee_1proportional_1millionths(JNIEnv *env, jclass clz, int64_t this_ptr) {
10130 LDKChannelConfig this_ptr_conv;
10131 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10132 this_ptr_conv.is_owned = false;
10133 int32_t ret_val = ChannelConfig_get_fee_proportional_millionths(&this_ptr_conv);
10137 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1set_1fee_1proportional_1millionths(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
10138 LDKChannelConfig this_ptr_conv;
10139 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10140 this_ptr_conv.is_owned = false;
10141 ChannelConfig_set_fee_proportional_millionths(&this_ptr_conv, val);
10144 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1get_1announced_1channel(JNIEnv *env, jclass clz, int64_t this_ptr) {
10145 LDKChannelConfig this_ptr_conv;
10146 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10147 this_ptr_conv.is_owned = false;
10148 jboolean ret_val = ChannelConfig_get_announced_channel(&this_ptr_conv);
10152 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1set_1announced_1channel(JNIEnv *env, jclass clz, int64_t this_ptr, jboolean val) {
10153 LDKChannelConfig this_ptr_conv;
10154 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10155 this_ptr_conv.is_owned = false;
10156 ChannelConfig_set_announced_channel(&this_ptr_conv, val);
10159 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1get_1commit_1upfront_1shutdown_1pubkey(JNIEnv *env, jclass clz, int64_t this_ptr) {
10160 LDKChannelConfig this_ptr_conv;
10161 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10162 this_ptr_conv.is_owned = false;
10163 jboolean ret_val = ChannelConfig_get_commit_upfront_shutdown_pubkey(&this_ptr_conv);
10167 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1set_1commit_1upfront_1shutdown_1pubkey(JNIEnv *env, jclass clz, int64_t this_ptr, jboolean val) {
10168 LDKChannelConfig this_ptr_conv;
10169 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10170 this_ptr_conv.is_owned = false;
10171 ChannelConfig_set_commit_upfront_shutdown_pubkey(&this_ptr_conv, val);
10174 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1new(JNIEnv *env, jclass clz, int32_t fee_proportional_millionths_arg, jboolean announced_channel_arg, jboolean commit_upfront_shutdown_pubkey_arg) {
10175 LDKChannelConfig ret_var = ChannelConfig_new(fee_proportional_millionths_arg, announced_channel_arg, commit_upfront_shutdown_pubkey_arg);
10176 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
10177 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
10178 long ret_ref = (long)ret_var.inner;
10179 if (ret_var.is_owned) {
10185 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10186 LDKChannelConfig orig_conv;
10187 orig_conv.inner = (void*)(orig & (~1));
10188 orig_conv.is_owned = false;
10189 LDKChannelConfig ret_var = ChannelConfig_clone(&orig_conv);
10190 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
10191 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
10192 long ret_ref = (long)ret_var.inner;
10193 if (ret_var.is_owned) {
10199 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1default(JNIEnv *env, jclass clz) {
10200 LDKChannelConfig ret_var = ChannelConfig_default();
10201 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
10202 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
10203 long ret_ref = (long)ret_var.inner;
10204 if (ret_var.is_owned) {
10210 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1write(JNIEnv *env, jclass clz, int64_t obj) {
10211 LDKChannelConfig obj_conv;
10212 obj_conv.inner = (void*)(obj & (~1));
10213 obj_conv.is_owned = false;
10214 LDKCVec_u8Z ret_var = ChannelConfig_write(&obj_conv);
10215 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
10216 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
10217 CVec_u8Z_free(ret_var);
10221 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
10222 LDKu8slice ser_ref;
10223 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
10224 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
10225 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
10226 *ret_conv = ChannelConfig_read(ser_ref);
10227 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
10228 return (long)ret_conv;
10231 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UserConfig_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
10232 LDKUserConfig this_obj_conv;
10233 this_obj_conv.inner = (void*)(this_obj & (~1));
10234 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
10235 UserConfig_free(this_obj_conv);
10238 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UserConfig_1get_1own_1channel_1config(JNIEnv *env, jclass clz, int64_t this_ptr) {
10239 LDKUserConfig this_ptr_conv;
10240 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10241 this_ptr_conv.is_owned = false;
10242 LDKChannelHandshakeConfig ret_var = UserConfig_get_own_channel_config(&this_ptr_conv);
10243 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
10244 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
10245 long ret_ref = (long)ret_var.inner;
10246 if (ret_var.is_owned) {
10252 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UserConfig_1set_1own_1channel_1config(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
10253 LDKUserConfig this_ptr_conv;
10254 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10255 this_ptr_conv.is_owned = false;
10256 LDKChannelHandshakeConfig val_conv;
10257 val_conv.inner = (void*)(val & (~1));
10258 val_conv.is_owned = (val & 1) || (val == 0);
10259 val_conv = ChannelHandshakeConfig_clone(&val_conv);
10260 UserConfig_set_own_channel_config(&this_ptr_conv, val_conv);
10263 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UserConfig_1get_1peer_1channel_1config_1limits(JNIEnv *env, jclass clz, int64_t this_ptr) {
10264 LDKUserConfig this_ptr_conv;
10265 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10266 this_ptr_conv.is_owned = false;
10267 LDKChannelHandshakeLimits ret_var = UserConfig_get_peer_channel_config_limits(&this_ptr_conv);
10268 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
10269 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
10270 long ret_ref = (long)ret_var.inner;
10271 if (ret_var.is_owned) {
10277 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) {
10278 LDKUserConfig this_ptr_conv;
10279 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10280 this_ptr_conv.is_owned = false;
10281 LDKChannelHandshakeLimits val_conv;
10282 val_conv.inner = (void*)(val & (~1));
10283 val_conv.is_owned = (val & 1) || (val == 0);
10284 val_conv = ChannelHandshakeLimits_clone(&val_conv);
10285 UserConfig_set_peer_channel_config_limits(&this_ptr_conv, val_conv);
10288 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UserConfig_1get_1channel_1options(JNIEnv *env, jclass clz, int64_t this_ptr) {
10289 LDKUserConfig this_ptr_conv;
10290 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10291 this_ptr_conv.is_owned = false;
10292 LDKChannelConfig ret_var = UserConfig_get_channel_options(&this_ptr_conv);
10293 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
10294 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
10295 long ret_ref = (long)ret_var.inner;
10296 if (ret_var.is_owned) {
10302 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UserConfig_1set_1channel_1options(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
10303 LDKUserConfig this_ptr_conv;
10304 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10305 this_ptr_conv.is_owned = false;
10306 LDKChannelConfig val_conv;
10307 val_conv.inner = (void*)(val & (~1));
10308 val_conv.is_owned = (val & 1) || (val == 0);
10309 val_conv = ChannelConfig_clone(&val_conv);
10310 UserConfig_set_channel_options(&this_ptr_conv, val_conv);
10313 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) {
10314 LDKChannelHandshakeConfig own_channel_config_arg_conv;
10315 own_channel_config_arg_conv.inner = (void*)(own_channel_config_arg & (~1));
10316 own_channel_config_arg_conv.is_owned = (own_channel_config_arg & 1) || (own_channel_config_arg == 0);
10317 own_channel_config_arg_conv = ChannelHandshakeConfig_clone(&own_channel_config_arg_conv);
10318 LDKChannelHandshakeLimits peer_channel_config_limits_arg_conv;
10319 peer_channel_config_limits_arg_conv.inner = (void*)(peer_channel_config_limits_arg & (~1));
10320 peer_channel_config_limits_arg_conv.is_owned = (peer_channel_config_limits_arg & 1) || (peer_channel_config_limits_arg == 0);
10321 peer_channel_config_limits_arg_conv = ChannelHandshakeLimits_clone(&peer_channel_config_limits_arg_conv);
10322 LDKChannelConfig channel_options_arg_conv;
10323 channel_options_arg_conv.inner = (void*)(channel_options_arg & (~1));
10324 channel_options_arg_conv.is_owned = (channel_options_arg & 1) || (channel_options_arg == 0);
10325 channel_options_arg_conv = ChannelConfig_clone(&channel_options_arg_conv);
10326 LDKUserConfig ret_var = UserConfig_new(own_channel_config_arg_conv, peer_channel_config_limits_arg_conv, channel_options_arg_conv);
10327 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
10328 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
10329 long ret_ref = (long)ret_var.inner;
10330 if (ret_var.is_owned) {
10336 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UserConfig_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10337 LDKUserConfig orig_conv;
10338 orig_conv.inner = (void*)(orig & (~1));
10339 orig_conv.is_owned = false;
10340 LDKUserConfig ret_var = UserConfig_clone(&orig_conv);
10341 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
10342 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
10343 long ret_ref = (long)ret_var.inner;
10344 if (ret_var.is_owned) {
10350 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UserConfig_1default(JNIEnv *env, jclass clz) {
10351 LDKUserConfig ret_var = UserConfig_default();
10352 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
10353 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
10354 long ret_ref = (long)ret_var.inner;
10355 if (ret_var.is_owned) {
10361 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_AccessError_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10362 LDKAccessError* orig_conv = (LDKAccessError*)(orig & ~1);
10363 jclass ret_conv = LDKAccessError_to_java(env, AccessError_clone(orig_conv));
10367 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Access_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
10368 if ((this_ptr & 1) != 0) return;
10369 LDKAccess this_ptr_conv = *(LDKAccess*)(((uint64_t)this_ptr) & ~1);
10370 FREE((void*)this_ptr);
10371 Access_free(this_ptr_conv);
10374 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Listen_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
10375 if ((this_ptr & 1) != 0) return;
10376 LDKListen this_ptr_conv = *(LDKListen*)(((uint64_t)this_ptr) & ~1);
10377 FREE((void*)this_ptr);
10378 Listen_free(this_ptr_conv);
10381 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Watch_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
10382 if ((this_ptr & 1) != 0) return;
10383 LDKWatch this_ptr_conv = *(LDKWatch*)(((uint64_t)this_ptr) & ~1);
10384 FREE((void*)this_ptr);
10385 Watch_free(this_ptr_conv);
10388 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Filter_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
10389 if ((this_ptr & 1) != 0) return;
10390 LDKFilter this_ptr_conv = *(LDKFilter*)(((uint64_t)this_ptr) & ~1);
10391 FREE((void*)this_ptr);
10392 Filter_free(this_ptr_conv);
10395 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_BroadcasterInterface_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
10396 if ((this_ptr & 1) != 0) return;
10397 LDKBroadcasterInterface this_ptr_conv = *(LDKBroadcasterInterface*)(((uint64_t)this_ptr) & ~1);
10398 FREE((void*)this_ptr);
10399 BroadcasterInterface_free(this_ptr_conv);
10402 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_ConfirmationTarget_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10403 LDKConfirmationTarget* orig_conv = (LDKConfirmationTarget*)(orig & ~1);
10404 jclass ret_conv = LDKConfirmationTarget_to_java(env, ConfirmationTarget_clone(orig_conv));
10408 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_FeeEstimator_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
10409 if ((this_ptr & 1) != 0) return;
10410 LDKFeeEstimator this_ptr_conv = *(LDKFeeEstimator*)(((uint64_t)this_ptr) & ~1);
10411 FREE((void*)this_ptr);
10412 FeeEstimator_free(this_ptr_conv);
10415 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChainMonitor_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
10416 LDKChainMonitor this_obj_conv;
10417 this_obj_conv.inner = (void*)(this_obj & (~1));
10418 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
10419 ChainMonitor_free(this_obj_conv);
10422 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChainMonitor_1block_1connected(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray header, int64_tArray txdata, int32_t height) {
10423 LDKChainMonitor this_arg_conv;
10424 this_arg_conv.inner = (void*)(this_arg & (~1));
10425 this_arg_conv.is_owned = false;
10426 unsigned char header_arr[80];
10427 CHECK((*env)->GetArrayLength(env, header) == 80);
10428 (*env)->GetByteArrayRegion(env, header, 0, 80, header_arr);
10429 unsigned char (*header_ref)[80] = &header_arr;
10430 LDKCVec_C2Tuple_usizeTransactionZZ txdata_constr;
10431 txdata_constr.datalen = (*env)->GetArrayLength(env, txdata);
10432 if (txdata_constr.datalen > 0)
10433 txdata_constr.data = MALLOC(txdata_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
10435 txdata_constr.data = NULL;
10436 int64_t* txdata_vals = (*env)->GetLongArrayElements (env, txdata, NULL);
10437 for (size_t y = 0; y < txdata_constr.datalen; y++) {
10438 int64_t txdata_conv_24 = txdata_vals[y];
10439 LDKC2Tuple_usizeTransactionZ txdata_conv_24_conv = *(LDKC2Tuple_usizeTransactionZ*)(((uint64_t)txdata_conv_24) & ~1);
10440 FREE((void*)txdata_conv_24);
10441 txdata_constr.data[y] = txdata_conv_24_conv;
10443 (*env)->ReleaseLongArrayElements(env, txdata, txdata_vals, 0);
10444 ChainMonitor_block_connected(&this_arg_conv, header_ref, txdata_constr, height);
10447 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChainMonitor_1block_1disconnected(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray header, int32_t disconnected_height) {
10448 LDKChainMonitor this_arg_conv;
10449 this_arg_conv.inner = (void*)(this_arg & (~1));
10450 this_arg_conv.is_owned = false;
10451 unsigned char header_arr[80];
10452 CHECK((*env)->GetArrayLength(env, header) == 80);
10453 (*env)->GetByteArrayRegion(env, header, 0, 80, header_arr);
10454 unsigned char (*header_ref)[80] = &header_arr;
10455 ChainMonitor_block_disconnected(&this_arg_conv, header_ref, disconnected_height);
10458 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) {
10459 LDKFilter *chain_source_conv_ptr = NULL;
10460 if (chain_source != 0) {
10461 LDKFilter chain_source_conv;
10462 chain_source_conv = *(LDKFilter*)(((uint64_t)chain_source) & ~1);
10463 if (chain_source_conv.free == LDKFilter_JCalls_free) {
10464 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
10465 LDKFilter_JCalls_clone(chain_source_conv.this_arg);
10467 chain_source_conv_ptr = MALLOC(sizeof(LDKFilter), "LDKFilter");
10468 *chain_source_conv_ptr = chain_source_conv;
10470 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(((uint64_t)broadcaster) & ~1);
10471 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
10472 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
10473 LDKBroadcasterInterface_JCalls_clone(broadcaster_conv.this_arg);
10475 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
10476 if (logger_conv.free == LDKLogger_JCalls_free) {
10477 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
10478 LDKLogger_JCalls_clone(logger_conv.this_arg);
10480 LDKFeeEstimator feeest_conv = *(LDKFeeEstimator*)(((uint64_t)feeest) & ~1);
10481 if (feeest_conv.free == LDKFeeEstimator_JCalls_free) {
10482 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
10483 LDKFeeEstimator_JCalls_clone(feeest_conv.this_arg);
10485 LDKPersist persister_conv = *(LDKPersist*)(((uint64_t)persister) & ~1);
10486 if (persister_conv.free == LDKPersist_JCalls_free) {
10487 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
10488 LDKPersist_JCalls_clone(persister_conv.this_arg);
10490 LDKChainMonitor ret_var = ChainMonitor_new(chain_source_conv_ptr, broadcaster_conv, logger_conv, feeest_conv, persister_conv);
10491 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
10492 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
10493 long ret_ref = (long)ret_var.inner;
10494 if (ret_var.is_owned) {
10500 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChainMonitor_1as_1Watch(JNIEnv *env, jclass clz, int64_t this_arg) {
10501 LDKChainMonitor this_arg_conv;
10502 this_arg_conv.inner = (void*)(this_arg & (~1));
10503 this_arg_conv.is_owned = false;
10504 LDKWatch* ret = MALLOC(sizeof(LDKWatch), "LDKWatch");
10505 *ret = ChainMonitor_as_Watch(&this_arg_conv);
10509 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChainMonitor_1as_1EventsProvider(JNIEnv *env, jclass clz, int64_t this_arg) {
10510 LDKChainMonitor this_arg_conv;
10511 this_arg_conv.inner = (void*)(this_arg & (~1));
10512 this_arg_conv.is_owned = false;
10513 LDKEventsProvider* ret = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider");
10514 *ret = ChainMonitor_as_EventsProvider(&this_arg_conv);
10518 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMonitorUpdate_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
10519 LDKChannelMonitorUpdate this_obj_conv;
10520 this_obj_conv.inner = (void*)(this_obj & (~1));
10521 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
10522 ChannelMonitorUpdate_free(this_obj_conv);
10525 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelMonitorUpdate_1get_1update_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
10526 LDKChannelMonitorUpdate this_ptr_conv;
10527 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10528 this_ptr_conv.is_owned = false;
10529 int64_t ret_val = ChannelMonitorUpdate_get_update_id(&this_ptr_conv);
10533 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMonitorUpdate_1set_1update_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
10534 LDKChannelMonitorUpdate this_ptr_conv;
10535 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10536 this_ptr_conv.is_owned = false;
10537 ChannelMonitorUpdate_set_update_id(&this_ptr_conv, val);
10540 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelMonitorUpdate_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10541 LDKChannelMonitorUpdate orig_conv;
10542 orig_conv.inner = (void*)(orig & (~1));
10543 orig_conv.is_owned = false;
10544 LDKChannelMonitorUpdate ret_var = ChannelMonitorUpdate_clone(&orig_conv);
10545 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
10546 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
10547 long ret_ref = (long)ret_var.inner;
10548 if (ret_var.is_owned) {
10554 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelMonitorUpdate_1write(JNIEnv *env, jclass clz, int64_t obj) {
10555 LDKChannelMonitorUpdate obj_conv;
10556 obj_conv.inner = (void*)(obj & (~1));
10557 obj_conv.is_owned = false;
10558 LDKCVec_u8Z ret_var = ChannelMonitorUpdate_write(&obj_conv);
10559 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
10560 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
10561 CVec_u8Z_free(ret_var);
10565 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelMonitorUpdate_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
10566 LDKu8slice ser_ref;
10567 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
10568 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
10569 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
10570 *ret_conv = ChannelMonitorUpdate_read(ser_ref);
10571 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
10572 return (long)ret_conv;
10575 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_ChannelMonitorUpdateErr_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10576 LDKChannelMonitorUpdateErr* orig_conv = (LDKChannelMonitorUpdateErr*)(orig & ~1);
10577 jclass ret_conv = LDKChannelMonitorUpdateErr_to_java(env, ChannelMonitorUpdateErr_clone(orig_conv));
10581 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_MonitorUpdateError_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
10582 LDKMonitorUpdateError this_obj_conv;
10583 this_obj_conv.inner = (void*)(this_obj & (~1));
10584 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
10585 MonitorUpdateError_free(this_obj_conv);
10588 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MonitorUpdateError_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10589 LDKMonitorUpdateError orig_conv;
10590 orig_conv.inner = (void*)(orig & (~1));
10591 orig_conv.is_owned = false;
10592 LDKMonitorUpdateError ret_var = MonitorUpdateError_clone(&orig_conv);
10593 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
10594 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
10595 long ret_ref = (long)ret_var.inner;
10596 if (ret_var.is_owned) {
10602 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_MonitorEvent_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
10603 if ((this_ptr & 1) != 0) return;
10604 LDKMonitorEvent this_ptr_conv = *(LDKMonitorEvent*)(((uint64_t)this_ptr) & ~1);
10605 FREE((void*)this_ptr);
10606 MonitorEvent_free(this_ptr_conv);
10609 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MonitorEvent_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10610 LDKMonitorEvent* orig_conv = (LDKMonitorEvent*)orig;
10611 LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
10612 *ret_copy = MonitorEvent_clone(orig_conv);
10613 long ret_ref = (long)ret_copy;
10617 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_HTLCUpdate_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
10618 LDKHTLCUpdate this_obj_conv;
10619 this_obj_conv.inner = (void*)(this_obj & (~1));
10620 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
10621 HTLCUpdate_free(this_obj_conv);
10624 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_HTLCUpdate_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10625 LDKHTLCUpdate orig_conv;
10626 orig_conv.inner = (void*)(orig & (~1));
10627 orig_conv.is_owned = false;
10628 LDKHTLCUpdate ret_var = HTLCUpdate_clone(&orig_conv);
10629 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
10630 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
10631 long ret_ref = (long)ret_var.inner;
10632 if (ret_var.is_owned) {
10638 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_HTLCUpdate_1write(JNIEnv *env, jclass clz, int64_t obj) {
10639 LDKHTLCUpdate obj_conv;
10640 obj_conv.inner = (void*)(obj & (~1));
10641 obj_conv.is_owned = false;
10642 LDKCVec_u8Z ret_var = HTLCUpdate_write(&obj_conv);
10643 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
10644 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
10645 CVec_u8Z_free(ret_var);
10649 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_HTLCUpdate_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
10650 LDKu8slice ser_ref;
10651 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
10652 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
10653 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
10654 *ret_conv = HTLCUpdate_read(ser_ref);
10655 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
10656 return (long)ret_conv;
10659 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMonitor_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
10660 LDKChannelMonitor this_obj_conv;
10661 this_obj_conv.inner = (void*)(this_obj & (~1));
10662 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
10663 ChannelMonitor_free(this_obj_conv);
10666 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelMonitor_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10667 LDKChannelMonitor orig_conv;
10668 orig_conv.inner = (void*)(orig & (~1));
10669 orig_conv.is_owned = false;
10670 LDKChannelMonitor ret_var = ChannelMonitor_clone(&orig_conv);
10671 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
10672 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
10673 long ret_ref = (long)ret_var.inner;
10674 if (ret_var.is_owned) {
10680 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelMonitor_1write(JNIEnv *env, jclass clz, int64_t obj) {
10681 LDKChannelMonitor obj_conv;
10682 obj_conv.inner = (void*)(obj & (~1));
10683 obj_conv.is_owned = false;
10684 LDKCVec_u8Z ret_var = ChannelMonitor_write(&obj_conv);
10685 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
10686 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
10687 CVec_u8Z_free(ret_var);
10691 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) {
10692 LDKChannelMonitor this_arg_conv;
10693 this_arg_conv.inner = (void*)(this_arg & (~1));
10694 this_arg_conv.is_owned = false;
10695 LDKChannelMonitorUpdate updates_conv;
10696 updates_conv.inner = (void*)(updates & (~1));
10697 updates_conv.is_owned = false;
10698 LDKBroadcasterInterface* broadcaster_conv = (LDKBroadcasterInterface*)(((uint64_t)broadcaster) & ~1);
10699 LDKFeeEstimator* fee_estimator_conv = (LDKFeeEstimator*)(((uint64_t)fee_estimator) & ~1);
10700 LDKLogger* logger_conv = (LDKLogger*)(((uint64_t)logger) & ~1);
10701 LDKCResult_NoneMonitorUpdateErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneMonitorUpdateErrorZ), "LDKCResult_NoneMonitorUpdateErrorZ");
10702 *ret_conv = ChannelMonitor_update_monitor(&this_arg_conv, &updates_conv, broadcaster_conv, fee_estimator_conv, logger_conv);
10703 return (long)ret_conv;
10706 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelMonitor_1get_1latest_1update_1id(JNIEnv *env, jclass clz, int64_t this_arg) {
10707 LDKChannelMonitor this_arg_conv;
10708 this_arg_conv.inner = (void*)(this_arg & (~1));
10709 this_arg_conv.is_owned = false;
10710 int64_t ret_val = ChannelMonitor_get_latest_update_id(&this_arg_conv);
10714 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelMonitor_1get_1funding_1txo(JNIEnv *env, jclass clz, int64_t this_arg) {
10715 LDKChannelMonitor this_arg_conv;
10716 this_arg_conv.inner = (void*)(this_arg & (~1));
10717 this_arg_conv.is_owned = false;
10718 LDKC2Tuple_OutPointScriptZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
10719 *ret_ref = ChannelMonitor_get_funding_txo(&this_arg_conv);
10720 return (long)ret_ref;
10723 JNIEXPORT int64_tArray JNICALL Java_org_ldk_impl_bindings_ChannelMonitor_1get_1outputs_1to_1watch(JNIEnv *env, jclass clz, int64_t this_arg) {
10724 LDKChannelMonitor this_arg_conv;
10725 this_arg_conv.inner = (void*)(this_arg & (~1));
10726 this_arg_conv.is_owned = false;
10727 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ret_var = ChannelMonitor_get_outputs_to_watch(&this_arg_conv);
10728 int64_tArray ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
10729 int64_t *ret_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, ret_arr, NULL);
10730 for (size_t v = 0; v < ret_var.datalen; v++) {
10731 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv_47_ref = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
10732 *ret_conv_47_ref = ret_var.data[v];
10733 ret_arr_ptr[v] = (long)ret_conv_47_ref;
10735 (*env)->ReleasePrimitiveArrayCritical(env, ret_arr, ret_arr_ptr, 0);
10736 FREE(ret_var.data);
10740 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMonitor_1load_1outputs_1to_1watch(JNIEnv *env, jclass clz, int64_t this_arg, int64_t filter) {
10741 LDKChannelMonitor this_arg_conv;
10742 this_arg_conv.inner = (void*)(this_arg & (~1));
10743 this_arg_conv.is_owned = false;
10744 LDKFilter* filter_conv = (LDKFilter*)(((uint64_t)filter) & ~1);
10745 ChannelMonitor_load_outputs_to_watch(&this_arg_conv, filter_conv);
10748 JNIEXPORT int64_tArray JNICALL Java_org_ldk_impl_bindings_ChannelMonitor_1get_1and_1clear_1pending_1monitor_1events(JNIEnv *env, jclass clz, int64_t this_arg) {
10749 LDKChannelMonitor this_arg_conv;
10750 this_arg_conv.inner = (void*)(this_arg & (~1));
10751 this_arg_conv.is_owned = false;
10752 LDKCVec_MonitorEventZ ret_var = ChannelMonitor_get_and_clear_pending_monitor_events(&this_arg_conv);
10753 int64_tArray ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
10754 int64_t *ret_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, ret_arr, NULL);
10755 for (size_t o = 0; o < ret_var.datalen; o++) {
10756 LDKMonitorEvent *ret_conv_14_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
10757 *ret_conv_14_copy = MonitorEvent_clone(&ret_var.data[o]);
10758 long ret_conv_14_ref = (long)ret_conv_14_copy;
10759 ret_arr_ptr[o] = ret_conv_14_ref;
10761 (*env)->ReleasePrimitiveArrayCritical(env, ret_arr, ret_arr_ptr, 0);
10762 FREE(ret_var.data);
10766 JNIEXPORT int64_tArray JNICALL Java_org_ldk_impl_bindings_ChannelMonitor_1get_1and_1clear_1pending_1events(JNIEnv *env, jclass clz, int64_t this_arg) {
10767 LDKChannelMonitor this_arg_conv;
10768 this_arg_conv.inner = (void*)(this_arg & (~1));
10769 this_arg_conv.is_owned = false;
10770 LDKCVec_EventZ ret_var = ChannelMonitor_get_and_clear_pending_events(&this_arg_conv);
10771 int64_tArray ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
10772 int64_t *ret_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, ret_arr, NULL);
10773 for (size_t h = 0; h < ret_var.datalen; h++) {
10774 LDKEvent *ret_conv_7_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
10775 *ret_conv_7_copy = Event_clone(&ret_var.data[h]);
10776 long ret_conv_7_ref = (long)ret_conv_7_copy;
10777 ret_arr_ptr[h] = ret_conv_7_ref;
10779 (*env)->ReleasePrimitiveArrayCritical(env, ret_arr, ret_arr_ptr, 0);
10780 FREE(ret_var.data);
10784 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) {
10785 LDKChannelMonitor this_arg_conv;
10786 this_arg_conv.inner = (void*)(this_arg & (~1));
10787 this_arg_conv.is_owned = false;
10788 LDKLogger* logger_conv = (LDKLogger*)(((uint64_t)logger) & ~1);
10789 LDKCVec_TransactionZ ret_var = ChannelMonitor_get_latest_holder_commitment_txn(&this_arg_conv, logger_conv);
10790 jobjectArray ret_arr = (*env)->NewObjectArray(env, ret_var.datalen, arr_of_B_clz, NULL);
10792 for (size_t i = 0; i < ret_var.datalen; i++) {
10793 LDKTransaction ret_conv_8_var = ret_var.data[i];
10794 int8_tArray ret_conv_8_arr = (*env)->NewByteArray(env, ret_conv_8_var.datalen);
10795 (*env)->SetByteArrayRegion(env, ret_conv_8_arr, 0, ret_conv_8_var.datalen, ret_conv_8_var.data);
10796 Transaction_free(ret_conv_8_var);
10797 (*env)->SetObjectArrayElement(env, ret_arr, i, ret_conv_8_arr);
10799 FREE(ret_var.data);
10803 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) {
10804 LDKChannelMonitor this_arg_conv;
10805 this_arg_conv.inner = (void*)(this_arg & (~1));
10806 this_arg_conv.is_owned = false;
10807 unsigned char header_arr[80];
10808 CHECK((*env)->GetArrayLength(env, header) == 80);
10809 (*env)->GetByteArrayRegion(env, header, 0, 80, header_arr);
10810 unsigned char (*header_ref)[80] = &header_arr;
10811 LDKCVec_C2Tuple_usizeTransactionZZ txdata_constr;
10812 txdata_constr.datalen = (*env)->GetArrayLength(env, txdata);
10813 if (txdata_constr.datalen > 0)
10814 txdata_constr.data = MALLOC(txdata_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
10816 txdata_constr.data = NULL;
10817 int64_t* txdata_vals = (*env)->GetLongArrayElements (env, txdata, NULL);
10818 for (size_t y = 0; y < txdata_constr.datalen; y++) {
10819 int64_t txdata_conv_24 = txdata_vals[y];
10820 LDKC2Tuple_usizeTransactionZ txdata_conv_24_conv = *(LDKC2Tuple_usizeTransactionZ*)(((uint64_t)txdata_conv_24) & ~1);
10821 FREE((void*)txdata_conv_24);
10822 txdata_constr.data[y] = txdata_conv_24_conv;
10824 (*env)->ReleaseLongArrayElements(env, txdata, txdata_vals, 0);
10825 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(((uint64_t)broadcaster) & ~1);
10826 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
10827 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
10828 LDKBroadcasterInterface_JCalls_clone(broadcaster_conv.this_arg);
10830 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(((uint64_t)fee_estimator) & ~1);
10831 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
10832 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
10833 LDKFeeEstimator_JCalls_clone(fee_estimator_conv.this_arg);
10835 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
10836 if (logger_conv.free == LDKLogger_JCalls_free) {
10837 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
10838 LDKLogger_JCalls_clone(logger_conv.this_arg);
10840 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);
10841 int64_tArray ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
10842 int64_t *ret_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, ret_arr, NULL);
10843 for (size_t u = 0; u < ret_var.datalen; u++) {
10844 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv_46_ref = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
10845 *ret_conv_46_ref = ret_var.data[u];
10846 ret_arr_ptr[u] = (long)ret_conv_46_ref;
10848 (*env)->ReleasePrimitiveArrayCritical(env, ret_arr, ret_arr_ptr, 0);
10849 FREE(ret_var.data);
10853 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) {
10854 LDKChannelMonitor this_arg_conv;
10855 this_arg_conv.inner = (void*)(this_arg & (~1));
10856 this_arg_conv.is_owned = false;
10857 unsigned char header_arr[80];
10858 CHECK((*env)->GetArrayLength(env, header) == 80);
10859 (*env)->GetByteArrayRegion(env, header, 0, 80, header_arr);
10860 unsigned char (*header_ref)[80] = &header_arr;
10861 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(((uint64_t)broadcaster) & ~1);
10862 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
10863 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
10864 LDKBroadcasterInterface_JCalls_clone(broadcaster_conv.this_arg);
10866 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(((uint64_t)fee_estimator) & ~1);
10867 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
10868 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
10869 LDKFeeEstimator_JCalls_clone(fee_estimator_conv.this_arg);
10871 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
10872 if (logger_conv.free == LDKLogger_JCalls_free) {
10873 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
10874 LDKLogger_JCalls_clone(logger_conv.this_arg);
10876 ChannelMonitor_block_disconnected(&this_arg_conv, header_ref, height, broadcaster_conv, fee_estimator_conv, logger_conv);
10879 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Persist_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
10880 if ((this_ptr & 1) != 0) return;
10881 LDKPersist this_ptr_conv = *(LDKPersist*)(((uint64_t)this_ptr) & ~1);
10882 FREE((void*)this_ptr);
10883 Persist_free(this_ptr_conv);
10886 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1BlockHashChannelMonitorZ_1read(JNIEnv *env, jclass clz, int8_tArray ser, int64_t arg) {
10887 LDKu8slice ser_ref;
10888 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
10889 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
10890 LDKKeysInterface* arg_conv = (LDKKeysInterface*)(((uint64_t)arg) & ~1);
10891 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
10892 *ret_conv = C2Tuple_BlockHashChannelMonitorZ_read(ser_ref, arg_conv);
10893 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
10894 return (long)ret_conv;
10897 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OutPoint_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
10898 LDKOutPoint this_obj_conv;
10899 this_obj_conv.inner = (void*)(this_obj & (~1));
10900 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
10901 OutPoint_free(this_obj_conv);
10904 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_OutPoint_1get_1txid(JNIEnv *env, jclass clz, int64_t this_ptr) {
10905 LDKOutPoint this_ptr_conv;
10906 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10907 this_ptr_conv.is_owned = false;
10908 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
10909 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *OutPoint_get_txid(&this_ptr_conv));
10913 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OutPoint_1set_1txid(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
10914 LDKOutPoint this_ptr_conv;
10915 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10916 this_ptr_conv.is_owned = false;
10917 LDKThirtyTwoBytes val_ref;
10918 CHECK((*env)->GetArrayLength(env, val) == 32);
10919 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
10920 OutPoint_set_txid(&this_ptr_conv, val_ref);
10923 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_OutPoint_1get_1index(JNIEnv *env, jclass clz, int64_t this_ptr) {
10924 LDKOutPoint this_ptr_conv;
10925 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10926 this_ptr_conv.is_owned = false;
10927 int16_t ret_val = OutPoint_get_index(&this_ptr_conv);
10931 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OutPoint_1set_1index(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
10932 LDKOutPoint this_ptr_conv;
10933 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10934 this_ptr_conv.is_owned = false;
10935 OutPoint_set_index(&this_ptr_conv, val);
10938 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OutPoint_1new(JNIEnv *env, jclass clz, int8_tArray txid_arg, int16_t index_arg) {
10939 LDKThirtyTwoBytes txid_arg_ref;
10940 CHECK((*env)->GetArrayLength(env, txid_arg) == 32);
10941 (*env)->GetByteArrayRegion(env, txid_arg, 0, 32, txid_arg_ref.data);
10942 LDKOutPoint ret_var = OutPoint_new(txid_arg_ref, index_arg);
10943 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
10944 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
10945 long ret_ref = (long)ret_var.inner;
10946 if (ret_var.is_owned) {
10952 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OutPoint_1clone(JNIEnv *env, jclass clz, int64_t orig) {
10953 LDKOutPoint orig_conv;
10954 orig_conv.inner = (void*)(orig & (~1));
10955 orig_conv.is_owned = false;
10956 LDKOutPoint ret_var = OutPoint_clone(&orig_conv);
10957 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
10958 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
10959 long ret_ref = (long)ret_var.inner;
10960 if (ret_var.is_owned) {
10966 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_OutPoint_1to_1channel_1id(JNIEnv *env, jclass clz, int64_t this_arg) {
10967 LDKOutPoint this_arg_conv;
10968 this_arg_conv.inner = (void*)(this_arg & (~1));
10969 this_arg_conv.is_owned = false;
10970 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
10971 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, OutPoint_to_channel_id(&this_arg_conv).data);
10975 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_OutPoint_1write(JNIEnv *env, jclass clz, int64_t obj) {
10976 LDKOutPoint obj_conv;
10977 obj_conv.inner = (void*)(obj & (~1));
10978 obj_conv.is_owned = false;
10979 LDKCVec_u8Z ret_var = OutPoint_write(&obj_conv);
10980 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
10981 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
10982 CVec_u8Z_free(ret_var);
10986 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OutPoint_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
10987 LDKu8slice ser_ref;
10988 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
10989 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
10990 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
10991 *ret_conv = OutPoint_read(ser_ref);
10992 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
10993 return (long)ret_conv;
10996 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
10997 LDKDelayedPaymentOutputDescriptor this_obj_conv;
10998 this_obj_conv.inner = (void*)(this_obj & (~1));
10999 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
11000 DelayedPaymentOutputDescriptor_free(this_obj_conv);
11003 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1get_1outpoint(JNIEnv *env, jclass clz, int64_t this_ptr) {
11004 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
11005 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11006 this_ptr_conv.is_owned = false;
11007 LDKOutPoint ret_var = DelayedPaymentOutputDescriptor_get_outpoint(&this_ptr_conv);
11008 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11009 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11010 long ret_ref = (long)ret_var.inner;
11011 if (ret_var.is_owned) {
11017 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1set_1outpoint(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
11018 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
11019 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11020 this_ptr_conv.is_owned = false;
11021 LDKOutPoint val_conv;
11022 val_conv.inner = (void*)(val & (~1));
11023 val_conv.is_owned = (val & 1) || (val == 0);
11024 val_conv = OutPoint_clone(&val_conv);
11025 DelayedPaymentOutputDescriptor_set_outpoint(&this_ptr_conv, val_conv);
11028 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1get_1per_1commitment_1point(JNIEnv *env, jclass clz, int64_t this_ptr) {
11029 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
11030 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11031 this_ptr_conv.is_owned = false;
11032 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
11033 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, DelayedPaymentOutputDescriptor_get_per_commitment_point(&this_ptr_conv).compressed_form);
11037 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1set_1per_1commitment_1point(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
11038 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
11039 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11040 this_ptr_conv.is_owned = false;
11041 LDKPublicKey val_ref;
11042 CHECK((*env)->GetArrayLength(env, val) == 33);
11043 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
11044 DelayedPaymentOutputDescriptor_set_per_commitment_point(&this_ptr_conv, val_ref);
11047 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1get_1to_1self_1delay(JNIEnv *env, jclass clz, int64_t this_ptr) {
11048 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
11049 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11050 this_ptr_conv.is_owned = false;
11051 int16_t ret_val = DelayedPaymentOutputDescriptor_get_to_self_delay(&this_ptr_conv);
11055 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1set_1to_1self_1delay(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
11056 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
11057 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11058 this_ptr_conv.is_owned = false;
11059 DelayedPaymentOutputDescriptor_set_to_self_delay(&this_ptr_conv, val);
11062 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1set_1output(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
11063 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
11064 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11065 this_ptr_conv.is_owned = false;
11066 LDKTxOut val_conv = *(LDKTxOut*)(((uint64_t)val) & ~1);
11068 DelayedPaymentOutputDescriptor_set_output(&this_ptr_conv, val_conv);
11071 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1get_1revocation_1pubkey(JNIEnv *env, jclass clz, int64_t this_ptr) {
11072 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
11073 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11074 this_ptr_conv.is_owned = false;
11075 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
11076 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, DelayedPaymentOutputDescriptor_get_revocation_pubkey(&this_ptr_conv).compressed_form);
11080 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1set_1revocation_1pubkey(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
11081 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
11082 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11083 this_ptr_conv.is_owned = false;
11084 LDKPublicKey val_ref;
11085 CHECK((*env)->GetArrayLength(env, val) == 33);
11086 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
11087 DelayedPaymentOutputDescriptor_set_revocation_pubkey(&this_ptr_conv, val_ref);
11090 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1get_1channel_1keys_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
11091 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
11092 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11093 this_ptr_conv.is_owned = false;
11094 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
11095 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *DelayedPaymentOutputDescriptor_get_channel_keys_id(&this_ptr_conv));
11099 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1set_1channel_1keys_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
11100 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
11101 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11102 this_ptr_conv.is_owned = false;
11103 LDKThirtyTwoBytes val_ref;
11104 CHECK((*env)->GetArrayLength(env, val) == 32);
11105 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
11106 DelayedPaymentOutputDescriptor_set_channel_keys_id(&this_ptr_conv, val_ref);
11109 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1get_1channel_1value_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr) {
11110 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
11111 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11112 this_ptr_conv.is_owned = false;
11113 int64_t ret_val = DelayedPaymentOutputDescriptor_get_channel_value_satoshis(&this_ptr_conv);
11117 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1set_1channel_1value_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
11118 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
11119 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11120 this_ptr_conv.is_owned = false;
11121 DelayedPaymentOutputDescriptor_set_channel_value_satoshis(&this_ptr_conv, val);
11124 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) {
11125 LDKOutPoint outpoint_arg_conv;
11126 outpoint_arg_conv.inner = (void*)(outpoint_arg & (~1));
11127 outpoint_arg_conv.is_owned = (outpoint_arg & 1) || (outpoint_arg == 0);
11128 outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
11129 LDKPublicKey per_commitment_point_arg_ref;
11130 CHECK((*env)->GetArrayLength(env, per_commitment_point_arg) == 33);
11131 (*env)->GetByteArrayRegion(env, per_commitment_point_arg, 0, 33, per_commitment_point_arg_ref.compressed_form);
11132 LDKTxOut output_arg_conv = *(LDKTxOut*)(((uint64_t)output_arg) & ~1);
11133 FREE((void*)output_arg);
11134 LDKPublicKey revocation_pubkey_arg_ref;
11135 CHECK((*env)->GetArrayLength(env, revocation_pubkey_arg) == 33);
11136 (*env)->GetByteArrayRegion(env, revocation_pubkey_arg, 0, 33, revocation_pubkey_arg_ref.compressed_form);
11137 LDKThirtyTwoBytes channel_keys_id_arg_ref;
11138 CHECK((*env)->GetArrayLength(env, channel_keys_id_arg) == 32);
11139 (*env)->GetByteArrayRegion(env, channel_keys_id_arg, 0, 32, channel_keys_id_arg_ref.data);
11140 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);
11141 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11142 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11143 long ret_ref = (long)ret_var.inner;
11144 if (ret_var.is_owned) {
11150 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1clone(JNIEnv *env, jclass clz, int64_t orig) {
11151 LDKDelayedPaymentOutputDescriptor orig_conv;
11152 orig_conv.inner = (void*)(orig & (~1));
11153 orig_conv.is_owned = false;
11154 LDKDelayedPaymentOutputDescriptor ret_var = DelayedPaymentOutputDescriptor_clone(&orig_conv);
11155 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11156 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11157 long ret_ref = (long)ret_var.inner;
11158 if (ret_var.is_owned) {
11164 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_StaticPaymentOutputDescriptor_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
11165 LDKStaticPaymentOutputDescriptor this_obj_conv;
11166 this_obj_conv.inner = (void*)(this_obj & (~1));
11167 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
11168 StaticPaymentOutputDescriptor_free(this_obj_conv);
11171 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_StaticPaymentOutputDescriptor_1get_1outpoint(JNIEnv *env, jclass clz, int64_t this_ptr) {
11172 LDKStaticPaymentOutputDescriptor this_ptr_conv;
11173 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11174 this_ptr_conv.is_owned = false;
11175 LDKOutPoint ret_var = StaticPaymentOutputDescriptor_get_outpoint(&this_ptr_conv);
11176 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11177 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11178 long ret_ref = (long)ret_var.inner;
11179 if (ret_var.is_owned) {
11185 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_StaticPaymentOutputDescriptor_1set_1outpoint(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
11186 LDKStaticPaymentOutputDescriptor this_ptr_conv;
11187 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11188 this_ptr_conv.is_owned = false;
11189 LDKOutPoint val_conv;
11190 val_conv.inner = (void*)(val & (~1));
11191 val_conv.is_owned = (val & 1) || (val == 0);
11192 val_conv = OutPoint_clone(&val_conv);
11193 StaticPaymentOutputDescriptor_set_outpoint(&this_ptr_conv, val_conv);
11196 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_StaticPaymentOutputDescriptor_1set_1output(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
11197 LDKStaticPaymentOutputDescriptor this_ptr_conv;
11198 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11199 this_ptr_conv.is_owned = false;
11200 LDKTxOut val_conv = *(LDKTxOut*)(((uint64_t)val) & ~1);
11202 StaticPaymentOutputDescriptor_set_output(&this_ptr_conv, val_conv);
11205 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_StaticPaymentOutputDescriptor_1get_1channel_1keys_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
11206 LDKStaticPaymentOutputDescriptor this_ptr_conv;
11207 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11208 this_ptr_conv.is_owned = false;
11209 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
11210 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *StaticPaymentOutputDescriptor_get_channel_keys_id(&this_ptr_conv));
11214 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_StaticPaymentOutputDescriptor_1set_1channel_1keys_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
11215 LDKStaticPaymentOutputDescriptor this_ptr_conv;
11216 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11217 this_ptr_conv.is_owned = false;
11218 LDKThirtyTwoBytes val_ref;
11219 CHECK((*env)->GetArrayLength(env, val) == 32);
11220 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
11221 StaticPaymentOutputDescriptor_set_channel_keys_id(&this_ptr_conv, val_ref);
11224 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_StaticPaymentOutputDescriptor_1get_1channel_1value_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr) {
11225 LDKStaticPaymentOutputDescriptor this_ptr_conv;
11226 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11227 this_ptr_conv.is_owned = false;
11228 int64_t ret_val = StaticPaymentOutputDescriptor_get_channel_value_satoshis(&this_ptr_conv);
11232 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_StaticPaymentOutputDescriptor_1set_1channel_1value_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
11233 LDKStaticPaymentOutputDescriptor this_ptr_conv;
11234 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11235 this_ptr_conv.is_owned = false;
11236 StaticPaymentOutputDescriptor_set_channel_value_satoshis(&this_ptr_conv, val);
11239 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) {
11240 LDKOutPoint outpoint_arg_conv;
11241 outpoint_arg_conv.inner = (void*)(outpoint_arg & (~1));
11242 outpoint_arg_conv.is_owned = (outpoint_arg & 1) || (outpoint_arg == 0);
11243 outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
11244 LDKTxOut output_arg_conv = *(LDKTxOut*)(((uint64_t)output_arg) & ~1);
11245 FREE((void*)output_arg);
11246 LDKThirtyTwoBytes channel_keys_id_arg_ref;
11247 CHECK((*env)->GetArrayLength(env, channel_keys_id_arg) == 32);
11248 (*env)->GetByteArrayRegion(env, channel_keys_id_arg, 0, 32, channel_keys_id_arg_ref.data);
11249 LDKStaticPaymentOutputDescriptor ret_var = StaticPaymentOutputDescriptor_new(outpoint_arg_conv, output_arg_conv, channel_keys_id_arg_ref, channel_value_satoshis_arg);
11250 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11251 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11252 long ret_ref = (long)ret_var.inner;
11253 if (ret_var.is_owned) {
11259 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_StaticPaymentOutputDescriptor_1clone(JNIEnv *env, jclass clz, int64_t orig) {
11260 LDKStaticPaymentOutputDescriptor orig_conv;
11261 orig_conv.inner = (void*)(orig & (~1));
11262 orig_conv.is_owned = false;
11263 LDKStaticPaymentOutputDescriptor ret_var = StaticPaymentOutputDescriptor_clone(&orig_conv);
11264 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11265 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11266 long ret_ref = (long)ret_var.inner;
11267 if (ret_var.is_owned) {
11273 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_SpendableOutputDescriptor_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
11274 if ((this_ptr & 1) != 0) return;
11275 LDKSpendableOutputDescriptor this_ptr_conv = *(LDKSpendableOutputDescriptor*)(((uint64_t)this_ptr) & ~1);
11276 FREE((void*)this_ptr);
11277 SpendableOutputDescriptor_free(this_ptr_conv);
11280 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SpendableOutputDescriptor_1clone(JNIEnv *env, jclass clz, int64_t orig) {
11281 LDKSpendableOutputDescriptor* orig_conv = (LDKSpendableOutputDescriptor*)orig;
11282 LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
11283 *ret_copy = SpendableOutputDescriptor_clone(orig_conv);
11284 long ret_ref = (long)ret_copy;
11288 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_SpendableOutputDescriptor_1write(JNIEnv *env, jclass clz, int64_t obj) {
11289 LDKSpendableOutputDescriptor* obj_conv = (LDKSpendableOutputDescriptor*)obj;
11290 LDKCVec_u8Z ret_var = SpendableOutputDescriptor_write(obj_conv);
11291 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
11292 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
11293 CVec_u8Z_free(ret_var);
11297 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SpendableOutputDescriptor_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
11298 LDKu8slice ser_ref;
11299 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
11300 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
11301 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
11302 *ret_conv = SpendableOutputDescriptor_read(ser_ref);
11303 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
11304 return (long)ret_conv;
11307 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Sign_1clone(JNIEnv *env, jclass clz, int64_t orig) {
11308 LDKSign* orig_conv = (LDKSign*)(((uint64_t)orig) & ~1);
11309 LDKSign* ret = MALLOC(sizeof(LDKSign), "LDKSign");
11310 *ret = Sign_clone(orig_conv);
11314 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Sign_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
11315 if ((this_ptr & 1) != 0) return;
11316 LDKSign this_ptr_conv = *(LDKSign*)(((uint64_t)this_ptr) & ~1);
11317 FREE((void*)this_ptr);
11318 Sign_free(this_ptr_conv);
11321 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_KeysInterface_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
11322 if ((this_ptr & 1) != 0) return;
11323 LDKKeysInterface this_ptr_conv = *(LDKKeysInterface*)(((uint64_t)this_ptr) & ~1);
11324 FREE((void*)this_ptr);
11325 KeysInterface_free(this_ptr_conv);
11328 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
11329 LDKInMemorySigner this_obj_conv;
11330 this_obj_conv.inner = (void*)(this_obj & (~1));
11331 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
11332 InMemorySigner_free(this_obj_conv);
11335 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1get_1funding_1key(JNIEnv *env, jclass clz, int64_t this_ptr) {
11336 LDKInMemorySigner this_ptr_conv;
11337 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11338 this_ptr_conv.is_owned = false;
11339 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
11340 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *InMemorySigner_get_funding_key(&this_ptr_conv));
11344 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1set_1funding_1key(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
11345 LDKInMemorySigner this_ptr_conv;
11346 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11347 this_ptr_conv.is_owned = false;
11348 LDKSecretKey val_ref;
11349 CHECK((*env)->GetArrayLength(env, val) == 32);
11350 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.bytes);
11351 InMemorySigner_set_funding_key(&this_ptr_conv, val_ref);
11354 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1get_1revocation_1base_1key(JNIEnv *env, jclass clz, int64_t this_ptr) {
11355 LDKInMemorySigner this_ptr_conv;
11356 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11357 this_ptr_conv.is_owned = false;
11358 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
11359 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *InMemorySigner_get_revocation_base_key(&this_ptr_conv));
11363 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1set_1revocation_1base_1key(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
11364 LDKInMemorySigner this_ptr_conv;
11365 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11366 this_ptr_conv.is_owned = false;
11367 LDKSecretKey val_ref;
11368 CHECK((*env)->GetArrayLength(env, val) == 32);
11369 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.bytes);
11370 InMemorySigner_set_revocation_base_key(&this_ptr_conv, val_ref);
11373 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1get_1payment_1key(JNIEnv *env, jclass clz, int64_t this_ptr) {
11374 LDKInMemorySigner this_ptr_conv;
11375 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11376 this_ptr_conv.is_owned = false;
11377 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
11378 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *InMemorySigner_get_payment_key(&this_ptr_conv));
11382 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1set_1payment_1key(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
11383 LDKInMemorySigner this_ptr_conv;
11384 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11385 this_ptr_conv.is_owned = false;
11386 LDKSecretKey val_ref;
11387 CHECK((*env)->GetArrayLength(env, val) == 32);
11388 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.bytes);
11389 InMemorySigner_set_payment_key(&this_ptr_conv, val_ref);
11392 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1get_1delayed_1payment_1base_1key(JNIEnv *env, jclass clz, int64_t this_ptr) {
11393 LDKInMemorySigner this_ptr_conv;
11394 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11395 this_ptr_conv.is_owned = false;
11396 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
11397 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *InMemorySigner_get_delayed_payment_base_key(&this_ptr_conv));
11401 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) {
11402 LDKInMemorySigner this_ptr_conv;
11403 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11404 this_ptr_conv.is_owned = false;
11405 LDKSecretKey val_ref;
11406 CHECK((*env)->GetArrayLength(env, val) == 32);
11407 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.bytes);
11408 InMemorySigner_set_delayed_payment_base_key(&this_ptr_conv, val_ref);
11411 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1get_1htlc_1base_1key(JNIEnv *env, jclass clz, int64_t this_ptr) {
11412 LDKInMemorySigner this_ptr_conv;
11413 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11414 this_ptr_conv.is_owned = false;
11415 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
11416 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *InMemorySigner_get_htlc_base_key(&this_ptr_conv));
11420 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1set_1htlc_1base_1key(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
11421 LDKInMemorySigner this_ptr_conv;
11422 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11423 this_ptr_conv.is_owned = false;
11424 LDKSecretKey val_ref;
11425 CHECK((*env)->GetArrayLength(env, val) == 32);
11426 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.bytes);
11427 InMemorySigner_set_htlc_base_key(&this_ptr_conv, val_ref);
11430 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1get_1commitment_1seed(JNIEnv *env, jclass clz, int64_t this_ptr) {
11431 LDKInMemorySigner this_ptr_conv;
11432 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11433 this_ptr_conv.is_owned = false;
11434 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
11435 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *InMemorySigner_get_commitment_seed(&this_ptr_conv));
11439 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1set_1commitment_1seed(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
11440 LDKInMemorySigner this_ptr_conv;
11441 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11442 this_ptr_conv.is_owned = false;
11443 LDKThirtyTwoBytes val_ref;
11444 CHECK((*env)->GetArrayLength(env, val) == 32);
11445 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
11446 InMemorySigner_set_commitment_seed(&this_ptr_conv, val_ref);
11449 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1clone(JNIEnv *env, jclass clz, int64_t orig) {
11450 LDKInMemorySigner orig_conv;
11451 orig_conv.inner = (void*)(orig & (~1));
11452 orig_conv.is_owned = false;
11453 LDKInMemorySigner ret_var = InMemorySigner_clone(&orig_conv);
11454 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11455 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11456 long ret_ref = (long)ret_var.inner;
11457 if (ret_var.is_owned) {
11463 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) {
11464 LDKSecretKey funding_key_ref;
11465 CHECK((*env)->GetArrayLength(env, funding_key) == 32);
11466 (*env)->GetByteArrayRegion(env, funding_key, 0, 32, funding_key_ref.bytes);
11467 LDKSecretKey revocation_base_key_ref;
11468 CHECK((*env)->GetArrayLength(env, revocation_base_key) == 32);
11469 (*env)->GetByteArrayRegion(env, revocation_base_key, 0, 32, revocation_base_key_ref.bytes);
11470 LDKSecretKey payment_key_ref;
11471 CHECK((*env)->GetArrayLength(env, payment_key) == 32);
11472 (*env)->GetByteArrayRegion(env, payment_key, 0, 32, payment_key_ref.bytes);
11473 LDKSecretKey delayed_payment_base_key_ref;
11474 CHECK((*env)->GetArrayLength(env, delayed_payment_base_key) == 32);
11475 (*env)->GetByteArrayRegion(env, delayed_payment_base_key, 0, 32, delayed_payment_base_key_ref.bytes);
11476 LDKSecretKey htlc_base_key_ref;
11477 CHECK((*env)->GetArrayLength(env, htlc_base_key) == 32);
11478 (*env)->GetByteArrayRegion(env, htlc_base_key, 0, 32, htlc_base_key_ref.bytes);
11479 LDKThirtyTwoBytes commitment_seed_ref;
11480 CHECK((*env)->GetArrayLength(env, commitment_seed) == 32);
11481 (*env)->GetByteArrayRegion(env, commitment_seed, 0, 32, commitment_seed_ref.data);
11482 LDKThirtyTwoBytes channel_keys_id_ref;
11483 CHECK((*env)->GetArrayLength(env, channel_keys_id) == 32);
11484 (*env)->GetByteArrayRegion(env, channel_keys_id, 0, 32, channel_keys_id_ref.data);
11485 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);
11486 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11487 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11488 long ret_ref = (long)ret_var.inner;
11489 if (ret_var.is_owned) {
11495 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1counterparty_1pubkeys(JNIEnv *env, jclass clz, int64_t this_arg) {
11496 LDKInMemorySigner this_arg_conv;
11497 this_arg_conv.inner = (void*)(this_arg & (~1));
11498 this_arg_conv.is_owned = false;
11499 LDKChannelPublicKeys ret_var = InMemorySigner_counterparty_pubkeys(&this_arg_conv);
11500 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11501 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11502 long ret_ref = (long)ret_var.inner;
11503 if (ret_var.is_owned) {
11509 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1counterparty_1selected_1contest_1delay(JNIEnv *env, jclass clz, int64_t this_arg) {
11510 LDKInMemorySigner this_arg_conv;
11511 this_arg_conv.inner = (void*)(this_arg & (~1));
11512 this_arg_conv.is_owned = false;
11513 int16_t ret_val = InMemorySigner_counterparty_selected_contest_delay(&this_arg_conv);
11517 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1holder_1selected_1contest_1delay(JNIEnv *env, jclass clz, int64_t this_arg) {
11518 LDKInMemorySigner this_arg_conv;
11519 this_arg_conv.inner = (void*)(this_arg & (~1));
11520 this_arg_conv.is_owned = false;
11521 int16_t ret_val = InMemorySigner_holder_selected_contest_delay(&this_arg_conv);
11525 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1is_1outbound(JNIEnv *env, jclass clz, int64_t this_arg) {
11526 LDKInMemorySigner this_arg_conv;
11527 this_arg_conv.inner = (void*)(this_arg & (~1));
11528 this_arg_conv.is_owned = false;
11529 jboolean ret_val = InMemorySigner_is_outbound(&this_arg_conv);
11533 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1funding_1outpoint(JNIEnv *env, jclass clz, int64_t this_arg) {
11534 LDKInMemorySigner this_arg_conv;
11535 this_arg_conv.inner = (void*)(this_arg & (~1));
11536 this_arg_conv.is_owned = false;
11537 LDKOutPoint ret_var = InMemorySigner_funding_outpoint(&this_arg_conv);
11538 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11539 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11540 long ret_ref = (long)ret_var.inner;
11541 if (ret_var.is_owned) {
11547 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1get_1channel_1parameters(JNIEnv *env, jclass clz, int64_t this_arg) {
11548 LDKInMemorySigner this_arg_conv;
11549 this_arg_conv.inner = (void*)(this_arg & (~1));
11550 this_arg_conv.is_owned = false;
11551 LDKChannelTransactionParameters ret_var = InMemorySigner_get_channel_parameters(&this_arg_conv);
11552 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11553 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11554 long ret_ref = (long)ret_var.inner;
11555 if (ret_var.is_owned) {
11561 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) {
11562 LDKInMemorySigner this_arg_conv;
11563 this_arg_conv.inner = (void*)(this_arg & (~1));
11564 this_arg_conv.is_owned = false;
11565 LDKTransaction spend_tx_ref;
11566 spend_tx_ref.datalen = (*env)->GetArrayLength(env, spend_tx);
11567 spend_tx_ref.data = MALLOC(spend_tx_ref.datalen, "LDKTransaction Bytes");
11568 (*env)->GetByteArrayRegion(env, spend_tx, 0, spend_tx_ref.datalen, spend_tx_ref.data);
11569 spend_tx_ref.data_is_owned = true;
11570 LDKStaticPaymentOutputDescriptor descriptor_conv;
11571 descriptor_conv.inner = (void*)(descriptor & (~1));
11572 descriptor_conv.is_owned = false;
11573 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
11574 *ret_conv = InMemorySigner_sign_counterparty_payment_input(&this_arg_conv, spend_tx_ref, input_idx, &descriptor_conv);
11575 return (long)ret_conv;
11578 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) {
11579 LDKInMemorySigner this_arg_conv;
11580 this_arg_conv.inner = (void*)(this_arg & (~1));
11581 this_arg_conv.is_owned = false;
11582 LDKTransaction spend_tx_ref;
11583 spend_tx_ref.datalen = (*env)->GetArrayLength(env, spend_tx);
11584 spend_tx_ref.data = MALLOC(spend_tx_ref.datalen, "LDKTransaction Bytes");
11585 (*env)->GetByteArrayRegion(env, spend_tx, 0, spend_tx_ref.datalen, spend_tx_ref.data);
11586 spend_tx_ref.data_is_owned = true;
11587 LDKDelayedPaymentOutputDescriptor descriptor_conv;
11588 descriptor_conv.inner = (void*)(descriptor & (~1));
11589 descriptor_conv.is_owned = false;
11590 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
11591 *ret_conv = InMemorySigner_sign_dynamic_p2wsh_input(&this_arg_conv, spend_tx_ref, input_idx, &descriptor_conv);
11592 return (long)ret_conv;
11595 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1as_1Sign(JNIEnv *env, jclass clz, int64_t this_arg) {
11596 LDKInMemorySigner this_arg_conv;
11597 this_arg_conv.inner = (void*)(this_arg & (~1));
11598 this_arg_conv.is_owned = false;
11599 LDKSign* ret = MALLOC(sizeof(LDKSign), "LDKSign");
11600 *ret = InMemorySigner_as_Sign(&this_arg_conv);
11604 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1write(JNIEnv *env, jclass clz, int64_t obj) {
11605 LDKInMemorySigner obj_conv;
11606 obj_conv.inner = (void*)(obj & (~1));
11607 obj_conv.is_owned = false;
11608 LDKCVec_u8Z ret_var = InMemorySigner_write(&obj_conv);
11609 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
11610 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
11611 CVec_u8Z_free(ret_var);
11615 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
11616 LDKu8slice ser_ref;
11617 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
11618 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
11619 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
11620 *ret_conv = InMemorySigner_read(ser_ref);
11621 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
11622 return (long)ret_conv;
11625 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_KeysManager_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
11626 LDKKeysManager this_obj_conv;
11627 this_obj_conv.inner = (void*)(this_obj & (~1));
11628 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
11629 KeysManager_free(this_obj_conv);
11632 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) {
11633 unsigned char seed_arr[32];
11634 CHECK((*env)->GetArrayLength(env, seed) == 32);
11635 (*env)->GetByteArrayRegion(env, seed, 0, 32, seed_arr);
11636 unsigned char (*seed_ref)[32] = &seed_arr;
11637 LDKKeysManager ret_var = KeysManager_new(seed_ref, starting_time_secs, starting_time_nanos);
11638 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11639 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11640 long ret_ref = (long)ret_var.inner;
11641 if (ret_var.is_owned) {
11647 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) {
11648 LDKKeysManager this_arg_conv;
11649 this_arg_conv.inner = (void*)(this_arg & (~1));
11650 this_arg_conv.is_owned = false;
11651 unsigned char params_arr[32];
11652 CHECK((*env)->GetArrayLength(env, params) == 32);
11653 (*env)->GetByteArrayRegion(env, params, 0, 32, params_arr);
11654 unsigned char (*params_ref)[32] = ¶ms_arr;
11655 LDKInMemorySigner ret_var = KeysManager_derive_channel_keys(&this_arg_conv, channel_value_satoshis, params_ref);
11656 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11657 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11658 long ret_ref = (long)ret_var.inner;
11659 if (ret_var.is_owned) {
11665 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) {
11666 LDKKeysManager this_arg_conv;
11667 this_arg_conv.inner = (void*)(this_arg & (~1));
11668 this_arg_conv.is_owned = false;
11669 LDKCVec_SpendableOutputDescriptorZ descriptors_constr;
11670 descriptors_constr.datalen = (*env)->GetArrayLength(env, descriptors);
11671 if (descriptors_constr.datalen > 0)
11672 descriptors_constr.data = MALLOC(descriptors_constr.datalen * sizeof(LDKSpendableOutputDescriptor), "LDKCVec_SpendableOutputDescriptorZ Elements");
11674 descriptors_constr.data = NULL;
11675 int64_t* descriptors_vals = (*env)->GetLongArrayElements (env, descriptors, NULL);
11676 for (size_t b = 0; b < descriptors_constr.datalen; b++) {
11677 int64_t descriptors_conv_27 = descriptors_vals[b];
11678 LDKSpendableOutputDescriptor descriptors_conv_27_conv = *(LDKSpendableOutputDescriptor*)(((uint64_t)descriptors_conv_27) & ~1);
11679 FREE((void*)descriptors_conv_27);
11680 descriptors_constr.data[b] = descriptors_conv_27_conv;
11682 (*env)->ReleaseLongArrayElements(env, descriptors, descriptors_vals, 0);
11683 LDKCVec_TxOutZ outputs_constr;
11684 outputs_constr.datalen = (*env)->GetArrayLength(env, outputs);
11685 if (outputs_constr.datalen > 0)
11686 outputs_constr.data = MALLOC(outputs_constr.datalen * sizeof(LDKTxOut), "LDKCVec_TxOutZ Elements");
11688 outputs_constr.data = NULL;
11689 int64_t* outputs_vals = (*env)->GetLongArrayElements (env, outputs, NULL);
11690 for (size_t h = 0; h < outputs_constr.datalen; h++) {
11691 int64_t outputs_conv_7 = outputs_vals[h];
11692 LDKTxOut outputs_conv_7_conv = *(LDKTxOut*)(((uint64_t)outputs_conv_7) & ~1);
11693 FREE((void*)outputs_conv_7);
11694 outputs_constr.data[h] = outputs_conv_7_conv;
11696 (*env)->ReleaseLongArrayElements(env, outputs, outputs_vals, 0);
11697 LDKCVec_u8Z change_destination_script_ref;
11698 change_destination_script_ref.datalen = (*env)->GetArrayLength(env, change_destination_script);
11699 change_destination_script_ref.data = MALLOC(change_destination_script_ref.datalen, "LDKCVec_u8Z Bytes");
11700 (*env)->GetByteArrayRegion(env, change_destination_script, 0, change_destination_script_ref.datalen, change_destination_script_ref.data);
11701 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
11702 *ret_conv = KeysManager_spend_spendable_outputs(&this_arg_conv, descriptors_constr, outputs_constr, change_destination_script_ref, feerate_sat_per_1000_weight);
11703 return (long)ret_conv;
11706 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_KeysManager_1as_1KeysInterface(JNIEnv *env, jclass clz, int64_t this_arg) {
11707 LDKKeysManager this_arg_conv;
11708 this_arg_conv.inner = (void*)(this_arg & (~1));
11709 this_arg_conv.is_owned = false;
11710 LDKKeysInterface* ret = MALLOC(sizeof(LDKKeysInterface), "LDKKeysInterface");
11711 *ret = KeysManager_as_KeysInterface(&this_arg_conv);
11715 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelManager_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
11716 LDKChannelManager this_obj_conv;
11717 this_obj_conv.inner = (void*)(this_obj & (~1));
11718 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
11719 ChannelManager_free(this_obj_conv);
11722 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChainParameters_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
11723 LDKChainParameters this_obj_conv;
11724 this_obj_conv.inner = (void*)(this_obj & (~1));
11725 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
11726 ChainParameters_free(this_obj_conv);
11729 JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_ChainParameters_1get_1network(JNIEnv *env, jclass clz, int64_t this_ptr) {
11730 LDKChainParameters this_ptr_conv;
11731 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11732 this_ptr_conv.is_owned = false;
11733 jclass ret_conv = LDKNetwork_to_java(env, ChainParameters_get_network(&this_ptr_conv));
11737 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChainParameters_1set_1network(JNIEnv *env, jclass clz, int64_t this_ptr, jclass val) {
11738 LDKChainParameters this_ptr_conv;
11739 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11740 this_ptr_conv.is_owned = false;
11741 LDKNetwork val_conv = LDKNetwork_from_java(env, val);
11742 ChainParameters_set_network(&this_ptr_conv, val_conv);
11745 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChainParameters_1get_1latest_1hash(JNIEnv *env, jclass clz, int64_t this_ptr) {
11746 LDKChainParameters this_ptr_conv;
11747 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11748 this_ptr_conv.is_owned = false;
11749 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
11750 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *ChainParameters_get_latest_hash(&this_ptr_conv));
11754 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChainParameters_1set_1latest_1hash(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
11755 LDKChainParameters this_ptr_conv;
11756 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11757 this_ptr_conv.is_owned = false;
11758 LDKThirtyTwoBytes val_ref;
11759 CHECK((*env)->GetArrayLength(env, val) == 32);
11760 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
11761 ChainParameters_set_latest_hash(&this_ptr_conv, val_ref);
11764 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChainParameters_1get_1latest_1height(JNIEnv *env, jclass clz, int64_t this_ptr) {
11765 LDKChainParameters this_ptr_conv;
11766 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11767 this_ptr_conv.is_owned = false;
11768 int64_t ret_val = ChainParameters_get_latest_height(&this_ptr_conv);
11772 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChainParameters_1set_1latest_1height(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
11773 LDKChainParameters this_ptr_conv;
11774 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11775 this_ptr_conv.is_owned = false;
11776 ChainParameters_set_latest_height(&this_ptr_conv, val);
11779 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChainParameters_1new(JNIEnv *env, jclass clz, jclass network_arg, int8_tArray latest_hash_arg, int64_t latest_height_arg) {
11780 LDKNetwork network_arg_conv = LDKNetwork_from_java(env, network_arg);
11781 LDKThirtyTwoBytes latest_hash_arg_ref;
11782 CHECK((*env)->GetArrayLength(env, latest_hash_arg) == 32);
11783 (*env)->GetByteArrayRegion(env, latest_hash_arg, 0, 32, latest_hash_arg_ref.data);
11784 LDKChainParameters ret_var = ChainParameters_new(network_arg_conv, latest_hash_arg_ref, latest_height_arg);
11785 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11786 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11787 long ret_ref = (long)ret_var.inner;
11788 if (ret_var.is_owned) {
11794 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
11795 LDKChannelDetails this_obj_conv;
11796 this_obj_conv.inner = (void*)(this_obj & (~1));
11797 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
11798 ChannelDetails_free(this_obj_conv);
11801 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1get_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
11802 LDKChannelDetails this_ptr_conv;
11803 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11804 this_ptr_conv.is_owned = false;
11805 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
11806 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *ChannelDetails_get_channel_id(&this_ptr_conv));
11810 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1set_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
11811 LDKChannelDetails this_ptr_conv;
11812 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11813 this_ptr_conv.is_owned = false;
11814 LDKThirtyTwoBytes val_ref;
11815 CHECK((*env)->GetArrayLength(env, val) == 32);
11816 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
11817 ChannelDetails_set_channel_id(&this_ptr_conv, val_ref);
11820 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1get_1remote_1network_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
11821 LDKChannelDetails this_ptr_conv;
11822 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11823 this_ptr_conv.is_owned = false;
11824 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
11825 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ChannelDetails_get_remote_network_id(&this_ptr_conv).compressed_form);
11829 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1set_1remote_1network_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
11830 LDKChannelDetails this_ptr_conv;
11831 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11832 this_ptr_conv.is_owned = false;
11833 LDKPublicKey val_ref;
11834 CHECK((*env)->GetArrayLength(env, val) == 33);
11835 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
11836 ChannelDetails_set_remote_network_id(&this_ptr_conv, val_ref);
11839 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1get_1counterparty_1features(JNIEnv *env, jclass clz, int64_t this_ptr) {
11840 LDKChannelDetails this_ptr_conv;
11841 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11842 this_ptr_conv.is_owned = false;
11843 LDKInitFeatures ret_var = ChannelDetails_get_counterparty_features(&this_ptr_conv);
11844 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11845 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11846 long ret_ref = (long)ret_var.inner;
11847 if (ret_var.is_owned) {
11853 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1set_1counterparty_1features(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
11854 LDKChannelDetails this_ptr_conv;
11855 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11856 this_ptr_conv.is_owned = false;
11857 LDKInitFeatures val_conv;
11858 val_conv.inner = (void*)(val & (~1));
11859 val_conv.is_owned = (val & 1) || (val == 0);
11860 val_conv = InitFeatures_clone(&val_conv);
11861 ChannelDetails_set_counterparty_features(&this_ptr_conv, val_conv);
11864 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1get_1channel_1value_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr) {
11865 LDKChannelDetails this_ptr_conv;
11866 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11867 this_ptr_conv.is_owned = false;
11868 int64_t ret_val = ChannelDetails_get_channel_value_satoshis(&this_ptr_conv);
11872 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1set_1channel_1value_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
11873 LDKChannelDetails this_ptr_conv;
11874 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11875 this_ptr_conv.is_owned = false;
11876 ChannelDetails_set_channel_value_satoshis(&this_ptr_conv, val);
11879 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1get_1user_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
11880 LDKChannelDetails this_ptr_conv;
11881 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11882 this_ptr_conv.is_owned = false;
11883 int64_t ret_val = ChannelDetails_get_user_id(&this_ptr_conv);
11887 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1set_1user_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
11888 LDKChannelDetails this_ptr_conv;
11889 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11890 this_ptr_conv.is_owned = false;
11891 ChannelDetails_set_user_id(&this_ptr_conv, val);
11894 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1get_1outbound_1capacity_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
11895 LDKChannelDetails this_ptr_conv;
11896 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11897 this_ptr_conv.is_owned = false;
11898 int64_t ret_val = ChannelDetails_get_outbound_capacity_msat(&this_ptr_conv);
11902 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1set_1outbound_1capacity_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
11903 LDKChannelDetails this_ptr_conv;
11904 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11905 this_ptr_conv.is_owned = false;
11906 ChannelDetails_set_outbound_capacity_msat(&this_ptr_conv, val);
11909 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1get_1inbound_1capacity_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
11910 LDKChannelDetails this_ptr_conv;
11911 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11912 this_ptr_conv.is_owned = false;
11913 int64_t ret_val = ChannelDetails_get_inbound_capacity_msat(&this_ptr_conv);
11917 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1set_1inbound_1capacity_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
11918 LDKChannelDetails this_ptr_conv;
11919 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11920 this_ptr_conv.is_owned = false;
11921 ChannelDetails_set_inbound_capacity_msat(&this_ptr_conv, val);
11924 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1get_1is_1live(JNIEnv *env, jclass clz, int64_t this_ptr) {
11925 LDKChannelDetails this_ptr_conv;
11926 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11927 this_ptr_conv.is_owned = false;
11928 jboolean ret_val = ChannelDetails_get_is_live(&this_ptr_conv);
11932 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1set_1is_1live(JNIEnv *env, jclass clz, int64_t this_ptr, jboolean val) {
11933 LDKChannelDetails this_ptr_conv;
11934 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11935 this_ptr_conv.is_owned = false;
11936 ChannelDetails_set_is_live(&this_ptr_conv, val);
11939 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1clone(JNIEnv *env, jclass clz, int64_t orig) {
11940 LDKChannelDetails orig_conv;
11941 orig_conv.inner = (void*)(orig & (~1));
11942 orig_conv.is_owned = false;
11943 LDKChannelDetails ret_var = ChannelDetails_clone(&orig_conv);
11944 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11945 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11946 long ret_ref = (long)ret_var.inner;
11947 if (ret_var.is_owned) {
11953 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_PaymentSendFailure_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
11954 if ((this_ptr & 1) != 0) return;
11955 LDKPaymentSendFailure this_ptr_conv = *(LDKPaymentSendFailure*)(((uint64_t)this_ptr) & ~1);
11956 FREE((void*)this_ptr);
11957 PaymentSendFailure_free(this_ptr_conv);
11960 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PaymentSendFailure_1clone(JNIEnv *env, jclass clz, int64_t orig) {
11961 LDKPaymentSendFailure* orig_conv = (LDKPaymentSendFailure*)orig;
11962 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
11963 *ret_copy = PaymentSendFailure_clone(orig_conv);
11964 long ret_ref = (long)ret_copy;
11968 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) {
11969 LDKFeeEstimator fee_est_conv = *(LDKFeeEstimator*)(((uint64_t)fee_est) & ~1);
11970 if (fee_est_conv.free == LDKFeeEstimator_JCalls_free) {
11971 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
11972 LDKFeeEstimator_JCalls_clone(fee_est_conv.this_arg);
11974 LDKWatch chain_monitor_conv = *(LDKWatch*)(((uint64_t)chain_monitor) & ~1);
11975 if (chain_monitor_conv.free == LDKWatch_JCalls_free) {
11976 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
11977 LDKWatch_JCalls_clone(chain_monitor_conv.this_arg);
11979 LDKBroadcasterInterface tx_broadcaster_conv = *(LDKBroadcasterInterface*)(((uint64_t)tx_broadcaster) & ~1);
11980 if (tx_broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
11981 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
11982 LDKBroadcasterInterface_JCalls_clone(tx_broadcaster_conv.this_arg);
11984 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
11985 if (logger_conv.free == LDKLogger_JCalls_free) {
11986 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
11987 LDKLogger_JCalls_clone(logger_conv.this_arg);
11989 LDKKeysInterface keys_manager_conv = *(LDKKeysInterface*)(((uint64_t)keys_manager) & ~1);
11990 if (keys_manager_conv.free == LDKKeysInterface_JCalls_free) {
11991 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
11992 LDKKeysInterface_JCalls_clone(keys_manager_conv.this_arg);
11994 LDKUserConfig config_conv;
11995 config_conv.inner = (void*)(config & (~1));
11996 config_conv.is_owned = (config & 1) || (config == 0);
11997 config_conv = UserConfig_clone(&config_conv);
11998 LDKChainParameters params_conv;
11999 params_conv.inner = (void*)(params & (~1));
12000 params_conv.is_owned = (params & 1) || (params == 0);
12001 // Warning: we need a move here but no clone is available for LDKChainParameters
12002 LDKChannelManager ret_var = ChannelManager_new(fee_est_conv, chain_monitor_conv, tx_broadcaster_conv, logger_conv, keys_manager_conv, config_conv, params_conv);
12003 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
12004 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
12005 long ret_ref = (long)ret_var.inner;
12006 if (ret_var.is_owned) {
12012 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) {
12013 LDKChannelManager this_arg_conv;
12014 this_arg_conv.inner = (void*)(this_arg & (~1));
12015 this_arg_conv.is_owned = false;
12016 LDKPublicKey their_network_key_ref;
12017 CHECK((*env)->GetArrayLength(env, their_network_key) == 33);
12018 (*env)->GetByteArrayRegion(env, their_network_key, 0, 33, their_network_key_ref.compressed_form);
12019 LDKUserConfig override_config_conv;
12020 override_config_conv.inner = (void*)(override_config & (~1));
12021 override_config_conv.is_owned = (override_config & 1) || (override_config == 0);
12022 override_config_conv = UserConfig_clone(&override_config_conv);
12023 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
12024 *ret_conv = ChannelManager_create_channel(&this_arg_conv, their_network_key_ref, channel_value_satoshis, push_msat, user_id, override_config_conv);
12025 return (long)ret_conv;
12028 JNIEXPORT int64_tArray JNICALL Java_org_ldk_impl_bindings_ChannelManager_1list_1channels(JNIEnv *env, jclass clz, int64_t this_arg) {
12029 LDKChannelManager this_arg_conv;
12030 this_arg_conv.inner = (void*)(this_arg & (~1));
12031 this_arg_conv.is_owned = false;
12032 LDKCVec_ChannelDetailsZ ret_var = ChannelManager_list_channels(&this_arg_conv);
12033 int64_tArray ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
12034 int64_t *ret_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, ret_arr, NULL);
12035 for (size_t q = 0; q < ret_var.datalen; q++) {
12036 LDKChannelDetails ret_conv_16_var = ret_var.data[q];
12037 CHECK((((long)ret_conv_16_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
12038 CHECK((((long)&ret_conv_16_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
12039 long ret_conv_16_ref = (long)ret_conv_16_var.inner;
12040 if (ret_conv_16_var.is_owned) {
12041 ret_conv_16_ref |= 1;
12043 ret_arr_ptr[q] = ret_conv_16_ref;
12045 (*env)->ReleasePrimitiveArrayCritical(env, ret_arr, ret_arr_ptr, 0);
12046 FREE(ret_var.data);
12050 JNIEXPORT int64_tArray JNICALL Java_org_ldk_impl_bindings_ChannelManager_1list_1usable_1channels(JNIEnv *env, jclass clz, int64_t this_arg) {
12051 LDKChannelManager this_arg_conv;
12052 this_arg_conv.inner = (void*)(this_arg & (~1));
12053 this_arg_conv.is_owned = false;
12054 LDKCVec_ChannelDetailsZ ret_var = ChannelManager_list_usable_channels(&this_arg_conv);
12055 int64_tArray ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
12056 int64_t *ret_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, ret_arr, NULL);
12057 for (size_t q = 0; q < ret_var.datalen; q++) {
12058 LDKChannelDetails ret_conv_16_var = ret_var.data[q];
12059 CHECK((((long)ret_conv_16_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
12060 CHECK((((long)&ret_conv_16_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
12061 long ret_conv_16_ref = (long)ret_conv_16_var.inner;
12062 if (ret_conv_16_var.is_owned) {
12063 ret_conv_16_ref |= 1;
12065 ret_arr_ptr[q] = ret_conv_16_ref;
12067 (*env)->ReleasePrimitiveArrayCritical(env, ret_arr, ret_arr_ptr, 0);
12068 FREE(ret_var.data);
12072 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManager_1close_1channel(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray channel_id) {
12073 LDKChannelManager this_arg_conv;
12074 this_arg_conv.inner = (void*)(this_arg & (~1));
12075 this_arg_conv.is_owned = false;
12076 unsigned char channel_id_arr[32];
12077 CHECK((*env)->GetArrayLength(env, channel_id) == 32);
12078 (*env)->GetByteArrayRegion(env, channel_id, 0, 32, channel_id_arr);
12079 unsigned char (*channel_id_ref)[32] = &channel_id_arr;
12080 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
12081 *ret_conv = ChannelManager_close_channel(&this_arg_conv, channel_id_ref);
12082 return (long)ret_conv;
12085 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) {
12086 LDKChannelManager this_arg_conv;
12087 this_arg_conv.inner = (void*)(this_arg & (~1));
12088 this_arg_conv.is_owned = false;
12089 unsigned char channel_id_arr[32];
12090 CHECK((*env)->GetArrayLength(env, channel_id) == 32);
12091 (*env)->GetByteArrayRegion(env, channel_id, 0, 32, channel_id_arr);
12092 unsigned char (*channel_id_ref)[32] = &channel_id_arr;
12093 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
12094 *ret_conv = ChannelManager_force_close_channel(&this_arg_conv, channel_id_ref);
12095 return (long)ret_conv;
12098 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelManager_1force_1close_1all_1channels(JNIEnv *env, jclass clz, int64_t this_arg) {
12099 LDKChannelManager this_arg_conv;
12100 this_arg_conv.inner = (void*)(this_arg & (~1));
12101 this_arg_conv.is_owned = false;
12102 ChannelManager_force_close_all_channels(&this_arg_conv);
12105 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) {
12106 LDKChannelManager this_arg_conv;
12107 this_arg_conv.inner = (void*)(this_arg & (~1));
12108 this_arg_conv.is_owned = false;
12109 LDKRoute route_conv;
12110 route_conv.inner = (void*)(route & (~1));
12111 route_conv.is_owned = false;
12112 LDKThirtyTwoBytes payment_hash_ref;
12113 CHECK((*env)->GetArrayLength(env, payment_hash) == 32);
12114 (*env)->GetByteArrayRegion(env, payment_hash, 0, 32, payment_hash_ref.data);
12115 LDKThirtyTwoBytes payment_secret_ref;
12116 CHECK((*env)->GetArrayLength(env, payment_secret) == 32);
12117 (*env)->GetByteArrayRegion(env, payment_secret, 0, 32, payment_secret_ref.data);
12118 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
12119 *ret_conv = ChannelManager_send_payment(&this_arg_conv, &route_conv, payment_hash_ref, payment_secret_ref);
12120 return (long)ret_conv;
12123 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelManager_1funding_1transaction_1generated(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray temporary_channel_id, int64_t funding_txo) {
12124 LDKChannelManager this_arg_conv;
12125 this_arg_conv.inner = (void*)(this_arg & (~1));
12126 this_arg_conv.is_owned = false;
12127 unsigned char temporary_channel_id_arr[32];
12128 CHECK((*env)->GetArrayLength(env, temporary_channel_id) == 32);
12129 (*env)->GetByteArrayRegion(env, temporary_channel_id, 0, 32, temporary_channel_id_arr);
12130 unsigned char (*temporary_channel_id_ref)[32] = &temporary_channel_id_arr;
12131 LDKOutPoint funding_txo_conv;
12132 funding_txo_conv.inner = (void*)(funding_txo & (~1));
12133 funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
12134 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
12135 ChannelManager_funding_transaction_generated(&this_arg_conv, temporary_channel_id_ref, funding_txo_conv);
12138 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) {
12139 LDKChannelManager this_arg_conv;
12140 this_arg_conv.inner = (void*)(this_arg & (~1));
12141 this_arg_conv.is_owned = false;
12142 LDKThreeBytes rgb_ref;
12143 CHECK((*env)->GetArrayLength(env, rgb) == 3);
12144 (*env)->GetByteArrayRegion(env, rgb, 0, 3, rgb_ref.data);
12145 LDKThirtyTwoBytes alias_ref;
12146 CHECK((*env)->GetArrayLength(env, alias) == 32);
12147 (*env)->GetByteArrayRegion(env, alias, 0, 32, alias_ref.data);
12148 LDKCVec_NetAddressZ addresses_constr;
12149 addresses_constr.datalen = (*env)->GetArrayLength(env, addresses);
12150 if (addresses_constr.datalen > 0)
12151 addresses_constr.data = MALLOC(addresses_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
12153 addresses_constr.data = NULL;
12154 int64_t* addresses_vals = (*env)->GetLongArrayElements (env, addresses, NULL);
12155 for (size_t m = 0; m < addresses_constr.datalen; m++) {
12156 int64_t addresses_conv_12 = addresses_vals[m];
12157 LDKNetAddress addresses_conv_12_conv = *(LDKNetAddress*)(((uint64_t)addresses_conv_12) & ~1);
12158 FREE((void*)addresses_conv_12);
12159 addresses_constr.data[m] = addresses_conv_12_conv;
12161 (*env)->ReleaseLongArrayElements(env, addresses, addresses_vals, 0);
12162 ChannelManager_broadcast_node_announcement(&this_arg_conv, rgb_ref, alias_ref, addresses_constr);
12165 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelManager_1process_1pending_1htlc_1forwards(JNIEnv *env, jclass clz, int64_t this_arg) {
12166 LDKChannelManager this_arg_conv;
12167 this_arg_conv.inner = (void*)(this_arg & (~1));
12168 this_arg_conv.is_owned = false;
12169 ChannelManager_process_pending_htlc_forwards(&this_arg_conv);
12172 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelManager_1timer_1chan_1freshness_1every_1min(JNIEnv *env, jclass clz, int64_t this_arg) {
12173 LDKChannelManager this_arg_conv;
12174 this_arg_conv.inner = (void*)(this_arg & (~1));
12175 this_arg_conv.is_owned = false;
12176 ChannelManager_timer_chan_freshness_every_min(&this_arg_conv);
12179 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_ChannelManager_1fail_1htlc_1backwards(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray payment_hash, int8_tArray payment_secret) {
12180 LDKChannelManager this_arg_conv;
12181 this_arg_conv.inner = (void*)(this_arg & (~1));
12182 this_arg_conv.is_owned = false;
12183 unsigned char payment_hash_arr[32];
12184 CHECK((*env)->GetArrayLength(env, payment_hash) == 32);
12185 (*env)->GetByteArrayRegion(env, payment_hash, 0, 32, payment_hash_arr);
12186 unsigned char (*payment_hash_ref)[32] = &payment_hash_arr;
12187 LDKThirtyTwoBytes payment_secret_ref;
12188 CHECK((*env)->GetArrayLength(env, payment_secret) == 32);
12189 (*env)->GetByteArrayRegion(env, payment_secret, 0, 32, payment_secret_ref.data);
12190 jboolean ret_val = ChannelManager_fail_htlc_backwards(&this_arg_conv, payment_hash_ref, payment_secret_ref);
12194 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_ChannelManager_1claim_1funds(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray payment_preimage, int8_tArray payment_secret, int64_t expected_amount) {
12195 LDKChannelManager this_arg_conv;
12196 this_arg_conv.inner = (void*)(this_arg & (~1));
12197 this_arg_conv.is_owned = false;
12198 LDKThirtyTwoBytes payment_preimage_ref;
12199 CHECK((*env)->GetArrayLength(env, payment_preimage) == 32);
12200 (*env)->GetByteArrayRegion(env, payment_preimage, 0, 32, payment_preimage_ref.data);
12201 LDKThirtyTwoBytes payment_secret_ref;
12202 CHECK((*env)->GetArrayLength(env, payment_secret) == 32);
12203 (*env)->GetByteArrayRegion(env, payment_secret, 0, 32, payment_secret_ref.data);
12204 jboolean ret_val = ChannelManager_claim_funds(&this_arg_conv, payment_preimage_ref, payment_secret_ref, expected_amount);
12208 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelManager_1get_1our_1node_1id(JNIEnv *env, jclass clz, int64_t this_arg) {
12209 LDKChannelManager this_arg_conv;
12210 this_arg_conv.inner = (void*)(this_arg & (~1));
12211 this_arg_conv.is_owned = false;
12212 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
12213 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ChannelManager_get_our_node_id(&this_arg_conv).compressed_form);
12217 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) {
12218 LDKChannelManager this_arg_conv;
12219 this_arg_conv.inner = (void*)(this_arg & (~1));
12220 this_arg_conv.is_owned = false;
12221 LDKOutPoint funding_txo_conv;
12222 funding_txo_conv.inner = (void*)(funding_txo & (~1));
12223 funding_txo_conv.is_owned = false;
12224 ChannelManager_channel_monitor_updated(&this_arg_conv, &funding_txo_conv, highest_applied_update_id);
12227 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManager_1as_1MessageSendEventsProvider(JNIEnv *env, jclass clz, int64_t this_arg) {
12228 LDKChannelManager this_arg_conv;
12229 this_arg_conv.inner = (void*)(this_arg & (~1));
12230 this_arg_conv.is_owned = false;
12231 LDKMessageSendEventsProvider* ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
12232 *ret = ChannelManager_as_MessageSendEventsProvider(&this_arg_conv);
12236 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManager_1as_1EventsProvider(JNIEnv *env, jclass clz, int64_t this_arg) {
12237 LDKChannelManager this_arg_conv;
12238 this_arg_conv.inner = (void*)(this_arg & (~1));
12239 this_arg_conv.is_owned = false;
12240 LDKEventsProvider* ret = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider");
12241 *ret = ChannelManager_as_EventsProvider(&this_arg_conv);
12245 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManager_1as_1Listen(JNIEnv *env, jclass clz, int64_t this_arg) {
12246 LDKChannelManager this_arg_conv;
12247 this_arg_conv.inner = (void*)(this_arg & (~1));
12248 this_arg_conv.is_owned = false;
12249 LDKListen* ret = MALLOC(sizeof(LDKListen), "LDKListen");
12250 *ret = ChannelManager_as_Listen(&this_arg_conv);
12254 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelManager_1block_1connected(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray header, int64_tArray txdata, int32_t height) {
12255 LDKChannelManager this_arg_conv;
12256 this_arg_conv.inner = (void*)(this_arg & (~1));
12257 this_arg_conv.is_owned = false;
12258 unsigned char header_arr[80];
12259 CHECK((*env)->GetArrayLength(env, header) == 80);
12260 (*env)->GetByteArrayRegion(env, header, 0, 80, header_arr);
12261 unsigned char (*header_ref)[80] = &header_arr;
12262 LDKCVec_C2Tuple_usizeTransactionZZ txdata_constr;
12263 txdata_constr.datalen = (*env)->GetArrayLength(env, txdata);
12264 if (txdata_constr.datalen > 0)
12265 txdata_constr.data = MALLOC(txdata_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
12267 txdata_constr.data = NULL;
12268 int64_t* txdata_vals = (*env)->GetLongArrayElements (env, txdata, NULL);
12269 for (size_t y = 0; y < txdata_constr.datalen; y++) {
12270 int64_t txdata_conv_24 = txdata_vals[y];
12271 LDKC2Tuple_usizeTransactionZ txdata_conv_24_conv = *(LDKC2Tuple_usizeTransactionZ*)(((uint64_t)txdata_conv_24) & ~1);
12272 FREE((void*)txdata_conv_24);
12273 txdata_constr.data[y] = txdata_conv_24_conv;
12275 (*env)->ReleaseLongArrayElements(env, txdata, txdata_vals, 0);
12276 ChannelManager_block_connected(&this_arg_conv, header_ref, txdata_constr, height);
12279 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelManager_1block_1disconnected(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray header) {
12280 LDKChannelManager this_arg_conv;
12281 this_arg_conv.inner = (void*)(this_arg & (~1));
12282 this_arg_conv.is_owned = false;
12283 unsigned char header_arr[80];
12284 CHECK((*env)->GetArrayLength(env, header) == 80);
12285 (*env)->GetByteArrayRegion(env, header, 0, 80, header_arr);
12286 unsigned char (*header_ref)[80] = &header_arr;
12287 ChannelManager_block_disconnected(&this_arg_conv, header_ref);
12290 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelManager_1await_1persistable_1update(JNIEnv *env, jclass clz, int64_t this_arg) {
12291 LDKChannelManager this_arg_conv;
12292 this_arg_conv.inner = (void*)(this_arg & (~1));
12293 this_arg_conv.is_owned = false;
12294 ChannelManager_await_persistable_update(&this_arg_conv);
12297 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManager_1as_1ChannelMessageHandler(JNIEnv *env, jclass clz, int64_t this_arg) {
12298 LDKChannelManager this_arg_conv;
12299 this_arg_conv.inner = (void*)(this_arg & (~1));
12300 this_arg_conv.is_owned = false;
12301 LDKChannelMessageHandler* ret = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
12302 *ret = ChannelManager_as_ChannelMessageHandler(&this_arg_conv);
12306 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelManager_1write(JNIEnv *env, jclass clz, int64_t obj) {
12307 LDKChannelManager obj_conv;
12308 obj_conv.inner = (void*)(obj & (~1));
12309 obj_conv.is_owned = false;
12310 LDKCVec_u8Z ret_var = ChannelManager_write(&obj_conv);
12311 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
12312 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
12313 CVec_u8Z_free(ret_var);
12317 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelManagerReadArgs_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
12318 LDKChannelManagerReadArgs this_obj_conv;
12319 this_obj_conv.inner = (void*)(this_obj & (~1));
12320 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
12321 ChannelManagerReadArgs_free(this_obj_conv);
12324 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManagerReadArgs_1get_1keys_1manager(JNIEnv *env, jclass clz, int64_t this_ptr) {
12325 LDKChannelManagerReadArgs this_ptr_conv;
12326 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12327 this_ptr_conv.is_owned = false;
12328 long ret_ret = (long)ChannelManagerReadArgs_get_keys_manager(&this_ptr_conv);
12332 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelManagerReadArgs_1set_1keys_1manager(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
12333 LDKChannelManagerReadArgs this_ptr_conv;
12334 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12335 this_ptr_conv.is_owned = false;
12336 LDKKeysInterface val_conv = *(LDKKeysInterface*)(((uint64_t)val) & ~1);
12337 if (val_conv.free == LDKKeysInterface_JCalls_free) {
12338 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
12339 LDKKeysInterface_JCalls_clone(val_conv.this_arg);
12341 ChannelManagerReadArgs_set_keys_manager(&this_ptr_conv, val_conv);
12344 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManagerReadArgs_1get_1fee_1estimator(JNIEnv *env, jclass clz, int64_t this_ptr) {
12345 LDKChannelManagerReadArgs this_ptr_conv;
12346 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12347 this_ptr_conv.is_owned = false;
12348 long ret_ret = (long)ChannelManagerReadArgs_get_fee_estimator(&this_ptr_conv);
12352 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelManagerReadArgs_1set_1fee_1estimator(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
12353 LDKChannelManagerReadArgs this_ptr_conv;
12354 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12355 this_ptr_conv.is_owned = false;
12356 LDKFeeEstimator val_conv = *(LDKFeeEstimator*)(((uint64_t)val) & ~1);
12357 if (val_conv.free == LDKFeeEstimator_JCalls_free) {
12358 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
12359 LDKFeeEstimator_JCalls_clone(val_conv.this_arg);
12361 ChannelManagerReadArgs_set_fee_estimator(&this_ptr_conv, val_conv);
12364 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManagerReadArgs_1get_1chain_1monitor(JNIEnv *env, jclass clz, int64_t this_ptr) {
12365 LDKChannelManagerReadArgs this_ptr_conv;
12366 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12367 this_ptr_conv.is_owned = false;
12368 long ret_ret = (long)ChannelManagerReadArgs_get_chain_monitor(&this_ptr_conv);
12372 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelManagerReadArgs_1set_1chain_1monitor(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
12373 LDKChannelManagerReadArgs this_ptr_conv;
12374 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12375 this_ptr_conv.is_owned = false;
12376 LDKWatch val_conv = *(LDKWatch*)(((uint64_t)val) & ~1);
12377 if (val_conv.free == LDKWatch_JCalls_free) {
12378 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
12379 LDKWatch_JCalls_clone(val_conv.this_arg);
12381 ChannelManagerReadArgs_set_chain_monitor(&this_ptr_conv, val_conv);
12384 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManagerReadArgs_1get_1tx_1broadcaster(JNIEnv *env, jclass clz, int64_t this_ptr) {
12385 LDKChannelManagerReadArgs this_ptr_conv;
12386 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12387 this_ptr_conv.is_owned = false;
12388 long ret_ret = (long)ChannelManagerReadArgs_get_tx_broadcaster(&this_ptr_conv);
12392 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelManagerReadArgs_1set_1tx_1broadcaster(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
12393 LDKChannelManagerReadArgs this_ptr_conv;
12394 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12395 this_ptr_conv.is_owned = false;
12396 LDKBroadcasterInterface val_conv = *(LDKBroadcasterInterface*)(((uint64_t)val) & ~1);
12397 if (val_conv.free == LDKBroadcasterInterface_JCalls_free) {
12398 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
12399 LDKBroadcasterInterface_JCalls_clone(val_conv.this_arg);
12401 ChannelManagerReadArgs_set_tx_broadcaster(&this_ptr_conv, val_conv);
12404 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManagerReadArgs_1get_1logger(JNIEnv *env, jclass clz, int64_t this_ptr) {
12405 LDKChannelManagerReadArgs this_ptr_conv;
12406 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12407 this_ptr_conv.is_owned = false;
12408 long ret_ret = (long)ChannelManagerReadArgs_get_logger(&this_ptr_conv);
12412 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelManagerReadArgs_1set_1logger(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
12413 LDKChannelManagerReadArgs this_ptr_conv;
12414 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12415 this_ptr_conv.is_owned = false;
12416 LDKLogger val_conv = *(LDKLogger*)(((uint64_t)val) & ~1);
12417 if (val_conv.free == LDKLogger_JCalls_free) {
12418 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
12419 LDKLogger_JCalls_clone(val_conv.this_arg);
12421 ChannelManagerReadArgs_set_logger(&this_ptr_conv, val_conv);
12424 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelManagerReadArgs_1get_1default_1config(JNIEnv *env, jclass clz, int64_t this_ptr) {
12425 LDKChannelManagerReadArgs this_ptr_conv;
12426 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12427 this_ptr_conv.is_owned = false;
12428 LDKUserConfig ret_var = ChannelManagerReadArgs_get_default_config(&this_ptr_conv);
12429 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
12430 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
12431 long ret_ref = (long)ret_var.inner;
12432 if (ret_var.is_owned) {
12438 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelManagerReadArgs_1set_1default_1config(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
12439 LDKChannelManagerReadArgs this_ptr_conv;
12440 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12441 this_ptr_conv.is_owned = false;
12442 LDKUserConfig val_conv;
12443 val_conv.inner = (void*)(val & (~1));
12444 val_conv.is_owned = (val & 1) || (val == 0);
12445 val_conv = UserConfig_clone(&val_conv);
12446 ChannelManagerReadArgs_set_default_config(&this_ptr_conv, val_conv);
12449 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) {
12450 LDKKeysInterface keys_manager_conv = *(LDKKeysInterface*)(((uint64_t)keys_manager) & ~1);
12451 if (keys_manager_conv.free == LDKKeysInterface_JCalls_free) {
12452 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
12453 LDKKeysInterface_JCalls_clone(keys_manager_conv.this_arg);
12455 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(((uint64_t)fee_estimator) & ~1);
12456 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
12457 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
12458 LDKFeeEstimator_JCalls_clone(fee_estimator_conv.this_arg);
12460 LDKWatch chain_monitor_conv = *(LDKWatch*)(((uint64_t)chain_monitor) & ~1);
12461 if (chain_monitor_conv.free == LDKWatch_JCalls_free) {
12462 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
12463 LDKWatch_JCalls_clone(chain_monitor_conv.this_arg);
12465 LDKBroadcasterInterface tx_broadcaster_conv = *(LDKBroadcasterInterface*)(((uint64_t)tx_broadcaster) & ~1);
12466 if (tx_broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
12467 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
12468 LDKBroadcasterInterface_JCalls_clone(tx_broadcaster_conv.this_arg);
12470 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
12471 if (logger_conv.free == LDKLogger_JCalls_free) {
12472 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
12473 LDKLogger_JCalls_clone(logger_conv.this_arg);
12475 LDKUserConfig default_config_conv;
12476 default_config_conv.inner = (void*)(default_config & (~1));
12477 default_config_conv.is_owned = (default_config & 1) || (default_config == 0);
12478 default_config_conv = UserConfig_clone(&default_config_conv);
12479 LDKCVec_ChannelMonitorZ channel_monitors_constr;
12480 channel_monitors_constr.datalen = (*env)->GetArrayLength(env, channel_monitors);
12481 if (channel_monitors_constr.datalen > 0)
12482 channel_monitors_constr.data = MALLOC(channel_monitors_constr.datalen * sizeof(LDKChannelMonitor), "LDKCVec_ChannelMonitorZ Elements");
12484 channel_monitors_constr.data = NULL;
12485 int64_t* channel_monitors_vals = (*env)->GetLongArrayElements (env, channel_monitors, NULL);
12486 for (size_t q = 0; q < channel_monitors_constr.datalen; q++) {
12487 int64_t channel_monitors_conv_16 = channel_monitors_vals[q];
12488 LDKChannelMonitor channel_monitors_conv_16_conv;
12489 channel_monitors_conv_16_conv.inner = (void*)(channel_monitors_conv_16 & (~1));
12490 channel_monitors_conv_16_conv.is_owned = (channel_monitors_conv_16 & 1) || (channel_monitors_conv_16 == 0);
12491 channel_monitors_constr.data[q] = channel_monitors_conv_16_conv;
12493 (*env)->ReleaseLongArrayElements(env, channel_monitors, channel_monitors_vals, 0);
12494 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);
12495 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
12496 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
12497 long ret_ref = (long)ret_var.inner;
12498 if (ret_var.is_owned) {
12504 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1BlockHashChannelManagerZ_1read(JNIEnv *env, jclass clz, int8_tArray ser, int64_t arg) {
12505 LDKu8slice ser_ref;
12506 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
12507 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
12508 LDKChannelManagerReadArgs arg_conv;
12509 arg_conv.inner = (void*)(arg & (~1));
12510 arg_conv.is_owned = (arg & 1) || (arg == 0);
12511 // Warning: we need a move here but no clone is available for LDKChannelManagerReadArgs
12512 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ");
12513 *ret_conv = C2Tuple_BlockHashChannelManagerZ_read(ser_ref, arg_conv);
12514 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
12515 return (long)ret_conv;
12518 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DecodeError_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
12519 LDKDecodeError this_obj_conv;
12520 this_obj_conv.inner = (void*)(this_obj & (~1));
12521 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
12522 DecodeError_free(this_obj_conv);
12525 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DecodeError_1clone(JNIEnv *env, jclass clz, int64_t orig) {
12526 LDKDecodeError orig_conv;
12527 orig_conv.inner = (void*)(orig & (~1));
12528 orig_conv.is_owned = false;
12529 LDKDecodeError ret_var = DecodeError_clone(&orig_conv);
12530 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
12531 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
12532 long ret_ref = (long)ret_var.inner;
12533 if (ret_var.is_owned) {
12539 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Init_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
12540 LDKInit this_obj_conv;
12541 this_obj_conv.inner = (void*)(this_obj & (~1));
12542 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
12543 Init_free(this_obj_conv);
12546 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Init_1get_1features(JNIEnv *env, jclass clz, int64_t this_ptr) {
12547 LDKInit this_ptr_conv;
12548 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12549 this_ptr_conv.is_owned = false;
12550 LDKInitFeatures ret_var = Init_get_features(&this_ptr_conv);
12551 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
12552 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
12553 long ret_ref = (long)ret_var.inner;
12554 if (ret_var.is_owned) {
12560 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Init_1set_1features(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
12561 LDKInit this_ptr_conv;
12562 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12563 this_ptr_conv.is_owned = false;
12564 LDKInitFeatures val_conv;
12565 val_conv.inner = (void*)(val & (~1));
12566 val_conv.is_owned = (val & 1) || (val == 0);
12567 val_conv = InitFeatures_clone(&val_conv);
12568 Init_set_features(&this_ptr_conv, val_conv);
12571 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Init_1new(JNIEnv *env, jclass clz, int64_t features_arg) {
12572 LDKInitFeatures features_arg_conv;
12573 features_arg_conv.inner = (void*)(features_arg & (~1));
12574 features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0);
12575 features_arg_conv = InitFeatures_clone(&features_arg_conv);
12576 LDKInit ret_var = Init_new(features_arg_conv);
12577 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
12578 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
12579 long ret_ref = (long)ret_var.inner;
12580 if (ret_var.is_owned) {
12586 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Init_1clone(JNIEnv *env, jclass clz, int64_t orig) {
12588 orig_conv.inner = (void*)(orig & (~1));
12589 orig_conv.is_owned = false;
12590 LDKInit ret_var = Init_clone(&orig_conv);
12591 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
12592 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
12593 long ret_ref = (long)ret_var.inner;
12594 if (ret_var.is_owned) {
12600 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ErrorMessage_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
12601 LDKErrorMessage this_obj_conv;
12602 this_obj_conv.inner = (void*)(this_obj & (~1));
12603 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
12604 ErrorMessage_free(this_obj_conv);
12607 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ErrorMessage_1get_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
12608 LDKErrorMessage this_ptr_conv;
12609 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12610 this_ptr_conv.is_owned = false;
12611 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
12612 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *ErrorMessage_get_channel_id(&this_ptr_conv));
12616 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ErrorMessage_1set_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
12617 LDKErrorMessage this_ptr_conv;
12618 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12619 this_ptr_conv.is_owned = false;
12620 LDKThirtyTwoBytes val_ref;
12621 CHECK((*env)->GetArrayLength(env, val) == 32);
12622 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
12623 ErrorMessage_set_channel_id(&this_ptr_conv, val_ref);
12626 JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_ErrorMessage_1get_1data(JNIEnv *env, jclass clz, int64_t this_ptr) {
12627 LDKErrorMessage this_ptr_conv;
12628 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12629 this_ptr_conv.is_owned = false;
12630 LDKStr _str = ErrorMessage_get_data(&this_ptr_conv);
12631 jstring _conv = str_ref_to_java(env, _str.chars, _str.len);
12635 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ErrorMessage_1set_1data(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
12636 LDKErrorMessage this_ptr_conv;
12637 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12638 this_ptr_conv.is_owned = false;
12639 LDKCVec_u8Z val_ref;
12640 val_ref.datalen = (*env)->GetArrayLength(env, val);
12641 val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
12642 (*env)->GetByteArrayRegion(env, val, 0, val_ref.datalen, val_ref.data);
12643 ErrorMessage_set_data(&this_ptr_conv, val_ref);
12646 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ErrorMessage_1new(JNIEnv *env, jclass clz, int8_tArray channel_id_arg, int8_tArray data_arg) {
12647 LDKThirtyTwoBytes channel_id_arg_ref;
12648 CHECK((*env)->GetArrayLength(env, channel_id_arg) == 32);
12649 (*env)->GetByteArrayRegion(env, channel_id_arg, 0, 32, channel_id_arg_ref.data);
12650 LDKCVec_u8Z data_arg_ref;
12651 data_arg_ref.datalen = (*env)->GetArrayLength(env, data_arg);
12652 data_arg_ref.data = MALLOC(data_arg_ref.datalen, "LDKCVec_u8Z Bytes");
12653 (*env)->GetByteArrayRegion(env, data_arg, 0, data_arg_ref.datalen, data_arg_ref.data);
12654 LDKErrorMessage ret_var = ErrorMessage_new(channel_id_arg_ref, data_arg_ref);
12655 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
12656 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
12657 long ret_ref = (long)ret_var.inner;
12658 if (ret_var.is_owned) {
12664 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ErrorMessage_1clone(JNIEnv *env, jclass clz, int64_t orig) {
12665 LDKErrorMessage orig_conv;
12666 orig_conv.inner = (void*)(orig & (~1));
12667 orig_conv.is_owned = false;
12668 LDKErrorMessage ret_var = ErrorMessage_clone(&orig_conv);
12669 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
12670 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
12671 long ret_ref = (long)ret_var.inner;
12672 if (ret_var.is_owned) {
12678 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Ping_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
12679 LDKPing this_obj_conv;
12680 this_obj_conv.inner = (void*)(this_obj & (~1));
12681 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
12682 Ping_free(this_obj_conv);
12685 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_Ping_1get_1ponglen(JNIEnv *env, jclass clz, int64_t this_ptr) {
12686 LDKPing this_ptr_conv;
12687 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12688 this_ptr_conv.is_owned = false;
12689 int16_t ret_val = Ping_get_ponglen(&this_ptr_conv);
12693 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Ping_1set_1ponglen(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
12694 LDKPing this_ptr_conv;
12695 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12696 this_ptr_conv.is_owned = false;
12697 Ping_set_ponglen(&this_ptr_conv, val);
12700 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_Ping_1get_1byteslen(JNIEnv *env, jclass clz, int64_t this_ptr) {
12701 LDKPing this_ptr_conv;
12702 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12703 this_ptr_conv.is_owned = false;
12704 int16_t ret_val = Ping_get_byteslen(&this_ptr_conv);
12708 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Ping_1set_1byteslen(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
12709 LDKPing this_ptr_conv;
12710 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12711 this_ptr_conv.is_owned = false;
12712 Ping_set_byteslen(&this_ptr_conv, val);
12715 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Ping_1new(JNIEnv *env, jclass clz, int16_t ponglen_arg, int16_t byteslen_arg) {
12716 LDKPing ret_var = Ping_new(ponglen_arg, byteslen_arg);
12717 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
12718 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
12719 long ret_ref = (long)ret_var.inner;
12720 if (ret_var.is_owned) {
12726 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Ping_1clone(JNIEnv *env, jclass clz, int64_t orig) {
12728 orig_conv.inner = (void*)(orig & (~1));
12729 orig_conv.is_owned = false;
12730 LDKPing ret_var = Ping_clone(&orig_conv);
12731 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
12732 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
12733 long ret_ref = (long)ret_var.inner;
12734 if (ret_var.is_owned) {
12740 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Pong_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
12741 LDKPong this_obj_conv;
12742 this_obj_conv.inner = (void*)(this_obj & (~1));
12743 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
12744 Pong_free(this_obj_conv);
12747 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_Pong_1get_1byteslen(JNIEnv *env, jclass clz, int64_t this_ptr) {
12748 LDKPong this_ptr_conv;
12749 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12750 this_ptr_conv.is_owned = false;
12751 int16_t ret_val = Pong_get_byteslen(&this_ptr_conv);
12755 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Pong_1set_1byteslen(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
12756 LDKPong this_ptr_conv;
12757 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12758 this_ptr_conv.is_owned = false;
12759 Pong_set_byteslen(&this_ptr_conv, val);
12762 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Pong_1new(JNIEnv *env, jclass clz, int16_t byteslen_arg) {
12763 LDKPong ret_var = Pong_new(byteslen_arg);
12764 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
12765 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
12766 long ret_ref = (long)ret_var.inner;
12767 if (ret_var.is_owned) {
12773 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Pong_1clone(JNIEnv *env, jclass clz, int64_t orig) {
12775 orig_conv.inner = (void*)(orig & (~1));
12776 orig_conv.is_owned = false;
12777 LDKPong ret_var = Pong_clone(&orig_conv);
12778 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
12779 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
12780 long ret_ref = (long)ret_var.inner;
12781 if (ret_var.is_owned) {
12787 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
12788 LDKOpenChannel this_obj_conv;
12789 this_obj_conv.inner = (void*)(this_obj & (~1));
12790 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
12791 OpenChannel_free(this_obj_conv);
12794 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1chain_1hash(JNIEnv *env, jclass clz, int64_t this_ptr) {
12795 LDKOpenChannel this_ptr_conv;
12796 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12797 this_ptr_conv.is_owned = false;
12798 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
12799 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *OpenChannel_get_chain_hash(&this_ptr_conv));
12803 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1chain_1hash(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
12804 LDKOpenChannel this_ptr_conv;
12805 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12806 this_ptr_conv.is_owned = false;
12807 LDKThirtyTwoBytes val_ref;
12808 CHECK((*env)->GetArrayLength(env, val) == 32);
12809 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
12810 OpenChannel_set_chain_hash(&this_ptr_conv, val_ref);
12813 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1temporary_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
12814 LDKOpenChannel this_ptr_conv;
12815 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12816 this_ptr_conv.is_owned = false;
12817 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
12818 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *OpenChannel_get_temporary_channel_id(&this_ptr_conv));
12822 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1temporary_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
12823 LDKOpenChannel this_ptr_conv;
12824 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12825 this_ptr_conv.is_owned = false;
12826 LDKThirtyTwoBytes val_ref;
12827 CHECK((*env)->GetArrayLength(env, val) == 32);
12828 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
12829 OpenChannel_set_temporary_channel_id(&this_ptr_conv, val_ref);
12832 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1funding_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr) {
12833 LDKOpenChannel this_ptr_conv;
12834 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12835 this_ptr_conv.is_owned = false;
12836 int64_t ret_val = OpenChannel_get_funding_satoshis(&this_ptr_conv);
12840 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1funding_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
12841 LDKOpenChannel this_ptr_conv;
12842 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12843 this_ptr_conv.is_owned = false;
12844 OpenChannel_set_funding_satoshis(&this_ptr_conv, val);
12847 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1push_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
12848 LDKOpenChannel this_ptr_conv;
12849 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12850 this_ptr_conv.is_owned = false;
12851 int64_t ret_val = OpenChannel_get_push_msat(&this_ptr_conv);
12855 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1push_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
12856 LDKOpenChannel this_ptr_conv;
12857 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12858 this_ptr_conv.is_owned = false;
12859 OpenChannel_set_push_msat(&this_ptr_conv, val);
12862 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1dust_1limit_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr) {
12863 LDKOpenChannel this_ptr_conv;
12864 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12865 this_ptr_conv.is_owned = false;
12866 int64_t ret_val = OpenChannel_get_dust_limit_satoshis(&this_ptr_conv);
12870 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1dust_1limit_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
12871 LDKOpenChannel this_ptr_conv;
12872 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12873 this_ptr_conv.is_owned = false;
12874 OpenChannel_set_dust_limit_satoshis(&this_ptr_conv, val);
12877 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) {
12878 LDKOpenChannel this_ptr_conv;
12879 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12880 this_ptr_conv.is_owned = false;
12881 int64_t ret_val = OpenChannel_get_max_htlc_value_in_flight_msat(&this_ptr_conv);
12885 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) {
12886 LDKOpenChannel this_ptr_conv;
12887 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12888 this_ptr_conv.is_owned = false;
12889 OpenChannel_set_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
12892 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1channel_1reserve_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr) {
12893 LDKOpenChannel this_ptr_conv;
12894 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12895 this_ptr_conv.is_owned = false;
12896 int64_t ret_val = OpenChannel_get_channel_reserve_satoshis(&this_ptr_conv);
12900 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1channel_1reserve_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
12901 LDKOpenChannel this_ptr_conv;
12902 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12903 this_ptr_conv.is_owned = false;
12904 OpenChannel_set_channel_reserve_satoshis(&this_ptr_conv, val);
12907 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1htlc_1minimum_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
12908 LDKOpenChannel this_ptr_conv;
12909 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12910 this_ptr_conv.is_owned = false;
12911 int64_t ret_val = OpenChannel_get_htlc_minimum_msat(&this_ptr_conv);
12915 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1htlc_1minimum_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
12916 LDKOpenChannel this_ptr_conv;
12917 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12918 this_ptr_conv.is_owned = false;
12919 OpenChannel_set_htlc_minimum_msat(&this_ptr_conv, val);
12922 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1feerate_1per_1kw(JNIEnv *env, jclass clz, int64_t this_ptr) {
12923 LDKOpenChannel this_ptr_conv;
12924 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12925 this_ptr_conv.is_owned = false;
12926 int32_t ret_val = OpenChannel_get_feerate_per_kw(&this_ptr_conv);
12930 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1feerate_1per_1kw(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
12931 LDKOpenChannel this_ptr_conv;
12932 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12933 this_ptr_conv.is_owned = false;
12934 OpenChannel_set_feerate_per_kw(&this_ptr_conv, val);
12937 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1to_1self_1delay(JNIEnv *env, jclass clz, int64_t this_ptr) {
12938 LDKOpenChannel this_ptr_conv;
12939 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12940 this_ptr_conv.is_owned = false;
12941 int16_t ret_val = OpenChannel_get_to_self_delay(&this_ptr_conv);
12945 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1to_1self_1delay(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
12946 LDKOpenChannel this_ptr_conv;
12947 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12948 this_ptr_conv.is_owned = false;
12949 OpenChannel_set_to_self_delay(&this_ptr_conv, val);
12952 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1max_1accepted_1htlcs(JNIEnv *env, jclass clz, int64_t this_ptr) {
12953 LDKOpenChannel this_ptr_conv;
12954 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12955 this_ptr_conv.is_owned = false;
12956 int16_t ret_val = OpenChannel_get_max_accepted_htlcs(&this_ptr_conv);
12960 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1max_1accepted_1htlcs(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
12961 LDKOpenChannel this_ptr_conv;
12962 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12963 this_ptr_conv.is_owned = false;
12964 OpenChannel_set_max_accepted_htlcs(&this_ptr_conv, val);
12967 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1funding_1pubkey(JNIEnv *env, jclass clz, int64_t this_ptr) {
12968 LDKOpenChannel this_ptr_conv;
12969 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12970 this_ptr_conv.is_owned = false;
12971 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
12972 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, OpenChannel_get_funding_pubkey(&this_ptr_conv).compressed_form);
12976 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1funding_1pubkey(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
12977 LDKOpenChannel this_ptr_conv;
12978 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12979 this_ptr_conv.is_owned = false;
12980 LDKPublicKey val_ref;
12981 CHECK((*env)->GetArrayLength(env, val) == 33);
12982 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
12983 OpenChannel_set_funding_pubkey(&this_ptr_conv, val_ref);
12986 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1revocation_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr) {
12987 LDKOpenChannel this_ptr_conv;
12988 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12989 this_ptr_conv.is_owned = false;
12990 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
12991 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, OpenChannel_get_revocation_basepoint(&this_ptr_conv).compressed_form);
12995 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1revocation_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
12996 LDKOpenChannel this_ptr_conv;
12997 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12998 this_ptr_conv.is_owned = false;
12999 LDKPublicKey val_ref;
13000 CHECK((*env)->GetArrayLength(env, val) == 33);
13001 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
13002 OpenChannel_set_revocation_basepoint(&this_ptr_conv, val_ref);
13005 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1payment_1point(JNIEnv *env, jclass clz, int64_t this_ptr) {
13006 LDKOpenChannel this_ptr_conv;
13007 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13008 this_ptr_conv.is_owned = false;
13009 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
13010 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, OpenChannel_get_payment_point(&this_ptr_conv).compressed_form);
13014 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1payment_1point(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
13015 LDKOpenChannel this_ptr_conv;
13016 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13017 this_ptr_conv.is_owned = false;
13018 LDKPublicKey val_ref;
13019 CHECK((*env)->GetArrayLength(env, val) == 33);
13020 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
13021 OpenChannel_set_payment_point(&this_ptr_conv, val_ref);
13024 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1delayed_1payment_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr) {
13025 LDKOpenChannel this_ptr_conv;
13026 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13027 this_ptr_conv.is_owned = false;
13028 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
13029 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, OpenChannel_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form);
13033 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1delayed_1payment_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
13034 LDKOpenChannel this_ptr_conv;
13035 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13036 this_ptr_conv.is_owned = false;
13037 LDKPublicKey val_ref;
13038 CHECK((*env)->GetArrayLength(env, val) == 33);
13039 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
13040 OpenChannel_set_delayed_payment_basepoint(&this_ptr_conv, val_ref);
13043 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1htlc_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr) {
13044 LDKOpenChannel this_ptr_conv;
13045 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13046 this_ptr_conv.is_owned = false;
13047 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
13048 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, OpenChannel_get_htlc_basepoint(&this_ptr_conv).compressed_form);
13052 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1htlc_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
13053 LDKOpenChannel this_ptr_conv;
13054 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13055 this_ptr_conv.is_owned = false;
13056 LDKPublicKey val_ref;
13057 CHECK((*env)->GetArrayLength(env, val) == 33);
13058 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
13059 OpenChannel_set_htlc_basepoint(&this_ptr_conv, val_ref);
13062 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1first_1per_1commitment_1point(JNIEnv *env, jclass clz, int64_t this_ptr) {
13063 LDKOpenChannel this_ptr_conv;
13064 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13065 this_ptr_conv.is_owned = false;
13066 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
13067 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, OpenChannel_get_first_per_commitment_point(&this_ptr_conv).compressed_form);
13071 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) {
13072 LDKOpenChannel this_ptr_conv;
13073 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13074 this_ptr_conv.is_owned = false;
13075 LDKPublicKey val_ref;
13076 CHECK((*env)->GetArrayLength(env, val) == 33);
13077 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
13078 OpenChannel_set_first_per_commitment_point(&this_ptr_conv, val_ref);
13081 JNIEXPORT int8_t JNICALL Java_org_ldk_impl_bindings_OpenChannel_1get_1channel_1flags(JNIEnv *env, jclass clz, int64_t this_ptr) {
13082 LDKOpenChannel this_ptr_conv;
13083 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13084 this_ptr_conv.is_owned = false;
13085 int8_t ret_val = OpenChannel_get_channel_flags(&this_ptr_conv);
13089 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1channel_1flags(JNIEnv *env, jclass clz, int64_t this_ptr, int8_t val) {
13090 LDKOpenChannel this_ptr_conv;
13091 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13092 this_ptr_conv.is_owned = false;
13093 OpenChannel_set_channel_flags(&this_ptr_conv, val);
13096 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OpenChannel_1clone(JNIEnv *env, jclass clz, int64_t orig) {
13097 LDKOpenChannel orig_conv;
13098 orig_conv.inner = (void*)(orig & (~1));
13099 orig_conv.is_owned = false;
13100 LDKOpenChannel ret_var = OpenChannel_clone(&orig_conv);
13101 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13102 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13103 long ret_ref = (long)ret_var.inner;
13104 if (ret_var.is_owned) {
13110 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
13111 LDKAcceptChannel this_obj_conv;
13112 this_obj_conv.inner = (void*)(this_obj & (~1));
13113 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
13114 AcceptChannel_free(this_obj_conv);
13117 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1get_1temporary_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
13118 LDKAcceptChannel this_ptr_conv;
13119 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13120 this_ptr_conv.is_owned = false;
13121 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
13122 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *AcceptChannel_get_temporary_channel_id(&this_ptr_conv));
13126 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1set_1temporary_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
13127 LDKAcceptChannel this_ptr_conv;
13128 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13129 this_ptr_conv.is_owned = false;
13130 LDKThirtyTwoBytes val_ref;
13131 CHECK((*env)->GetArrayLength(env, val) == 32);
13132 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
13133 AcceptChannel_set_temporary_channel_id(&this_ptr_conv, val_ref);
13136 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1get_1dust_1limit_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr) {
13137 LDKAcceptChannel this_ptr_conv;
13138 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13139 this_ptr_conv.is_owned = false;
13140 int64_t ret_val = AcceptChannel_get_dust_limit_satoshis(&this_ptr_conv);
13144 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1set_1dust_1limit_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
13145 LDKAcceptChannel this_ptr_conv;
13146 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13147 this_ptr_conv.is_owned = false;
13148 AcceptChannel_set_dust_limit_satoshis(&this_ptr_conv, val);
13151 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) {
13152 LDKAcceptChannel this_ptr_conv;
13153 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13154 this_ptr_conv.is_owned = false;
13155 int64_t ret_val = AcceptChannel_get_max_htlc_value_in_flight_msat(&this_ptr_conv);
13159 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) {
13160 LDKAcceptChannel this_ptr_conv;
13161 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13162 this_ptr_conv.is_owned = false;
13163 AcceptChannel_set_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
13166 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1get_1channel_1reserve_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr) {
13167 LDKAcceptChannel this_ptr_conv;
13168 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13169 this_ptr_conv.is_owned = false;
13170 int64_t ret_val = AcceptChannel_get_channel_reserve_satoshis(&this_ptr_conv);
13174 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1set_1channel_1reserve_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
13175 LDKAcceptChannel this_ptr_conv;
13176 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13177 this_ptr_conv.is_owned = false;
13178 AcceptChannel_set_channel_reserve_satoshis(&this_ptr_conv, val);
13181 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1get_1htlc_1minimum_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
13182 LDKAcceptChannel this_ptr_conv;
13183 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13184 this_ptr_conv.is_owned = false;
13185 int64_t ret_val = AcceptChannel_get_htlc_minimum_msat(&this_ptr_conv);
13189 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1set_1htlc_1minimum_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
13190 LDKAcceptChannel this_ptr_conv;
13191 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13192 this_ptr_conv.is_owned = false;
13193 AcceptChannel_set_htlc_minimum_msat(&this_ptr_conv, val);
13196 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1get_1minimum_1depth(JNIEnv *env, jclass clz, int64_t this_ptr) {
13197 LDKAcceptChannel this_ptr_conv;
13198 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13199 this_ptr_conv.is_owned = false;
13200 int32_t ret_val = AcceptChannel_get_minimum_depth(&this_ptr_conv);
13204 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1set_1minimum_1depth(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
13205 LDKAcceptChannel this_ptr_conv;
13206 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13207 this_ptr_conv.is_owned = false;
13208 AcceptChannel_set_minimum_depth(&this_ptr_conv, val);
13211 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1get_1to_1self_1delay(JNIEnv *env, jclass clz, int64_t this_ptr) {
13212 LDKAcceptChannel this_ptr_conv;
13213 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13214 this_ptr_conv.is_owned = false;
13215 int16_t ret_val = AcceptChannel_get_to_self_delay(&this_ptr_conv);
13219 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1set_1to_1self_1delay(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
13220 LDKAcceptChannel this_ptr_conv;
13221 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13222 this_ptr_conv.is_owned = false;
13223 AcceptChannel_set_to_self_delay(&this_ptr_conv, val);
13226 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1get_1max_1accepted_1htlcs(JNIEnv *env, jclass clz, int64_t this_ptr) {
13227 LDKAcceptChannel this_ptr_conv;
13228 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13229 this_ptr_conv.is_owned = false;
13230 int16_t ret_val = AcceptChannel_get_max_accepted_htlcs(&this_ptr_conv);
13234 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1set_1max_1accepted_1htlcs(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
13235 LDKAcceptChannel this_ptr_conv;
13236 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13237 this_ptr_conv.is_owned = false;
13238 AcceptChannel_set_max_accepted_htlcs(&this_ptr_conv, val);
13241 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1get_1funding_1pubkey(JNIEnv *env, jclass clz, int64_t this_ptr) {
13242 LDKAcceptChannel this_ptr_conv;
13243 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13244 this_ptr_conv.is_owned = false;
13245 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
13246 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, AcceptChannel_get_funding_pubkey(&this_ptr_conv).compressed_form);
13250 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1set_1funding_1pubkey(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
13251 LDKAcceptChannel this_ptr_conv;
13252 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13253 this_ptr_conv.is_owned = false;
13254 LDKPublicKey val_ref;
13255 CHECK((*env)->GetArrayLength(env, val) == 33);
13256 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
13257 AcceptChannel_set_funding_pubkey(&this_ptr_conv, val_ref);
13260 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1get_1revocation_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr) {
13261 LDKAcceptChannel this_ptr_conv;
13262 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13263 this_ptr_conv.is_owned = false;
13264 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
13265 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, AcceptChannel_get_revocation_basepoint(&this_ptr_conv).compressed_form);
13269 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1set_1revocation_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
13270 LDKAcceptChannel this_ptr_conv;
13271 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13272 this_ptr_conv.is_owned = false;
13273 LDKPublicKey val_ref;
13274 CHECK((*env)->GetArrayLength(env, val) == 33);
13275 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
13276 AcceptChannel_set_revocation_basepoint(&this_ptr_conv, val_ref);
13279 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1get_1payment_1point(JNIEnv *env, jclass clz, int64_t this_ptr) {
13280 LDKAcceptChannel this_ptr_conv;
13281 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13282 this_ptr_conv.is_owned = false;
13283 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
13284 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, AcceptChannel_get_payment_point(&this_ptr_conv).compressed_form);
13288 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1set_1payment_1point(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
13289 LDKAcceptChannel this_ptr_conv;
13290 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13291 this_ptr_conv.is_owned = false;
13292 LDKPublicKey val_ref;
13293 CHECK((*env)->GetArrayLength(env, val) == 33);
13294 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
13295 AcceptChannel_set_payment_point(&this_ptr_conv, val_ref);
13298 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1get_1delayed_1payment_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr) {
13299 LDKAcceptChannel this_ptr_conv;
13300 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13301 this_ptr_conv.is_owned = false;
13302 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
13303 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, AcceptChannel_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form);
13307 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1set_1delayed_1payment_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
13308 LDKAcceptChannel this_ptr_conv;
13309 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13310 this_ptr_conv.is_owned = false;
13311 LDKPublicKey val_ref;
13312 CHECK((*env)->GetArrayLength(env, val) == 33);
13313 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
13314 AcceptChannel_set_delayed_payment_basepoint(&this_ptr_conv, val_ref);
13317 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1get_1htlc_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr) {
13318 LDKAcceptChannel this_ptr_conv;
13319 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13320 this_ptr_conv.is_owned = false;
13321 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
13322 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, AcceptChannel_get_htlc_basepoint(&this_ptr_conv).compressed_form);
13326 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1set_1htlc_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
13327 LDKAcceptChannel this_ptr_conv;
13328 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13329 this_ptr_conv.is_owned = false;
13330 LDKPublicKey val_ref;
13331 CHECK((*env)->GetArrayLength(env, val) == 33);
13332 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
13333 AcceptChannel_set_htlc_basepoint(&this_ptr_conv, val_ref);
13336 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1get_1first_1per_1commitment_1point(JNIEnv *env, jclass clz, int64_t this_ptr) {
13337 LDKAcceptChannel this_ptr_conv;
13338 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13339 this_ptr_conv.is_owned = false;
13340 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
13341 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, AcceptChannel_get_first_per_commitment_point(&this_ptr_conv).compressed_form);
13345 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) {
13346 LDKAcceptChannel this_ptr_conv;
13347 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13348 this_ptr_conv.is_owned = false;
13349 LDKPublicKey val_ref;
13350 CHECK((*env)->GetArrayLength(env, val) == 33);
13351 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
13352 AcceptChannel_set_first_per_commitment_point(&this_ptr_conv, val_ref);
13355 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1clone(JNIEnv *env, jclass clz, int64_t orig) {
13356 LDKAcceptChannel orig_conv;
13357 orig_conv.inner = (void*)(orig & (~1));
13358 orig_conv.is_owned = false;
13359 LDKAcceptChannel ret_var = AcceptChannel_clone(&orig_conv);
13360 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13361 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13362 long ret_ref = (long)ret_var.inner;
13363 if (ret_var.is_owned) {
13369 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_FundingCreated_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
13370 LDKFundingCreated this_obj_conv;
13371 this_obj_conv.inner = (void*)(this_obj & (~1));
13372 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
13373 FundingCreated_free(this_obj_conv);
13376 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_FundingCreated_1get_1temporary_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
13377 LDKFundingCreated this_ptr_conv;
13378 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13379 this_ptr_conv.is_owned = false;
13380 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
13381 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *FundingCreated_get_temporary_channel_id(&this_ptr_conv));
13385 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_FundingCreated_1set_1temporary_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
13386 LDKFundingCreated this_ptr_conv;
13387 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13388 this_ptr_conv.is_owned = false;
13389 LDKThirtyTwoBytes val_ref;
13390 CHECK((*env)->GetArrayLength(env, val) == 32);
13391 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
13392 FundingCreated_set_temporary_channel_id(&this_ptr_conv, val_ref);
13395 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_FundingCreated_1get_1funding_1txid(JNIEnv *env, jclass clz, int64_t this_ptr) {
13396 LDKFundingCreated this_ptr_conv;
13397 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13398 this_ptr_conv.is_owned = false;
13399 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
13400 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *FundingCreated_get_funding_txid(&this_ptr_conv));
13404 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_FundingCreated_1set_1funding_1txid(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
13405 LDKFundingCreated this_ptr_conv;
13406 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13407 this_ptr_conv.is_owned = false;
13408 LDKThirtyTwoBytes val_ref;
13409 CHECK((*env)->GetArrayLength(env, val) == 32);
13410 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
13411 FundingCreated_set_funding_txid(&this_ptr_conv, val_ref);
13414 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_FundingCreated_1get_1funding_1output_1index(JNIEnv *env, jclass clz, int64_t this_ptr) {
13415 LDKFundingCreated this_ptr_conv;
13416 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13417 this_ptr_conv.is_owned = false;
13418 int16_t ret_val = FundingCreated_get_funding_output_index(&this_ptr_conv);
13422 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_FundingCreated_1set_1funding_1output_1index(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
13423 LDKFundingCreated this_ptr_conv;
13424 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13425 this_ptr_conv.is_owned = false;
13426 FundingCreated_set_funding_output_index(&this_ptr_conv, val);
13429 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_FundingCreated_1get_1signature(JNIEnv *env, jclass clz, int64_t this_ptr) {
13430 LDKFundingCreated this_ptr_conv;
13431 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13432 this_ptr_conv.is_owned = false;
13433 int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
13434 (*env)->SetByteArrayRegion(env, ret_arr, 0, 64, FundingCreated_get_signature(&this_ptr_conv).compact_form);
13438 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_FundingCreated_1set_1signature(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
13439 LDKFundingCreated this_ptr_conv;
13440 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13441 this_ptr_conv.is_owned = false;
13442 LDKSignature val_ref;
13443 CHECK((*env)->GetArrayLength(env, val) == 64);
13444 (*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
13445 FundingCreated_set_signature(&this_ptr_conv, val_ref);
13448 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) {
13449 LDKThirtyTwoBytes temporary_channel_id_arg_ref;
13450 CHECK((*env)->GetArrayLength(env, temporary_channel_id_arg) == 32);
13451 (*env)->GetByteArrayRegion(env, temporary_channel_id_arg, 0, 32, temporary_channel_id_arg_ref.data);
13452 LDKThirtyTwoBytes funding_txid_arg_ref;
13453 CHECK((*env)->GetArrayLength(env, funding_txid_arg) == 32);
13454 (*env)->GetByteArrayRegion(env, funding_txid_arg, 0, 32, funding_txid_arg_ref.data);
13455 LDKSignature signature_arg_ref;
13456 CHECK((*env)->GetArrayLength(env, signature_arg) == 64);
13457 (*env)->GetByteArrayRegion(env, signature_arg, 0, 64, signature_arg_ref.compact_form);
13458 LDKFundingCreated ret_var = FundingCreated_new(temporary_channel_id_arg_ref, funding_txid_arg_ref, funding_output_index_arg, signature_arg_ref);
13459 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13460 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13461 long ret_ref = (long)ret_var.inner;
13462 if (ret_var.is_owned) {
13468 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_FundingCreated_1clone(JNIEnv *env, jclass clz, int64_t orig) {
13469 LDKFundingCreated orig_conv;
13470 orig_conv.inner = (void*)(orig & (~1));
13471 orig_conv.is_owned = false;
13472 LDKFundingCreated ret_var = FundingCreated_clone(&orig_conv);
13473 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13474 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13475 long ret_ref = (long)ret_var.inner;
13476 if (ret_var.is_owned) {
13482 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_FundingSigned_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
13483 LDKFundingSigned this_obj_conv;
13484 this_obj_conv.inner = (void*)(this_obj & (~1));
13485 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
13486 FundingSigned_free(this_obj_conv);
13489 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_FundingSigned_1get_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
13490 LDKFundingSigned this_ptr_conv;
13491 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13492 this_ptr_conv.is_owned = false;
13493 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
13494 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *FundingSigned_get_channel_id(&this_ptr_conv));
13498 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_FundingSigned_1set_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
13499 LDKFundingSigned this_ptr_conv;
13500 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13501 this_ptr_conv.is_owned = false;
13502 LDKThirtyTwoBytes val_ref;
13503 CHECK((*env)->GetArrayLength(env, val) == 32);
13504 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
13505 FundingSigned_set_channel_id(&this_ptr_conv, val_ref);
13508 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_FundingSigned_1get_1signature(JNIEnv *env, jclass clz, int64_t this_ptr) {
13509 LDKFundingSigned this_ptr_conv;
13510 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13511 this_ptr_conv.is_owned = false;
13512 int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
13513 (*env)->SetByteArrayRegion(env, ret_arr, 0, 64, FundingSigned_get_signature(&this_ptr_conv).compact_form);
13517 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_FundingSigned_1set_1signature(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
13518 LDKFundingSigned this_ptr_conv;
13519 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13520 this_ptr_conv.is_owned = false;
13521 LDKSignature val_ref;
13522 CHECK((*env)->GetArrayLength(env, val) == 64);
13523 (*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
13524 FundingSigned_set_signature(&this_ptr_conv, val_ref);
13527 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_FundingSigned_1new(JNIEnv *env, jclass clz, int8_tArray channel_id_arg, int8_tArray signature_arg) {
13528 LDKThirtyTwoBytes channel_id_arg_ref;
13529 CHECK((*env)->GetArrayLength(env, channel_id_arg) == 32);
13530 (*env)->GetByteArrayRegion(env, channel_id_arg, 0, 32, channel_id_arg_ref.data);
13531 LDKSignature signature_arg_ref;
13532 CHECK((*env)->GetArrayLength(env, signature_arg) == 64);
13533 (*env)->GetByteArrayRegion(env, signature_arg, 0, 64, signature_arg_ref.compact_form);
13534 LDKFundingSigned ret_var = FundingSigned_new(channel_id_arg_ref, signature_arg_ref);
13535 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13536 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13537 long ret_ref = (long)ret_var.inner;
13538 if (ret_var.is_owned) {
13544 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_FundingSigned_1clone(JNIEnv *env, jclass clz, int64_t orig) {
13545 LDKFundingSigned orig_conv;
13546 orig_conv.inner = (void*)(orig & (~1));
13547 orig_conv.is_owned = false;
13548 LDKFundingSigned ret_var = FundingSigned_clone(&orig_conv);
13549 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13550 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13551 long ret_ref = (long)ret_var.inner;
13552 if (ret_var.is_owned) {
13558 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_FundingLocked_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
13559 LDKFundingLocked this_obj_conv;
13560 this_obj_conv.inner = (void*)(this_obj & (~1));
13561 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
13562 FundingLocked_free(this_obj_conv);
13565 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_FundingLocked_1get_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
13566 LDKFundingLocked this_ptr_conv;
13567 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13568 this_ptr_conv.is_owned = false;
13569 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
13570 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *FundingLocked_get_channel_id(&this_ptr_conv));
13574 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_FundingLocked_1set_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
13575 LDKFundingLocked this_ptr_conv;
13576 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13577 this_ptr_conv.is_owned = false;
13578 LDKThirtyTwoBytes val_ref;
13579 CHECK((*env)->GetArrayLength(env, val) == 32);
13580 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
13581 FundingLocked_set_channel_id(&this_ptr_conv, val_ref);
13584 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_FundingLocked_1get_1next_1per_1commitment_1point(JNIEnv *env, jclass clz, int64_t this_ptr) {
13585 LDKFundingLocked this_ptr_conv;
13586 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13587 this_ptr_conv.is_owned = false;
13588 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
13589 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, FundingLocked_get_next_per_commitment_point(&this_ptr_conv).compressed_form);
13593 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) {
13594 LDKFundingLocked this_ptr_conv;
13595 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13596 this_ptr_conv.is_owned = false;
13597 LDKPublicKey val_ref;
13598 CHECK((*env)->GetArrayLength(env, val) == 33);
13599 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
13600 FundingLocked_set_next_per_commitment_point(&this_ptr_conv, val_ref);
13603 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) {
13604 LDKThirtyTwoBytes channel_id_arg_ref;
13605 CHECK((*env)->GetArrayLength(env, channel_id_arg) == 32);
13606 (*env)->GetByteArrayRegion(env, channel_id_arg, 0, 32, channel_id_arg_ref.data);
13607 LDKPublicKey next_per_commitment_point_arg_ref;
13608 CHECK((*env)->GetArrayLength(env, next_per_commitment_point_arg) == 33);
13609 (*env)->GetByteArrayRegion(env, next_per_commitment_point_arg, 0, 33, next_per_commitment_point_arg_ref.compressed_form);
13610 LDKFundingLocked ret_var = FundingLocked_new(channel_id_arg_ref, next_per_commitment_point_arg_ref);
13611 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13612 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13613 long ret_ref = (long)ret_var.inner;
13614 if (ret_var.is_owned) {
13620 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_FundingLocked_1clone(JNIEnv *env, jclass clz, int64_t orig) {
13621 LDKFundingLocked orig_conv;
13622 orig_conv.inner = (void*)(orig & (~1));
13623 orig_conv.is_owned = false;
13624 LDKFundingLocked ret_var = FundingLocked_clone(&orig_conv);
13625 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13626 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13627 long ret_ref = (long)ret_var.inner;
13628 if (ret_var.is_owned) {
13634 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Shutdown_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
13635 LDKShutdown this_obj_conv;
13636 this_obj_conv.inner = (void*)(this_obj & (~1));
13637 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
13638 Shutdown_free(this_obj_conv);
13641 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_Shutdown_1get_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
13642 LDKShutdown this_ptr_conv;
13643 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13644 this_ptr_conv.is_owned = false;
13645 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
13646 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *Shutdown_get_channel_id(&this_ptr_conv));
13650 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Shutdown_1set_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
13651 LDKShutdown this_ptr_conv;
13652 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13653 this_ptr_conv.is_owned = false;
13654 LDKThirtyTwoBytes val_ref;
13655 CHECK((*env)->GetArrayLength(env, val) == 32);
13656 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
13657 Shutdown_set_channel_id(&this_ptr_conv, val_ref);
13660 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_Shutdown_1get_1scriptpubkey(JNIEnv *env, jclass clz, int64_t this_ptr) {
13661 LDKShutdown this_ptr_conv;
13662 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13663 this_ptr_conv.is_owned = false;
13664 LDKu8slice ret_var = Shutdown_get_scriptpubkey(&this_ptr_conv);
13665 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
13666 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
13670 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Shutdown_1set_1scriptpubkey(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
13671 LDKShutdown this_ptr_conv;
13672 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13673 this_ptr_conv.is_owned = false;
13674 LDKCVec_u8Z val_ref;
13675 val_ref.datalen = (*env)->GetArrayLength(env, val);
13676 val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
13677 (*env)->GetByteArrayRegion(env, val, 0, val_ref.datalen, val_ref.data);
13678 Shutdown_set_scriptpubkey(&this_ptr_conv, val_ref);
13681 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Shutdown_1new(JNIEnv *env, jclass clz, int8_tArray channel_id_arg, int8_tArray scriptpubkey_arg) {
13682 LDKThirtyTwoBytes channel_id_arg_ref;
13683 CHECK((*env)->GetArrayLength(env, channel_id_arg) == 32);
13684 (*env)->GetByteArrayRegion(env, channel_id_arg, 0, 32, channel_id_arg_ref.data);
13685 LDKCVec_u8Z scriptpubkey_arg_ref;
13686 scriptpubkey_arg_ref.datalen = (*env)->GetArrayLength(env, scriptpubkey_arg);
13687 scriptpubkey_arg_ref.data = MALLOC(scriptpubkey_arg_ref.datalen, "LDKCVec_u8Z Bytes");
13688 (*env)->GetByteArrayRegion(env, scriptpubkey_arg, 0, scriptpubkey_arg_ref.datalen, scriptpubkey_arg_ref.data);
13689 LDKShutdown ret_var = Shutdown_new(channel_id_arg_ref, scriptpubkey_arg_ref);
13690 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13691 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13692 long ret_ref = (long)ret_var.inner;
13693 if (ret_var.is_owned) {
13699 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Shutdown_1clone(JNIEnv *env, jclass clz, int64_t orig) {
13700 LDKShutdown orig_conv;
13701 orig_conv.inner = (void*)(orig & (~1));
13702 orig_conv.is_owned = false;
13703 LDKShutdown ret_var = Shutdown_clone(&orig_conv);
13704 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13705 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13706 long ret_ref = (long)ret_var.inner;
13707 if (ret_var.is_owned) {
13713 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ClosingSigned_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
13714 LDKClosingSigned this_obj_conv;
13715 this_obj_conv.inner = (void*)(this_obj & (~1));
13716 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
13717 ClosingSigned_free(this_obj_conv);
13720 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ClosingSigned_1get_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
13721 LDKClosingSigned this_ptr_conv;
13722 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13723 this_ptr_conv.is_owned = false;
13724 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
13725 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *ClosingSigned_get_channel_id(&this_ptr_conv));
13729 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ClosingSigned_1set_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
13730 LDKClosingSigned this_ptr_conv;
13731 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13732 this_ptr_conv.is_owned = false;
13733 LDKThirtyTwoBytes val_ref;
13734 CHECK((*env)->GetArrayLength(env, val) == 32);
13735 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
13736 ClosingSigned_set_channel_id(&this_ptr_conv, val_ref);
13739 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ClosingSigned_1get_1fee_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr) {
13740 LDKClosingSigned this_ptr_conv;
13741 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13742 this_ptr_conv.is_owned = false;
13743 int64_t ret_val = ClosingSigned_get_fee_satoshis(&this_ptr_conv);
13747 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ClosingSigned_1set_1fee_1satoshis(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
13748 LDKClosingSigned this_ptr_conv;
13749 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13750 this_ptr_conv.is_owned = false;
13751 ClosingSigned_set_fee_satoshis(&this_ptr_conv, val);
13754 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ClosingSigned_1get_1signature(JNIEnv *env, jclass clz, int64_t this_ptr) {
13755 LDKClosingSigned this_ptr_conv;
13756 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13757 this_ptr_conv.is_owned = false;
13758 int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
13759 (*env)->SetByteArrayRegion(env, ret_arr, 0, 64, ClosingSigned_get_signature(&this_ptr_conv).compact_form);
13763 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ClosingSigned_1set_1signature(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
13764 LDKClosingSigned this_ptr_conv;
13765 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13766 this_ptr_conv.is_owned = false;
13767 LDKSignature val_ref;
13768 CHECK((*env)->GetArrayLength(env, val) == 64);
13769 (*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
13770 ClosingSigned_set_signature(&this_ptr_conv, val_ref);
13773 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) {
13774 LDKThirtyTwoBytes channel_id_arg_ref;
13775 CHECK((*env)->GetArrayLength(env, channel_id_arg) == 32);
13776 (*env)->GetByteArrayRegion(env, channel_id_arg, 0, 32, channel_id_arg_ref.data);
13777 LDKSignature signature_arg_ref;
13778 CHECK((*env)->GetArrayLength(env, signature_arg) == 64);
13779 (*env)->GetByteArrayRegion(env, signature_arg, 0, 64, signature_arg_ref.compact_form);
13780 LDKClosingSigned ret_var = ClosingSigned_new(channel_id_arg_ref, fee_satoshis_arg, signature_arg_ref);
13781 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13782 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13783 long ret_ref = (long)ret_var.inner;
13784 if (ret_var.is_owned) {
13790 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ClosingSigned_1clone(JNIEnv *env, jclass clz, int64_t orig) {
13791 LDKClosingSigned orig_conv;
13792 orig_conv.inner = (void*)(orig & (~1));
13793 orig_conv.is_owned = false;
13794 LDKClosingSigned ret_var = ClosingSigned_clone(&orig_conv);
13795 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13796 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13797 long ret_ref = (long)ret_var.inner;
13798 if (ret_var.is_owned) {
13804 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
13805 LDKUpdateAddHTLC this_obj_conv;
13806 this_obj_conv.inner = (void*)(this_obj & (~1));
13807 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
13808 UpdateAddHTLC_free(this_obj_conv);
13811 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1get_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
13812 LDKUpdateAddHTLC this_ptr_conv;
13813 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13814 this_ptr_conv.is_owned = false;
13815 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
13816 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UpdateAddHTLC_get_channel_id(&this_ptr_conv));
13820 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1set_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
13821 LDKUpdateAddHTLC this_ptr_conv;
13822 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13823 this_ptr_conv.is_owned = false;
13824 LDKThirtyTwoBytes val_ref;
13825 CHECK((*env)->GetArrayLength(env, val) == 32);
13826 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
13827 UpdateAddHTLC_set_channel_id(&this_ptr_conv, val_ref);
13830 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1get_1htlc_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
13831 LDKUpdateAddHTLC this_ptr_conv;
13832 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13833 this_ptr_conv.is_owned = false;
13834 int64_t ret_val = UpdateAddHTLC_get_htlc_id(&this_ptr_conv);
13838 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1set_1htlc_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
13839 LDKUpdateAddHTLC this_ptr_conv;
13840 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13841 this_ptr_conv.is_owned = false;
13842 UpdateAddHTLC_set_htlc_id(&this_ptr_conv, val);
13845 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1get_1amount_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
13846 LDKUpdateAddHTLC this_ptr_conv;
13847 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13848 this_ptr_conv.is_owned = false;
13849 int64_t ret_val = UpdateAddHTLC_get_amount_msat(&this_ptr_conv);
13853 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1set_1amount_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
13854 LDKUpdateAddHTLC this_ptr_conv;
13855 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13856 this_ptr_conv.is_owned = false;
13857 UpdateAddHTLC_set_amount_msat(&this_ptr_conv, val);
13860 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1get_1payment_1hash(JNIEnv *env, jclass clz, int64_t this_ptr) {
13861 LDKUpdateAddHTLC this_ptr_conv;
13862 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13863 this_ptr_conv.is_owned = false;
13864 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
13865 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UpdateAddHTLC_get_payment_hash(&this_ptr_conv));
13869 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1set_1payment_1hash(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
13870 LDKUpdateAddHTLC this_ptr_conv;
13871 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13872 this_ptr_conv.is_owned = false;
13873 LDKThirtyTwoBytes val_ref;
13874 CHECK((*env)->GetArrayLength(env, val) == 32);
13875 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
13876 UpdateAddHTLC_set_payment_hash(&this_ptr_conv, val_ref);
13879 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1get_1cltv_1expiry(JNIEnv *env, jclass clz, int64_t this_ptr) {
13880 LDKUpdateAddHTLC this_ptr_conv;
13881 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13882 this_ptr_conv.is_owned = false;
13883 int32_t ret_val = UpdateAddHTLC_get_cltv_expiry(&this_ptr_conv);
13887 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1set_1cltv_1expiry(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
13888 LDKUpdateAddHTLC this_ptr_conv;
13889 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13890 this_ptr_conv.is_owned = false;
13891 UpdateAddHTLC_set_cltv_expiry(&this_ptr_conv, val);
13894 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1clone(JNIEnv *env, jclass clz, int64_t orig) {
13895 LDKUpdateAddHTLC orig_conv;
13896 orig_conv.inner = (void*)(orig & (~1));
13897 orig_conv.is_owned = false;
13898 LDKUpdateAddHTLC ret_var = UpdateAddHTLC_clone(&orig_conv);
13899 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13900 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13901 long ret_ref = (long)ret_var.inner;
13902 if (ret_var.is_owned) {
13908 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateFulfillHTLC_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
13909 LDKUpdateFulfillHTLC this_obj_conv;
13910 this_obj_conv.inner = (void*)(this_obj & (~1));
13911 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
13912 UpdateFulfillHTLC_free(this_obj_conv);
13915 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UpdateFulfillHTLC_1get_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
13916 LDKUpdateFulfillHTLC this_ptr_conv;
13917 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13918 this_ptr_conv.is_owned = false;
13919 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
13920 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UpdateFulfillHTLC_get_channel_id(&this_ptr_conv));
13924 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateFulfillHTLC_1set_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
13925 LDKUpdateFulfillHTLC this_ptr_conv;
13926 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13927 this_ptr_conv.is_owned = false;
13928 LDKThirtyTwoBytes val_ref;
13929 CHECK((*env)->GetArrayLength(env, val) == 32);
13930 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
13931 UpdateFulfillHTLC_set_channel_id(&this_ptr_conv, val_ref);
13934 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFulfillHTLC_1get_1htlc_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
13935 LDKUpdateFulfillHTLC this_ptr_conv;
13936 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13937 this_ptr_conv.is_owned = false;
13938 int64_t ret_val = UpdateFulfillHTLC_get_htlc_id(&this_ptr_conv);
13942 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateFulfillHTLC_1set_1htlc_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
13943 LDKUpdateFulfillHTLC this_ptr_conv;
13944 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13945 this_ptr_conv.is_owned = false;
13946 UpdateFulfillHTLC_set_htlc_id(&this_ptr_conv, val);
13949 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UpdateFulfillHTLC_1get_1payment_1preimage(JNIEnv *env, jclass clz, int64_t this_ptr) {
13950 LDKUpdateFulfillHTLC this_ptr_conv;
13951 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13952 this_ptr_conv.is_owned = false;
13953 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
13954 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UpdateFulfillHTLC_get_payment_preimage(&this_ptr_conv));
13958 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateFulfillHTLC_1set_1payment_1preimage(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
13959 LDKUpdateFulfillHTLC this_ptr_conv;
13960 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13961 this_ptr_conv.is_owned = false;
13962 LDKThirtyTwoBytes val_ref;
13963 CHECK((*env)->GetArrayLength(env, val) == 32);
13964 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
13965 UpdateFulfillHTLC_set_payment_preimage(&this_ptr_conv, val_ref);
13968 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) {
13969 LDKThirtyTwoBytes channel_id_arg_ref;
13970 CHECK((*env)->GetArrayLength(env, channel_id_arg) == 32);
13971 (*env)->GetByteArrayRegion(env, channel_id_arg, 0, 32, channel_id_arg_ref.data);
13972 LDKThirtyTwoBytes payment_preimage_arg_ref;
13973 CHECK((*env)->GetArrayLength(env, payment_preimage_arg) == 32);
13974 (*env)->GetByteArrayRegion(env, payment_preimage_arg, 0, 32, payment_preimage_arg_ref.data);
13975 LDKUpdateFulfillHTLC ret_var = UpdateFulfillHTLC_new(channel_id_arg_ref, htlc_id_arg, payment_preimage_arg_ref);
13976 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13977 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13978 long ret_ref = (long)ret_var.inner;
13979 if (ret_var.is_owned) {
13985 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFulfillHTLC_1clone(JNIEnv *env, jclass clz, int64_t orig) {
13986 LDKUpdateFulfillHTLC orig_conv;
13987 orig_conv.inner = (void*)(orig & (~1));
13988 orig_conv.is_owned = false;
13989 LDKUpdateFulfillHTLC ret_var = UpdateFulfillHTLC_clone(&orig_conv);
13990 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13991 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13992 long ret_ref = (long)ret_var.inner;
13993 if (ret_var.is_owned) {
13999 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateFailHTLC_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
14000 LDKUpdateFailHTLC this_obj_conv;
14001 this_obj_conv.inner = (void*)(this_obj & (~1));
14002 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
14003 UpdateFailHTLC_free(this_obj_conv);
14006 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UpdateFailHTLC_1get_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
14007 LDKUpdateFailHTLC this_ptr_conv;
14008 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14009 this_ptr_conv.is_owned = false;
14010 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
14011 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UpdateFailHTLC_get_channel_id(&this_ptr_conv));
14015 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateFailHTLC_1set_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
14016 LDKUpdateFailHTLC this_ptr_conv;
14017 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14018 this_ptr_conv.is_owned = false;
14019 LDKThirtyTwoBytes val_ref;
14020 CHECK((*env)->GetArrayLength(env, val) == 32);
14021 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
14022 UpdateFailHTLC_set_channel_id(&this_ptr_conv, val_ref);
14025 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFailHTLC_1get_1htlc_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
14026 LDKUpdateFailHTLC this_ptr_conv;
14027 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14028 this_ptr_conv.is_owned = false;
14029 int64_t ret_val = UpdateFailHTLC_get_htlc_id(&this_ptr_conv);
14033 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateFailHTLC_1set_1htlc_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
14034 LDKUpdateFailHTLC this_ptr_conv;
14035 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14036 this_ptr_conv.is_owned = false;
14037 UpdateFailHTLC_set_htlc_id(&this_ptr_conv, val);
14040 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFailHTLC_1clone(JNIEnv *env, jclass clz, int64_t orig) {
14041 LDKUpdateFailHTLC orig_conv;
14042 orig_conv.inner = (void*)(orig & (~1));
14043 orig_conv.is_owned = false;
14044 LDKUpdateFailHTLC ret_var = UpdateFailHTLC_clone(&orig_conv);
14045 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14046 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14047 long ret_ref = (long)ret_var.inner;
14048 if (ret_var.is_owned) {
14054 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateFailMalformedHTLC_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
14055 LDKUpdateFailMalformedHTLC this_obj_conv;
14056 this_obj_conv.inner = (void*)(this_obj & (~1));
14057 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
14058 UpdateFailMalformedHTLC_free(this_obj_conv);
14061 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UpdateFailMalformedHTLC_1get_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
14062 LDKUpdateFailMalformedHTLC this_ptr_conv;
14063 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14064 this_ptr_conv.is_owned = false;
14065 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
14066 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UpdateFailMalformedHTLC_get_channel_id(&this_ptr_conv));
14070 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateFailMalformedHTLC_1set_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
14071 LDKUpdateFailMalformedHTLC this_ptr_conv;
14072 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14073 this_ptr_conv.is_owned = false;
14074 LDKThirtyTwoBytes val_ref;
14075 CHECK((*env)->GetArrayLength(env, val) == 32);
14076 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
14077 UpdateFailMalformedHTLC_set_channel_id(&this_ptr_conv, val_ref);
14080 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFailMalformedHTLC_1get_1htlc_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
14081 LDKUpdateFailMalformedHTLC this_ptr_conv;
14082 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14083 this_ptr_conv.is_owned = false;
14084 int64_t ret_val = UpdateFailMalformedHTLC_get_htlc_id(&this_ptr_conv);
14088 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateFailMalformedHTLC_1set_1htlc_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
14089 LDKUpdateFailMalformedHTLC this_ptr_conv;
14090 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14091 this_ptr_conv.is_owned = false;
14092 UpdateFailMalformedHTLC_set_htlc_id(&this_ptr_conv, val);
14095 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_UpdateFailMalformedHTLC_1get_1failure_1code(JNIEnv *env, jclass clz, int64_t this_ptr) {
14096 LDKUpdateFailMalformedHTLC this_ptr_conv;
14097 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14098 this_ptr_conv.is_owned = false;
14099 int16_t ret_val = UpdateFailMalformedHTLC_get_failure_code(&this_ptr_conv);
14103 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateFailMalformedHTLC_1set_1failure_1code(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
14104 LDKUpdateFailMalformedHTLC this_ptr_conv;
14105 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14106 this_ptr_conv.is_owned = false;
14107 UpdateFailMalformedHTLC_set_failure_code(&this_ptr_conv, val);
14110 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFailMalformedHTLC_1clone(JNIEnv *env, jclass clz, int64_t orig) {
14111 LDKUpdateFailMalformedHTLC orig_conv;
14112 orig_conv.inner = (void*)(orig & (~1));
14113 orig_conv.is_owned = false;
14114 LDKUpdateFailMalformedHTLC ret_var = UpdateFailMalformedHTLC_clone(&orig_conv);
14115 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14116 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14117 long ret_ref = (long)ret_var.inner;
14118 if (ret_var.is_owned) {
14124 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CommitmentSigned_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
14125 LDKCommitmentSigned this_obj_conv;
14126 this_obj_conv.inner = (void*)(this_obj & (~1));
14127 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
14128 CommitmentSigned_free(this_obj_conv);
14131 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_CommitmentSigned_1get_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
14132 LDKCommitmentSigned this_ptr_conv;
14133 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14134 this_ptr_conv.is_owned = false;
14135 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
14136 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *CommitmentSigned_get_channel_id(&this_ptr_conv));
14140 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CommitmentSigned_1set_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
14141 LDKCommitmentSigned this_ptr_conv;
14142 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14143 this_ptr_conv.is_owned = false;
14144 LDKThirtyTwoBytes val_ref;
14145 CHECK((*env)->GetArrayLength(env, val) == 32);
14146 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
14147 CommitmentSigned_set_channel_id(&this_ptr_conv, val_ref);
14150 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_CommitmentSigned_1get_1signature(JNIEnv *env, jclass clz, int64_t this_ptr) {
14151 LDKCommitmentSigned this_ptr_conv;
14152 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14153 this_ptr_conv.is_owned = false;
14154 int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
14155 (*env)->SetByteArrayRegion(env, ret_arr, 0, 64, CommitmentSigned_get_signature(&this_ptr_conv).compact_form);
14159 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CommitmentSigned_1set_1signature(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
14160 LDKCommitmentSigned this_ptr_conv;
14161 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14162 this_ptr_conv.is_owned = false;
14163 LDKSignature val_ref;
14164 CHECK((*env)->GetArrayLength(env, val) == 64);
14165 (*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
14166 CommitmentSigned_set_signature(&this_ptr_conv, val_ref);
14169 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CommitmentSigned_1set_1htlc_1signatures(JNIEnv *env, jclass clz, int64_t this_ptr, jobjectArray val) {
14170 LDKCommitmentSigned this_ptr_conv;
14171 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14172 this_ptr_conv.is_owned = false;
14173 LDKCVec_SignatureZ val_constr;
14174 val_constr.datalen = (*env)->GetArrayLength(env, val);
14175 if (val_constr.datalen > 0)
14176 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
14178 val_constr.data = NULL;
14179 for (size_t i = 0; i < val_constr.datalen; i++) {
14180 int8_tArray val_conv_8 = (*env)->GetObjectArrayElement(env, val, i);
14181 LDKSignature val_conv_8_ref;
14182 CHECK((*env)->GetArrayLength(env, val_conv_8) == 64);
14183 (*env)->GetByteArrayRegion(env, val_conv_8, 0, 64, val_conv_8_ref.compact_form);
14184 val_constr.data[i] = val_conv_8_ref;
14186 CommitmentSigned_set_htlc_signatures(&this_ptr_conv, val_constr);
14189 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) {
14190 LDKThirtyTwoBytes channel_id_arg_ref;
14191 CHECK((*env)->GetArrayLength(env, channel_id_arg) == 32);
14192 (*env)->GetByteArrayRegion(env, channel_id_arg, 0, 32, channel_id_arg_ref.data);
14193 LDKSignature signature_arg_ref;
14194 CHECK((*env)->GetArrayLength(env, signature_arg) == 64);
14195 (*env)->GetByteArrayRegion(env, signature_arg, 0, 64, signature_arg_ref.compact_form);
14196 LDKCVec_SignatureZ htlc_signatures_arg_constr;
14197 htlc_signatures_arg_constr.datalen = (*env)->GetArrayLength(env, htlc_signatures_arg);
14198 if (htlc_signatures_arg_constr.datalen > 0)
14199 htlc_signatures_arg_constr.data = MALLOC(htlc_signatures_arg_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
14201 htlc_signatures_arg_constr.data = NULL;
14202 for (size_t i = 0; i < htlc_signatures_arg_constr.datalen; i++) {
14203 int8_tArray htlc_signatures_arg_conv_8 = (*env)->GetObjectArrayElement(env, htlc_signatures_arg, i);
14204 LDKSignature htlc_signatures_arg_conv_8_ref;
14205 CHECK((*env)->GetArrayLength(env, htlc_signatures_arg_conv_8) == 64);
14206 (*env)->GetByteArrayRegion(env, htlc_signatures_arg_conv_8, 0, 64, htlc_signatures_arg_conv_8_ref.compact_form);
14207 htlc_signatures_arg_constr.data[i] = htlc_signatures_arg_conv_8_ref;
14209 LDKCommitmentSigned ret_var = CommitmentSigned_new(channel_id_arg_ref, signature_arg_ref, htlc_signatures_arg_constr);
14210 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14211 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14212 long ret_ref = (long)ret_var.inner;
14213 if (ret_var.is_owned) {
14219 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentSigned_1clone(JNIEnv *env, jclass clz, int64_t orig) {
14220 LDKCommitmentSigned orig_conv;
14221 orig_conv.inner = (void*)(orig & (~1));
14222 orig_conv.is_owned = false;
14223 LDKCommitmentSigned ret_var = CommitmentSigned_clone(&orig_conv);
14224 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14225 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14226 long ret_ref = (long)ret_var.inner;
14227 if (ret_var.is_owned) {
14233 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RevokeAndACK_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
14234 LDKRevokeAndACK this_obj_conv;
14235 this_obj_conv.inner = (void*)(this_obj & (~1));
14236 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
14237 RevokeAndACK_free(this_obj_conv);
14240 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_RevokeAndACK_1get_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
14241 LDKRevokeAndACK this_ptr_conv;
14242 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14243 this_ptr_conv.is_owned = false;
14244 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
14245 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *RevokeAndACK_get_channel_id(&this_ptr_conv));
14249 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RevokeAndACK_1set_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
14250 LDKRevokeAndACK this_ptr_conv;
14251 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14252 this_ptr_conv.is_owned = false;
14253 LDKThirtyTwoBytes val_ref;
14254 CHECK((*env)->GetArrayLength(env, val) == 32);
14255 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
14256 RevokeAndACK_set_channel_id(&this_ptr_conv, val_ref);
14259 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_RevokeAndACK_1get_1per_1commitment_1secret(JNIEnv *env, jclass clz, int64_t this_ptr) {
14260 LDKRevokeAndACK this_ptr_conv;
14261 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14262 this_ptr_conv.is_owned = false;
14263 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
14264 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *RevokeAndACK_get_per_commitment_secret(&this_ptr_conv));
14268 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RevokeAndACK_1set_1per_1commitment_1secret(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
14269 LDKRevokeAndACK this_ptr_conv;
14270 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14271 this_ptr_conv.is_owned = false;
14272 LDKThirtyTwoBytes val_ref;
14273 CHECK((*env)->GetArrayLength(env, val) == 32);
14274 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
14275 RevokeAndACK_set_per_commitment_secret(&this_ptr_conv, val_ref);
14278 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_RevokeAndACK_1get_1next_1per_1commitment_1point(JNIEnv *env, jclass clz, int64_t this_ptr) {
14279 LDKRevokeAndACK this_ptr_conv;
14280 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14281 this_ptr_conv.is_owned = false;
14282 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
14283 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, RevokeAndACK_get_next_per_commitment_point(&this_ptr_conv).compressed_form);
14287 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) {
14288 LDKRevokeAndACK this_ptr_conv;
14289 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14290 this_ptr_conv.is_owned = false;
14291 LDKPublicKey val_ref;
14292 CHECK((*env)->GetArrayLength(env, val) == 33);
14293 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
14294 RevokeAndACK_set_next_per_commitment_point(&this_ptr_conv, val_ref);
14297 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) {
14298 LDKThirtyTwoBytes channel_id_arg_ref;
14299 CHECK((*env)->GetArrayLength(env, channel_id_arg) == 32);
14300 (*env)->GetByteArrayRegion(env, channel_id_arg, 0, 32, channel_id_arg_ref.data);
14301 LDKThirtyTwoBytes per_commitment_secret_arg_ref;
14302 CHECK((*env)->GetArrayLength(env, per_commitment_secret_arg) == 32);
14303 (*env)->GetByteArrayRegion(env, per_commitment_secret_arg, 0, 32, per_commitment_secret_arg_ref.data);
14304 LDKPublicKey next_per_commitment_point_arg_ref;
14305 CHECK((*env)->GetArrayLength(env, next_per_commitment_point_arg) == 33);
14306 (*env)->GetByteArrayRegion(env, next_per_commitment_point_arg, 0, 33, next_per_commitment_point_arg_ref.compressed_form);
14307 LDKRevokeAndACK ret_var = RevokeAndACK_new(channel_id_arg_ref, per_commitment_secret_arg_ref, next_per_commitment_point_arg_ref);
14308 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14309 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14310 long ret_ref = (long)ret_var.inner;
14311 if (ret_var.is_owned) {
14317 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RevokeAndACK_1clone(JNIEnv *env, jclass clz, int64_t orig) {
14318 LDKRevokeAndACK orig_conv;
14319 orig_conv.inner = (void*)(orig & (~1));
14320 orig_conv.is_owned = false;
14321 LDKRevokeAndACK ret_var = RevokeAndACK_clone(&orig_conv);
14322 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14323 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14324 long ret_ref = (long)ret_var.inner;
14325 if (ret_var.is_owned) {
14331 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateFee_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
14332 LDKUpdateFee this_obj_conv;
14333 this_obj_conv.inner = (void*)(this_obj & (~1));
14334 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
14335 UpdateFee_free(this_obj_conv);
14338 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UpdateFee_1get_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
14339 LDKUpdateFee this_ptr_conv;
14340 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14341 this_ptr_conv.is_owned = false;
14342 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
14343 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UpdateFee_get_channel_id(&this_ptr_conv));
14347 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateFee_1set_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
14348 LDKUpdateFee this_ptr_conv;
14349 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14350 this_ptr_conv.is_owned = false;
14351 LDKThirtyTwoBytes val_ref;
14352 CHECK((*env)->GetArrayLength(env, val) == 32);
14353 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
14354 UpdateFee_set_channel_id(&this_ptr_conv, val_ref);
14357 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_UpdateFee_1get_1feerate_1per_1kw(JNIEnv *env, jclass clz, int64_t this_ptr) {
14358 LDKUpdateFee this_ptr_conv;
14359 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14360 this_ptr_conv.is_owned = false;
14361 int32_t ret_val = UpdateFee_get_feerate_per_kw(&this_ptr_conv);
14365 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateFee_1set_1feerate_1per_1kw(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
14366 LDKUpdateFee this_ptr_conv;
14367 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14368 this_ptr_conv.is_owned = false;
14369 UpdateFee_set_feerate_per_kw(&this_ptr_conv, val);
14372 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) {
14373 LDKThirtyTwoBytes channel_id_arg_ref;
14374 CHECK((*env)->GetArrayLength(env, channel_id_arg) == 32);
14375 (*env)->GetByteArrayRegion(env, channel_id_arg, 0, 32, channel_id_arg_ref.data);
14376 LDKUpdateFee ret_var = UpdateFee_new(channel_id_arg_ref, feerate_per_kw_arg);
14377 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14378 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14379 long ret_ref = (long)ret_var.inner;
14380 if (ret_var.is_owned) {
14386 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFee_1clone(JNIEnv *env, jclass clz, int64_t orig) {
14387 LDKUpdateFee orig_conv;
14388 orig_conv.inner = (void*)(orig & (~1));
14389 orig_conv.is_owned = false;
14390 LDKUpdateFee ret_var = UpdateFee_clone(&orig_conv);
14391 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14392 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14393 long ret_ref = (long)ret_var.inner;
14394 if (ret_var.is_owned) {
14400 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DataLossProtect_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
14401 LDKDataLossProtect 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 DataLossProtect_free(this_obj_conv);
14407 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_DataLossProtect_1get_1your_1last_1per_1commitment_1secret(JNIEnv *env, jclass clz, int64_t this_ptr) {
14408 LDKDataLossProtect this_ptr_conv;
14409 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14410 this_ptr_conv.is_owned = false;
14411 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
14412 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *DataLossProtect_get_your_last_per_commitment_secret(&this_ptr_conv));
14416 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) {
14417 LDKDataLossProtect this_ptr_conv;
14418 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14419 this_ptr_conv.is_owned = false;
14420 LDKThirtyTwoBytes val_ref;
14421 CHECK((*env)->GetArrayLength(env, val) == 32);
14422 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
14423 DataLossProtect_set_your_last_per_commitment_secret(&this_ptr_conv, val_ref);
14426 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_DataLossProtect_1get_1my_1current_1per_1commitment_1point(JNIEnv *env, jclass clz, int64_t this_ptr) {
14427 LDKDataLossProtect this_ptr_conv;
14428 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14429 this_ptr_conv.is_owned = false;
14430 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
14431 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, DataLossProtect_get_my_current_per_commitment_point(&this_ptr_conv).compressed_form);
14435 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) {
14436 LDKDataLossProtect this_ptr_conv;
14437 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14438 this_ptr_conv.is_owned = false;
14439 LDKPublicKey val_ref;
14440 CHECK((*env)->GetArrayLength(env, val) == 33);
14441 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
14442 DataLossProtect_set_my_current_per_commitment_point(&this_ptr_conv, val_ref);
14445 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) {
14446 LDKThirtyTwoBytes your_last_per_commitment_secret_arg_ref;
14447 CHECK((*env)->GetArrayLength(env, your_last_per_commitment_secret_arg) == 32);
14448 (*env)->GetByteArrayRegion(env, your_last_per_commitment_secret_arg, 0, 32, your_last_per_commitment_secret_arg_ref.data);
14449 LDKPublicKey my_current_per_commitment_point_arg_ref;
14450 CHECK((*env)->GetArrayLength(env, my_current_per_commitment_point_arg) == 33);
14451 (*env)->GetByteArrayRegion(env, my_current_per_commitment_point_arg, 0, 33, my_current_per_commitment_point_arg_ref.compressed_form);
14452 LDKDataLossProtect ret_var = DataLossProtect_new(your_last_per_commitment_secret_arg_ref, my_current_per_commitment_point_arg_ref);
14453 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14454 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14455 long ret_ref = (long)ret_var.inner;
14456 if (ret_var.is_owned) {
14462 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DataLossProtect_1clone(JNIEnv *env, jclass clz, int64_t orig) {
14463 LDKDataLossProtect orig_conv;
14464 orig_conv.inner = (void*)(orig & (~1));
14465 orig_conv.is_owned = false;
14466 LDKDataLossProtect ret_var = DataLossProtect_clone(&orig_conv);
14467 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14468 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14469 long ret_ref = (long)ret_var.inner;
14470 if (ret_var.is_owned) {
14476 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelReestablish_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
14477 LDKChannelReestablish this_obj_conv;
14478 this_obj_conv.inner = (void*)(this_obj & (~1));
14479 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
14480 ChannelReestablish_free(this_obj_conv);
14483 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelReestablish_1get_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
14484 LDKChannelReestablish this_ptr_conv;
14485 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14486 this_ptr_conv.is_owned = false;
14487 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
14488 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *ChannelReestablish_get_channel_id(&this_ptr_conv));
14492 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelReestablish_1set_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
14493 LDKChannelReestablish this_ptr_conv;
14494 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14495 this_ptr_conv.is_owned = false;
14496 LDKThirtyTwoBytes val_ref;
14497 CHECK((*env)->GetArrayLength(env, val) == 32);
14498 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
14499 ChannelReestablish_set_channel_id(&this_ptr_conv, val_ref);
14502 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelReestablish_1get_1next_1local_1commitment_1number(JNIEnv *env, jclass clz, int64_t this_ptr) {
14503 LDKChannelReestablish this_ptr_conv;
14504 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14505 this_ptr_conv.is_owned = false;
14506 int64_t ret_val = ChannelReestablish_get_next_local_commitment_number(&this_ptr_conv);
14510 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) {
14511 LDKChannelReestablish this_ptr_conv;
14512 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14513 this_ptr_conv.is_owned = false;
14514 ChannelReestablish_set_next_local_commitment_number(&this_ptr_conv, val);
14517 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelReestablish_1get_1next_1remote_1commitment_1number(JNIEnv *env, jclass clz, int64_t this_ptr) {
14518 LDKChannelReestablish this_ptr_conv;
14519 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14520 this_ptr_conv.is_owned = false;
14521 int64_t ret_val = ChannelReestablish_get_next_remote_commitment_number(&this_ptr_conv);
14525 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) {
14526 LDKChannelReestablish this_ptr_conv;
14527 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14528 this_ptr_conv.is_owned = false;
14529 ChannelReestablish_set_next_remote_commitment_number(&this_ptr_conv, val);
14532 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelReestablish_1clone(JNIEnv *env, jclass clz, int64_t orig) {
14533 LDKChannelReestablish orig_conv;
14534 orig_conv.inner = (void*)(orig & (~1));
14535 orig_conv.is_owned = false;
14536 LDKChannelReestablish ret_var = ChannelReestablish_clone(&orig_conv);
14537 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14538 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14539 long ret_ref = (long)ret_var.inner;
14540 if (ret_var.is_owned) {
14546 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AnnouncementSignatures_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
14547 LDKAnnouncementSignatures this_obj_conv;
14548 this_obj_conv.inner = (void*)(this_obj & (~1));
14549 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
14550 AnnouncementSignatures_free(this_obj_conv);
14553 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_AnnouncementSignatures_1get_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
14554 LDKAnnouncementSignatures this_ptr_conv;
14555 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14556 this_ptr_conv.is_owned = false;
14557 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
14558 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *AnnouncementSignatures_get_channel_id(&this_ptr_conv));
14562 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AnnouncementSignatures_1set_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
14563 LDKAnnouncementSignatures this_ptr_conv;
14564 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14565 this_ptr_conv.is_owned = false;
14566 LDKThirtyTwoBytes val_ref;
14567 CHECK((*env)->GetArrayLength(env, val) == 32);
14568 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
14569 AnnouncementSignatures_set_channel_id(&this_ptr_conv, val_ref);
14572 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_AnnouncementSignatures_1get_1short_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
14573 LDKAnnouncementSignatures this_ptr_conv;
14574 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14575 this_ptr_conv.is_owned = false;
14576 int64_t ret_val = AnnouncementSignatures_get_short_channel_id(&this_ptr_conv);
14580 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AnnouncementSignatures_1set_1short_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
14581 LDKAnnouncementSignatures this_ptr_conv;
14582 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14583 this_ptr_conv.is_owned = false;
14584 AnnouncementSignatures_set_short_channel_id(&this_ptr_conv, val);
14587 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_AnnouncementSignatures_1get_1node_1signature(JNIEnv *env, jclass clz, int64_t this_ptr) {
14588 LDKAnnouncementSignatures this_ptr_conv;
14589 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14590 this_ptr_conv.is_owned = false;
14591 int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
14592 (*env)->SetByteArrayRegion(env, ret_arr, 0, 64, AnnouncementSignatures_get_node_signature(&this_ptr_conv).compact_form);
14596 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AnnouncementSignatures_1set_1node_1signature(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
14597 LDKAnnouncementSignatures this_ptr_conv;
14598 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14599 this_ptr_conv.is_owned = false;
14600 LDKSignature val_ref;
14601 CHECK((*env)->GetArrayLength(env, val) == 64);
14602 (*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
14603 AnnouncementSignatures_set_node_signature(&this_ptr_conv, val_ref);
14606 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_AnnouncementSignatures_1get_1bitcoin_1signature(JNIEnv *env, jclass clz, int64_t this_ptr) {
14607 LDKAnnouncementSignatures this_ptr_conv;
14608 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14609 this_ptr_conv.is_owned = false;
14610 int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
14611 (*env)->SetByteArrayRegion(env, ret_arr, 0, 64, AnnouncementSignatures_get_bitcoin_signature(&this_ptr_conv).compact_form);
14615 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AnnouncementSignatures_1set_1bitcoin_1signature(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
14616 LDKAnnouncementSignatures this_ptr_conv;
14617 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14618 this_ptr_conv.is_owned = false;
14619 LDKSignature val_ref;
14620 CHECK((*env)->GetArrayLength(env, val) == 64);
14621 (*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
14622 AnnouncementSignatures_set_bitcoin_signature(&this_ptr_conv, val_ref);
14625 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) {
14626 LDKThirtyTwoBytes channel_id_arg_ref;
14627 CHECK((*env)->GetArrayLength(env, channel_id_arg) == 32);
14628 (*env)->GetByteArrayRegion(env, channel_id_arg, 0, 32, channel_id_arg_ref.data);
14629 LDKSignature node_signature_arg_ref;
14630 CHECK((*env)->GetArrayLength(env, node_signature_arg) == 64);
14631 (*env)->GetByteArrayRegion(env, node_signature_arg, 0, 64, node_signature_arg_ref.compact_form);
14632 LDKSignature bitcoin_signature_arg_ref;
14633 CHECK((*env)->GetArrayLength(env, bitcoin_signature_arg) == 64);
14634 (*env)->GetByteArrayRegion(env, bitcoin_signature_arg, 0, 64, bitcoin_signature_arg_ref.compact_form);
14635 LDKAnnouncementSignatures ret_var = AnnouncementSignatures_new(channel_id_arg_ref, short_channel_id_arg, node_signature_arg_ref, bitcoin_signature_arg_ref);
14636 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14637 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14638 long ret_ref = (long)ret_var.inner;
14639 if (ret_var.is_owned) {
14645 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_AnnouncementSignatures_1clone(JNIEnv *env, jclass clz, int64_t orig) {
14646 LDKAnnouncementSignatures orig_conv;
14647 orig_conv.inner = (void*)(orig & (~1));
14648 orig_conv.is_owned = false;
14649 LDKAnnouncementSignatures ret_var = AnnouncementSignatures_clone(&orig_conv);
14650 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14651 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14652 long ret_ref = (long)ret_var.inner;
14653 if (ret_var.is_owned) {
14659 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NetAddress_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
14660 if ((this_ptr & 1) != 0) return;
14661 LDKNetAddress this_ptr_conv = *(LDKNetAddress*)(((uint64_t)this_ptr) & ~1);
14662 FREE((void*)this_ptr);
14663 NetAddress_free(this_ptr_conv);
14666 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetAddress_1clone(JNIEnv *env, jclass clz, int64_t orig) {
14667 LDKNetAddress* orig_conv = (LDKNetAddress*)orig;
14668 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
14669 *ret_copy = NetAddress_clone(orig_conv);
14670 long ret_ref = (long)ret_copy;
14674 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_NetAddress_1write(JNIEnv *env, jclass clz, int64_t obj) {
14675 LDKNetAddress* obj_conv = (LDKNetAddress*)obj;
14676 LDKCVec_u8Z ret_var = NetAddress_write(obj_conv);
14677 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
14678 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
14679 CVec_u8Z_free(ret_var);
14683 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Result_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
14684 LDKu8slice ser_ref;
14685 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
14686 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
14687 LDKCResult_CResult_NetAddressu8ZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CResult_NetAddressu8ZDecodeErrorZ), "LDKCResult_CResult_NetAddressu8ZDecodeErrorZ");
14688 *ret_conv = Result_read(ser_ref);
14689 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
14690 return (long)ret_conv;
14693 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
14694 LDKUnsignedNodeAnnouncement this_obj_conv;
14695 this_obj_conv.inner = (void*)(this_obj & (~1));
14696 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
14697 UnsignedNodeAnnouncement_free(this_obj_conv);
14700 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1get_1features(JNIEnv *env, jclass clz, int64_t this_ptr) {
14701 LDKUnsignedNodeAnnouncement this_ptr_conv;
14702 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14703 this_ptr_conv.is_owned = false;
14704 LDKNodeFeatures ret_var = UnsignedNodeAnnouncement_get_features(&this_ptr_conv);
14705 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14706 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14707 long ret_ref = (long)ret_var.inner;
14708 if (ret_var.is_owned) {
14714 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1set_1features(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
14715 LDKUnsignedNodeAnnouncement this_ptr_conv;
14716 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14717 this_ptr_conv.is_owned = false;
14718 LDKNodeFeatures val_conv;
14719 val_conv.inner = (void*)(val & (~1));
14720 val_conv.is_owned = (val & 1) || (val == 0);
14721 val_conv = NodeFeatures_clone(&val_conv);
14722 UnsignedNodeAnnouncement_set_features(&this_ptr_conv, val_conv);
14725 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1get_1timestamp(JNIEnv *env, jclass clz, int64_t this_ptr) {
14726 LDKUnsignedNodeAnnouncement this_ptr_conv;
14727 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14728 this_ptr_conv.is_owned = false;
14729 int32_t ret_val = UnsignedNodeAnnouncement_get_timestamp(&this_ptr_conv);
14733 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1set_1timestamp(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
14734 LDKUnsignedNodeAnnouncement this_ptr_conv;
14735 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14736 this_ptr_conv.is_owned = false;
14737 UnsignedNodeAnnouncement_set_timestamp(&this_ptr_conv, val);
14740 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1get_1node_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
14741 LDKUnsignedNodeAnnouncement this_ptr_conv;
14742 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14743 this_ptr_conv.is_owned = false;
14744 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
14745 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, UnsignedNodeAnnouncement_get_node_id(&this_ptr_conv).compressed_form);
14749 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1set_1node_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
14750 LDKUnsignedNodeAnnouncement this_ptr_conv;
14751 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14752 this_ptr_conv.is_owned = false;
14753 LDKPublicKey val_ref;
14754 CHECK((*env)->GetArrayLength(env, val) == 33);
14755 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
14756 UnsignedNodeAnnouncement_set_node_id(&this_ptr_conv, val_ref);
14759 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1get_1rgb(JNIEnv *env, jclass clz, int64_t this_ptr) {
14760 LDKUnsignedNodeAnnouncement this_ptr_conv;
14761 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14762 this_ptr_conv.is_owned = false;
14763 int8_tArray ret_arr = (*env)->NewByteArray(env, 3);
14764 (*env)->SetByteArrayRegion(env, ret_arr, 0, 3, *UnsignedNodeAnnouncement_get_rgb(&this_ptr_conv));
14768 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1set_1rgb(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
14769 LDKUnsignedNodeAnnouncement this_ptr_conv;
14770 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14771 this_ptr_conv.is_owned = false;
14772 LDKThreeBytes val_ref;
14773 CHECK((*env)->GetArrayLength(env, val) == 3);
14774 (*env)->GetByteArrayRegion(env, val, 0, 3, val_ref.data);
14775 UnsignedNodeAnnouncement_set_rgb(&this_ptr_conv, val_ref);
14778 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1get_1alias(JNIEnv *env, jclass clz, int64_t this_ptr) {
14779 LDKUnsignedNodeAnnouncement this_ptr_conv;
14780 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14781 this_ptr_conv.is_owned = false;
14782 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
14783 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UnsignedNodeAnnouncement_get_alias(&this_ptr_conv));
14787 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1set_1alias(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
14788 LDKUnsignedNodeAnnouncement this_ptr_conv;
14789 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14790 this_ptr_conv.is_owned = false;
14791 LDKThirtyTwoBytes val_ref;
14792 CHECK((*env)->GetArrayLength(env, val) == 32);
14793 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
14794 UnsignedNodeAnnouncement_set_alias(&this_ptr_conv, val_ref);
14797 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1set_1addresses(JNIEnv *env, jclass clz, int64_t this_ptr, int64_tArray val) {
14798 LDKUnsignedNodeAnnouncement this_ptr_conv;
14799 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14800 this_ptr_conv.is_owned = false;
14801 LDKCVec_NetAddressZ val_constr;
14802 val_constr.datalen = (*env)->GetArrayLength(env, val);
14803 if (val_constr.datalen > 0)
14804 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
14806 val_constr.data = NULL;
14807 int64_t* val_vals = (*env)->GetLongArrayElements (env, val, NULL);
14808 for (size_t m = 0; m < val_constr.datalen; m++) {
14809 int64_t val_conv_12 = val_vals[m];
14810 LDKNetAddress val_conv_12_conv = *(LDKNetAddress*)(((uint64_t)val_conv_12) & ~1);
14811 FREE((void*)val_conv_12);
14812 val_constr.data[m] = val_conv_12_conv;
14814 (*env)->ReleaseLongArrayElements(env, val, val_vals, 0);
14815 UnsignedNodeAnnouncement_set_addresses(&this_ptr_conv, val_constr);
14818 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1clone(JNIEnv *env, jclass clz, int64_t orig) {
14819 LDKUnsignedNodeAnnouncement orig_conv;
14820 orig_conv.inner = (void*)(orig & (~1));
14821 orig_conv.is_owned = false;
14822 LDKUnsignedNodeAnnouncement ret_var = UnsignedNodeAnnouncement_clone(&orig_conv);
14823 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14824 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14825 long ret_ref = (long)ret_var.inner;
14826 if (ret_var.is_owned) {
14832 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NodeAnnouncement_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
14833 LDKNodeAnnouncement this_obj_conv;
14834 this_obj_conv.inner = (void*)(this_obj & (~1));
14835 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
14836 NodeAnnouncement_free(this_obj_conv);
14839 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_NodeAnnouncement_1get_1signature(JNIEnv *env, jclass clz, int64_t this_ptr) {
14840 LDKNodeAnnouncement this_ptr_conv;
14841 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14842 this_ptr_conv.is_owned = false;
14843 int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
14844 (*env)->SetByteArrayRegion(env, ret_arr, 0, 64, NodeAnnouncement_get_signature(&this_ptr_conv).compact_form);
14848 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NodeAnnouncement_1set_1signature(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
14849 LDKNodeAnnouncement this_ptr_conv;
14850 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14851 this_ptr_conv.is_owned = false;
14852 LDKSignature val_ref;
14853 CHECK((*env)->GetArrayLength(env, val) == 64);
14854 (*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
14855 NodeAnnouncement_set_signature(&this_ptr_conv, val_ref);
14858 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeAnnouncement_1get_1contents(JNIEnv *env, jclass clz, int64_t this_ptr) {
14859 LDKNodeAnnouncement this_ptr_conv;
14860 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14861 this_ptr_conv.is_owned = false;
14862 LDKUnsignedNodeAnnouncement ret_var = NodeAnnouncement_get_contents(&this_ptr_conv);
14863 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14864 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14865 long ret_ref = (long)ret_var.inner;
14866 if (ret_var.is_owned) {
14872 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NodeAnnouncement_1set_1contents(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
14873 LDKNodeAnnouncement this_ptr_conv;
14874 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14875 this_ptr_conv.is_owned = false;
14876 LDKUnsignedNodeAnnouncement val_conv;
14877 val_conv.inner = (void*)(val & (~1));
14878 val_conv.is_owned = (val & 1) || (val == 0);
14879 val_conv = UnsignedNodeAnnouncement_clone(&val_conv);
14880 NodeAnnouncement_set_contents(&this_ptr_conv, val_conv);
14883 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeAnnouncement_1new(JNIEnv *env, jclass clz, int8_tArray signature_arg, int64_t contents_arg) {
14884 LDKSignature signature_arg_ref;
14885 CHECK((*env)->GetArrayLength(env, signature_arg) == 64);
14886 (*env)->GetByteArrayRegion(env, signature_arg, 0, 64, signature_arg_ref.compact_form);
14887 LDKUnsignedNodeAnnouncement contents_arg_conv;
14888 contents_arg_conv.inner = (void*)(contents_arg & (~1));
14889 contents_arg_conv.is_owned = (contents_arg & 1) || (contents_arg == 0);
14890 contents_arg_conv = UnsignedNodeAnnouncement_clone(&contents_arg_conv);
14891 LDKNodeAnnouncement ret_var = NodeAnnouncement_new(signature_arg_ref, contents_arg_conv);
14892 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14893 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14894 long ret_ref = (long)ret_var.inner;
14895 if (ret_var.is_owned) {
14901 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeAnnouncement_1clone(JNIEnv *env, jclass clz, int64_t orig) {
14902 LDKNodeAnnouncement orig_conv;
14903 orig_conv.inner = (void*)(orig & (~1));
14904 orig_conv.is_owned = false;
14905 LDKNodeAnnouncement ret_var = NodeAnnouncement_clone(&orig_conv);
14906 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14907 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14908 long ret_ref = (long)ret_var.inner;
14909 if (ret_var.is_owned) {
14915 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
14916 LDKUnsignedChannelAnnouncement this_obj_conv;
14917 this_obj_conv.inner = (void*)(this_obj & (~1));
14918 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
14919 UnsignedChannelAnnouncement_free(this_obj_conv);
14922 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1get_1features(JNIEnv *env, jclass clz, int64_t this_ptr) {
14923 LDKUnsignedChannelAnnouncement this_ptr_conv;
14924 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14925 this_ptr_conv.is_owned = false;
14926 LDKChannelFeatures ret_var = UnsignedChannelAnnouncement_get_features(&this_ptr_conv);
14927 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14928 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14929 long ret_ref = (long)ret_var.inner;
14930 if (ret_var.is_owned) {
14936 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1set_1features(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
14937 LDKUnsignedChannelAnnouncement this_ptr_conv;
14938 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14939 this_ptr_conv.is_owned = false;
14940 LDKChannelFeatures val_conv;
14941 val_conv.inner = (void*)(val & (~1));
14942 val_conv.is_owned = (val & 1) || (val == 0);
14943 val_conv = ChannelFeatures_clone(&val_conv);
14944 UnsignedChannelAnnouncement_set_features(&this_ptr_conv, val_conv);
14947 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1get_1chain_1hash(JNIEnv *env, jclass clz, int64_t this_ptr) {
14948 LDKUnsignedChannelAnnouncement this_ptr_conv;
14949 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14950 this_ptr_conv.is_owned = false;
14951 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
14952 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UnsignedChannelAnnouncement_get_chain_hash(&this_ptr_conv));
14956 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1set_1chain_1hash(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
14957 LDKUnsignedChannelAnnouncement this_ptr_conv;
14958 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14959 this_ptr_conv.is_owned = false;
14960 LDKThirtyTwoBytes val_ref;
14961 CHECK((*env)->GetArrayLength(env, val) == 32);
14962 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
14963 UnsignedChannelAnnouncement_set_chain_hash(&this_ptr_conv, val_ref);
14966 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1get_1short_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
14967 LDKUnsignedChannelAnnouncement this_ptr_conv;
14968 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14969 this_ptr_conv.is_owned = false;
14970 int64_t ret_val = UnsignedChannelAnnouncement_get_short_channel_id(&this_ptr_conv);
14974 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1set_1short_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
14975 LDKUnsignedChannelAnnouncement this_ptr_conv;
14976 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14977 this_ptr_conv.is_owned = false;
14978 UnsignedChannelAnnouncement_set_short_channel_id(&this_ptr_conv, val);
14981 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1get_1node_1id_11(JNIEnv *env, jclass clz, int64_t this_ptr) {
14982 LDKUnsignedChannelAnnouncement this_ptr_conv;
14983 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14984 this_ptr_conv.is_owned = false;
14985 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
14986 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, UnsignedChannelAnnouncement_get_node_id_1(&this_ptr_conv).compressed_form);
14990 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1set_1node_1id_11(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
14991 LDKUnsignedChannelAnnouncement this_ptr_conv;
14992 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14993 this_ptr_conv.is_owned = false;
14994 LDKPublicKey val_ref;
14995 CHECK((*env)->GetArrayLength(env, val) == 33);
14996 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
14997 UnsignedChannelAnnouncement_set_node_id_1(&this_ptr_conv, val_ref);
15000 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1get_1node_1id_12(JNIEnv *env, jclass clz, int64_t this_ptr) {
15001 LDKUnsignedChannelAnnouncement this_ptr_conv;
15002 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15003 this_ptr_conv.is_owned = false;
15004 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
15005 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, UnsignedChannelAnnouncement_get_node_id_2(&this_ptr_conv).compressed_form);
15009 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1set_1node_1id_12(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
15010 LDKUnsignedChannelAnnouncement this_ptr_conv;
15011 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15012 this_ptr_conv.is_owned = false;
15013 LDKPublicKey val_ref;
15014 CHECK((*env)->GetArrayLength(env, val) == 33);
15015 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
15016 UnsignedChannelAnnouncement_set_node_id_2(&this_ptr_conv, val_ref);
15019 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1get_1bitcoin_1key_11(JNIEnv *env, jclass clz, int64_t this_ptr) {
15020 LDKUnsignedChannelAnnouncement this_ptr_conv;
15021 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15022 this_ptr_conv.is_owned = false;
15023 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
15024 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, UnsignedChannelAnnouncement_get_bitcoin_key_1(&this_ptr_conv).compressed_form);
15028 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1set_1bitcoin_1key_11(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
15029 LDKUnsignedChannelAnnouncement this_ptr_conv;
15030 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15031 this_ptr_conv.is_owned = false;
15032 LDKPublicKey val_ref;
15033 CHECK((*env)->GetArrayLength(env, val) == 33);
15034 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
15035 UnsignedChannelAnnouncement_set_bitcoin_key_1(&this_ptr_conv, val_ref);
15038 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1get_1bitcoin_1key_12(JNIEnv *env, jclass clz, int64_t this_ptr) {
15039 LDKUnsignedChannelAnnouncement this_ptr_conv;
15040 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15041 this_ptr_conv.is_owned = false;
15042 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
15043 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, UnsignedChannelAnnouncement_get_bitcoin_key_2(&this_ptr_conv).compressed_form);
15047 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1set_1bitcoin_1key_12(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
15048 LDKUnsignedChannelAnnouncement this_ptr_conv;
15049 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15050 this_ptr_conv.is_owned = false;
15051 LDKPublicKey val_ref;
15052 CHECK((*env)->GetArrayLength(env, val) == 33);
15053 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
15054 UnsignedChannelAnnouncement_set_bitcoin_key_2(&this_ptr_conv, val_ref);
15057 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1clone(JNIEnv *env, jclass clz, int64_t orig) {
15058 LDKUnsignedChannelAnnouncement orig_conv;
15059 orig_conv.inner = (void*)(orig & (~1));
15060 orig_conv.is_owned = false;
15061 LDKUnsignedChannelAnnouncement ret_var = UnsignedChannelAnnouncement_clone(&orig_conv);
15062 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15063 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15064 long ret_ref = (long)ret_var.inner;
15065 if (ret_var.is_owned) {
15071 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
15072 LDKChannelAnnouncement this_obj_conv;
15073 this_obj_conv.inner = (void*)(this_obj & (~1));
15074 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
15075 ChannelAnnouncement_free(this_obj_conv);
15078 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1get_1node_1signature_11(JNIEnv *env, jclass clz, int64_t this_ptr) {
15079 LDKChannelAnnouncement this_ptr_conv;
15080 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15081 this_ptr_conv.is_owned = false;
15082 int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
15083 (*env)->SetByteArrayRegion(env, ret_arr, 0, 64, ChannelAnnouncement_get_node_signature_1(&this_ptr_conv).compact_form);
15087 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1set_1node_1signature_11(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
15088 LDKChannelAnnouncement this_ptr_conv;
15089 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15090 this_ptr_conv.is_owned = false;
15091 LDKSignature val_ref;
15092 CHECK((*env)->GetArrayLength(env, val) == 64);
15093 (*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
15094 ChannelAnnouncement_set_node_signature_1(&this_ptr_conv, val_ref);
15097 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1get_1node_1signature_12(JNIEnv *env, jclass clz, int64_t this_ptr) {
15098 LDKChannelAnnouncement this_ptr_conv;
15099 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15100 this_ptr_conv.is_owned = false;
15101 int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
15102 (*env)->SetByteArrayRegion(env, ret_arr, 0, 64, ChannelAnnouncement_get_node_signature_2(&this_ptr_conv).compact_form);
15106 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1set_1node_1signature_12(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
15107 LDKChannelAnnouncement this_ptr_conv;
15108 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15109 this_ptr_conv.is_owned = false;
15110 LDKSignature val_ref;
15111 CHECK((*env)->GetArrayLength(env, val) == 64);
15112 (*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
15113 ChannelAnnouncement_set_node_signature_2(&this_ptr_conv, val_ref);
15116 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1get_1bitcoin_1signature_11(JNIEnv *env, jclass clz, int64_t this_ptr) {
15117 LDKChannelAnnouncement this_ptr_conv;
15118 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15119 this_ptr_conv.is_owned = false;
15120 int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
15121 (*env)->SetByteArrayRegion(env, ret_arr, 0, 64, ChannelAnnouncement_get_bitcoin_signature_1(&this_ptr_conv).compact_form);
15125 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1set_1bitcoin_1signature_11(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
15126 LDKChannelAnnouncement this_ptr_conv;
15127 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15128 this_ptr_conv.is_owned = false;
15129 LDKSignature val_ref;
15130 CHECK((*env)->GetArrayLength(env, val) == 64);
15131 (*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
15132 ChannelAnnouncement_set_bitcoin_signature_1(&this_ptr_conv, val_ref);
15135 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1get_1bitcoin_1signature_12(JNIEnv *env, jclass clz, int64_t this_ptr) {
15136 LDKChannelAnnouncement this_ptr_conv;
15137 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15138 this_ptr_conv.is_owned = false;
15139 int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
15140 (*env)->SetByteArrayRegion(env, ret_arr, 0, 64, ChannelAnnouncement_get_bitcoin_signature_2(&this_ptr_conv).compact_form);
15144 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1set_1bitcoin_1signature_12(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
15145 LDKChannelAnnouncement this_ptr_conv;
15146 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15147 this_ptr_conv.is_owned = false;
15148 LDKSignature val_ref;
15149 CHECK((*env)->GetArrayLength(env, val) == 64);
15150 (*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
15151 ChannelAnnouncement_set_bitcoin_signature_2(&this_ptr_conv, val_ref);
15154 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1get_1contents(JNIEnv *env, jclass clz, int64_t this_ptr) {
15155 LDKChannelAnnouncement this_ptr_conv;
15156 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15157 this_ptr_conv.is_owned = false;
15158 LDKUnsignedChannelAnnouncement ret_var = ChannelAnnouncement_get_contents(&this_ptr_conv);
15159 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15160 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15161 long ret_ref = (long)ret_var.inner;
15162 if (ret_var.is_owned) {
15168 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1set_1contents(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
15169 LDKChannelAnnouncement this_ptr_conv;
15170 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15171 this_ptr_conv.is_owned = false;
15172 LDKUnsignedChannelAnnouncement val_conv;
15173 val_conv.inner = (void*)(val & (~1));
15174 val_conv.is_owned = (val & 1) || (val == 0);
15175 val_conv = UnsignedChannelAnnouncement_clone(&val_conv);
15176 ChannelAnnouncement_set_contents(&this_ptr_conv, val_conv);
15179 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) {
15180 LDKSignature node_signature_1_arg_ref;
15181 CHECK((*env)->GetArrayLength(env, node_signature_1_arg) == 64);
15182 (*env)->GetByteArrayRegion(env, node_signature_1_arg, 0, 64, node_signature_1_arg_ref.compact_form);
15183 LDKSignature node_signature_2_arg_ref;
15184 CHECK((*env)->GetArrayLength(env, node_signature_2_arg) == 64);
15185 (*env)->GetByteArrayRegion(env, node_signature_2_arg, 0, 64, node_signature_2_arg_ref.compact_form);
15186 LDKSignature bitcoin_signature_1_arg_ref;
15187 CHECK((*env)->GetArrayLength(env, bitcoin_signature_1_arg) == 64);
15188 (*env)->GetByteArrayRegion(env, bitcoin_signature_1_arg, 0, 64, bitcoin_signature_1_arg_ref.compact_form);
15189 LDKSignature bitcoin_signature_2_arg_ref;
15190 CHECK((*env)->GetArrayLength(env, bitcoin_signature_2_arg) == 64);
15191 (*env)->GetByteArrayRegion(env, bitcoin_signature_2_arg, 0, 64, bitcoin_signature_2_arg_ref.compact_form);
15192 LDKUnsignedChannelAnnouncement contents_arg_conv;
15193 contents_arg_conv.inner = (void*)(contents_arg & (~1));
15194 contents_arg_conv.is_owned = (contents_arg & 1) || (contents_arg == 0);
15195 contents_arg_conv = UnsignedChannelAnnouncement_clone(&contents_arg_conv);
15196 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);
15197 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15198 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15199 long ret_ref = (long)ret_var.inner;
15200 if (ret_var.is_owned) {
15206 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1clone(JNIEnv *env, jclass clz, int64_t orig) {
15207 LDKChannelAnnouncement orig_conv;
15208 orig_conv.inner = (void*)(orig & (~1));
15209 orig_conv.is_owned = false;
15210 LDKChannelAnnouncement ret_var = ChannelAnnouncement_clone(&orig_conv);
15211 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15212 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15213 long ret_ref = (long)ret_var.inner;
15214 if (ret_var.is_owned) {
15220 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
15221 LDKUnsignedChannelUpdate this_obj_conv;
15222 this_obj_conv.inner = (void*)(this_obj & (~1));
15223 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
15224 UnsignedChannelUpdate_free(this_obj_conv);
15227 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1get_1chain_1hash(JNIEnv *env, jclass clz, int64_t this_ptr) {
15228 LDKUnsignedChannelUpdate this_ptr_conv;
15229 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15230 this_ptr_conv.is_owned = false;
15231 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
15232 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UnsignedChannelUpdate_get_chain_hash(&this_ptr_conv));
15236 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1set_1chain_1hash(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
15237 LDKUnsignedChannelUpdate this_ptr_conv;
15238 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15239 this_ptr_conv.is_owned = false;
15240 LDKThirtyTwoBytes val_ref;
15241 CHECK((*env)->GetArrayLength(env, val) == 32);
15242 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
15243 UnsignedChannelUpdate_set_chain_hash(&this_ptr_conv, val_ref);
15246 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1get_1short_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
15247 LDKUnsignedChannelUpdate this_ptr_conv;
15248 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15249 this_ptr_conv.is_owned = false;
15250 int64_t ret_val = UnsignedChannelUpdate_get_short_channel_id(&this_ptr_conv);
15254 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1set_1short_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
15255 LDKUnsignedChannelUpdate this_ptr_conv;
15256 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15257 this_ptr_conv.is_owned = false;
15258 UnsignedChannelUpdate_set_short_channel_id(&this_ptr_conv, val);
15261 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1get_1timestamp(JNIEnv *env, jclass clz, int64_t this_ptr) {
15262 LDKUnsignedChannelUpdate this_ptr_conv;
15263 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15264 this_ptr_conv.is_owned = false;
15265 int32_t ret_val = UnsignedChannelUpdate_get_timestamp(&this_ptr_conv);
15269 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1set_1timestamp(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
15270 LDKUnsignedChannelUpdate this_ptr_conv;
15271 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15272 this_ptr_conv.is_owned = false;
15273 UnsignedChannelUpdate_set_timestamp(&this_ptr_conv, val);
15276 JNIEXPORT int8_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1get_1flags(JNIEnv *env, jclass clz, int64_t this_ptr) {
15277 LDKUnsignedChannelUpdate this_ptr_conv;
15278 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15279 this_ptr_conv.is_owned = false;
15280 int8_t ret_val = UnsignedChannelUpdate_get_flags(&this_ptr_conv);
15284 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1set_1flags(JNIEnv *env, jclass clz, int64_t this_ptr, int8_t val) {
15285 LDKUnsignedChannelUpdate this_ptr_conv;
15286 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15287 this_ptr_conv.is_owned = false;
15288 UnsignedChannelUpdate_set_flags(&this_ptr_conv, val);
15291 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1get_1cltv_1expiry_1delta(JNIEnv *env, jclass clz, int64_t this_ptr) {
15292 LDKUnsignedChannelUpdate this_ptr_conv;
15293 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15294 this_ptr_conv.is_owned = false;
15295 int16_t ret_val = UnsignedChannelUpdate_get_cltv_expiry_delta(&this_ptr_conv);
15299 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1set_1cltv_1expiry_1delta(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
15300 LDKUnsignedChannelUpdate this_ptr_conv;
15301 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15302 this_ptr_conv.is_owned = false;
15303 UnsignedChannelUpdate_set_cltv_expiry_delta(&this_ptr_conv, val);
15306 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1get_1htlc_1minimum_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
15307 LDKUnsignedChannelUpdate this_ptr_conv;
15308 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15309 this_ptr_conv.is_owned = false;
15310 int64_t ret_val = UnsignedChannelUpdate_get_htlc_minimum_msat(&this_ptr_conv);
15314 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1set_1htlc_1minimum_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
15315 LDKUnsignedChannelUpdate this_ptr_conv;
15316 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15317 this_ptr_conv.is_owned = false;
15318 UnsignedChannelUpdate_set_htlc_minimum_msat(&this_ptr_conv, val);
15321 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1get_1fee_1base_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
15322 LDKUnsignedChannelUpdate this_ptr_conv;
15323 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15324 this_ptr_conv.is_owned = false;
15325 int32_t ret_val = UnsignedChannelUpdate_get_fee_base_msat(&this_ptr_conv);
15329 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1set_1fee_1base_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
15330 LDKUnsignedChannelUpdate this_ptr_conv;
15331 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15332 this_ptr_conv.is_owned = false;
15333 UnsignedChannelUpdate_set_fee_base_msat(&this_ptr_conv, val);
15336 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1get_1fee_1proportional_1millionths(JNIEnv *env, jclass clz, int64_t this_ptr) {
15337 LDKUnsignedChannelUpdate this_ptr_conv;
15338 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15339 this_ptr_conv.is_owned = false;
15340 int32_t ret_val = UnsignedChannelUpdate_get_fee_proportional_millionths(&this_ptr_conv);
15344 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1set_1fee_1proportional_1millionths(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
15345 LDKUnsignedChannelUpdate this_ptr_conv;
15346 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15347 this_ptr_conv.is_owned = false;
15348 UnsignedChannelUpdate_set_fee_proportional_millionths(&this_ptr_conv, val);
15351 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1clone(JNIEnv *env, jclass clz, int64_t orig) {
15352 LDKUnsignedChannelUpdate orig_conv;
15353 orig_conv.inner = (void*)(orig & (~1));
15354 orig_conv.is_owned = false;
15355 LDKUnsignedChannelUpdate ret_var = UnsignedChannelUpdate_clone(&orig_conv);
15356 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15357 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15358 long ret_ref = (long)ret_var.inner;
15359 if (ret_var.is_owned) {
15365 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelUpdate_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
15366 LDKChannelUpdate this_obj_conv;
15367 this_obj_conv.inner = (void*)(this_obj & (~1));
15368 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
15369 ChannelUpdate_free(this_obj_conv);
15372 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelUpdate_1get_1signature(JNIEnv *env, jclass clz, int64_t this_ptr) {
15373 LDKChannelUpdate this_ptr_conv;
15374 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15375 this_ptr_conv.is_owned = false;
15376 int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
15377 (*env)->SetByteArrayRegion(env, ret_arr, 0, 64, ChannelUpdate_get_signature(&this_ptr_conv).compact_form);
15381 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelUpdate_1set_1signature(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
15382 LDKChannelUpdate this_ptr_conv;
15383 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15384 this_ptr_conv.is_owned = false;
15385 LDKSignature val_ref;
15386 CHECK((*env)->GetArrayLength(env, val) == 64);
15387 (*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
15388 ChannelUpdate_set_signature(&this_ptr_conv, val_ref);
15391 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelUpdate_1get_1contents(JNIEnv *env, jclass clz, int64_t this_ptr) {
15392 LDKChannelUpdate this_ptr_conv;
15393 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15394 this_ptr_conv.is_owned = false;
15395 LDKUnsignedChannelUpdate ret_var = ChannelUpdate_get_contents(&this_ptr_conv);
15396 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15397 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15398 long ret_ref = (long)ret_var.inner;
15399 if (ret_var.is_owned) {
15405 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelUpdate_1set_1contents(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
15406 LDKChannelUpdate this_ptr_conv;
15407 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15408 this_ptr_conv.is_owned = false;
15409 LDKUnsignedChannelUpdate val_conv;
15410 val_conv.inner = (void*)(val & (~1));
15411 val_conv.is_owned = (val & 1) || (val == 0);
15412 val_conv = UnsignedChannelUpdate_clone(&val_conv);
15413 ChannelUpdate_set_contents(&this_ptr_conv, val_conv);
15416 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelUpdate_1new(JNIEnv *env, jclass clz, int8_tArray signature_arg, int64_t contents_arg) {
15417 LDKSignature signature_arg_ref;
15418 CHECK((*env)->GetArrayLength(env, signature_arg) == 64);
15419 (*env)->GetByteArrayRegion(env, signature_arg, 0, 64, signature_arg_ref.compact_form);
15420 LDKUnsignedChannelUpdate contents_arg_conv;
15421 contents_arg_conv.inner = (void*)(contents_arg & (~1));
15422 contents_arg_conv.is_owned = (contents_arg & 1) || (contents_arg == 0);
15423 contents_arg_conv = UnsignedChannelUpdate_clone(&contents_arg_conv);
15424 LDKChannelUpdate ret_var = ChannelUpdate_new(signature_arg_ref, contents_arg_conv);
15425 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15426 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15427 long ret_ref = (long)ret_var.inner;
15428 if (ret_var.is_owned) {
15434 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelUpdate_1clone(JNIEnv *env, jclass clz, int64_t orig) {
15435 LDKChannelUpdate orig_conv;
15436 orig_conv.inner = (void*)(orig & (~1));
15437 orig_conv.is_owned = false;
15438 LDKChannelUpdate ret_var = ChannelUpdate_clone(&orig_conv);
15439 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15440 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15441 long ret_ref = (long)ret_var.inner;
15442 if (ret_var.is_owned) {
15448 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_QueryChannelRange_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
15449 LDKQueryChannelRange this_obj_conv;
15450 this_obj_conv.inner = (void*)(this_obj & (~1));
15451 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
15452 QueryChannelRange_free(this_obj_conv);
15455 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_QueryChannelRange_1get_1chain_1hash(JNIEnv *env, jclass clz, int64_t this_ptr) {
15456 LDKQueryChannelRange this_ptr_conv;
15457 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15458 this_ptr_conv.is_owned = false;
15459 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
15460 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *QueryChannelRange_get_chain_hash(&this_ptr_conv));
15464 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_QueryChannelRange_1set_1chain_1hash(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
15465 LDKQueryChannelRange this_ptr_conv;
15466 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15467 this_ptr_conv.is_owned = false;
15468 LDKThirtyTwoBytes val_ref;
15469 CHECK((*env)->GetArrayLength(env, val) == 32);
15470 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
15471 QueryChannelRange_set_chain_hash(&this_ptr_conv, val_ref);
15474 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_QueryChannelRange_1get_1first_1blocknum(JNIEnv *env, jclass clz, int64_t this_ptr) {
15475 LDKQueryChannelRange this_ptr_conv;
15476 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15477 this_ptr_conv.is_owned = false;
15478 int32_t ret_val = QueryChannelRange_get_first_blocknum(&this_ptr_conv);
15482 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_QueryChannelRange_1set_1first_1blocknum(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
15483 LDKQueryChannelRange this_ptr_conv;
15484 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15485 this_ptr_conv.is_owned = false;
15486 QueryChannelRange_set_first_blocknum(&this_ptr_conv, val);
15489 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_QueryChannelRange_1get_1number_1of_1blocks(JNIEnv *env, jclass clz, int64_t this_ptr) {
15490 LDKQueryChannelRange this_ptr_conv;
15491 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15492 this_ptr_conv.is_owned = false;
15493 int32_t ret_val = QueryChannelRange_get_number_of_blocks(&this_ptr_conv);
15497 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_QueryChannelRange_1set_1number_1of_1blocks(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
15498 LDKQueryChannelRange this_ptr_conv;
15499 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15500 this_ptr_conv.is_owned = false;
15501 QueryChannelRange_set_number_of_blocks(&this_ptr_conv, val);
15504 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) {
15505 LDKThirtyTwoBytes chain_hash_arg_ref;
15506 CHECK((*env)->GetArrayLength(env, chain_hash_arg) == 32);
15507 (*env)->GetByteArrayRegion(env, chain_hash_arg, 0, 32, chain_hash_arg_ref.data);
15508 LDKQueryChannelRange ret_var = QueryChannelRange_new(chain_hash_arg_ref, first_blocknum_arg, number_of_blocks_arg);
15509 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15510 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15511 long ret_ref = (long)ret_var.inner;
15512 if (ret_var.is_owned) {
15518 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_QueryChannelRange_1clone(JNIEnv *env, jclass clz, int64_t orig) {
15519 LDKQueryChannelRange orig_conv;
15520 orig_conv.inner = (void*)(orig & (~1));
15521 orig_conv.is_owned = false;
15522 LDKQueryChannelRange ret_var = QueryChannelRange_clone(&orig_conv);
15523 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15524 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15525 long ret_ref = (long)ret_var.inner;
15526 if (ret_var.is_owned) {
15532 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ReplyChannelRange_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
15533 LDKReplyChannelRange this_obj_conv;
15534 this_obj_conv.inner = (void*)(this_obj & (~1));
15535 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
15536 ReplyChannelRange_free(this_obj_conv);
15539 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ReplyChannelRange_1get_1chain_1hash(JNIEnv *env, jclass clz, int64_t this_ptr) {
15540 LDKReplyChannelRange this_ptr_conv;
15541 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15542 this_ptr_conv.is_owned = false;
15543 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
15544 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *ReplyChannelRange_get_chain_hash(&this_ptr_conv));
15548 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ReplyChannelRange_1set_1chain_1hash(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
15549 LDKReplyChannelRange this_ptr_conv;
15550 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15551 this_ptr_conv.is_owned = false;
15552 LDKThirtyTwoBytes val_ref;
15553 CHECK((*env)->GetArrayLength(env, val) == 32);
15554 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
15555 ReplyChannelRange_set_chain_hash(&this_ptr_conv, val_ref);
15558 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_ReplyChannelRange_1get_1first_1blocknum(JNIEnv *env, jclass clz, int64_t this_ptr) {
15559 LDKReplyChannelRange this_ptr_conv;
15560 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15561 this_ptr_conv.is_owned = false;
15562 int32_t ret_val = ReplyChannelRange_get_first_blocknum(&this_ptr_conv);
15566 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ReplyChannelRange_1set_1first_1blocknum(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
15567 LDKReplyChannelRange this_ptr_conv;
15568 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15569 this_ptr_conv.is_owned = false;
15570 ReplyChannelRange_set_first_blocknum(&this_ptr_conv, val);
15573 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_ReplyChannelRange_1get_1number_1of_1blocks(JNIEnv *env, jclass clz, int64_t this_ptr) {
15574 LDKReplyChannelRange this_ptr_conv;
15575 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15576 this_ptr_conv.is_owned = false;
15577 int32_t ret_val = ReplyChannelRange_get_number_of_blocks(&this_ptr_conv);
15581 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ReplyChannelRange_1set_1number_1of_1blocks(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
15582 LDKReplyChannelRange this_ptr_conv;
15583 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15584 this_ptr_conv.is_owned = false;
15585 ReplyChannelRange_set_number_of_blocks(&this_ptr_conv, val);
15588 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_ReplyChannelRange_1get_1sync_1complete(JNIEnv *env, jclass clz, int64_t this_ptr) {
15589 LDKReplyChannelRange this_ptr_conv;
15590 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15591 this_ptr_conv.is_owned = false;
15592 jboolean ret_val = ReplyChannelRange_get_sync_complete(&this_ptr_conv);
15596 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ReplyChannelRange_1set_1sync_1complete(JNIEnv *env, jclass clz, int64_t this_ptr, jboolean val) {
15597 LDKReplyChannelRange this_ptr_conv;
15598 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15599 this_ptr_conv.is_owned = false;
15600 ReplyChannelRange_set_sync_complete(&this_ptr_conv, val);
15603 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ReplyChannelRange_1set_1short_1channel_1ids(JNIEnv *env, jclass clz, int64_t this_ptr, int64_tArray val) {
15604 LDKReplyChannelRange this_ptr_conv;
15605 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15606 this_ptr_conv.is_owned = false;
15607 LDKCVec_u64Z val_constr;
15608 val_constr.datalen = (*env)->GetArrayLength(env, val);
15609 if (val_constr.datalen > 0)
15610 val_constr.data = MALLOC(val_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
15612 val_constr.data = NULL;
15613 int64_t* val_vals = (*env)->GetLongArrayElements (env, val, NULL);
15614 for (size_t g = 0; g < val_constr.datalen; g++) {
15615 int64_t val_conv_6 = val_vals[g];
15616 val_constr.data[g] = val_conv_6;
15618 (*env)->ReleaseLongArrayElements(env, val, val_vals, 0);
15619 ReplyChannelRange_set_short_channel_ids(&this_ptr_conv, val_constr);
15622 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) {
15623 LDKThirtyTwoBytes chain_hash_arg_ref;
15624 CHECK((*env)->GetArrayLength(env, chain_hash_arg) == 32);
15625 (*env)->GetByteArrayRegion(env, chain_hash_arg, 0, 32, chain_hash_arg_ref.data);
15626 LDKCVec_u64Z short_channel_ids_arg_constr;
15627 short_channel_ids_arg_constr.datalen = (*env)->GetArrayLength(env, short_channel_ids_arg);
15628 if (short_channel_ids_arg_constr.datalen > 0)
15629 short_channel_ids_arg_constr.data = MALLOC(short_channel_ids_arg_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
15631 short_channel_ids_arg_constr.data = NULL;
15632 int64_t* short_channel_ids_arg_vals = (*env)->GetLongArrayElements (env, short_channel_ids_arg, NULL);
15633 for (size_t g = 0; g < short_channel_ids_arg_constr.datalen; g++) {
15634 int64_t short_channel_ids_arg_conv_6 = short_channel_ids_arg_vals[g];
15635 short_channel_ids_arg_constr.data[g] = short_channel_ids_arg_conv_6;
15637 (*env)->ReleaseLongArrayElements(env, short_channel_ids_arg, short_channel_ids_arg_vals, 0);
15638 LDKReplyChannelRange ret_var = ReplyChannelRange_new(chain_hash_arg_ref, first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg_constr);
15639 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15640 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15641 long ret_ref = (long)ret_var.inner;
15642 if (ret_var.is_owned) {
15648 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ReplyChannelRange_1clone(JNIEnv *env, jclass clz, int64_t orig) {
15649 LDKReplyChannelRange orig_conv;
15650 orig_conv.inner = (void*)(orig & (~1));
15651 orig_conv.is_owned = false;
15652 LDKReplyChannelRange ret_var = ReplyChannelRange_clone(&orig_conv);
15653 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15654 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15655 long ret_ref = (long)ret_var.inner;
15656 if (ret_var.is_owned) {
15662 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_QueryShortChannelIds_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
15663 LDKQueryShortChannelIds this_obj_conv;
15664 this_obj_conv.inner = (void*)(this_obj & (~1));
15665 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
15666 QueryShortChannelIds_free(this_obj_conv);
15669 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_QueryShortChannelIds_1get_1chain_1hash(JNIEnv *env, jclass clz, int64_t this_ptr) {
15670 LDKQueryShortChannelIds this_ptr_conv;
15671 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15672 this_ptr_conv.is_owned = false;
15673 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
15674 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *QueryShortChannelIds_get_chain_hash(&this_ptr_conv));
15678 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_QueryShortChannelIds_1set_1chain_1hash(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
15679 LDKQueryShortChannelIds this_ptr_conv;
15680 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15681 this_ptr_conv.is_owned = false;
15682 LDKThirtyTwoBytes val_ref;
15683 CHECK((*env)->GetArrayLength(env, val) == 32);
15684 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
15685 QueryShortChannelIds_set_chain_hash(&this_ptr_conv, val_ref);
15688 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_QueryShortChannelIds_1set_1short_1channel_1ids(JNIEnv *env, jclass clz, int64_t this_ptr, int64_tArray val) {
15689 LDKQueryShortChannelIds this_ptr_conv;
15690 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15691 this_ptr_conv.is_owned = false;
15692 LDKCVec_u64Z val_constr;
15693 val_constr.datalen = (*env)->GetArrayLength(env, val);
15694 if (val_constr.datalen > 0)
15695 val_constr.data = MALLOC(val_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
15697 val_constr.data = NULL;
15698 int64_t* val_vals = (*env)->GetLongArrayElements (env, val, NULL);
15699 for (size_t g = 0; g < val_constr.datalen; g++) {
15700 int64_t val_conv_6 = val_vals[g];
15701 val_constr.data[g] = val_conv_6;
15703 (*env)->ReleaseLongArrayElements(env, val, val_vals, 0);
15704 QueryShortChannelIds_set_short_channel_ids(&this_ptr_conv, val_constr);
15707 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) {
15708 LDKThirtyTwoBytes chain_hash_arg_ref;
15709 CHECK((*env)->GetArrayLength(env, chain_hash_arg) == 32);
15710 (*env)->GetByteArrayRegion(env, chain_hash_arg, 0, 32, chain_hash_arg_ref.data);
15711 LDKCVec_u64Z short_channel_ids_arg_constr;
15712 short_channel_ids_arg_constr.datalen = (*env)->GetArrayLength(env, short_channel_ids_arg);
15713 if (short_channel_ids_arg_constr.datalen > 0)
15714 short_channel_ids_arg_constr.data = MALLOC(short_channel_ids_arg_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
15716 short_channel_ids_arg_constr.data = NULL;
15717 int64_t* short_channel_ids_arg_vals = (*env)->GetLongArrayElements (env, short_channel_ids_arg, NULL);
15718 for (size_t g = 0; g < short_channel_ids_arg_constr.datalen; g++) {
15719 int64_t short_channel_ids_arg_conv_6 = short_channel_ids_arg_vals[g];
15720 short_channel_ids_arg_constr.data[g] = short_channel_ids_arg_conv_6;
15722 (*env)->ReleaseLongArrayElements(env, short_channel_ids_arg, short_channel_ids_arg_vals, 0);
15723 LDKQueryShortChannelIds ret_var = QueryShortChannelIds_new(chain_hash_arg_ref, short_channel_ids_arg_constr);
15724 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15725 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15726 long ret_ref = (long)ret_var.inner;
15727 if (ret_var.is_owned) {
15733 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_QueryShortChannelIds_1clone(JNIEnv *env, jclass clz, int64_t orig) {
15734 LDKQueryShortChannelIds orig_conv;
15735 orig_conv.inner = (void*)(orig & (~1));
15736 orig_conv.is_owned = false;
15737 LDKQueryShortChannelIds ret_var = QueryShortChannelIds_clone(&orig_conv);
15738 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15739 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15740 long ret_ref = (long)ret_var.inner;
15741 if (ret_var.is_owned) {
15747 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ReplyShortChannelIdsEnd_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
15748 LDKReplyShortChannelIdsEnd this_obj_conv;
15749 this_obj_conv.inner = (void*)(this_obj & (~1));
15750 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
15751 ReplyShortChannelIdsEnd_free(this_obj_conv);
15754 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ReplyShortChannelIdsEnd_1get_1chain_1hash(JNIEnv *env, jclass clz, int64_t this_ptr) {
15755 LDKReplyShortChannelIdsEnd this_ptr_conv;
15756 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15757 this_ptr_conv.is_owned = false;
15758 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
15759 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *ReplyShortChannelIdsEnd_get_chain_hash(&this_ptr_conv));
15763 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ReplyShortChannelIdsEnd_1set_1chain_1hash(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
15764 LDKReplyShortChannelIdsEnd this_ptr_conv;
15765 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15766 this_ptr_conv.is_owned = false;
15767 LDKThirtyTwoBytes val_ref;
15768 CHECK((*env)->GetArrayLength(env, val) == 32);
15769 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
15770 ReplyShortChannelIdsEnd_set_chain_hash(&this_ptr_conv, val_ref);
15773 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_ReplyShortChannelIdsEnd_1get_1full_1information(JNIEnv *env, jclass clz, int64_t this_ptr) {
15774 LDKReplyShortChannelIdsEnd this_ptr_conv;
15775 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15776 this_ptr_conv.is_owned = false;
15777 jboolean ret_val = ReplyShortChannelIdsEnd_get_full_information(&this_ptr_conv);
15781 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ReplyShortChannelIdsEnd_1set_1full_1information(JNIEnv *env, jclass clz, int64_t this_ptr, jboolean val) {
15782 LDKReplyShortChannelIdsEnd this_ptr_conv;
15783 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15784 this_ptr_conv.is_owned = false;
15785 ReplyShortChannelIdsEnd_set_full_information(&this_ptr_conv, val);
15788 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ReplyShortChannelIdsEnd_1new(JNIEnv *env, jclass clz, int8_tArray chain_hash_arg, jboolean full_information_arg) {
15789 LDKThirtyTwoBytes chain_hash_arg_ref;
15790 CHECK((*env)->GetArrayLength(env, chain_hash_arg) == 32);
15791 (*env)->GetByteArrayRegion(env, chain_hash_arg, 0, 32, chain_hash_arg_ref.data);
15792 LDKReplyShortChannelIdsEnd ret_var = ReplyShortChannelIdsEnd_new(chain_hash_arg_ref, full_information_arg);
15793 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15794 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15795 long ret_ref = (long)ret_var.inner;
15796 if (ret_var.is_owned) {
15802 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ReplyShortChannelIdsEnd_1clone(JNIEnv *env, jclass clz, int64_t orig) {
15803 LDKReplyShortChannelIdsEnd orig_conv;
15804 orig_conv.inner = (void*)(orig & (~1));
15805 orig_conv.is_owned = false;
15806 LDKReplyShortChannelIdsEnd ret_var = ReplyShortChannelIdsEnd_clone(&orig_conv);
15807 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15808 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15809 long ret_ref = (long)ret_var.inner;
15810 if (ret_var.is_owned) {
15816 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_GossipTimestampFilter_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
15817 LDKGossipTimestampFilter this_obj_conv;
15818 this_obj_conv.inner = (void*)(this_obj & (~1));
15819 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
15820 GossipTimestampFilter_free(this_obj_conv);
15823 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_GossipTimestampFilter_1get_1chain_1hash(JNIEnv *env, jclass clz, int64_t this_ptr) {
15824 LDKGossipTimestampFilter this_ptr_conv;
15825 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15826 this_ptr_conv.is_owned = false;
15827 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
15828 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *GossipTimestampFilter_get_chain_hash(&this_ptr_conv));
15832 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_GossipTimestampFilter_1set_1chain_1hash(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
15833 LDKGossipTimestampFilter this_ptr_conv;
15834 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15835 this_ptr_conv.is_owned = false;
15836 LDKThirtyTwoBytes val_ref;
15837 CHECK((*env)->GetArrayLength(env, val) == 32);
15838 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
15839 GossipTimestampFilter_set_chain_hash(&this_ptr_conv, val_ref);
15842 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_GossipTimestampFilter_1get_1first_1timestamp(JNIEnv *env, jclass clz, int64_t this_ptr) {
15843 LDKGossipTimestampFilter this_ptr_conv;
15844 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15845 this_ptr_conv.is_owned = false;
15846 int32_t ret_val = GossipTimestampFilter_get_first_timestamp(&this_ptr_conv);
15850 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_GossipTimestampFilter_1set_1first_1timestamp(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
15851 LDKGossipTimestampFilter this_ptr_conv;
15852 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15853 this_ptr_conv.is_owned = false;
15854 GossipTimestampFilter_set_first_timestamp(&this_ptr_conv, val);
15857 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_GossipTimestampFilter_1get_1timestamp_1range(JNIEnv *env, jclass clz, int64_t this_ptr) {
15858 LDKGossipTimestampFilter this_ptr_conv;
15859 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15860 this_ptr_conv.is_owned = false;
15861 int32_t ret_val = GossipTimestampFilter_get_timestamp_range(&this_ptr_conv);
15865 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_GossipTimestampFilter_1set_1timestamp_1range(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
15866 LDKGossipTimestampFilter this_ptr_conv;
15867 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15868 this_ptr_conv.is_owned = false;
15869 GossipTimestampFilter_set_timestamp_range(&this_ptr_conv, val);
15872 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) {
15873 LDKThirtyTwoBytes chain_hash_arg_ref;
15874 CHECK((*env)->GetArrayLength(env, chain_hash_arg) == 32);
15875 (*env)->GetByteArrayRegion(env, chain_hash_arg, 0, 32, chain_hash_arg_ref.data);
15876 LDKGossipTimestampFilter ret_var = GossipTimestampFilter_new(chain_hash_arg_ref, first_timestamp_arg, timestamp_range_arg);
15877 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15878 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15879 long ret_ref = (long)ret_var.inner;
15880 if (ret_var.is_owned) {
15886 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_GossipTimestampFilter_1clone(JNIEnv *env, jclass clz, int64_t orig) {
15887 LDKGossipTimestampFilter orig_conv;
15888 orig_conv.inner = (void*)(orig & (~1));
15889 orig_conv.is_owned = false;
15890 LDKGossipTimestampFilter ret_var = GossipTimestampFilter_clone(&orig_conv);
15891 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15892 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15893 long ret_ref = (long)ret_var.inner;
15894 if (ret_var.is_owned) {
15900 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ErrorAction_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
15901 if ((this_ptr & 1) != 0) return;
15902 LDKErrorAction this_ptr_conv = *(LDKErrorAction*)(((uint64_t)this_ptr) & ~1);
15903 FREE((void*)this_ptr);
15904 ErrorAction_free(this_ptr_conv);
15907 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ErrorAction_1clone(JNIEnv *env, jclass clz, int64_t orig) {
15908 LDKErrorAction* orig_conv = (LDKErrorAction*)orig;
15909 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
15910 *ret_copy = ErrorAction_clone(orig_conv);
15911 long ret_ref = (long)ret_copy;
15915 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LightningError_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
15916 LDKLightningError this_obj_conv;
15917 this_obj_conv.inner = (void*)(this_obj & (~1));
15918 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
15919 LightningError_free(this_obj_conv);
15922 JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_LightningError_1get_1err(JNIEnv *env, jclass clz, int64_t this_ptr) {
15923 LDKLightningError this_ptr_conv;
15924 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15925 this_ptr_conv.is_owned = false;
15926 LDKStr _str = LightningError_get_err(&this_ptr_conv);
15927 jstring _conv = str_ref_to_java(env, _str.chars, _str.len);
15931 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LightningError_1set_1err(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
15932 LDKLightningError this_ptr_conv;
15933 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15934 this_ptr_conv.is_owned = false;
15935 LDKCVec_u8Z val_ref;
15936 val_ref.datalen = (*env)->GetArrayLength(env, val);
15937 val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
15938 (*env)->GetByteArrayRegion(env, val, 0, val_ref.datalen, val_ref.data);
15939 LightningError_set_err(&this_ptr_conv, val_ref);
15942 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LightningError_1get_1action(JNIEnv *env, jclass clz, int64_t this_ptr) {
15943 LDKLightningError this_ptr_conv;
15944 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15945 this_ptr_conv.is_owned = false;
15946 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
15947 *ret_copy = LightningError_get_action(&this_ptr_conv);
15948 long ret_ref = (long)ret_copy;
15952 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LightningError_1set_1action(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
15953 LDKLightningError this_ptr_conv;
15954 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15955 this_ptr_conv.is_owned = false;
15956 LDKErrorAction val_conv = *(LDKErrorAction*)(((uint64_t)val) & ~1);
15958 LightningError_set_action(&this_ptr_conv, val_conv);
15961 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LightningError_1new(JNIEnv *env, jclass clz, int8_tArray err_arg, int64_t action_arg) {
15962 LDKCVec_u8Z err_arg_ref;
15963 err_arg_ref.datalen = (*env)->GetArrayLength(env, err_arg);
15964 err_arg_ref.data = MALLOC(err_arg_ref.datalen, "LDKCVec_u8Z Bytes");
15965 (*env)->GetByteArrayRegion(env, err_arg, 0, err_arg_ref.datalen, err_arg_ref.data);
15966 LDKErrorAction action_arg_conv = *(LDKErrorAction*)(((uint64_t)action_arg) & ~1);
15967 FREE((void*)action_arg);
15968 LDKLightningError ret_var = LightningError_new(err_arg_ref, action_arg_conv);
15969 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15970 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15971 long ret_ref = (long)ret_var.inner;
15972 if (ret_var.is_owned) {
15978 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LightningError_1clone(JNIEnv *env, jclass clz, int64_t orig) {
15979 LDKLightningError orig_conv;
15980 orig_conv.inner = (void*)(orig & (~1));
15981 orig_conv.is_owned = false;
15982 LDKLightningError ret_var = LightningError_clone(&orig_conv);
15983 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15984 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15985 long ret_ref = (long)ret_var.inner;
15986 if (ret_var.is_owned) {
15992 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CommitmentUpdate_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
15993 LDKCommitmentUpdate this_obj_conv;
15994 this_obj_conv.inner = (void*)(this_obj & (~1));
15995 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
15996 CommitmentUpdate_free(this_obj_conv);
15999 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CommitmentUpdate_1set_1update_1add_1htlcs(JNIEnv *env, jclass clz, int64_t this_ptr, int64_tArray val) {
16000 LDKCommitmentUpdate this_ptr_conv;
16001 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16002 this_ptr_conv.is_owned = false;
16003 LDKCVec_UpdateAddHTLCZ val_constr;
16004 val_constr.datalen = (*env)->GetArrayLength(env, val);
16005 if (val_constr.datalen > 0)
16006 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKUpdateAddHTLC), "LDKCVec_UpdateAddHTLCZ Elements");
16008 val_constr.data = NULL;
16009 int64_t* val_vals = (*env)->GetLongArrayElements (env, val, NULL);
16010 for (size_t p = 0; p < val_constr.datalen; p++) {
16011 int64_t val_conv_15 = val_vals[p];
16012 LDKUpdateAddHTLC val_conv_15_conv;
16013 val_conv_15_conv.inner = (void*)(val_conv_15 & (~1));
16014 val_conv_15_conv.is_owned = (val_conv_15 & 1) || (val_conv_15 == 0);
16015 val_conv_15_conv = UpdateAddHTLC_clone(&val_conv_15_conv);
16016 val_constr.data[p] = val_conv_15_conv;
16018 (*env)->ReleaseLongArrayElements(env, val, val_vals, 0);
16019 CommitmentUpdate_set_update_add_htlcs(&this_ptr_conv, val_constr);
16022 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CommitmentUpdate_1set_1update_1fulfill_1htlcs(JNIEnv *env, jclass clz, int64_t this_ptr, int64_tArray val) {
16023 LDKCommitmentUpdate this_ptr_conv;
16024 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16025 this_ptr_conv.is_owned = false;
16026 LDKCVec_UpdateFulfillHTLCZ val_constr;
16027 val_constr.datalen = (*env)->GetArrayLength(env, val);
16028 if (val_constr.datalen > 0)
16029 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKUpdateFulfillHTLC), "LDKCVec_UpdateFulfillHTLCZ Elements");
16031 val_constr.data = NULL;
16032 int64_t* val_vals = (*env)->GetLongArrayElements (env, val, NULL);
16033 for (size_t t = 0; t < val_constr.datalen; t++) {
16034 int64_t val_conv_19 = val_vals[t];
16035 LDKUpdateFulfillHTLC val_conv_19_conv;
16036 val_conv_19_conv.inner = (void*)(val_conv_19 & (~1));
16037 val_conv_19_conv.is_owned = (val_conv_19 & 1) || (val_conv_19 == 0);
16038 val_conv_19_conv = UpdateFulfillHTLC_clone(&val_conv_19_conv);
16039 val_constr.data[t] = val_conv_19_conv;
16041 (*env)->ReleaseLongArrayElements(env, val, val_vals, 0);
16042 CommitmentUpdate_set_update_fulfill_htlcs(&this_ptr_conv, val_constr);
16045 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CommitmentUpdate_1set_1update_1fail_1htlcs(JNIEnv *env, jclass clz, int64_t this_ptr, int64_tArray val) {
16046 LDKCommitmentUpdate this_ptr_conv;
16047 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16048 this_ptr_conv.is_owned = false;
16049 LDKCVec_UpdateFailHTLCZ val_constr;
16050 val_constr.datalen = (*env)->GetArrayLength(env, val);
16051 if (val_constr.datalen > 0)
16052 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKUpdateFailHTLC), "LDKCVec_UpdateFailHTLCZ Elements");
16054 val_constr.data = NULL;
16055 int64_t* val_vals = (*env)->GetLongArrayElements (env, val, NULL);
16056 for (size_t q = 0; q < val_constr.datalen; q++) {
16057 int64_t val_conv_16 = val_vals[q];
16058 LDKUpdateFailHTLC val_conv_16_conv;
16059 val_conv_16_conv.inner = (void*)(val_conv_16 & (~1));
16060 val_conv_16_conv.is_owned = (val_conv_16 & 1) || (val_conv_16 == 0);
16061 val_conv_16_conv = UpdateFailHTLC_clone(&val_conv_16_conv);
16062 val_constr.data[q] = val_conv_16_conv;
16064 (*env)->ReleaseLongArrayElements(env, val, val_vals, 0);
16065 CommitmentUpdate_set_update_fail_htlcs(&this_ptr_conv, val_constr);
16068 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) {
16069 LDKCommitmentUpdate this_ptr_conv;
16070 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16071 this_ptr_conv.is_owned = false;
16072 LDKCVec_UpdateFailMalformedHTLCZ val_constr;
16073 val_constr.datalen = (*env)->GetArrayLength(env, val);
16074 if (val_constr.datalen > 0)
16075 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKUpdateFailMalformedHTLC), "LDKCVec_UpdateFailMalformedHTLCZ Elements");
16077 val_constr.data = NULL;
16078 int64_t* val_vals = (*env)->GetLongArrayElements (env, val, NULL);
16079 for (size_t z = 0; z < val_constr.datalen; z++) {
16080 int64_t val_conv_25 = val_vals[z];
16081 LDKUpdateFailMalformedHTLC val_conv_25_conv;
16082 val_conv_25_conv.inner = (void*)(val_conv_25 & (~1));
16083 val_conv_25_conv.is_owned = (val_conv_25 & 1) || (val_conv_25 == 0);
16084 val_conv_25_conv = UpdateFailMalformedHTLC_clone(&val_conv_25_conv);
16085 val_constr.data[z] = val_conv_25_conv;
16087 (*env)->ReleaseLongArrayElements(env, val, val_vals, 0);
16088 CommitmentUpdate_set_update_fail_malformed_htlcs(&this_ptr_conv, val_constr);
16091 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentUpdate_1get_1update_1fee(JNIEnv *env, jclass clz, int64_t this_ptr) {
16092 LDKCommitmentUpdate this_ptr_conv;
16093 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16094 this_ptr_conv.is_owned = false;
16095 LDKUpdateFee ret_var = CommitmentUpdate_get_update_fee(&this_ptr_conv);
16096 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16097 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16098 long ret_ref = (long)ret_var.inner;
16099 if (ret_var.is_owned) {
16105 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CommitmentUpdate_1set_1update_1fee(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
16106 LDKCommitmentUpdate this_ptr_conv;
16107 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16108 this_ptr_conv.is_owned = false;
16109 LDKUpdateFee val_conv;
16110 val_conv.inner = (void*)(val & (~1));
16111 val_conv.is_owned = (val & 1) || (val == 0);
16112 val_conv = UpdateFee_clone(&val_conv);
16113 CommitmentUpdate_set_update_fee(&this_ptr_conv, val_conv);
16116 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentUpdate_1get_1commitment_1signed(JNIEnv *env, jclass clz, int64_t this_ptr) {
16117 LDKCommitmentUpdate this_ptr_conv;
16118 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16119 this_ptr_conv.is_owned = false;
16120 LDKCommitmentSigned ret_var = CommitmentUpdate_get_commitment_signed(&this_ptr_conv);
16121 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16122 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16123 long ret_ref = (long)ret_var.inner;
16124 if (ret_var.is_owned) {
16130 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CommitmentUpdate_1set_1commitment_1signed(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
16131 LDKCommitmentUpdate this_ptr_conv;
16132 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16133 this_ptr_conv.is_owned = false;
16134 LDKCommitmentSigned val_conv;
16135 val_conv.inner = (void*)(val & (~1));
16136 val_conv.is_owned = (val & 1) || (val == 0);
16137 val_conv = CommitmentSigned_clone(&val_conv);
16138 CommitmentUpdate_set_commitment_signed(&this_ptr_conv, val_conv);
16141 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) {
16142 LDKCVec_UpdateAddHTLCZ update_add_htlcs_arg_constr;
16143 update_add_htlcs_arg_constr.datalen = (*env)->GetArrayLength(env, update_add_htlcs_arg);
16144 if (update_add_htlcs_arg_constr.datalen > 0)
16145 update_add_htlcs_arg_constr.data = MALLOC(update_add_htlcs_arg_constr.datalen * sizeof(LDKUpdateAddHTLC), "LDKCVec_UpdateAddHTLCZ Elements");
16147 update_add_htlcs_arg_constr.data = NULL;
16148 int64_t* update_add_htlcs_arg_vals = (*env)->GetLongArrayElements (env, update_add_htlcs_arg, NULL);
16149 for (size_t p = 0; p < update_add_htlcs_arg_constr.datalen; p++) {
16150 int64_t update_add_htlcs_arg_conv_15 = update_add_htlcs_arg_vals[p];
16151 LDKUpdateAddHTLC update_add_htlcs_arg_conv_15_conv;
16152 update_add_htlcs_arg_conv_15_conv.inner = (void*)(update_add_htlcs_arg_conv_15 & (~1));
16153 update_add_htlcs_arg_conv_15_conv.is_owned = (update_add_htlcs_arg_conv_15 & 1) || (update_add_htlcs_arg_conv_15 == 0);
16154 update_add_htlcs_arg_conv_15_conv = UpdateAddHTLC_clone(&update_add_htlcs_arg_conv_15_conv);
16155 update_add_htlcs_arg_constr.data[p] = update_add_htlcs_arg_conv_15_conv;
16157 (*env)->ReleaseLongArrayElements(env, update_add_htlcs_arg, update_add_htlcs_arg_vals, 0);
16158 LDKCVec_UpdateFulfillHTLCZ update_fulfill_htlcs_arg_constr;
16159 update_fulfill_htlcs_arg_constr.datalen = (*env)->GetArrayLength(env, update_fulfill_htlcs_arg);
16160 if (update_fulfill_htlcs_arg_constr.datalen > 0)
16161 update_fulfill_htlcs_arg_constr.data = MALLOC(update_fulfill_htlcs_arg_constr.datalen * sizeof(LDKUpdateFulfillHTLC), "LDKCVec_UpdateFulfillHTLCZ Elements");
16163 update_fulfill_htlcs_arg_constr.data = NULL;
16164 int64_t* update_fulfill_htlcs_arg_vals = (*env)->GetLongArrayElements (env, update_fulfill_htlcs_arg, NULL);
16165 for (size_t t = 0; t < update_fulfill_htlcs_arg_constr.datalen; t++) {
16166 int64_t update_fulfill_htlcs_arg_conv_19 = update_fulfill_htlcs_arg_vals[t];
16167 LDKUpdateFulfillHTLC update_fulfill_htlcs_arg_conv_19_conv;
16168 update_fulfill_htlcs_arg_conv_19_conv.inner = (void*)(update_fulfill_htlcs_arg_conv_19 & (~1));
16169 update_fulfill_htlcs_arg_conv_19_conv.is_owned = (update_fulfill_htlcs_arg_conv_19 & 1) || (update_fulfill_htlcs_arg_conv_19 == 0);
16170 update_fulfill_htlcs_arg_conv_19_conv = UpdateFulfillHTLC_clone(&update_fulfill_htlcs_arg_conv_19_conv);
16171 update_fulfill_htlcs_arg_constr.data[t] = update_fulfill_htlcs_arg_conv_19_conv;
16173 (*env)->ReleaseLongArrayElements(env, update_fulfill_htlcs_arg, update_fulfill_htlcs_arg_vals, 0);
16174 LDKCVec_UpdateFailHTLCZ update_fail_htlcs_arg_constr;
16175 update_fail_htlcs_arg_constr.datalen = (*env)->GetArrayLength(env, update_fail_htlcs_arg);
16176 if (update_fail_htlcs_arg_constr.datalen > 0)
16177 update_fail_htlcs_arg_constr.data = MALLOC(update_fail_htlcs_arg_constr.datalen * sizeof(LDKUpdateFailHTLC), "LDKCVec_UpdateFailHTLCZ Elements");
16179 update_fail_htlcs_arg_constr.data = NULL;
16180 int64_t* update_fail_htlcs_arg_vals = (*env)->GetLongArrayElements (env, update_fail_htlcs_arg, NULL);
16181 for (size_t q = 0; q < update_fail_htlcs_arg_constr.datalen; q++) {
16182 int64_t update_fail_htlcs_arg_conv_16 = update_fail_htlcs_arg_vals[q];
16183 LDKUpdateFailHTLC update_fail_htlcs_arg_conv_16_conv;
16184 update_fail_htlcs_arg_conv_16_conv.inner = (void*)(update_fail_htlcs_arg_conv_16 & (~1));
16185 update_fail_htlcs_arg_conv_16_conv.is_owned = (update_fail_htlcs_arg_conv_16 & 1) || (update_fail_htlcs_arg_conv_16 == 0);
16186 update_fail_htlcs_arg_conv_16_conv = UpdateFailHTLC_clone(&update_fail_htlcs_arg_conv_16_conv);
16187 update_fail_htlcs_arg_constr.data[q] = update_fail_htlcs_arg_conv_16_conv;
16189 (*env)->ReleaseLongArrayElements(env, update_fail_htlcs_arg, update_fail_htlcs_arg_vals, 0);
16190 LDKCVec_UpdateFailMalformedHTLCZ update_fail_malformed_htlcs_arg_constr;
16191 update_fail_malformed_htlcs_arg_constr.datalen = (*env)->GetArrayLength(env, update_fail_malformed_htlcs_arg);
16192 if (update_fail_malformed_htlcs_arg_constr.datalen > 0)
16193 update_fail_malformed_htlcs_arg_constr.data = MALLOC(update_fail_malformed_htlcs_arg_constr.datalen * sizeof(LDKUpdateFailMalformedHTLC), "LDKCVec_UpdateFailMalformedHTLCZ Elements");
16195 update_fail_malformed_htlcs_arg_constr.data = NULL;
16196 int64_t* update_fail_malformed_htlcs_arg_vals = (*env)->GetLongArrayElements (env, update_fail_malformed_htlcs_arg, NULL);
16197 for (size_t z = 0; z < update_fail_malformed_htlcs_arg_constr.datalen; z++) {
16198 int64_t update_fail_malformed_htlcs_arg_conv_25 = update_fail_malformed_htlcs_arg_vals[z];
16199 LDKUpdateFailMalformedHTLC update_fail_malformed_htlcs_arg_conv_25_conv;
16200 update_fail_malformed_htlcs_arg_conv_25_conv.inner = (void*)(update_fail_malformed_htlcs_arg_conv_25 & (~1));
16201 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);
16202 update_fail_malformed_htlcs_arg_conv_25_conv = UpdateFailMalformedHTLC_clone(&update_fail_malformed_htlcs_arg_conv_25_conv);
16203 update_fail_malformed_htlcs_arg_constr.data[z] = update_fail_malformed_htlcs_arg_conv_25_conv;
16205 (*env)->ReleaseLongArrayElements(env, update_fail_malformed_htlcs_arg, update_fail_malformed_htlcs_arg_vals, 0);
16206 LDKUpdateFee update_fee_arg_conv;
16207 update_fee_arg_conv.inner = (void*)(update_fee_arg & (~1));
16208 update_fee_arg_conv.is_owned = (update_fee_arg & 1) || (update_fee_arg == 0);
16209 update_fee_arg_conv = UpdateFee_clone(&update_fee_arg_conv);
16210 LDKCommitmentSigned commitment_signed_arg_conv;
16211 commitment_signed_arg_conv.inner = (void*)(commitment_signed_arg & (~1));
16212 commitment_signed_arg_conv.is_owned = (commitment_signed_arg & 1) || (commitment_signed_arg == 0);
16213 commitment_signed_arg_conv = CommitmentSigned_clone(&commitment_signed_arg_conv);
16214 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);
16215 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16216 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16217 long ret_ref = (long)ret_var.inner;
16218 if (ret_var.is_owned) {
16224 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentUpdate_1clone(JNIEnv *env, jclass clz, int64_t orig) {
16225 LDKCommitmentUpdate orig_conv;
16226 orig_conv.inner = (void*)(orig & (~1));
16227 orig_conv.is_owned = false;
16228 LDKCommitmentUpdate ret_var = CommitmentUpdate_clone(&orig_conv);
16229 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16230 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16231 long ret_ref = (long)ret_var.inner;
16232 if (ret_var.is_owned) {
16238 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_HTLCFailChannelUpdate_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
16239 if ((this_ptr & 1) != 0) return;
16240 LDKHTLCFailChannelUpdate this_ptr_conv = *(LDKHTLCFailChannelUpdate*)(((uint64_t)this_ptr) & ~1);
16241 FREE((void*)this_ptr);
16242 HTLCFailChannelUpdate_free(this_ptr_conv);
16245 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_HTLCFailChannelUpdate_1clone(JNIEnv *env, jclass clz, int64_t orig) {
16246 LDKHTLCFailChannelUpdate* orig_conv = (LDKHTLCFailChannelUpdate*)orig;
16247 LDKHTLCFailChannelUpdate *ret_copy = MALLOC(sizeof(LDKHTLCFailChannelUpdate), "LDKHTLCFailChannelUpdate");
16248 *ret_copy = HTLCFailChannelUpdate_clone(orig_conv);
16249 long ret_ref = (long)ret_copy;
16253 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMessageHandler_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
16254 if ((this_ptr & 1) != 0) return;
16255 LDKChannelMessageHandler this_ptr_conv = *(LDKChannelMessageHandler*)(((uint64_t)this_ptr) & ~1);
16256 FREE((void*)this_ptr);
16257 ChannelMessageHandler_free(this_ptr_conv);
16260 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RoutingMessageHandler_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
16261 if ((this_ptr & 1) != 0) return;
16262 LDKRoutingMessageHandler this_ptr_conv = *(LDKRoutingMessageHandler*)(((uint64_t)this_ptr) & ~1);
16263 FREE((void*)this_ptr);
16264 RoutingMessageHandler_free(this_ptr_conv);
16267 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1write(JNIEnv *env, jclass clz, int64_t obj) {
16268 LDKAcceptChannel obj_conv;
16269 obj_conv.inner = (void*)(obj & (~1));
16270 obj_conv.is_owned = false;
16271 LDKCVec_u8Z ret_var = AcceptChannel_write(&obj_conv);
16272 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
16273 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
16274 CVec_u8Z_free(ret_var);
16278 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
16279 LDKu8slice ser_ref;
16280 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
16281 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
16282 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
16283 *ret_conv = AcceptChannel_read(ser_ref);
16284 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
16285 return (long)ret_conv;
16288 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_AnnouncementSignatures_1write(JNIEnv *env, jclass clz, int64_t obj) {
16289 LDKAnnouncementSignatures obj_conv;
16290 obj_conv.inner = (void*)(obj & (~1));
16291 obj_conv.is_owned = false;
16292 LDKCVec_u8Z ret_var = AnnouncementSignatures_write(&obj_conv);
16293 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
16294 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
16295 CVec_u8Z_free(ret_var);
16299 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_AnnouncementSignatures_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
16300 LDKu8slice ser_ref;
16301 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
16302 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
16303 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
16304 *ret_conv = AnnouncementSignatures_read(ser_ref);
16305 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
16306 return (long)ret_conv;
16309 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelReestablish_1write(JNIEnv *env, jclass clz, int64_t obj) {
16310 LDKChannelReestablish obj_conv;
16311 obj_conv.inner = (void*)(obj & (~1));
16312 obj_conv.is_owned = false;
16313 LDKCVec_u8Z ret_var = ChannelReestablish_write(&obj_conv);
16314 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
16315 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
16316 CVec_u8Z_free(ret_var);
16320 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelReestablish_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
16321 LDKu8slice ser_ref;
16322 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
16323 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
16324 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
16325 *ret_conv = ChannelReestablish_read(ser_ref);
16326 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
16327 return (long)ret_conv;
16330 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ClosingSigned_1write(JNIEnv *env, jclass clz, int64_t obj) {
16331 LDKClosingSigned obj_conv;
16332 obj_conv.inner = (void*)(obj & (~1));
16333 obj_conv.is_owned = false;
16334 LDKCVec_u8Z ret_var = ClosingSigned_write(&obj_conv);
16335 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
16336 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
16337 CVec_u8Z_free(ret_var);
16341 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ClosingSigned_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
16342 LDKu8slice ser_ref;
16343 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
16344 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
16345 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
16346 *ret_conv = ClosingSigned_read(ser_ref);
16347 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
16348 return (long)ret_conv;
16351 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_CommitmentSigned_1write(JNIEnv *env, jclass clz, int64_t obj) {
16352 LDKCommitmentSigned obj_conv;
16353 obj_conv.inner = (void*)(obj & (~1));
16354 obj_conv.is_owned = false;
16355 LDKCVec_u8Z ret_var = CommitmentSigned_write(&obj_conv);
16356 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
16357 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
16358 CVec_u8Z_free(ret_var);
16362 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentSigned_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
16363 LDKu8slice ser_ref;
16364 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
16365 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
16366 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
16367 *ret_conv = CommitmentSigned_read(ser_ref);
16368 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
16369 return (long)ret_conv;
16372 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_FundingCreated_1write(JNIEnv *env, jclass clz, int64_t obj) {
16373 LDKFundingCreated obj_conv;
16374 obj_conv.inner = (void*)(obj & (~1));
16375 obj_conv.is_owned = false;
16376 LDKCVec_u8Z ret_var = FundingCreated_write(&obj_conv);
16377 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
16378 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
16379 CVec_u8Z_free(ret_var);
16383 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_FundingCreated_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
16384 LDKu8slice ser_ref;
16385 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
16386 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
16387 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
16388 *ret_conv = FundingCreated_read(ser_ref);
16389 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
16390 return (long)ret_conv;
16393 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_FundingSigned_1write(JNIEnv *env, jclass clz, int64_t obj) {
16394 LDKFundingSigned obj_conv;
16395 obj_conv.inner = (void*)(obj & (~1));
16396 obj_conv.is_owned = false;
16397 LDKCVec_u8Z ret_var = FundingSigned_write(&obj_conv);
16398 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
16399 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
16400 CVec_u8Z_free(ret_var);
16404 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_FundingSigned_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
16405 LDKu8slice ser_ref;
16406 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
16407 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
16408 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
16409 *ret_conv = FundingSigned_read(ser_ref);
16410 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
16411 return (long)ret_conv;
16414 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_FundingLocked_1write(JNIEnv *env, jclass clz, int64_t obj) {
16415 LDKFundingLocked obj_conv;
16416 obj_conv.inner = (void*)(obj & (~1));
16417 obj_conv.is_owned = false;
16418 LDKCVec_u8Z ret_var = FundingLocked_write(&obj_conv);
16419 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
16420 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
16421 CVec_u8Z_free(ret_var);
16425 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_FundingLocked_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
16426 LDKu8slice ser_ref;
16427 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
16428 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
16429 LDKCResult_FundingLockedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingLockedDecodeErrorZ), "LDKCResult_FundingLockedDecodeErrorZ");
16430 *ret_conv = FundingLocked_read(ser_ref);
16431 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
16432 return (long)ret_conv;
16435 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_Init_1write(JNIEnv *env, jclass clz, int64_t obj) {
16437 obj_conv.inner = (void*)(obj & (~1));
16438 obj_conv.is_owned = false;
16439 LDKCVec_u8Z ret_var = Init_write(&obj_conv);
16440 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
16441 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
16442 CVec_u8Z_free(ret_var);
16446 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Init_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
16447 LDKu8slice ser_ref;
16448 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
16449 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
16450 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
16451 *ret_conv = Init_read(ser_ref);
16452 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
16453 return (long)ret_conv;
16456 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_OpenChannel_1write(JNIEnv *env, jclass clz, int64_t obj) {
16457 LDKOpenChannel obj_conv;
16458 obj_conv.inner = (void*)(obj & (~1));
16459 obj_conv.is_owned = false;
16460 LDKCVec_u8Z ret_var = OpenChannel_write(&obj_conv);
16461 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
16462 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
16463 CVec_u8Z_free(ret_var);
16467 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OpenChannel_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
16468 LDKu8slice ser_ref;
16469 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
16470 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
16471 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
16472 *ret_conv = OpenChannel_read(ser_ref);
16473 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
16474 return (long)ret_conv;
16477 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_RevokeAndACK_1write(JNIEnv *env, jclass clz, int64_t obj) {
16478 LDKRevokeAndACK obj_conv;
16479 obj_conv.inner = (void*)(obj & (~1));
16480 obj_conv.is_owned = false;
16481 LDKCVec_u8Z ret_var = RevokeAndACK_write(&obj_conv);
16482 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
16483 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
16484 CVec_u8Z_free(ret_var);
16488 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RevokeAndACK_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
16489 LDKu8slice ser_ref;
16490 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
16491 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
16492 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
16493 *ret_conv = RevokeAndACK_read(ser_ref);
16494 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
16495 return (long)ret_conv;
16498 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_Shutdown_1write(JNIEnv *env, jclass clz, int64_t obj) {
16499 LDKShutdown obj_conv;
16500 obj_conv.inner = (void*)(obj & (~1));
16501 obj_conv.is_owned = false;
16502 LDKCVec_u8Z ret_var = Shutdown_write(&obj_conv);
16503 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
16504 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
16505 CVec_u8Z_free(ret_var);
16509 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Shutdown_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
16510 LDKu8slice ser_ref;
16511 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
16512 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
16513 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
16514 *ret_conv = Shutdown_read(ser_ref);
16515 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
16516 return (long)ret_conv;
16519 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UpdateFailHTLC_1write(JNIEnv *env, jclass clz, int64_t obj) {
16520 LDKUpdateFailHTLC obj_conv;
16521 obj_conv.inner = (void*)(obj & (~1));
16522 obj_conv.is_owned = false;
16523 LDKCVec_u8Z ret_var = UpdateFailHTLC_write(&obj_conv);
16524 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
16525 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
16526 CVec_u8Z_free(ret_var);
16530 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFailHTLC_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
16531 LDKu8slice ser_ref;
16532 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
16533 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
16534 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
16535 *ret_conv = UpdateFailHTLC_read(ser_ref);
16536 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
16537 return (long)ret_conv;
16540 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UpdateFailMalformedHTLC_1write(JNIEnv *env, jclass clz, int64_t obj) {
16541 LDKUpdateFailMalformedHTLC obj_conv;
16542 obj_conv.inner = (void*)(obj & (~1));
16543 obj_conv.is_owned = false;
16544 LDKCVec_u8Z ret_var = UpdateFailMalformedHTLC_write(&obj_conv);
16545 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
16546 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
16547 CVec_u8Z_free(ret_var);
16551 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFailMalformedHTLC_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
16552 LDKu8slice ser_ref;
16553 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
16554 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
16555 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
16556 *ret_conv = UpdateFailMalformedHTLC_read(ser_ref);
16557 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
16558 return (long)ret_conv;
16561 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UpdateFee_1write(JNIEnv *env, jclass clz, int64_t obj) {
16562 LDKUpdateFee obj_conv;
16563 obj_conv.inner = (void*)(obj & (~1));
16564 obj_conv.is_owned = false;
16565 LDKCVec_u8Z ret_var = UpdateFee_write(&obj_conv);
16566 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
16567 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
16568 CVec_u8Z_free(ret_var);
16572 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFee_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
16573 LDKu8slice ser_ref;
16574 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
16575 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
16576 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
16577 *ret_conv = UpdateFee_read(ser_ref);
16578 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
16579 return (long)ret_conv;
16582 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UpdateFulfillHTLC_1write(JNIEnv *env, jclass clz, int64_t obj) {
16583 LDKUpdateFulfillHTLC obj_conv;
16584 obj_conv.inner = (void*)(obj & (~1));
16585 obj_conv.is_owned = false;
16586 LDKCVec_u8Z ret_var = UpdateFulfillHTLC_write(&obj_conv);
16587 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
16588 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
16589 CVec_u8Z_free(ret_var);
16593 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFulfillHTLC_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
16594 LDKu8slice ser_ref;
16595 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
16596 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
16597 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
16598 *ret_conv = UpdateFulfillHTLC_read(ser_ref);
16599 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
16600 return (long)ret_conv;
16603 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1write(JNIEnv *env, jclass clz, int64_t obj) {
16604 LDKUpdateAddHTLC obj_conv;
16605 obj_conv.inner = (void*)(obj & (~1));
16606 obj_conv.is_owned = false;
16607 LDKCVec_u8Z ret_var = UpdateAddHTLC_write(&obj_conv);
16608 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
16609 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
16610 CVec_u8Z_free(ret_var);
16614 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
16615 LDKu8slice ser_ref;
16616 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
16617 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
16618 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
16619 *ret_conv = UpdateAddHTLC_read(ser_ref);
16620 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
16621 return (long)ret_conv;
16624 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_Ping_1write(JNIEnv *env, jclass clz, int64_t obj) {
16626 obj_conv.inner = (void*)(obj & (~1));
16627 obj_conv.is_owned = false;
16628 LDKCVec_u8Z ret_var = Ping_write(&obj_conv);
16629 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
16630 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
16631 CVec_u8Z_free(ret_var);
16635 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Ping_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
16636 LDKu8slice ser_ref;
16637 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
16638 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
16639 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
16640 *ret_conv = Ping_read(ser_ref);
16641 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
16642 return (long)ret_conv;
16645 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_Pong_1write(JNIEnv *env, jclass clz, int64_t obj) {
16647 obj_conv.inner = (void*)(obj & (~1));
16648 obj_conv.is_owned = false;
16649 LDKCVec_u8Z ret_var = Pong_write(&obj_conv);
16650 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
16651 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
16652 CVec_u8Z_free(ret_var);
16656 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Pong_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
16657 LDKu8slice ser_ref;
16658 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
16659 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
16660 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
16661 *ret_conv = Pong_read(ser_ref);
16662 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
16663 return (long)ret_conv;
16666 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1write(JNIEnv *env, jclass clz, int64_t obj) {
16667 LDKUnsignedChannelAnnouncement obj_conv;
16668 obj_conv.inner = (void*)(obj & (~1));
16669 obj_conv.is_owned = false;
16670 LDKCVec_u8Z ret_var = UnsignedChannelAnnouncement_write(&obj_conv);
16671 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
16672 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
16673 CVec_u8Z_free(ret_var);
16677 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
16678 LDKu8slice ser_ref;
16679 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
16680 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
16681 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
16682 *ret_conv = UnsignedChannelAnnouncement_read(ser_ref);
16683 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
16684 return (long)ret_conv;
16687 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1write(JNIEnv *env, jclass clz, int64_t obj) {
16688 LDKChannelAnnouncement obj_conv;
16689 obj_conv.inner = (void*)(obj & (~1));
16690 obj_conv.is_owned = false;
16691 LDKCVec_u8Z ret_var = ChannelAnnouncement_write(&obj_conv);
16692 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
16693 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
16694 CVec_u8Z_free(ret_var);
16698 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
16699 LDKu8slice ser_ref;
16700 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
16701 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
16702 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
16703 *ret_conv = ChannelAnnouncement_read(ser_ref);
16704 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
16705 return (long)ret_conv;
16708 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1write(JNIEnv *env, jclass clz, int64_t obj) {
16709 LDKUnsignedChannelUpdate obj_conv;
16710 obj_conv.inner = (void*)(obj & (~1));
16711 obj_conv.is_owned = false;
16712 LDKCVec_u8Z ret_var = UnsignedChannelUpdate_write(&obj_conv);
16713 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
16714 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
16715 CVec_u8Z_free(ret_var);
16719 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
16720 LDKu8slice ser_ref;
16721 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
16722 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
16723 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
16724 *ret_conv = UnsignedChannelUpdate_read(ser_ref);
16725 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
16726 return (long)ret_conv;
16729 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelUpdate_1write(JNIEnv *env, jclass clz, int64_t obj) {
16730 LDKChannelUpdate obj_conv;
16731 obj_conv.inner = (void*)(obj & (~1));
16732 obj_conv.is_owned = false;
16733 LDKCVec_u8Z ret_var = ChannelUpdate_write(&obj_conv);
16734 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
16735 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
16736 CVec_u8Z_free(ret_var);
16740 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelUpdate_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
16741 LDKu8slice ser_ref;
16742 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
16743 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
16744 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
16745 *ret_conv = ChannelUpdate_read(ser_ref);
16746 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
16747 return (long)ret_conv;
16750 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ErrorMessage_1write(JNIEnv *env, jclass clz, int64_t obj) {
16751 LDKErrorMessage obj_conv;
16752 obj_conv.inner = (void*)(obj & (~1));
16753 obj_conv.is_owned = false;
16754 LDKCVec_u8Z ret_var = ErrorMessage_write(&obj_conv);
16755 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
16756 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
16757 CVec_u8Z_free(ret_var);
16761 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ErrorMessage_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
16762 LDKu8slice ser_ref;
16763 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
16764 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
16765 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
16766 *ret_conv = ErrorMessage_read(ser_ref);
16767 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
16768 return (long)ret_conv;
16771 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1write(JNIEnv *env, jclass clz, int64_t obj) {
16772 LDKUnsignedNodeAnnouncement obj_conv;
16773 obj_conv.inner = (void*)(obj & (~1));
16774 obj_conv.is_owned = false;
16775 LDKCVec_u8Z ret_var = UnsignedNodeAnnouncement_write(&obj_conv);
16776 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
16777 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
16778 CVec_u8Z_free(ret_var);
16782 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
16783 LDKu8slice ser_ref;
16784 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
16785 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
16786 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
16787 *ret_conv = UnsignedNodeAnnouncement_read(ser_ref);
16788 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
16789 return (long)ret_conv;
16792 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_NodeAnnouncement_1write(JNIEnv *env, jclass clz, int64_t obj) {
16793 LDKNodeAnnouncement obj_conv;
16794 obj_conv.inner = (void*)(obj & (~1));
16795 obj_conv.is_owned = false;
16796 LDKCVec_u8Z ret_var = NodeAnnouncement_write(&obj_conv);
16797 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
16798 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
16799 CVec_u8Z_free(ret_var);
16803 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeAnnouncement_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
16804 LDKu8slice ser_ref;
16805 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
16806 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
16807 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
16808 *ret_conv = NodeAnnouncement_read(ser_ref);
16809 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
16810 return (long)ret_conv;
16813 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_QueryShortChannelIds_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
16814 LDKu8slice ser_ref;
16815 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
16816 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
16817 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
16818 *ret_conv = QueryShortChannelIds_read(ser_ref);
16819 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
16820 return (long)ret_conv;
16823 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_QueryShortChannelIds_1write(JNIEnv *env, jclass clz, int64_t obj) {
16824 LDKQueryShortChannelIds obj_conv;
16825 obj_conv.inner = (void*)(obj & (~1));
16826 obj_conv.is_owned = false;
16827 LDKCVec_u8Z ret_var = QueryShortChannelIds_write(&obj_conv);
16828 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
16829 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
16830 CVec_u8Z_free(ret_var);
16834 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ReplyShortChannelIdsEnd_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
16835 LDKu8slice ser_ref;
16836 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
16837 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
16838 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
16839 *ret_conv = ReplyShortChannelIdsEnd_read(ser_ref);
16840 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
16841 return (long)ret_conv;
16844 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ReplyShortChannelIdsEnd_1write(JNIEnv *env, jclass clz, int64_t obj) {
16845 LDKReplyShortChannelIdsEnd obj_conv;
16846 obj_conv.inner = (void*)(obj & (~1));
16847 obj_conv.is_owned = false;
16848 LDKCVec_u8Z ret_var = ReplyShortChannelIdsEnd_write(&obj_conv);
16849 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
16850 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
16851 CVec_u8Z_free(ret_var);
16855 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_QueryChannelRange_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
16856 LDKu8slice ser_ref;
16857 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
16858 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
16859 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
16860 *ret_conv = QueryChannelRange_read(ser_ref);
16861 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
16862 return (long)ret_conv;
16865 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_QueryChannelRange_1write(JNIEnv *env, jclass clz, int64_t obj) {
16866 LDKQueryChannelRange obj_conv;
16867 obj_conv.inner = (void*)(obj & (~1));
16868 obj_conv.is_owned = false;
16869 LDKCVec_u8Z ret_var = QueryChannelRange_write(&obj_conv);
16870 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
16871 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
16872 CVec_u8Z_free(ret_var);
16876 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ReplyChannelRange_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
16877 LDKu8slice ser_ref;
16878 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
16879 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
16880 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
16881 *ret_conv = ReplyChannelRange_read(ser_ref);
16882 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
16883 return (long)ret_conv;
16886 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ReplyChannelRange_1write(JNIEnv *env, jclass clz, int64_t obj) {
16887 LDKReplyChannelRange obj_conv;
16888 obj_conv.inner = (void*)(obj & (~1));
16889 obj_conv.is_owned = false;
16890 LDKCVec_u8Z ret_var = ReplyChannelRange_write(&obj_conv);
16891 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
16892 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
16893 CVec_u8Z_free(ret_var);
16897 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_GossipTimestampFilter_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
16898 LDKu8slice ser_ref;
16899 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
16900 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
16901 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
16902 *ret_conv = GossipTimestampFilter_read(ser_ref);
16903 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
16904 return (long)ret_conv;
16907 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_GossipTimestampFilter_1write(JNIEnv *env, jclass clz, int64_t obj) {
16908 LDKGossipTimestampFilter obj_conv;
16909 obj_conv.inner = (void*)(obj & (~1));
16910 obj_conv.is_owned = false;
16911 LDKCVec_u8Z ret_var = GossipTimestampFilter_write(&obj_conv);
16912 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
16913 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
16914 CVec_u8Z_free(ret_var);
16918 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_IgnoringMessageHandler_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
16919 LDKIgnoringMessageHandler this_obj_conv;
16920 this_obj_conv.inner = (void*)(this_obj & (~1));
16921 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
16922 IgnoringMessageHandler_free(this_obj_conv);
16925 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_IgnoringMessageHandler_1new(JNIEnv *env, jclass clz) {
16926 LDKIgnoringMessageHandler ret_var = IgnoringMessageHandler_new();
16927 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16928 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16929 long ret_ref = (long)ret_var.inner;
16930 if (ret_var.is_owned) {
16936 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_IgnoringMessageHandler_1as_1MessageSendEventsProvider(JNIEnv *env, jclass clz, int64_t this_arg) {
16937 LDKIgnoringMessageHandler this_arg_conv;
16938 this_arg_conv.inner = (void*)(this_arg & (~1));
16939 this_arg_conv.is_owned = false;
16940 LDKMessageSendEventsProvider* ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
16941 *ret = IgnoringMessageHandler_as_MessageSendEventsProvider(&this_arg_conv);
16945 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_IgnoringMessageHandler_1as_1RoutingMessageHandler(JNIEnv *env, jclass clz, int64_t this_arg) {
16946 LDKIgnoringMessageHandler this_arg_conv;
16947 this_arg_conv.inner = (void*)(this_arg & (~1));
16948 this_arg_conv.is_owned = false;
16949 LDKRoutingMessageHandler* ret = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
16950 *ret = IgnoringMessageHandler_as_RoutingMessageHandler(&this_arg_conv);
16954 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ErroringMessageHandler_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
16955 LDKErroringMessageHandler this_obj_conv;
16956 this_obj_conv.inner = (void*)(this_obj & (~1));
16957 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
16958 ErroringMessageHandler_free(this_obj_conv);
16961 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ErroringMessageHandler_1new(JNIEnv *env, jclass clz) {
16962 LDKErroringMessageHandler ret_var = ErroringMessageHandler_new();
16963 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16964 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16965 long ret_ref = (long)ret_var.inner;
16966 if (ret_var.is_owned) {
16972 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ErroringMessageHandler_1as_1MessageSendEventsProvider(JNIEnv *env, jclass clz, int64_t this_arg) {
16973 LDKErroringMessageHandler this_arg_conv;
16974 this_arg_conv.inner = (void*)(this_arg & (~1));
16975 this_arg_conv.is_owned = false;
16976 LDKMessageSendEventsProvider* ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
16977 *ret = ErroringMessageHandler_as_MessageSendEventsProvider(&this_arg_conv);
16981 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ErroringMessageHandler_1as_1ChannelMessageHandler(JNIEnv *env, jclass clz, int64_t this_arg) {
16982 LDKErroringMessageHandler this_arg_conv;
16983 this_arg_conv.inner = (void*)(this_arg & (~1));
16984 this_arg_conv.is_owned = false;
16985 LDKChannelMessageHandler* ret = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
16986 *ret = ErroringMessageHandler_as_ChannelMessageHandler(&this_arg_conv);
16990 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_MessageHandler_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
16991 LDKMessageHandler this_obj_conv;
16992 this_obj_conv.inner = (void*)(this_obj & (~1));
16993 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
16994 MessageHandler_free(this_obj_conv);
16997 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MessageHandler_1get_1chan_1handler(JNIEnv *env, jclass clz, int64_t this_ptr) {
16998 LDKMessageHandler this_ptr_conv;
16999 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17000 this_ptr_conv.is_owned = false;
17001 long ret_ret = (long)MessageHandler_get_chan_handler(&this_ptr_conv);
17005 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_MessageHandler_1set_1chan_1handler(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
17006 LDKMessageHandler this_ptr_conv;
17007 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17008 this_ptr_conv.is_owned = false;
17009 LDKChannelMessageHandler val_conv = *(LDKChannelMessageHandler*)(((uint64_t)val) & ~1);
17010 if (val_conv.free == LDKChannelMessageHandler_JCalls_free) {
17011 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
17012 LDKChannelMessageHandler_JCalls_clone(val_conv.this_arg);
17014 MessageHandler_set_chan_handler(&this_ptr_conv, val_conv);
17017 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MessageHandler_1get_1route_1handler(JNIEnv *env, jclass clz, int64_t this_ptr) {
17018 LDKMessageHandler this_ptr_conv;
17019 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17020 this_ptr_conv.is_owned = false;
17021 long ret_ret = (long)MessageHandler_get_route_handler(&this_ptr_conv);
17025 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_MessageHandler_1set_1route_1handler(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
17026 LDKMessageHandler this_ptr_conv;
17027 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17028 this_ptr_conv.is_owned = false;
17029 LDKRoutingMessageHandler val_conv = *(LDKRoutingMessageHandler*)(((uint64_t)val) & ~1);
17030 if (val_conv.free == LDKRoutingMessageHandler_JCalls_free) {
17031 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
17032 LDKRoutingMessageHandler_JCalls_clone(val_conv.this_arg);
17034 MessageHandler_set_route_handler(&this_ptr_conv, val_conv);
17037 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) {
17038 LDKChannelMessageHandler chan_handler_arg_conv = *(LDKChannelMessageHandler*)(((uint64_t)chan_handler_arg) & ~1);
17039 if (chan_handler_arg_conv.free == LDKChannelMessageHandler_JCalls_free) {
17040 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
17041 LDKChannelMessageHandler_JCalls_clone(chan_handler_arg_conv.this_arg);
17043 LDKRoutingMessageHandler route_handler_arg_conv = *(LDKRoutingMessageHandler*)(((uint64_t)route_handler_arg) & ~1);
17044 if (route_handler_arg_conv.free == LDKRoutingMessageHandler_JCalls_free) {
17045 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
17046 LDKRoutingMessageHandler_JCalls_clone(route_handler_arg_conv.this_arg);
17048 LDKMessageHandler ret_var = MessageHandler_new(chan_handler_arg_conv, route_handler_arg_conv);
17049 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17050 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17051 long ret_ref = (long)ret_var.inner;
17052 if (ret_var.is_owned) {
17058 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SocketDescriptor_1clone(JNIEnv *env, jclass clz, int64_t orig) {
17059 LDKSocketDescriptor* orig_conv = (LDKSocketDescriptor*)(((uint64_t)orig) & ~1);
17060 LDKSocketDescriptor* ret = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
17061 *ret = SocketDescriptor_clone(orig_conv);
17065 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_SocketDescriptor_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
17066 if ((this_ptr & 1) != 0) return;
17067 LDKSocketDescriptor this_ptr_conv = *(LDKSocketDescriptor*)(((uint64_t)this_ptr) & ~1);
17068 FREE((void*)this_ptr);
17069 SocketDescriptor_free(this_ptr_conv);
17072 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_PeerHandleError_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
17073 LDKPeerHandleError this_obj_conv;
17074 this_obj_conv.inner = (void*)(this_obj & (~1));
17075 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
17076 PeerHandleError_free(this_obj_conv);
17079 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_PeerHandleError_1get_1no_1connection_1possible(JNIEnv *env, jclass clz, int64_t this_ptr) {
17080 LDKPeerHandleError this_ptr_conv;
17081 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17082 this_ptr_conv.is_owned = false;
17083 jboolean ret_val = PeerHandleError_get_no_connection_possible(&this_ptr_conv);
17087 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_PeerHandleError_1set_1no_1connection_1possible(JNIEnv *env, jclass clz, int64_t this_ptr, jboolean val) {
17088 LDKPeerHandleError this_ptr_conv;
17089 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17090 this_ptr_conv.is_owned = false;
17091 PeerHandleError_set_no_connection_possible(&this_ptr_conv, val);
17094 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PeerHandleError_1new(JNIEnv *env, jclass clz, jboolean no_connection_possible_arg) {
17095 LDKPeerHandleError ret_var = PeerHandleError_new(no_connection_possible_arg);
17096 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17097 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17098 long ret_ref = (long)ret_var.inner;
17099 if (ret_var.is_owned) {
17105 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PeerHandleError_1clone(JNIEnv *env, jclass clz, int64_t orig) {
17106 LDKPeerHandleError orig_conv;
17107 orig_conv.inner = (void*)(orig & (~1));
17108 orig_conv.is_owned = false;
17109 LDKPeerHandleError ret_var = PeerHandleError_clone(&orig_conv);
17110 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17111 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17112 long ret_ref = (long)ret_var.inner;
17113 if (ret_var.is_owned) {
17119 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_PeerManager_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
17120 LDKPeerManager this_obj_conv;
17121 this_obj_conv.inner = (void*)(this_obj & (~1));
17122 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
17123 PeerManager_free(this_obj_conv);
17126 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) {
17127 LDKMessageHandler message_handler_conv;
17128 message_handler_conv.inner = (void*)(message_handler & (~1));
17129 message_handler_conv.is_owned = (message_handler & 1) || (message_handler == 0);
17130 // Warning: we need a move here but no clone is available for LDKMessageHandler
17131 LDKSecretKey our_node_secret_ref;
17132 CHECK((*env)->GetArrayLength(env, our_node_secret) == 32);
17133 (*env)->GetByteArrayRegion(env, our_node_secret, 0, 32, our_node_secret_ref.bytes);
17134 unsigned char ephemeral_random_data_arr[32];
17135 CHECK((*env)->GetArrayLength(env, ephemeral_random_data) == 32);
17136 (*env)->GetByteArrayRegion(env, ephemeral_random_data, 0, 32, ephemeral_random_data_arr);
17137 unsigned char (*ephemeral_random_data_ref)[32] = &ephemeral_random_data_arr;
17138 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
17139 if (logger_conv.free == LDKLogger_JCalls_free) {
17140 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
17141 LDKLogger_JCalls_clone(logger_conv.this_arg);
17143 LDKPeerManager ret_var = PeerManager_new(message_handler_conv, our_node_secret_ref, ephemeral_random_data_ref, logger_conv);
17144 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17145 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17146 long ret_ref = (long)ret_var.inner;
17147 if (ret_var.is_owned) {
17153 JNIEXPORT jobjectArray JNICALL Java_org_ldk_impl_bindings_PeerManager_1get_1peer_1node_1ids(JNIEnv *env, jclass clz, int64_t this_arg) {
17154 LDKPeerManager this_arg_conv;
17155 this_arg_conv.inner = (void*)(this_arg & (~1));
17156 this_arg_conv.is_owned = false;
17157 LDKCVec_PublicKeyZ ret_var = PeerManager_get_peer_node_ids(&this_arg_conv);
17158 jobjectArray ret_arr = (*env)->NewObjectArray(env, ret_var.datalen, arr_of_B_clz, NULL);
17160 for (size_t i = 0; i < ret_var.datalen; i++) {
17161 int8_tArray ret_conv_8_arr = (*env)->NewByteArray(env, 33);
17162 (*env)->SetByteArrayRegion(env, ret_conv_8_arr, 0, 33, ret_var.data[i].compressed_form);
17163 (*env)->SetObjectArrayElement(env, ret_arr, i, ret_conv_8_arr);
17165 FREE(ret_var.data);
17169 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) {
17170 LDKPeerManager this_arg_conv;
17171 this_arg_conv.inner = (void*)(this_arg & (~1));
17172 this_arg_conv.is_owned = false;
17173 LDKPublicKey their_node_id_ref;
17174 CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
17175 (*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
17176 LDKSocketDescriptor descriptor_conv = *(LDKSocketDescriptor*)(((uint64_t)descriptor) & ~1);
17177 if (descriptor_conv.free == LDKSocketDescriptor_JCalls_free) {
17178 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
17179 LDKSocketDescriptor_JCalls_clone(descriptor_conv.this_arg);
17181 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
17182 *ret_conv = PeerManager_new_outbound_connection(&this_arg_conv, their_node_id_ref, descriptor_conv);
17183 return (long)ret_conv;
17186 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PeerManager_1new_1inbound_1connection(JNIEnv *env, jclass clz, int64_t this_arg, int64_t descriptor) {
17187 LDKPeerManager this_arg_conv;
17188 this_arg_conv.inner = (void*)(this_arg & (~1));
17189 this_arg_conv.is_owned = false;
17190 LDKSocketDescriptor descriptor_conv = *(LDKSocketDescriptor*)(((uint64_t)descriptor) & ~1);
17191 if (descriptor_conv.free == LDKSocketDescriptor_JCalls_free) {
17192 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
17193 LDKSocketDescriptor_JCalls_clone(descriptor_conv.this_arg);
17195 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
17196 *ret_conv = PeerManager_new_inbound_connection(&this_arg_conv, descriptor_conv);
17197 return (long)ret_conv;
17200 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) {
17201 LDKPeerManager this_arg_conv;
17202 this_arg_conv.inner = (void*)(this_arg & (~1));
17203 this_arg_conv.is_owned = false;
17204 LDKSocketDescriptor* descriptor_conv = (LDKSocketDescriptor*)(((uint64_t)descriptor) & ~1);
17205 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
17206 *ret_conv = PeerManager_write_buffer_space_avail(&this_arg_conv, descriptor_conv);
17207 return (long)ret_conv;
17210 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) {
17211 LDKPeerManager this_arg_conv;
17212 this_arg_conv.inner = (void*)(this_arg & (~1));
17213 this_arg_conv.is_owned = false;
17214 LDKSocketDescriptor* peer_descriptor_conv = (LDKSocketDescriptor*)(((uint64_t)peer_descriptor) & ~1);
17215 LDKu8slice data_ref;
17216 data_ref.datalen = (*env)->GetArrayLength(env, data);
17217 data_ref.data = (*env)->GetByteArrayElements (env, data, NULL);
17218 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
17219 *ret_conv = PeerManager_read_event(&this_arg_conv, peer_descriptor_conv, data_ref);
17220 (*env)->ReleaseByteArrayElements(env, data, (int8_t*)data_ref.data, 0);
17221 return (long)ret_conv;
17224 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_PeerManager_1process_1events(JNIEnv *env, jclass clz, int64_t this_arg) {
17225 LDKPeerManager this_arg_conv;
17226 this_arg_conv.inner = (void*)(this_arg & (~1));
17227 this_arg_conv.is_owned = false;
17228 PeerManager_process_events(&this_arg_conv);
17231 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_PeerManager_1socket_1disconnected(JNIEnv *env, jclass clz, int64_t this_arg, int64_t descriptor) {
17232 LDKPeerManager this_arg_conv;
17233 this_arg_conv.inner = (void*)(this_arg & (~1));
17234 this_arg_conv.is_owned = false;
17235 LDKSocketDescriptor* descriptor_conv = (LDKSocketDescriptor*)(((uint64_t)descriptor) & ~1);
17236 PeerManager_socket_disconnected(&this_arg_conv, descriptor_conv);
17239 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) {
17240 LDKPeerManager this_arg_conv;
17241 this_arg_conv.inner = (void*)(this_arg & (~1));
17242 this_arg_conv.is_owned = false;
17243 LDKPublicKey node_id_ref;
17244 CHECK((*env)->GetArrayLength(env, node_id) == 33);
17245 (*env)->GetByteArrayRegion(env, node_id, 0, 33, node_id_ref.compressed_form);
17246 PeerManager_disconnect_by_node_id(&this_arg_conv, node_id_ref, no_connection_possible);
17249 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_PeerManager_1timer_1tick_1occured(JNIEnv *env, jclass clz, int64_t this_arg) {
17250 LDKPeerManager this_arg_conv;
17251 this_arg_conv.inner = (void*)(this_arg & (~1));
17252 this_arg_conv.is_owned = false;
17253 PeerManager_timer_tick_occured(&this_arg_conv);
17256 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_build_1commitment_1secret(JNIEnv *env, jclass clz, int8_tArray commitment_seed, int64_t idx) {
17257 unsigned char commitment_seed_arr[32];
17258 CHECK((*env)->GetArrayLength(env, commitment_seed) == 32);
17259 (*env)->GetByteArrayRegion(env, commitment_seed, 0, 32, commitment_seed_arr);
17260 unsigned char (*commitment_seed_ref)[32] = &commitment_seed_arr;
17261 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
17262 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, build_commitment_secret(commitment_seed_ref, idx).data);
17266 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) {
17267 LDKPublicKey per_commitment_point_ref;
17268 CHECK((*env)->GetArrayLength(env, per_commitment_point) == 33);
17269 (*env)->GetByteArrayRegion(env, per_commitment_point, 0, 33, per_commitment_point_ref.compressed_form);
17270 unsigned char base_secret_arr[32];
17271 CHECK((*env)->GetArrayLength(env, base_secret) == 32);
17272 (*env)->GetByteArrayRegion(env, base_secret, 0, 32, base_secret_arr);
17273 unsigned char (*base_secret_ref)[32] = &base_secret_arr;
17274 LDKCResult_SecretKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SecretKeyErrorZ), "LDKCResult_SecretKeyErrorZ");
17275 *ret_conv = derive_private_key(per_commitment_point_ref, base_secret_ref);
17276 return (long)ret_conv;
17279 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) {
17280 LDKPublicKey per_commitment_point_ref;
17281 CHECK((*env)->GetArrayLength(env, per_commitment_point) == 33);
17282 (*env)->GetByteArrayRegion(env, per_commitment_point, 0, 33, per_commitment_point_ref.compressed_form);
17283 LDKPublicKey base_point_ref;
17284 CHECK((*env)->GetArrayLength(env, base_point) == 33);
17285 (*env)->GetByteArrayRegion(env, base_point, 0, 33, base_point_ref.compressed_form);
17286 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
17287 *ret_conv = derive_public_key(per_commitment_point_ref, base_point_ref);
17288 return (long)ret_conv;
17291 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) {
17292 unsigned char per_commitment_secret_arr[32];
17293 CHECK((*env)->GetArrayLength(env, per_commitment_secret) == 32);
17294 (*env)->GetByteArrayRegion(env, per_commitment_secret, 0, 32, per_commitment_secret_arr);
17295 unsigned char (*per_commitment_secret_ref)[32] = &per_commitment_secret_arr;
17296 unsigned char countersignatory_revocation_base_secret_arr[32];
17297 CHECK((*env)->GetArrayLength(env, countersignatory_revocation_base_secret) == 32);
17298 (*env)->GetByteArrayRegion(env, countersignatory_revocation_base_secret, 0, 32, countersignatory_revocation_base_secret_arr);
17299 unsigned char (*countersignatory_revocation_base_secret_ref)[32] = &countersignatory_revocation_base_secret_arr;
17300 LDKCResult_SecretKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SecretKeyErrorZ), "LDKCResult_SecretKeyErrorZ");
17301 *ret_conv = derive_private_revocation_key(per_commitment_secret_ref, countersignatory_revocation_base_secret_ref);
17302 return (long)ret_conv;
17305 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) {
17306 LDKPublicKey per_commitment_point_ref;
17307 CHECK((*env)->GetArrayLength(env, per_commitment_point) == 33);
17308 (*env)->GetByteArrayRegion(env, per_commitment_point, 0, 33, per_commitment_point_ref.compressed_form);
17309 LDKPublicKey countersignatory_revocation_base_point_ref;
17310 CHECK((*env)->GetArrayLength(env, countersignatory_revocation_base_point) == 33);
17311 (*env)->GetByteArrayRegion(env, countersignatory_revocation_base_point, 0, 33, countersignatory_revocation_base_point_ref.compressed_form);
17312 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
17313 *ret_conv = derive_public_revocation_key(per_commitment_point_ref, countersignatory_revocation_base_point_ref);
17314 return (long)ret_conv;
17317 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
17318 LDKTxCreationKeys this_obj_conv;
17319 this_obj_conv.inner = (void*)(this_obj & (~1));
17320 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
17321 TxCreationKeys_free(this_obj_conv);
17324 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1get_1per_1commitment_1point(JNIEnv *env, jclass clz, int64_t this_ptr) {
17325 LDKTxCreationKeys this_ptr_conv;
17326 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17327 this_ptr_conv.is_owned = false;
17328 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
17329 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, TxCreationKeys_get_per_commitment_point(&this_ptr_conv).compressed_form);
17333 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1set_1per_1commitment_1point(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17334 LDKTxCreationKeys this_ptr_conv;
17335 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17336 this_ptr_conv.is_owned = false;
17337 LDKPublicKey val_ref;
17338 CHECK((*env)->GetArrayLength(env, val) == 33);
17339 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
17340 TxCreationKeys_set_per_commitment_point(&this_ptr_conv, val_ref);
17343 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1get_1revocation_1key(JNIEnv *env, jclass clz, int64_t this_ptr) {
17344 LDKTxCreationKeys this_ptr_conv;
17345 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17346 this_ptr_conv.is_owned = false;
17347 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
17348 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, TxCreationKeys_get_revocation_key(&this_ptr_conv).compressed_form);
17352 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1set_1revocation_1key(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17353 LDKTxCreationKeys this_ptr_conv;
17354 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17355 this_ptr_conv.is_owned = false;
17356 LDKPublicKey val_ref;
17357 CHECK((*env)->GetArrayLength(env, val) == 33);
17358 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
17359 TxCreationKeys_set_revocation_key(&this_ptr_conv, val_ref);
17362 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1get_1broadcaster_1htlc_1key(JNIEnv *env, jclass clz, int64_t this_ptr) {
17363 LDKTxCreationKeys this_ptr_conv;
17364 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17365 this_ptr_conv.is_owned = false;
17366 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
17367 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, TxCreationKeys_get_broadcaster_htlc_key(&this_ptr_conv).compressed_form);
17371 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1set_1broadcaster_1htlc_1key(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17372 LDKTxCreationKeys this_ptr_conv;
17373 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17374 this_ptr_conv.is_owned = false;
17375 LDKPublicKey val_ref;
17376 CHECK((*env)->GetArrayLength(env, val) == 33);
17377 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
17378 TxCreationKeys_set_broadcaster_htlc_key(&this_ptr_conv, val_ref);
17381 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1get_1countersignatory_1htlc_1key(JNIEnv *env, jclass clz, int64_t this_ptr) {
17382 LDKTxCreationKeys this_ptr_conv;
17383 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17384 this_ptr_conv.is_owned = false;
17385 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
17386 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, TxCreationKeys_get_countersignatory_htlc_key(&this_ptr_conv).compressed_form);
17390 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1set_1countersignatory_1htlc_1key(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17391 LDKTxCreationKeys this_ptr_conv;
17392 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17393 this_ptr_conv.is_owned = false;
17394 LDKPublicKey val_ref;
17395 CHECK((*env)->GetArrayLength(env, val) == 33);
17396 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
17397 TxCreationKeys_set_countersignatory_htlc_key(&this_ptr_conv, val_ref);
17400 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1get_1broadcaster_1delayed_1payment_1key(JNIEnv *env, jclass clz, int64_t this_ptr) {
17401 LDKTxCreationKeys this_ptr_conv;
17402 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17403 this_ptr_conv.is_owned = false;
17404 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
17405 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, TxCreationKeys_get_broadcaster_delayed_payment_key(&this_ptr_conv).compressed_form);
17409 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) {
17410 LDKTxCreationKeys this_ptr_conv;
17411 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17412 this_ptr_conv.is_owned = false;
17413 LDKPublicKey val_ref;
17414 CHECK((*env)->GetArrayLength(env, val) == 33);
17415 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
17416 TxCreationKeys_set_broadcaster_delayed_payment_key(&this_ptr_conv, val_ref);
17419 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) {
17420 LDKPublicKey per_commitment_point_arg_ref;
17421 CHECK((*env)->GetArrayLength(env, per_commitment_point_arg) == 33);
17422 (*env)->GetByteArrayRegion(env, per_commitment_point_arg, 0, 33, per_commitment_point_arg_ref.compressed_form);
17423 LDKPublicKey revocation_key_arg_ref;
17424 CHECK((*env)->GetArrayLength(env, revocation_key_arg) == 33);
17425 (*env)->GetByteArrayRegion(env, revocation_key_arg, 0, 33, revocation_key_arg_ref.compressed_form);
17426 LDKPublicKey broadcaster_htlc_key_arg_ref;
17427 CHECK((*env)->GetArrayLength(env, broadcaster_htlc_key_arg) == 33);
17428 (*env)->GetByteArrayRegion(env, broadcaster_htlc_key_arg, 0, 33, broadcaster_htlc_key_arg_ref.compressed_form);
17429 LDKPublicKey countersignatory_htlc_key_arg_ref;
17430 CHECK((*env)->GetArrayLength(env, countersignatory_htlc_key_arg) == 33);
17431 (*env)->GetByteArrayRegion(env, countersignatory_htlc_key_arg, 0, 33, countersignatory_htlc_key_arg_ref.compressed_form);
17432 LDKPublicKey broadcaster_delayed_payment_key_arg_ref;
17433 CHECK((*env)->GetArrayLength(env, broadcaster_delayed_payment_key_arg) == 33);
17434 (*env)->GetByteArrayRegion(env, broadcaster_delayed_payment_key_arg, 0, 33, broadcaster_delayed_payment_key_arg_ref.compressed_form);
17435 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);
17436 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17437 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17438 long ret_ref = (long)ret_var.inner;
17439 if (ret_var.is_owned) {
17445 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1clone(JNIEnv *env, jclass clz, int64_t orig) {
17446 LDKTxCreationKeys orig_conv;
17447 orig_conv.inner = (void*)(orig & (~1));
17448 orig_conv.is_owned = false;
17449 LDKTxCreationKeys ret_var = TxCreationKeys_clone(&orig_conv);
17450 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17451 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17452 long ret_ref = (long)ret_var.inner;
17453 if (ret_var.is_owned) {
17459 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1write(JNIEnv *env, jclass clz, int64_t obj) {
17460 LDKTxCreationKeys obj_conv;
17461 obj_conv.inner = (void*)(obj & (~1));
17462 obj_conv.is_owned = false;
17463 LDKCVec_u8Z ret_var = TxCreationKeys_write(&obj_conv);
17464 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
17465 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
17466 CVec_u8Z_free(ret_var);
17470 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
17471 LDKu8slice ser_ref;
17472 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
17473 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
17474 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
17475 *ret_conv = TxCreationKeys_read(ser_ref);
17476 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
17477 return (long)ret_conv;
17480 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
17481 LDKChannelPublicKeys this_obj_conv;
17482 this_obj_conv.inner = (void*)(this_obj & (~1));
17483 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
17484 ChannelPublicKeys_free(this_obj_conv);
17487 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1get_1funding_1pubkey(JNIEnv *env, jclass clz, int64_t this_ptr) {
17488 LDKChannelPublicKeys this_ptr_conv;
17489 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17490 this_ptr_conv.is_owned = false;
17491 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
17492 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ChannelPublicKeys_get_funding_pubkey(&this_ptr_conv).compressed_form);
17496 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1set_1funding_1pubkey(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17497 LDKChannelPublicKeys this_ptr_conv;
17498 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17499 this_ptr_conv.is_owned = false;
17500 LDKPublicKey val_ref;
17501 CHECK((*env)->GetArrayLength(env, val) == 33);
17502 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
17503 ChannelPublicKeys_set_funding_pubkey(&this_ptr_conv, val_ref);
17506 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1get_1revocation_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr) {
17507 LDKChannelPublicKeys this_ptr_conv;
17508 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17509 this_ptr_conv.is_owned = false;
17510 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
17511 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ChannelPublicKeys_get_revocation_basepoint(&this_ptr_conv).compressed_form);
17515 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1set_1revocation_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17516 LDKChannelPublicKeys this_ptr_conv;
17517 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17518 this_ptr_conv.is_owned = false;
17519 LDKPublicKey val_ref;
17520 CHECK((*env)->GetArrayLength(env, val) == 33);
17521 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
17522 ChannelPublicKeys_set_revocation_basepoint(&this_ptr_conv, val_ref);
17525 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1get_1payment_1point(JNIEnv *env, jclass clz, int64_t this_ptr) {
17526 LDKChannelPublicKeys this_ptr_conv;
17527 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17528 this_ptr_conv.is_owned = false;
17529 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
17530 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ChannelPublicKeys_get_payment_point(&this_ptr_conv).compressed_form);
17534 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1set_1payment_1point(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17535 LDKChannelPublicKeys this_ptr_conv;
17536 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17537 this_ptr_conv.is_owned = false;
17538 LDKPublicKey val_ref;
17539 CHECK((*env)->GetArrayLength(env, val) == 33);
17540 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
17541 ChannelPublicKeys_set_payment_point(&this_ptr_conv, val_ref);
17544 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1get_1delayed_1payment_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr) {
17545 LDKChannelPublicKeys this_ptr_conv;
17546 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17547 this_ptr_conv.is_owned = false;
17548 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
17549 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ChannelPublicKeys_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form);
17553 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1set_1delayed_1payment_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17554 LDKChannelPublicKeys this_ptr_conv;
17555 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17556 this_ptr_conv.is_owned = false;
17557 LDKPublicKey val_ref;
17558 CHECK((*env)->GetArrayLength(env, val) == 33);
17559 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
17560 ChannelPublicKeys_set_delayed_payment_basepoint(&this_ptr_conv, val_ref);
17563 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1get_1htlc_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr) {
17564 LDKChannelPublicKeys this_ptr_conv;
17565 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17566 this_ptr_conv.is_owned = false;
17567 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
17568 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ChannelPublicKeys_get_htlc_basepoint(&this_ptr_conv).compressed_form);
17572 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1set_1htlc_1basepoint(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17573 LDKChannelPublicKeys this_ptr_conv;
17574 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17575 this_ptr_conv.is_owned = false;
17576 LDKPublicKey val_ref;
17577 CHECK((*env)->GetArrayLength(env, val) == 33);
17578 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
17579 ChannelPublicKeys_set_htlc_basepoint(&this_ptr_conv, val_ref);
17582 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) {
17583 LDKPublicKey funding_pubkey_arg_ref;
17584 CHECK((*env)->GetArrayLength(env, funding_pubkey_arg) == 33);
17585 (*env)->GetByteArrayRegion(env, funding_pubkey_arg, 0, 33, funding_pubkey_arg_ref.compressed_form);
17586 LDKPublicKey revocation_basepoint_arg_ref;
17587 CHECK((*env)->GetArrayLength(env, revocation_basepoint_arg) == 33);
17588 (*env)->GetByteArrayRegion(env, revocation_basepoint_arg, 0, 33, revocation_basepoint_arg_ref.compressed_form);
17589 LDKPublicKey payment_point_arg_ref;
17590 CHECK((*env)->GetArrayLength(env, payment_point_arg) == 33);
17591 (*env)->GetByteArrayRegion(env, payment_point_arg, 0, 33, payment_point_arg_ref.compressed_form);
17592 LDKPublicKey delayed_payment_basepoint_arg_ref;
17593 CHECK((*env)->GetArrayLength(env, delayed_payment_basepoint_arg) == 33);
17594 (*env)->GetByteArrayRegion(env, delayed_payment_basepoint_arg, 0, 33, delayed_payment_basepoint_arg_ref.compressed_form);
17595 LDKPublicKey htlc_basepoint_arg_ref;
17596 CHECK((*env)->GetArrayLength(env, htlc_basepoint_arg) == 33);
17597 (*env)->GetByteArrayRegion(env, htlc_basepoint_arg, 0, 33, htlc_basepoint_arg_ref.compressed_form);
17598 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);
17599 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17600 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17601 long ret_ref = (long)ret_var.inner;
17602 if (ret_var.is_owned) {
17608 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1clone(JNIEnv *env, jclass clz, int64_t orig) {
17609 LDKChannelPublicKeys orig_conv;
17610 orig_conv.inner = (void*)(orig & (~1));
17611 orig_conv.is_owned = false;
17612 LDKChannelPublicKeys ret_var = ChannelPublicKeys_clone(&orig_conv);
17613 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17614 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17615 long ret_ref = (long)ret_var.inner;
17616 if (ret_var.is_owned) {
17622 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1write(JNIEnv *env, jclass clz, int64_t obj) {
17623 LDKChannelPublicKeys obj_conv;
17624 obj_conv.inner = (void*)(obj & (~1));
17625 obj_conv.is_owned = false;
17626 LDKCVec_u8Z ret_var = ChannelPublicKeys_write(&obj_conv);
17627 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
17628 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
17629 CVec_u8Z_free(ret_var);
17633 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
17634 LDKu8slice ser_ref;
17635 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
17636 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
17637 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
17638 *ret_conv = ChannelPublicKeys_read(ser_ref);
17639 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
17640 return (long)ret_conv;
17643 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) {
17644 LDKPublicKey per_commitment_point_ref;
17645 CHECK((*env)->GetArrayLength(env, per_commitment_point) == 33);
17646 (*env)->GetByteArrayRegion(env, per_commitment_point, 0, 33, per_commitment_point_ref.compressed_form);
17647 LDKPublicKey broadcaster_delayed_payment_base_ref;
17648 CHECK((*env)->GetArrayLength(env, broadcaster_delayed_payment_base) == 33);
17649 (*env)->GetByteArrayRegion(env, broadcaster_delayed_payment_base, 0, 33, broadcaster_delayed_payment_base_ref.compressed_form);
17650 LDKPublicKey broadcaster_htlc_base_ref;
17651 CHECK((*env)->GetArrayLength(env, broadcaster_htlc_base) == 33);
17652 (*env)->GetByteArrayRegion(env, broadcaster_htlc_base, 0, 33, broadcaster_htlc_base_ref.compressed_form);
17653 LDKPublicKey countersignatory_revocation_base_ref;
17654 CHECK((*env)->GetArrayLength(env, countersignatory_revocation_base) == 33);
17655 (*env)->GetByteArrayRegion(env, countersignatory_revocation_base, 0, 33, countersignatory_revocation_base_ref.compressed_form);
17656 LDKPublicKey countersignatory_htlc_base_ref;
17657 CHECK((*env)->GetArrayLength(env, countersignatory_htlc_base) == 33);
17658 (*env)->GetByteArrayRegion(env, countersignatory_htlc_base, 0, 33, countersignatory_htlc_base_ref.compressed_form);
17659 LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
17660 *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);
17661 return (long)ret_conv;
17664 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) {
17665 LDKPublicKey per_commitment_point_ref;
17666 CHECK((*env)->GetArrayLength(env, per_commitment_point) == 33);
17667 (*env)->GetByteArrayRegion(env, per_commitment_point, 0, 33, per_commitment_point_ref.compressed_form);
17668 LDKChannelPublicKeys broadcaster_keys_conv;
17669 broadcaster_keys_conv.inner = (void*)(broadcaster_keys & (~1));
17670 broadcaster_keys_conv.is_owned = false;
17671 LDKChannelPublicKeys countersignatory_keys_conv;
17672 countersignatory_keys_conv.inner = (void*)(countersignatory_keys & (~1));
17673 countersignatory_keys_conv.is_owned = false;
17674 LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
17675 *ret_conv = TxCreationKeys_from_channel_static_keys(per_commitment_point_ref, &broadcaster_keys_conv, &countersignatory_keys_conv);
17676 return (long)ret_conv;
17679 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) {
17680 LDKPublicKey revocation_key_ref;
17681 CHECK((*env)->GetArrayLength(env, revocation_key) == 33);
17682 (*env)->GetByteArrayRegion(env, revocation_key, 0, 33, revocation_key_ref.compressed_form);
17683 LDKPublicKey broadcaster_delayed_payment_key_ref;
17684 CHECK((*env)->GetArrayLength(env, broadcaster_delayed_payment_key) == 33);
17685 (*env)->GetByteArrayRegion(env, broadcaster_delayed_payment_key, 0, 33, broadcaster_delayed_payment_key_ref.compressed_form);
17686 LDKCVec_u8Z ret_var = get_revokeable_redeemscript(revocation_key_ref, contest_delay, broadcaster_delayed_payment_key_ref);
17687 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
17688 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
17689 CVec_u8Z_free(ret_var);
17693 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_HTLCOutputInCommitment_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
17694 LDKHTLCOutputInCommitment this_obj_conv;
17695 this_obj_conv.inner = (void*)(this_obj & (~1));
17696 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
17697 HTLCOutputInCommitment_free(this_obj_conv);
17700 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_HTLCOutputInCommitment_1get_1offered(JNIEnv *env, jclass clz, int64_t this_ptr) {
17701 LDKHTLCOutputInCommitment this_ptr_conv;
17702 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17703 this_ptr_conv.is_owned = false;
17704 jboolean ret_val = HTLCOutputInCommitment_get_offered(&this_ptr_conv);
17708 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_HTLCOutputInCommitment_1set_1offered(JNIEnv *env, jclass clz, int64_t this_ptr, jboolean val) {
17709 LDKHTLCOutputInCommitment this_ptr_conv;
17710 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17711 this_ptr_conv.is_owned = false;
17712 HTLCOutputInCommitment_set_offered(&this_ptr_conv, val);
17715 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_HTLCOutputInCommitment_1get_1amount_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
17716 LDKHTLCOutputInCommitment this_ptr_conv;
17717 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17718 this_ptr_conv.is_owned = false;
17719 int64_t ret_val = HTLCOutputInCommitment_get_amount_msat(&this_ptr_conv);
17723 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_HTLCOutputInCommitment_1set_1amount_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
17724 LDKHTLCOutputInCommitment this_ptr_conv;
17725 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17726 this_ptr_conv.is_owned = false;
17727 HTLCOutputInCommitment_set_amount_msat(&this_ptr_conv, val);
17730 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_HTLCOutputInCommitment_1get_1cltv_1expiry(JNIEnv *env, jclass clz, int64_t this_ptr) {
17731 LDKHTLCOutputInCommitment this_ptr_conv;
17732 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17733 this_ptr_conv.is_owned = false;
17734 int32_t ret_val = HTLCOutputInCommitment_get_cltv_expiry(&this_ptr_conv);
17738 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_HTLCOutputInCommitment_1set_1cltv_1expiry(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
17739 LDKHTLCOutputInCommitment this_ptr_conv;
17740 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17741 this_ptr_conv.is_owned = false;
17742 HTLCOutputInCommitment_set_cltv_expiry(&this_ptr_conv, val);
17745 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_HTLCOutputInCommitment_1get_1payment_1hash(JNIEnv *env, jclass clz, int64_t this_ptr) {
17746 LDKHTLCOutputInCommitment this_ptr_conv;
17747 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17748 this_ptr_conv.is_owned = false;
17749 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
17750 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *HTLCOutputInCommitment_get_payment_hash(&this_ptr_conv));
17754 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_HTLCOutputInCommitment_1set_1payment_1hash(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
17755 LDKHTLCOutputInCommitment this_ptr_conv;
17756 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17757 this_ptr_conv.is_owned = false;
17758 LDKThirtyTwoBytes val_ref;
17759 CHECK((*env)->GetArrayLength(env, val) == 32);
17760 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
17761 HTLCOutputInCommitment_set_payment_hash(&this_ptr_conv, val_ref);
17764 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_HTLCOutputInCommitment_1clone(JNIEnv *env, jclass clz, int64_t orig) {
17765 LDKHTLCOutputInCommitment orig_conv;
17766 orig_conv.inner = (void*)(orig & (~1));
17767 orig_conv.is_owned = false;
17768 LDKHTLCOutputInCommitment ret_var = HTLCOutputInCommitment_clone(&orig_conv);
17769 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17770 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17771 long ret_ref = (long)ret_var.inner;
17772 if (ret_var.is_owned) {
17778 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_HTLCOutputInCommitment_1write(JNIEnv *env, jclass clz, int64_t obj) {
17779 LDKHTLCOutputInCommitment obj_conv;
17780 obj_conv.inner = (void*)(obj & (~1));
17781 obj_conv.is_owned = false;
17782 LDKCVec_u8Z ret_var = HTLCOutputInCommitment_write(&obj_conv);
17783 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
17784 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
17785 CVec_u8Z_free(ret_var);
17789 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_HTLCOutputInCommitment_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
17790 LDKu8slice ser_ref;
17791 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
17792 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
17793 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
17794 *ret_conv = HTLCOutputInCommitment_read(ser_ref);
17795 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
17796 return (long)ret_conv;
17799 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_get_1htlc_1redeemscript(JNIEnv *env, jclass clz, int64_t htlc, int64_t keys) {
17800 LDKHTLCOutputInCommitment htlc_conv;
17801 htlc_conv.inner = (void*)(htlc & (~1));
17802 htlc_conv.is_owned = false;
17803 LDKTxCreationKeys keys_conv;
17804 keys_conv.inner = (void*)(keys & (~1));
17805 keys_conv.is_owned = false;
17806 LDKCVec_u8Z ret_var = get_htlc_redeemscript(&htlc_conv, &keys_conv);
17807 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
17808 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
17809 CVec_u8Z_free(ret_var);
17813 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_make_1funding_1redeemscript(JNIEnv *env, jclass clz, int8_tArray broadcaster, int8_tArray countersignatory) {
17814 LDKPublicKey broadcaster_ref;
17815 CHECK((*env)->GetArrayLength(env, broadcaster) == 33);
17816 (*env)->GetByteArrayRegion(env, broadcaster, 0, 33, broadcaster_ref.compressed_form);
17817 LDKPublicKey countersignatory_ref;
17818 CHECK((*env)->GetArrayLength(env, countersignatory) == 33);
17819 (*env)->GetByteArrayRegion(env, countersignatory, 0, 33, countersignatory_ref.compressed_form);
17820 LDKCVec_u8Z ret_var = make_funding_redeemscript(broadcaster_ref, countersignatory_ref);
17821 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
17822 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
17823 CVec_u8Z_free(ret_var);
17827 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_build_1htlc_1transaction(JNIEnv *env, jclass clz, int8_tArray prev_hash, int32_t feerate_per_kw, int16_t contest_delay, int64_t htlc, int8_tArray broadcaster_delayed_payment_key, int8_tArray revocation_key) {
17828 unsigned char prev_hash_arr[32];
17829 CHECK((*env)->GetArrayLength(env, prev_hash) == 32);
17830 (*env)->GetByteArrayRegion(env, prev_hash, 0, 32, prev_hash_arr);
17831 unsigned char (*prev_hash_ref)[32] = &prev_hash_arr;
17832 LDKHTLCOutputInCommitment htlc_conv;
17833 htlc_conv.inner = (void*)(htlc & (~1));
17834 htlc_conv.is_owned = false;
17835 LDKPublicKey broadcaster_delayed_payment_key_ref;
17836 CHECK((*env)->GetArrayLength(env, broadcaster_delayed_payment_key) == 33);
17837 (*env)->GetByteArrayRegion(env, broadcaster_delayed_payment_key, 0, 33, broadcaster_delayed_payment_key_ref.compressed_form);
17838 LDKPublicKey revocation_key_ref;
17839 CHECK((*env)->GetArrayLength(env, revocation_key) == 33);
17840 (*env)->GetByteArrayRegion(env, revocation_key, 0, 33, revocation_key_ref.compressed_form);
17841 LDKTransaction ret_var = build_htlc_transaction(prev_hash_ref, feerate_per_kw, contest_delay, &htlc_conv, broadcaster_delayed_payment_key_ref, revocation_key_ref);
17842 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
17843 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
17844 Transaction_free(ret_var);
17848 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
17849 LDKChannelTransactionParameters this_obj_conv;
17850 this_obj_conv.inner = (void*)(this_obj & (~1));
17851 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
17852 ChannelTransactionParameters_free(this_obj_conv);
17855 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1get_1holder_1pubkeys(JNIEnv *env, jclass clz, int64_t this_ptr) {
17856 LDKChannelTransactionParameters this_ptr_conv;
17857 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17858 this_ptr_conv.is_owned = false;
17859 LDKChannelPublicKeys ret_var = ChannelTransactionParameters_get_holder_pubkeys(&this_ptr_conv);
17860 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17861 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17862 long ret_ref = (long)ret_var.inner;
17863 if (ret_var.is_owned) {
17869 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1set_1holder_1pubkeys(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
17870 LDKChannelTransactionParameters this_ptr_conv;
17871 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17872 this_ptr_conv.is_owned = false;
17873 LDKChannelPublicKeys val_conv;
17874 val_conv.inner = (void*)(val & (~1));
17875 val_conv.is_owned = (val & 1) || (val == 0);
17876 val_conv = ChannelPublicKeys_clone(&val_conv);
17877 ChannelTransactionParameters_set_holder_pubkeys(&this_ptr_conv, val_conv);
17880 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1get_1holder_1selected_1contest_1delay(JNIEnv *env, jclass clz, int64_t this_ptr) {
17881 LDKChannelTransactionParameters this_ptr_conv;
17882 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17883 this_ptr_conv.is_owned = false;
17884 int16_t ret_val = ChannelTransactionParameters_get_holder_selected_contest_delay(&this_ptr_conv);
17888 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) {
17889 LDKChannelTransactionParameters this_ptr_conv;
17890 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17891 this_ptr_conv.is_owned = false;
17892 ChannelTransactionParameters_set_holder_selected_contest_delay(&this_ptr_conv, val);
17895 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1get_1is_1outbound_1from_1holder(JNIEnv *env, jclass clz, int64_t this_ptr) {
17896 LDKChannelTransactionParameters this_ptr_conv;
17897 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17898 this_ptr_conv.is_owned = false;
17899 jboolean ret_val = ChannelTransactionParameters_get_is_outbound_from_holder(&this_ptr_conv);
17903 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1set_1is_1outbound_1from_1holder(JNIEnv *env, jclass clz, int64_t this_ptr, jboolean val) {
17904 LDKChannelTransactionParameters this_ptr_conv;
17905 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17906 this_ptr_conv.is_owned = false;
17907 ChannelTransactionParameters_set_is_outbound_from_holder(&this_ptr_conv, val);
17910 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1get_1counterparty_1parameters(JNIEnv *env, jclass clz, int64_t this_ptr) {
17911 LDKChannelTransactionParameters this_ptr_conv;
17912 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17913 this_ptr_conv.is_owned = false;
17914 LDKCounterpartyChannelTransactionParameters ret_var = ChannelTransactionParameters_get_counterparty_parameters(&this_ptr_conv);
17915 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17916 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17917 long ret_ref = (long)ret_var.inner;
17918 if (ret_var.is_owned) {
17924 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1set_1counterparty_1parameters(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
17925 LDKChannelTransactionParameters this_ptr_conv;
17926 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17927 this_ptr_conv.is_owned = false;
17928 LDKCounterpartyChannelTransactionParameters val_conv;
17929 val_conv.inner = (void*)(val & (~1));
17930 val_conv.is_owned = (val & 1) || (val == 0);
17931 val_conv = CounterpartyChannelTransactionParameters_clone(&val_conv);
17932 ChannelTransactionParameters_set_counterparty_parameters(&this_ptr_conv, val_conv);
17935 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1get_1funding_1outpoint(JNIEnv *env, jclass clz, int64_t this_ptr) {
17936 LDKChannelTransactionParameters this_ptr_conv;
17937 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17938 this_ptr_conv.is_owned = false;
17939 LDKOutPoint ret_var = ChannelTransactionParameters_get_funding_outpoint(&this_ptr_conv);
17940 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17941 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17942 long ret_ref = (long)ret_var.inner;
17943 if (ret_var.is_owned) {
17949 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1set_1funding_1outpoint(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
17950 LDKChannelTransactionParameters this_ptr_conv;
17951 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17952 this_ptr_conv.is_owned = false;
17953 LDKOutPoint val_conv;
17954 val_conv.inner = (void*)(val & (~1));
17955 val_conv.is_owned = (val & 1) || (val == 0);
17956 val_conv = OutPoint_clone(&val_conv);
17957 ChannelTransactionParameters_set_funding_outpoint(&this_ptr_conv, val_conv);
17960 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) {
17961 LDKChannelPublicKeys holder_pubkeys_arg_conv;
17962 holder_pubkeys_arg_conv.inner = (void*)(holder_pubkeys_arg & (~1));
17963 holder_pubkeys_arg_conv.is_owned = (holder_pubkeys_arg & 1) || (holder_pubkeys_arg == 0);
17964 holder_pubkeys_arg_conv = ChannelPublicKeys_clone(&holder_pubkeys_arg_conv);
17965 LDKCounterpartyChannelTransactionParameters counterparty_parameters_arg_conv;
17966 counterparty_parameters_arg_conv.inner = (void*)(counterparty_parameters_arg & (~1));
17967 counterparty_parameters_arg_conv.is_owned = (counterparty_parameters_arg & 1) || (counterparty_parameters_arg == 0);
17968 counterparty_parameters_arg_conv = CounterpartyChannelTransactionParameters_clone(&counterparty_parameters_arg_conv);
17969 LDKOutPoint funding_outpoint_arg_conv;
17970 funding_outpoint_arg_conv.inner = (void*)(funding_outpoint_arg & (~1));
17971 funding_outpoint_arg_conv.is_owned = (funding_outpoint_arg & 1) || (funding_outpoint_arg == 0);
17972 funding_outpoint_arg_conv = OutPoint_clone(&funding_outpoint_arg_conv);
17973 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);
17974 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17975 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17976 long ret_ref = (long)ret_var.inner;
17977 if (ret_var.is_owned) {
17983 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1clone(JNIEnv *env, jclass clz, int64_t orig) {
17984 LDKChannelTransactionParameters orig_conv;
17985 orig_conv.inner = (void*)(orig & (~1));
17986 orig_conv.is_owned = false;
17987 LDKChannelTransactionParameters ret_var = ChannelTransactionParameters_clone(&orig_conv);
17988 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17989 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17990 long ret_ref = (long)ret_var.inner;
17991 if (ret_var.is_owned) {
17997 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CounterpartyChannelTransactionParameters_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
17998 LDKCounterpartyChannelTransactionParameters this_obj_conv;
17999 this_obj_conv.inner = (void*)(this_obj & (~1));
18000 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
18001 CounterpartyChannelTransactionParameters_free(this_obj_conv);
18004 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CounterpartyChannelTransactionParameters_1get_1pubkeys(JNIEnv *env, jclass clz, int64_t this_ptr) {
18005 LDKCounterpartyChannelTransactionParameters this_ptr_conv;
18006 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18007 this_ptr_conv.is_owned = false;
18008 LDKChannelPublicKeys ret_var = CounterpartyChannelTransactionParameters_get_pubkeys(&this_ptr_conv);
18009 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18010 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18011 long ret_ref = (long)ret_var.inner;
18012 if (ret_var.is_owned) {
18018 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CounterpartyChannelTransactionParameters_1set_1pubkeys(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
18019 LDKCounterpartyChannelTransactionParameters this_ptr_conv;
18020 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18021 this_ptr_conv.is_owned = false;
18022 LDKChannelPublicKeys val_conv;
18023 val_conv.inner = (void*)(val & (~1));
18024 val_conv.is_owned = (val & 1) || (val == 0);
18025 val_conv = ChannelPublicKeys_clone(&val_conv);
18026 CounterpartyChannelTransactionParameters_set_pubkeys(&this_ptr_conv, val_conv);
18029 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_CounterpartyChannelTransactionParameters_1get_1selected_1contest_1delay(JNIEnv *env, jclass clz, int64_t this_ptr) {
18030 LDKCounterpartyChannelTransactionParameters this_ptr_conv;
18031 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18032 this_ptr_conv.is_owned = false;
18033 int16_t ret_val = CounterpartyChannelTransactionParameters_get_selected_contest_delay(&this_ptr_conv);
18037 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CounterpartyChannelTransactionParameters_1set_1selected_1contest_1delay(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
18038 LDKCounterpartyChannelTransactionParameters this_ptr_conv;
18039 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18040 this_ptr_conv.is_owned = false;
18041 CounterpartyChannelTransactionParameters_set_selected_contest_delay(&this_ptr_conv, val);
18044 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) {
18045 LDKChannelPublicKeys pubkeys_arg_conv;
18046 pubkeys_arg_conv.inner = (void*)(pubkeys_arg & (~1));
18047 pubkeys_arg_conv.is_owned = (pubkeys_arg & 1) || (pubkeys_arg == 0);
18048 pubkeys_arg_conv = ChannelPublicKeys_clone(&pubkeys_arg_conv);
18049 LDKCounterpartyChannelTransactionParameters ret_var = CounterpartyChannelTransactionParameters_new(pubkeys_arg_conv, selected_contest_delay_arg);
18050 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18051 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18052 long ret_ref = (long)ret_var.inner;
18053 if (ret_var.is_owned) {
18059 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CounterpartyChannelTransactionParameters_1clone(JNIEnv *env, jclass clz, int64_t orig) {
18060 LDKCounterpartyChannelTransactionParameters orig_conv;
18061 orig_conv.inner = (void*)(orig & (~1));
18062 orig_conv.is_owned = false;
18063 LDKCounterpartyChannelTransactionParameters ret_var = CounterpartyChannelTransactionParameters_clone(&orig_conv);
18064 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18065 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18066 long ret_ref = (long)ret_var.inner;
18067 if (ret_var.is_owned) {
18073 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1is_1populated(JNIEnv *env, jclass clz, int64_t this_arg) {
18074 LDKChannelTransactionParameters this_arg_conv;
18075 this_arg_conv.inner = (void*)(this_arg & (~1));
18076 this_arg_conv.is_owned = false;
18077 jboolean ret_val = ChannelTransactionParameters_is_populated(&this_arg_conv);
18081 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1as_1holder_1broadcastable(JNIEnv *env, jclass clz, int64_t this_arg) {
18082 LDKChannelTransactionParameters this_arg_conv;
18083 this_arg_conv.inner = (void*)(this_arg & (~1));
18084 this_arg_conv.is_owned = false;
18085 LDKDirectedChannelTransactionParameters ret_var = ChannelTransactionParameters_as_holder_broadcastable(&this_arg_conv);
18086 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18087 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18088 long ret_ref = (long)ret_var.inner;
18089 if (ret_var.is_owned) {
18095 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1as_1counterparty_1broadcastable(JNIEnv *env, jclass clz, int64_t this_arg) {
18096 LDKChannelTransactionParameters this_arg_conv;
18097 this_arg_conv.inner = (void*)(this_arg & (~1));
18098 this_arg_conv.is_owned = false;
18099 LDKDirectedChannelTransactionParameters ret_var = ChannelTransactionParameters_as_counterparty_broadcastable(&this_arg_conv);
18100 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18101 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18102 long ret_ref = (long)ret_var.inner;
18103 if (ret_var.is_owned) {
18109 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_CounterpartyChannelTransactionParameters_1write(JNIEnv *env, jclass clz, int64_t obj) {
18110 LDKCounterpartyChannelTransactionParameters obj_conv;
18111 obj_conv.inner = (void*)(obj & (~1));
18112 obj_conv.is_owned = false;
18113 LDKCVec_u8Z ret_var = CounterpartyChannelTransactionParameters_write(&obj_conv);
18114 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
18115 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
18116 CVec_u8Z_free(ret_var);
18120 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CounterpartyChannelTransactionParameters_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
18121 LDKu8slice ser_ref;
18122 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
18123 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
18124 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
18125 *ret_conv = CounterpartyChannelTransactionParameters_read(ser_ref);
18126 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
18127 return (long)ret_conv;
18130 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1write(JNIEnv *env, jclass clz, int64_t obj) {
18131 LDKChannelTransactionParameters obj_conv;
18132 obj_conv.inner = (void*)(obj & (~1));
18133 obj_conv.is_owned = false;
18134 LDKCVec_u8Z ret_var = ChannelTransactionParameters_write(&obj_conv);
18135 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
18136 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
18137 CVec_u8Z_free(ret_var);
18141 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
18142 LDKu8slice ser_ref;
18143 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
18144 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
18145 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
18146 *ret_conv = ChannelTransactionParameters_read(ser_ref);
18147 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
18148 return (long)ret_conv;
18151 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DirectedChannelTransactionParameters_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
18152 LDKDirectedChannelTransactionParameters this_obj_conv;
18153 this_obj_conv.inner = (void*)(this_obj & (~1));
18154 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
18155 DirectedChannelTransactionParameters_free(this_obj_conv);
18158 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DirectedChannelTransactionParameters_1broadcaster_1pubkeys(JNIEnv *env, jclass clz, int64_t this_arg) {
18159 LDKDirectedChannelTransactionParameters this_arg_conv;
18160 this_arg_conv.inner = (void*)(this_arg & (~1));
18161 this_arg_conv.is_owned = false;
18162 LDKChannelPublicKeys ret_var = DirectedChannelTransactionParameters_broadcaster_pubkeys(&this_arg_conv);
18163 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18164 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18165 long ret_ref = (long)ret_var.inner;
18166 if (ret_var.is_owned) {
18172 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DirectedChannelTransactionParameters_1countersignatory_1pubkeys(JNIEnv *env, jclass clz, int64_t this_arg) {
18173 LDKDirectedChannelTransactionParameters this_arg_conv;
18174 this_arg_conv.inner = (void*)(this_arg & (~1));
18175 this_arg_conv.is_owned = false;
18176 LDKChannelPublicKeys ret_var = DirectedChannelTransactionParameters_countersignatory_pubkeys(&this_arg_conv);
18177 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18178 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18179 long ret_ref = (long)ret_var.inner;
18180 if (ret_var.is_owned) {
18186 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_DirectedChannelTransactionParameters_1contest_1delay(JNIEnv *env, jclass clz, int64_t this_arg) {
18187 LDKDirectedChannelTransactionParameters this_arg_conv;
18188 this_arg_conv.inner = (void*)(this_arg & (~1));
18189 this_arg_conv.is_owned = false;
18190 int16_t ret_val = DirectedChannelTransactionParameters_contest_delay(&this_arg_conv);
18194 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_DirectedChannelTransactionParameters_1is_1outbound(JNIEnv *env, jclass clz, int64_t this_arg) {
18195 LDKDirectedChannelTransactionParameters this_arg_conv;
18196 this_arg_conv.inner = (void*)(this_arg & (~1));
18197 this_arg_conv.is_owned = false;
18198 jboolean ret_val = DirectedChannelTransactionParameters_is_outbound(&this_arg_conv);
18202 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DirectedChannelTransactionParameters_1funding_1outpoint(JNIEnv *env, jclass clz, int64_t this_arg) {
18203 LDKDirectedChannelTransactionParameters this_arg_conv;
18204 this_arg_conv.inner = (void*)(this_arg & (~1));
18205 this_arg_conv.is_owned = false;
18206 LDKOutPoint ret_var = DirectedChannelTransactionParameters_funding_outpoint(&this_arg_conv);
18207 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18208 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18209 long ret_ref = (long)ret_var.inner;
18210 if (ret_var.is_owned) {
18216 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_HolderCommitmentTransaction_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
18217 LDKHolderCommitmentTransaction this_obj_conv;
18218 this_obj_conv.inner = (void*)(this_obj & (~1));
18219 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
18220 HolderCommitmentTransaction_free(this_obj_conv);
18223 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_HolderCommitmentTransaction_1get_1counterparty_1sig(JNIEnv *env, jclass clz, int64_t this_ptr) {
18224 LDKHolderCommitmentTransaction this_ptr_conv;
18225 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18226 this_ptr_conv.is_owned = false;
18227 int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
18228 (*env)->SetByteArrayRegion(env, ret_arr, 0, 64, HolderCommitmentTransaction_get_counterparty_sig(&this_ptr_conv).compact_form);
18232 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_HolderCommitmentTransaction_1set_1counterparty_1sig(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
18233 LDKHolderCommitmentTransaction this_ptr_conv;
18234 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18235 this_ptr_conv.is_owned = false;
18236 LDKSignature val_ref;
18237 CHECK((*env)->GetArrayLength(env, val) == 64);
18238 (*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
18239 HolderCommitmentTransaction_set_counterparty_sig(&this_ptr_conv, val_ref);
18242 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_HolderCommitmentTransaction_1set_1counterparty_1htlc_1sigs(JNIEnv *env, jclass clz, int64_t this_ptr, jobjectArray val) {
18243 LDKHolderCommitmentTransaction this_ptr_conv;
18244 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18245 this_ptr_conv.is_owned = false;
18246 LDKCVec_SignatureZ val_constr;
18247 val_constr.datalen = (*env)->GetArrayLength(env, val);
18248 if (val_constr.datalen > 0)
18249 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
18251 val_constr.data = NULL;
18252 for (size_t i = 0; i < val_constr.datalen; i++) {
18253 int8_tArray val_conv_8 = (*env)->GetObjectArrayElement(env, val, i);
18254 LDKSignature val_conv_8_ref;
18255 CHECK((*env)->GetArrayLength(env, val_conv_8) == 64);
18256 (*env)->GetByteArrayRegion(env, val_conv_8, 0, 64, val_conv_8_ref.compact_form);
18257 val_constr.data[i] = val_conv_8_ref;
18259 HolderCommitmentTransaction_set_counterparty_htlc_sigs(&this_ptr_conv, val_constr);
18262 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_HolderCommitmentTransaction_1clone(JNIEnv *env, jclass clz, int64_t orig) {
18263 LDKHolderCommitmentTransaction orig_conv;
18264 orig_conv.inner = (void*)(orig & (~1));
18265 orig_conv.is_owned = false;
18266 LDKHolderCommitmentTransaction ret_var = HolderCommitmentTransaction_clone(&orig_conv);
18267 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18268 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18269 long ret_ref = (long)ret_var.inner;
18270 if (ret_var.is_owned) {
18276 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_HolderCommitmentTransaction_1write(JNIEnv *env, jclass clz, int64_t obj) {
18277 LDKHolderCommitmentTransaction obj_conv;
18278 obj_conv.inner = (void*)(obj & (~1));
18279 obj_conv.is_owned = false;
18280 LDKCVec_u8Z ret_var = HolderCommitmentTransaction_write(&obj_conv);
18281 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
18282 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
18283 CVec_u8Z_free(ret_var);
18287 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_HolderCommitmentTransaction_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
18288 LDKu8slice ser_ref;
18289 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
18290 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
18291 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
18292 *ret_conv = HolderCommitmentTransaction_read(ser_ref);
18293 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
18294 return (long)ret_conv;
18297 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) {
18298 LDKCommitmentTransaction commitment_tx_conv;
18299 commitment_tx_conv.inner = (void*)(commitment_tx & (~1));
18300 commitment_tx_conv.is_owned = (commitment_tx & 1) || (commitment_tx == 0);
18301 commitment_tx_conv = CommitmentTransaction_clone(&commitment_tx_conv);
18302 LDKSignature counterparty_sig_ref;
18303 CHECK((*env)->GetArrayLength(env, counterparty_sig) == 64);
18304 (*env)->GetByteArrayRegion(env, counterparty_sig, 0, 64, counterparty_sig_ref.compact_form);
18305 LDKCVec_SignatureZ counterparty_htlc_sigs_constr;
18306 counterparty_htlc_sigs_constr.datalen = (*env)->GetArrayLength(env, counterparty_htlc_sigs);
18307 if (counterparty_htlc_sigs_constr.datalen > 0)
18308 counterparty_htlc_sigs_constr.data = MALLOC(counterparty_htlc_sigs_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
18310 counterparty_htlc_sigs_constr.data = NULL;
18311 for (size_t i = 0; i < counterparty_htlc_sigs_constr.datalen; i++) {
18312 int8_tArray counterparty_htlc_sigs_conv_8 = (*env)->GetObjectArrayElement(env, counterparty_htlc_sigs, i);
18313 LDKSignature counterparty_htlc_sigs_conv_8_ref;
18314 CHECK((*env)->GetArrayLength(env, counterparty_htlc_sigs_conv_8) == 64);
18315 (*env)->GetByteArrayRegion(env, counterparty_htlc_sigs_conv_8, 0, 64, counterparty_htlc_sigs_conv_8_ref.compact_form);
18316 counterparty_htlc_sigs_constr.data[i] = counterparty_htlc_sigs_conv_8_ref;
18318 LDKPublicKey holder_funding_key_ref;
18319 CHECK((*env)->GetArrayLength(env, holder_funding_key) == 33);
18320 (*env)->GetByteArrayRegion(env, holder_funding_key, 0, 33, holder_funding_key_ref.compressed_form);
18321 LDKPublicKey counterparty_funding_key_ref;
18322 CHECK((*env)->GetArrayLength(env, counterparty_funding_key) == 33);
18323 (*env)->GetByteArrayRegion(env, counterparty_funding_key, 0, 33, counterparty_funding_key_ref.compressed_form);
18324 LDKHolderCommitmentTransaction ret_var = HolderCommitmentTransaction_new(commitment_tx_conv, counterparty_sig_ref, counterparty_htlc_sigs_constr, holder_funding_key_ref, counterparty_funding_key_ref);
18325 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18326 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18327 long ret_ref = (long)ret_var.inner;
18328 if (ret_var.is_owned) {
18334 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_BuiltCommitmentTransaction_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
18335 LDKBuiltCommitmentTransaction this_obj_conv;
18336 this_obj_conv.inner = (void*)(this_obj & (~1));
18337 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
18338 BuiltCommitmentTransaction_free(this_obj_conv);
18341 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_BuiltCommitmentTransaction_1get_1transaction(JNIEnv *env, jclass clz, int64_t this_ptr) {
18342 LDKBuiltCommitmentTransaction this_ptr_conv;
18343 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18344 this_ptr_conv.is_owned = false;
18345 LDKTransaction ret_var = BuiltCommitmentTransaction_get_transaction(&this_ptr_conv);
18346 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
18347 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
18348 Transaction_free(ret_var);
18352 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_BuiltCommitmentTransaction_1set_1transaction(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
18353 LDKBuiltCommitmentTransaction this_ptr_conv;
18354 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18355 this_ptr_conv.is_owned = false;
18356 LDKTransaction val_ref;
18357 val_ref.datalen = (*env)->GetArrayLength(env, val);
18358 val_ref.data = MALLOC(val_ref.datalen, "LDKTransaction Bytes");
18359 (*env)->GetByteArrayRegion(env, val, 0, val_ref.datalen, val_ref.data);
18360 val_ref.data_is_owned = true;
18361 BuiltCommitmentTransaction_set_transaction(&this_ptr_conv, val_ref);
18364 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_BuiltCommitmentTransaction_1get_1txid(JNIEnv *env, jclass clz, int64_t this_ptr) {
18365 LDKBuiltCommitmentTransaction this_ptr_conv;
18366 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18367 this_ptr_conv.is_owned = false;
18368 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
18369 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *BuiltCommitmentTransaction_get_txid(&this_ptr_conv));
18373 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_BuiltCommitmentTransaction_1set_1txid(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
18374 LDKBuiltCommitmentTransaction this_ptr_conv;
18375 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18376 this_ptr_conv.is_owned = false;
18377 LDKThirtyTwoBytes val_ref;
18378 CHECK((*env)->GetArrayLength(env, val) == 32);
18379 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
18380 BuiltCommitmentTransaction_set_txid(&this_ptr_conv, val_ref);
18383 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_BuiltCommitmentTransaction_1new(JNIEnv *env, jclass clz, int8_tArray transaction_arg, int8_tArray txid_arg) {
18384 LDKTransaction transaction_arg_ref;
18385 transaction_arg_ref.datalen = (*env)->GetArrayLength(env, transaction_arg);
18386 transaction_arg_ref.data = MALLOC(transaction_arg_ref.datalen, "LDKTransaction Bytes");
18387 (*env)->GetByteArrayRegion(env, transaction_arg, 0, transaction_arg_ref.datalen, transaction_arg_ref.data);
18388 transaction_arg_ref.data_is_owned = true;
18389 LDKThirtyTwoBytes txid_arg_ref;
18390 CHECK((*env)->GetArrayLength(env, txid_arg) == 32);
18391 (*env)->GetByteArrayRegion(env, txid_arg, 0, 32, txid_arg_ref.data);
18392 LDKBuiltCommitmentTransaction ret_var = BuiltCommitmentTransaction_new(transaction_arg_ref, txid_arg_ref);
18393 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18394 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18395 long ret_ref = (long)ret_var.inner;
18396 if (ret_var.is_owned) {
18402 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_BuiltCommitmentTransaction_1clone(JNIEnv *env, jclass clz, int64_t orig) {
18403 LDKBuiltCommitmentTransaction orig_conv;
18404 orig_conv.inner = (void*)(orig & (~1));
18405 orig_conv.is_owned = false;
18406 LDKBuiltCommitmentTransaction ret_var = BuiltCommitmentTransaction_clone(&orig_conv);
18407 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18408 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18409 long ret_ref = (long)ret_var.inner;
18410 if (ret_var.is_owned) {
18416 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_BuiltCommitmentTransaction_1write(JNIEnv *env, jclass clz, int64_t obj) {
18417 LDKBuiltCommitmentTransaction obj_conv;
18418 obj_conv.inner = (void*)(obj & (~1));
18419 obj_conv.is_owned = false;
18420 LDKCVec_u8Z ret_var = BuiltCommitmentTransaction_write(&obj_conv);
18421 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
18422 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
18423 CVec_u8Z_free(ret_var);
18427 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_BuiltCommitmentTransaction_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
18428 LDKu8slice ser_ref;
18429 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
18430 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
18431 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
18432 *ret_conv = BuiltCommitmentTransaction_read(ser_ref);
18433 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
18434 return (long)ret_conv;
18437 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) {
18438 LDKBuiltCommitmentTransaction this_arg_conv;
18439 this_arg_conv.inner = (void*)(this_arg & (~1));
18440 this_arg_conv.is_owned = false;
18441 LDKu8slice funding_redeemscript_ref;
18442 funding_redeemscript_ref.datalen = (*env)->GetArrayLength(env, funding_redeemscript);
18443 funding_redeemscript_ref.data = (*env)->GetByteArrayElements (env, funding_redeemscript, NULL);
18444 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
18445 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, BuiltCommitmentTransaction_get_sighash_all(&this_arg_conv, funding_redeemscript_ref, channel_value_satoshis).data);
18446 (*env)->ReleaseByteArrayElements(env, funding_redeemscript, (int8_t*)funding_redeemscript_ref.data, 0);
18450 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) {
18451 LDKBuiltCommitmentTransaction this_arg_conv;
18452 this_arg_conv.inner = (void*)(this_arg & (~1));
18453 this_arg_conv.is_owned = false;
18454 unsigned char funding_key_arr[32];
18455 CHECK((*env)->GetArrayLength(env, funding_key) == 32);
18456 (*env)->GetByteArrayRegion(env, funding_key, 0, 32, funding_key_arr);
18457 unsigned char (*funding_key_ref)[32] = &funding_key_arr;
18458 LDKu8slice funding_redeemscript_ref;
18459 funding_redeemscript_ref.datalen = (*env)->GetArrayLength(env, funding_redeemscript);
18460 funding_redeemscript_ref.data = (*env)->GetByteArrayElements (env, funding_redeemscript, NULL);
18461 int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
18462 (*env)->SetByteArrayRegion(env, ret_arr, 0, 64, BuiltCommitmentTransaction_sign(&this_arg_conv, funding_key_ref, funding_redeemscript_ref, channel_value_satoshis).compact_form);
18463 (*env)->ReleaseByteArrayElements(env, funding_redeemscript, (int8_t*)funding_redeemscript_ref.data, 0);
18467 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CommitmentTransaction_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
18468 LDKCommitmentTransaction this_obj_conv;
18469 this_obj_conv.inner = (void*)(this_obj & (~1));
18470 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
18471 CommitmentTransaction_free(this_obj_conv);
18474 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentTransaction_1clone(JNIEnv *env, jclass clz, int64_t orig) {
18475 LDKCommitmentTransaction orig_conv;
18476 orig_conv.inner = (void*)(orig & (~1));
18477 orig_conv.is_owned = false;
18478 LDKCommitmentTransaction ret_var = CommitmentTransaction_clone(&orig_conv);
18479 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18480 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18481 long ret_ref = (long)ret_var.inner;
18482 if (ret_var.is_owned) {
18488 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_CommitmentTransaction_1write(JNIEnv *env, jclass clz, int64_t obj) {
18489 LDKCommitmentTransaction obj_conv;
18490 obj_conv.inner = (void*)(obj & (~1));
18491 obj_conv.is_owned = false;
18492 LDKCVec_u8Z ret_var = CommitmentTransaction_write(&obj_conv);
18493 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
18494 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
18495 CVec_u8Z_free(ret_var);
18499 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentTransaction_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
18500 LDKu8slice ser_ref;
18501 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
18502 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
18503 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
18504 *ret_conv = CommitmentTransaction_read(ser_ref);
18505 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
18506 return (long)ret_conv;
18509 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentTransaction_1commitment_1number(JNIEnv *env, jclass clz, int64_t this_arg) {
18510 LDKCommitmentTransaction this_arg_conv;
18511 this_arg_conv.inner = (void*)(this_arg & (~1));
18512 this_arg_conv.is_owned = false;
18513 int64_t ret_val = CommitmentTransaction_commitment_number(&this_arg_conv);
18517 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentTransaction_1to_1broadcaster_1value_1sat(JNIEnv *env, jclass clz, int64_t this_arg) {
18518 LDKCommitmentTransaction this_arg_conv;
18519 this_arg_conv.inner = (void*)(this_arg & (~1));
18520 this_arg_conv.is_owned = false;
18521 int64_t ret_val = CommitmentTransaction_to_broadcaster_value_sat(&this_arg_conv);
18525 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentTransaction_1to_1countersignatory_1value_1sat(JNIEnv *env, jclass clz, int64_t this_arg) {
18526 LDKCommitmentTransaction this_arg_conv;
18527 this_arg_conv.inner = (void*)(this_arg & (~1));
18528 this_arg_conv.is_owned = false;
18529 int64_t ret_val = CommitmentTransaction_to_countersignatory_value_sat(&this_arg_conv);
18533 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_CommitmentTransaction_1feerate_1per_1kw(JNIEnv *env, jclass clz, int64_t this_arg) {
18534 LDKCommitmentTransaction this_arg_conv;
18535 this_arg_conv.inner = (void*)(this_arg & (~1));
18536 this_arg_conv.is_owned = false;
18537 int32_t ret_val = CommitmentTransaction_feerate_per_kw(&this_arg_conv);
18541 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentTransaction_1trust(JNIEnv *env, jclass clz, int64_t this_arg) {
18542 LDKCommitmentTransaction this_arg_conv;
18543 this_arg_conv.inner = (void*)(this_arg & (~1));
18544 this_arg_conv.is_owned = false;
18545 LDKTrustedCommitmentTransaction ret_var = CommitmentTransaction_trust(&this_arg_conv);
18546 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18547 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18548 long ret_ref = (long)ret_var.inner;
18549 if (ret_var.is_owned) {
18555 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) {
18556 LDKCommitmentTransaction this_arg_conv;
18557 this_arg_conv.inner = (void*)(this_arg & (~1));
18558 this_arg_conv.is_owned = false;
18559 LDKDirectedChannelTransactionParameters channel_parameters_conv;
18560 channel_parameters_conv.inner = (void*)(channel_parameters & (~1));
18561 channel_parameters_conv.is_owned = false;
18562 LDKChannelPublicKeys broadcaster_keys_conv;
18563 broadcaster_keys_conv.inner = (void*)(broadcaster_keys & (~1));
18564 broadcaster_keys_conv.is_owned = false;
18565 LDKChannelPublicKeys countersignatory_keys_conv;
18566 countersignatory_keys_conv.inner = (void*)(countersignatory_keys & (~1));
18567 countersignatory_keys_conv.is_owned = false;
18568 LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
18569 *ret_conv = CommitmentTransaction_verify(&this_arg_conv, &channel_parameters_conv, &broadcaster_keys_conv, &countersignatory_keys_conv);
18570 return (long)ret_conv;
18573 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_TrustedCommitmentTransaction_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
18574 LDKTrustedCommitmentTransaction this_obj_conv;
18575 this_obj_conv.inner = (void*)(this_obj & (~1));
18576 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
18577 TrustedCommitmentTransaction_free(this_obj_conv);
18580 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_TrustedCommitmentTransaction_1txid(JNIEnv *env, jclass clz, int64_t this_arg) {
18581 LDKTrustedCommitmentTransaction this_arg_conv;
18582 this_arg_conv.inner = (void*)(this_arg & (~1));
18583 this_arg_conv.is_owned = false;
18584 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
18585 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, TrustedCommitmentTransaction_txid(&this_arg_conv).data);
18589 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_TrustedCommitmentTransaction_1built_1transaction(JNIEnv *env, jclass clz, int64_t this_arg) {
18590 LDKTrustedCommitmentTransaction this_arg_conv;
18591 this_arg_conv.inner = (void*)(this_arg & (~1));
18592 this_arg_conv.is_owned = false;
18593 LDKBuiltCommitmentTransaction ret_var = TrustedCommitmentTransaction_built_transaction(&this_arg_conv);
18594 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18595 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18596 long ret_ref = (long)ret_var.inner;
18597 if (ret_var.is_owned) {
18603 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_TrustedCommitmentTransaction_1keys(JNIEnv *env, jclass clz, int64_t this_arg) {
18604 LDKTrustedCommitmentTransaction this_arg_conv;
18605 this_arg_conv.inner = (void*)(this_arg & (~1));
18606 this_arg_conv.is_owned = false;
18607 LDKTxCreationKeys ret_var = TrustedCommitmentTransaction_keys(&this_arg_conv);
18608 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18609 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18610 long ret_ref = (long)ret_var.inner;
18611 if (ret_var.is_owned) {
18617 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) {
18618 LDKTrustedCommitmentTransaction this_arg_conv;
18619 this_arg_conv.inner = (void*)(this_arg & (~1));
18620 this_arg_conv.is_owned = false;
18621 unsigned char htlc_base_key_arr[32];
18622 CHECK((*env)->GetArrayLength(env, htlc_base_key) == 32);
18623 (*env)->GetByteArrayRegion(env, htlc_base_key, 0, 32, htlc_base_key_arr);
18624 unsigned char (*htlc_base_key_ref)[32] = &htlc_base_key_arr;
18625 LDKDirectedChannelTransactionParameters channel_parameters_conv;
18626 channel_parameters_conv.inner = (void*)(channel_parameters & (~1));
18627 channel_parameters_conv.is_owned = false;
18628 LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
18629 *ret_conv = TrustedCommitmentTransaction_get_htlc_sigs(&this_arg_conv, htlc_base_key_ref, &channel_parameters_conv);
18630 return (long)ret_conv;
18633 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) {
18634 LDKPublicKey broadcaster_payment_basepoint_ref;
18635 CHECK((*env)->GetArrayLength(env, broadcaster_payment_basepoint) == 33);
18636 (*env)->GetByteArrayRegion(env, broadcaster_payment_basepoint, 0, 33, broadcaster_payment_basepoint_ref.compressed_form);
18637 LDKPublicKey countersignatory_payment_basepoint_ref;
18638 CHECK((*env)->GetArrayLength(env, countersignatory_payment_basepoint) == 33);
18639 (*env)->GetByteArrayRegion(env, countersignatory_payment_basepoint, 0, 33, countersignatory_payment_basepoint_ref.compressed_form);
18640 int64_t ret_val = get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint_ref, countersignatory_payment_basepoint_ref, outbound_from_broadcaster);
18644 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InitFeatures_1clone(JNIEnv *env, jclass clz, int64_t orig) {
18645 LDKInitFeatures orig_conv;
18646 orig_conv.inner = (void*)(orig & (~1));
18647 orig_conv.is_owned = false;
18648 LDKInitFeatures ret_var = InitFeatures_clone(&orig_conv);
18649 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18650 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18651 long ret_ref = (long)ret_var.inner;
18652 if (ret_var.is_owned) {
18658 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeFeatures_1clone(JNIEnv *env, jclass clz, int64_t orig) {
18659 LDKNodeFeatures orig_conv;
18660 orig_conv.inner = (void*)(orig & (~1));
18661 orig_conv.is_owned = false;
18662 LDKNodeFeatures ret_var = NodeFeatures_clone(&orig_conv);
18663 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18664 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18665 long ret_ref = (long)ret_var.inner;
18666 if (ret_var.is_owned) {
18672 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelFeatures_1clone(JNIEnv *env, jclass clz, int64_t orig) {
18673 LDKChannelFeatures orig_conv;
18674 orig_conv.inner = (void*)(orig & (~1));
18675 orig_conv.is_owned = false;
18676 LDKChannelFeatures ret_var = ChannelFeatures_clone(&orig_conv);
18677 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18678 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18679 long ret_ref = (long)ret_var.inner;
18680 if (ret_var.is_owned) {
18686 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_InitFeatures_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
18687 LDKInitFeatures this_obj_conv;
18688 this_obj_conv.inner = (void*)(this_obj & (~1));
18689 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
18690 InitFeatures_free(this_obj_conv);
18693 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NodeFeatures_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
18694 LDKNodeFeatures this_obj_conv;
18695 this_obj_conv.inner = (void*)(this_obj & (~1));
18696 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
18697 NodeFeatures_free(this_obj_conv);
18700 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelFeatures_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
18701 LDKChannelFeatures this_obj_conv;
18702 this_obj_conv.inner = (void*)(this_obj & (~1));
18703 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
18704 ChannelFeatures_free(this_obj_conv);
18707 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InitFeatures_1empty(JNIEnv *env, jclass clz) {
18708 LDKInitFeatures ret_var = InitFeatures_empty();
18709 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18710 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18711 long ret_ref = (long)ret_var.inner;
18712 if (ret_var.is_owned) {
18718 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InitFeatures_1known(JNIEnv *env, jclass clz) {
18719 LDKInitFeatures ret_var = InitFeatures_known();
18720 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18721 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18722 long ret_ref = (long)ret_var.inner;
18723 if (ret_var.is_owned) {
18729 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeFeatures_1empty(JNIEnv *env, jclass clz) {
18730 LDKNodeFeatures ret_var = NodeFeatures_empty();
18731 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18732 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18733 long ret_ref = (long)ret_var.inner;
18734 if (ret_var.is_owned) {
18740 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeFeatures_1known(JNIEnv *env, jclass clz) {
18741 LDKNodeFeatures ret_var = NodeFeatures_known();
18742 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18743 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18744 long ret_ref = (long)ret_var.inner;
18745 if (ret_var.is_owned) {
18751 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelFeatures_1empty(JNIEnv *env, jclass clz) {
18752 LDKChannelFeatures ret_var = ChannelFeatures_empty();
18753 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18754 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18755 long ret_ref = (long)ret_var.inner;
18756 if (ret_var.is_owned) {
18762 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelFeatures_1known(JNIEnv *env, jclass clz) {
18763 LDKChannelFeatures ret_var = ChannelFeatures_known();
18764 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18765 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18766 long ret_ref = (long)ret_var.inner;
18767 if (ret_var.is_owned) {
18773 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_InitFeatures_1write(JNIEnv *env, jclass clz, int64_t obj) {
18774 LDKInitFeatures obj_conv;
18775 obj_conv.inner = (void*)(obj & (~1));
18776 obj_conv.is_owned = false;
18777 LDKCVec_u8Z ret_var = InitFeatures_write(&obj_conv);
18778 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
18779 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
18780 CVec_u8Z_free(ret_var);
18784 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_NodeFeatures_1write(JNIEnv *env, jclass clz, int64_t obj) {
18785 LDKNodeFeatures obj_conv;
18786 obj_conv.inner = (void*)(obj & (~1));
18787 obj_conv.is_owned = false;
18788 LDKCVec_u8Z ret_var = NodeFeatures_write(&obj_conv);
18789 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
18790 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
18791 CVec_u8Z_free(ret_var);
18795 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelFeatures_1write(JNIEnv *env, jclass clz, int64_t obj) {
18796 LDKChannelFeatures obj_conv;
18797 obj_conv.inner = (void*)(obj & (~1));
18798 obj_conv.is_owned = false;
18799 LDKCVec_u8Z ret_var = ChannelFeatures_write(&obj_conv);
18800 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
18801 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
18802 CVec_u8Z_free(ret_var);
18806 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InitFeatures_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
18807 LDKu8slice ser_ref;
18808 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
18809 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
18810 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
18811 *ret_conv = InitFeatures_read(ser_ref);
18812 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
18813 return (long)ret_conv;
18816 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeFeatures_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
18817 LDKu8slice ser_ref;
18818 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
18819 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
18820 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
18821 *ret_conv = NodeFeatures_read(ser_ref);
18822 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
18823 return (long)ret_conv;
18826 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelFeatures_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
18827 LDKu8slice ser_ref;
18828 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
18829 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
18830 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
18831 *ret_conv = ChannelFeatures_read(ser_ref);
18832 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
18833 return (long)ret_conv;
18836 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RouteHop_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
18837 LDKRouteHop this_obj_conv;
18838 this_obj_conv.inner = (void*)(this_obj & (~1));
18839 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
18840 RouteHop_free(this_obj_conv);
18843 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_RouteHop_1get_1pubkey(JNIEnv *env, jclass clz, int64_t this_ptr) {
18844 LDKRouteHop this_ptr_conv;
18845 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18846 this_ptr_conv.is_owned = false;
18847 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
18848 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, RouteHop_get_pubkey(&this_ptr_conv).compressed_form);
18852 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RouteHop_1set_1pubkey(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
18853 LDKRouteHop this_ptr_conv;
18854 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18855 this_ptr_conv.is_owned = false;
18856 LDKPublicKey val_ref;
18857 CHECK((*env)->GetArrayLength(env, val) == 33);
18858 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
18859 RouteHop_set_pubkey(&this_ptr_conv, val_ref);
18862 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHop_1get_1node_1features(JNIEnv *env, jclass clz, int64_t this_ptr) {
18863 LDKRouteHop this_ptr_conv;
18864 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18865 this_ptr_conv.is_owned = false;
18866 LDKNodeFeatures ret_var = RouteHop_get_node_features(&this_ptr_conv);
18867 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18868 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18869 long ret_ref = (long)ret_var.inner;
18870 if (ret_var.is_owned) {
18876 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RouteHop_1set_1node_1features(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
18877 LDKRouteHop this_ptr_conv;
18878 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18879 this_ptr_conv.is_owned = false;
18880 LDKNodeFeatures val_conv;
18881 val_conv.inner = (void*)(val & (~1));
18882 val_conv.is_owned = (val & 1) || (val == 0);
18883 val_conv = NodeFeatures_clone(&val_conv);
18884 RouteHop_set_node_features(&this_ptr_conv, val_conv);
18887 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHop_1get_1short_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
18888 LDKRouteHop this_ptr_conv;
18889 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18890 this_ptr_conv.is_owned = false;
18891 int64_t ret_val = RouteHop_get_short_channel_id(&this_ptr_conv);
18895 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RouteHop_1set_1short_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
18896 LDKRouteHop this_ptr_conv;
18897 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18898 this_ptr_conv.is_owned = false;
18899 RouteHop_set_short_channel_id(&this_ptr_conv, val);
18902 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHop_1get_1channel_1features(JNIEnv *env, jclass clz, int64_t this_ptr) {
18903 LDKRouteHop this_ptr_conv;
18904 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18905 this_ptr_conv.is_owned = false;
18906 LDKChannelFeatures ret_var = RouteHop_get_channel_features(&this_ptr_conv);
18907 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18908 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18909 long ret_ref = (long)ret_var.inner;
18910 if (ret_var.is_owned) {
18916 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RouteHop_1set_1channel_1features(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
18917 LDKRouteHop this_ptr_conv;
18918 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18919 this_ptr_conv.is_owned = false;
18920 LDKChannelFeatures val_conv;
18921 val_conv.inner = (void*)(val & (~1));
18922 val_conv.is_owned = (val & 1) || (val == 0);
18923 val_conv = ChannelFeatures_clone(&val_conv);
18924 RouteHop_set_channel_features(&this_ptr_conv, val_conv);
18927 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHop_1get_1fee_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
18928 LDKRouteHop this_ptr_conv;
18929 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18930 this_ptr_conv.is_owned = false;
18931 int64_t ret_val = RouteHop_get_fee_msat(&this_ptr_conv);
18935 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RouteHop_1set_1fee_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
18936 LDKRouteHop this_ptr_conv;
18937 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18938 this_ptr_conv.is_owned = false;
18939 RouteHop_set_fee_msat(&this_ptr_conv, val);
18942 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_RouteHop_1get_1cltv_1expiry_1delta(JNIEnv *env, jclass clz, int64_t this_ptr) {
18943 LDKRouteHop this_ptr_conv;
18944 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18945 this_ptr_conv.is_owned = false;
18946 int32_t ret_val = RouteHop_get_cltv_expiry_delta(&this_ptr_conv);
18950 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RouteHop_1set_1cltv_1expiry_1delta(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
18951 LDKRouteHop this_ptr_conv;
18952 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18953 this_ptr_conv.is_owned = false;
18954 RouteHop_set_cltv_expiry_delta(&this_ptr_conv, val);
18957 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) {
18958 LDKPublicKey pubkey_arg_ref;
18959 CHECK((*env)->GetArrayLength(env, pubkey_arg) == 33);
18960 (*env)->GetByteArrayRegion(env, pubkey_arg, 0, 33, pubkey_arg_ref.compressed_form);
18961 LDKNodeFeatures node_features_arg_conv;
18962 node_features_arg_conv.inner = (void*)(node_features_arg & (~1));
18963 node_features_arg_conv.is_owned = (node_features_arg & 1) || (node_features_arg == 0);
18964 node_features_arg_conv = NodeFeatures_clone(&node_features_arg_conv);
18965 LDKChannelFeatures channel_features_arg_conv;
18966 channel_features_arg_conv.inner = (void*)(channel_features_arg & (~1));
18967 channel_features_arg_conv.is_owned = (channel_features_arg & 1) || (channel_features_arg == 0);
18968 channel_features_arg_conv = ChannelFeatures_clone(&channel_features_arg_conv);
18969 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);
18970 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18971 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18972 long ret_ref = (long)ret_var.inner;
18973 if (ret_var.is_owned) {
18979 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHop_1clone(JNIEnv *env, jclass clz, int64_t orig) {
18980 LDKRouteHop orig_conv;
18981 orig_conv.inner = (void*)(orig & (~1));
18982 orig_conv.is_owned = false;
18983 LDKRouteHop ret_var = RouteHop_clone(&orig_conv);
18984 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18985 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18986 long ret_ref = (long)ret_var.inner;
18987 if (ret_var.is_owned) {
18993 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Route_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
18994 LDKRoute this_obj_conv;
18995 this_obj_conv.inner = (void*)(this_obj & (~1));
18996 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
18997 Route_free(this_obj_conv);
19000 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Route_1set_1paths(JNIEnv *env, jclass clz, int64_t this_ptr, jobjectArray val) {
19001 LDKRoute this_ptr_conv;
19002 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19003 this_ptr_conv.is_owned = false;
19004 LDKCVec_CVec_RouteHopZZ val_constr;
19005 val_constr.datalen = (*env)->GetArrayLength(env, val);
19006 if (val_constr.datalen > 0)
19007 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKCVec_RouteHopZ), "LDKCVec_CVec_RouteHopZZ Elements");
19009 val_constr.data = NULL;
19010 for (size_t m = 0; m < val_constr.datalen; m++) {
19011 int64_tArray val_conv_12 = (*env)->GetObjectArrayElement(env, val, m);
19012 LDKCVec_RouteHopZ val_conv_12_constr;
19013 val_conv_12_constr.datalen = (*env)->GetArrayLength(env, val_conv_12);
19014 if (val_conv_12_constr.datalen > 0)
19015 val_conv_12_constr.data = MALLOC(val_conv_12_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
19017 val_conv_12_constr.data = NULL;
19018 int64_t* val_conv_12_vals = (*env)->GetLongArrayElements (env, val_conv_12, NULL);
19019 for (size_t k = 0; k < val_conv_12_constr.datalen; k++) {
19020 int64_t val_conv_12_conv_10 = val_conv_12_vals[k];
19021 LDKRouteHop val_conv_12_conv_10_conv;
19022 val_conv_12_conv_10_conv.inner = (void*)(val_conv_12_conv_10 & (~1));
19023 val_conv_12_conv_10_conv.is_owned = (val_conv_12_conv_10 & 1) || (val_conv_12_conv_10 == 0);
19024 val_conv_12_conv_10_conv = RouteHop_clone(&val_conv_12_conv_10_conv);
19025 val_conv_12_constr.data[k] = val_conv_12_conv_10_conv;
19027 (*env)->ReleaseLongArrayElements(env, val_conv_12, val_conv_12_vals, 0);
19028 val_constr.data[m] = val_conv_12_constr;
19030 Route_set_paths(&this_ptr_conv, val_constr);
19033 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Route_1new(JNIEnv *env, jclass clz, jobjectArray paths_arg) {
19034 LDKCVec_CVec_RouteHopZZ paths_arg_constr;
19035 paths_arg_constr.datalen = (*env)->GetArrayLength(env, paths_arg);
19036 if (paths_arg_constr.datalen > 0)
19037 paths_arg_constr.data = MALLOC(paths_arg_constr.datalen * sizeof(LDKCVec_RouteHopZ), "LDKCVec_CVec_RouteHopZZ Elements");
19039 paths_arg_constr.data = NULL;
19040 for (size_t m = 0; m < paths_arg_constr.datalen; m++) {
19041 int64_tArray paths_arg_conv_12 = (*env)->GetObjectArrayElement(env, paths_arg, m);
19042 LDKCVec_RouteHopZ paths_arg_conv_12_constr;
19043 paths_arg_conv_12_constr.datalen = (*env)->GetArrayLength(env, paths_arg_conv_12);
19044 if (paths_arg_conv_12_constr.datalen > 0)
19045 paths_arg_conv_12_constr.data = MALLOC(paths_arg_conv_12_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
19047 paths_arg_conv_12_constr.data = NULL;
19048 int64_t* paths_arg_conv_12_vals = (*env)->GetLongArrayElements (env, paths_arg_conv_12, NULL);
19049 for (size_t k = 0; k < paths_arg_conv_12_constr.datalen; k++) {
19050 int64_t paths_arg_conv_12_conv_10 = paths_arg_conv_12_vals[k];
19051 LDKRouteHop paths_arg_conv_12_conv_10_conv;
19052 paths_arg_conv_12_conv_10_conv.inner = (void*)(paths_arg_conv_12_conv_10 & (~1));
19053 paths_arg_conv_12_conv_10_conv.is_owned = (paths_arg_conv_12_conv_10 & 1) || (paths_arg_conv_12_conv_10 == 0);
19054 paths_arg_conv_12_conv_10_conv = RouteHop_clone(&paths_arg_conv_12_conv_10_conv);
19055 paths_arg_conv_12_constr.data[k] = paths_arg_conv_12_conv_10_conv;
19057 (*env)->ReleaseLongArrayElements(env, paths_arg_conv_12, paths_arg_conv_12_vals, 0);
19058 paths_arg_constr.data[m] = paths_arg_conv_12_constr;
19060 LDKRoute ret_var = Route_new(paths_arg_constr);
19061 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19062 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19063 long ret_ref = (long)ret_var.inner;
19064 if (ret_var.is_owned) {
19070 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Route_1clone(JNIEnv *env, jclass clz, int64_t orig) {
19071 LDKRoute orig_conv;
19072 orig_conv.inner = (void*)(orig & (~1));
19073 orig_conv.is_owned = false;
19074 LDKRoute ret_var = Route_clone(&orig_conv);
19075 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19076 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19077 long ret_ref = (long)ret_var.inner;
19078 if (ret_var.is_owned) {
19084 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_Route_1write(JNIEnv *env, jclass clz, int64_t obj) {
19086 obj_conv.inner = (void*)(obj & (~1));
19087 obj_conv.is_owned = false;
19088 LDKCVec_u8Z ret_var = Route_write(&obj_conv);
19089 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
19090 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
19091 CVec_u8Z_free(ret_var);
19095 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Route_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
19096 LDKu8slice ser_ref;
19097 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
19098 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
19099 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
19100 *ret_conv = Route_read(ser_ref);
19101 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
19102 return (long)ret_conv;
19105 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RouteHint_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
19106 LDKRouteHint this_obj_conv;
19107 this_obj_conv.inner = (void*)(this_obj & (~1));
19108 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
19109 RouteHint_free(this_obj_conv);
19112 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_RouteHint_1get_1src_1node_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
19113 LDKRouteHint this_ptr_conv;
19114 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19115 this_ptr_conv.is_owned = false;
19116 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
19117 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, RouteHint_get_src_node_id(&this_ptr_conv).compressed_form);
19121 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RouteHint_1set_1src_1node_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
19122 LDKRouteHint this_ptr_conv;
19123 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19124 this_ptr_conv.is_owned = false;
19125 LDKPublicKey val_ref;
19126 CHECK((*env)->GetArrayLength(env, val) == 33);
19127 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
19128 RouteHint_set_src_node_id(&this_ptr_conv, val_ref);
19131 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHint_1get_1short_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr) {
19132 LDKRouteHint this_ptr_conv;
19133 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19134 this_ptr_conv.is_owned = false;
19135 int64_t ret_val = RouteHint_get_short_channel_id(&this_ptr_conv);
19139 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RouteHint_1set_1short_1channel_1id(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
19140 LDKRouteHint this_ptr_conv;
19141 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19142 this_ptr_conv.is_owned = false;
19143 RouteHint_set_short_channel_id(&this_ptr_conv, val);
19146 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHint_1get_1fees(JNIEnv *env, jclass clz, int64_t this_ptr) {
19147 LDKRouteHint this_ptr_conv;
19148 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19149 this_ptr_conv.is_owned = false;
19150 LDKRoutingFees ret_var = RouteHint_get_fees(&this_ptr_conv);
19151 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19152 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19153 long ret_ref = (long)ret_var.inner;
19154 if (ret_var.is_owned) {
19160 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RouteHint_1set_1fees(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
19161 LDKRouteHint this_ptr_conv;
19162 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19163 this_ptr_conv.is_owned = false;
19164 LDKRoutingFees val_conv;
19165 val_conv.inner = (void*)(val & (~1));
19166 val_conv.is_owned = (val & 1) || (val == 0);
19167 val_conv = RoutingFees_clone(&val_conv);
19168 RouteHint_set_fees(&this_ptr_conv, val_conv);
19171 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_RouteHint_1get_1cltv_1expiry_1delta(JNIEnv *env, jclass clz, int64_t this_ptr) {
19172 LDKRouteHint this_ptr_conv;
19173 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19174 this_ptr_conv.is_owned = false;
19175 int16_t ret_val = RouteHint_get_cltv_expiry_delta(&this_ptr_conv);
19179 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RouteHint_1set_1cltv_1expiry_1delta(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
19180 LDKRouteHint this_ptr_conv;
19181 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19182 this_ptr_conv.is_owned = false;
19183 RouteHint_set_cltv_expiry_delta(&this_ptr_conv, val);
19186 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHint_1clone(JNIEnv *env, jclass clz, int64_t orig) {
19187 LDKRouteHint orig_conv;
19188 orig_conv.inner = (void*)(orig & (~1));
19189 orig_conv.is_owned = false;
19190 LDKRouteHint ret_var = RouteHint_clone(&orig_conv);
19191 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19192 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19193 long ret_ref = (long)ret_var.inner;
19194 if (ret_var.is_owned) {
19200 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_tArray first_hops, int64_tArray last_hops, int64_t final_value_msat, int32_t final_cltv, int64_t logger) {
19201 LDKPublicKey our_node_id_ref;
19202 CHECK((*env)->GetArrayLength(env, our_node_id) == 33);
19203 (*env)->GetByteArrayRegion(env, our_node_id, 0, 33, our_node_id_ref.compressed_form);
19204 LDKNetworkGraph network_conv;
19205 network_conv.inner = (void*)(network & (~1));
19206 network_conv.is_owned = false;
19207 LDKPublicKey payee_ref;
19208 CHECK((*env)->GetArrayLength(env, payee) == 33);
19209 (*env)->GetByteArrayRegion(env, payee, 0, 33, payee_ref.compressed_form);
19210 LDKCVec_ChannelDetailsZ first_hops_constr;
19211 first_hops_constr.datalen = (*env)->GetArrayLength(env, first_hops);
19212 if (first_hops_constr.datalen > 0)
19213 first_hops_constr.data = MALLOC(first_hops_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
19215 first_hops_constr.data = NULL;
19216 int64_t* first_hops_vals = (*env)->GetLongArrayElements (env, first_hops, NULL);
19217 for (size_t q = 0; q < first_hops_constr.datalen; q++) {
19218 int64_t first_hops_conv_16 = first_hops_vals[q];
19219 LDKChannelDetails first_hops_conv_16_conv;
19220 first_hops_conv_16_conv.inner = (void*)(first_hops_conv_16 & (~1));
19221 first_hops_conv_16_conv.is_owned = (first_hops_conv_16 & 1) || (first_hops_conv_16 == 0);
19222 first_hops_constr.data[q] = first_hops_conv_16_conv;
19224 (*env)->ReleaseLongArrayElements(env, first_hops, first_hops_vals, 0);
19225 LDKCVec_RouteHintZ last_hops_constr;
19226 last_hops_constr.datalen = (*env)->GetArrayLength(env, last_hops);
19227 if (last_hops_constr.datalen > 0)
19228 last_hops_constr.data = MALLOC(last_hops_constr.datalen * sizeof(LDKRouteHint), "LDKCVec_RouteHintZ Elements");
19230 last_hops_constr.data = NULL;
19231 int64_t* last_hops_vals = (*env)->GetLongArrayElements (env, last_hops, NULL);
19232 for (size_t l = 0; l < last_hops_constr.datalen; l++) {
19233 int64_t last_hops_conv_11 = last_hops_vals[l];
19234 LDKRouteHint last_hops_conv_11_conv;
19235 last_hops_conv_11_conv.inner = (void*)(last_hops_conv_11 & (~1));
19236 last_hops_conv_11_conv.is_owned = (last_hops_conv_11 & 1) || (last_hops_conv_11 == 0);
19237 last_hops_conv_11_conv = RouteHint_clone(&last_hops_conv_11_conv);
19238 last_hops_constr.data[l] = last_hops_conv_11_conv;
19240 (*env)->ReleaseLongArrayElements(env, last_hops, last_hops_vals, 0);
19241 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
19242 if (logger_conv.free == LDKLogger_JCalls_free) {
19243 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
19244 LDKLogger_JCalls_clone(logger_conv.this_arg);
19246 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
19247 *ret_conv = get_route(our_node_id_ref, &network_conv, payee_ref, &first_hops_constr, last_hops_constr, final_value_msat, final_cltv, logger_conv);
19248 FREE(first_hops_constr.data);
19249 return (long)ret_conv;
19252 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NetworkGraph_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
19253 LDKNetworkGraph this_obj_conv;
19254 this_obj_conv.inner = (void*)(this_obj & (~1));
19255 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
19256 NetworkGraph_free(this_obj_conv);
19259 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetworkGraph_1clone(JNIEnv *env, jclass clz, int64_t orig) {
19260 LDKNetworkGraph orig_conv;
19261 orig_conv.inner = (void*)(orig & (~1));
19262 orig_conv.is_owned = false;
19263 LDKNetworkGraph ret_var = NetworkGraph_clone(&orig_conv);
19264 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19265 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19266 long ret_ref = (long)ret_var.inner;
19267 if (ret_var.is_owned) {
19273 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LockedNetworkGraph_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
19274 LDKLockedNetworkGraph this_obj_conv;
19275 this_obj_conv.inner = (void*)(this_obj & (~1));
19276 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
19277 LockedNetworkGraph_free(this_obj_conv);
19280 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NetGraphMsgHandler_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
19281 LDKNetGraphMsgHandler this_obj_conv;
19282 this_obj_conv.inner = (void*)(this_obj & (~1));
19283 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
19284 NetGraphMsgHandler_free(this_obj_conv);
19287 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) {
19288 LDKThirtyTwoBytes genesis_hash_ref;
19289 CHECK((*env)->GetArrayLength(env, genesis_hash) == 32);
19290 (*env)->GetByteArrayRegion(env, genesis_hash, 0, 32, genesis_hash_ref.data);
19291 LDKAccess *chain_access_conv_ptr = NULL;
19292 if (chain_access != 0) {
19293 LDKAccess chain_access_conv;
19294 chain_access_conv = *(LDKAccess*)(((uint64_t)chain_access) & ~1);
19295 if (chain_access_conv.free == LDKAccess_JCalls_free) {
19296 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
19297 LDKAccess_JCalls_clone(chain_access_conv.this_arg);
19299 chain_access_conv_ptr = MALLOC(sizeof(LDKAccess), "LDKAccess");
19300 *chain_access_conv_ptr = chain_access_conv;
19302 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
19303 if (logger_conv.free == LDKLogger_JCalls_free) {
19304 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
19305 LDKLogger_JCalls_clone(logger_conv.this_arg);
19307 LDKNetGraphMsgHandler ret_var = NetGraphMsgHandler_new(genesis_hash_ref, chain_access_conv_ptr, logger_conv);
19308 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19309 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19310 long ret_ref = (long)ret_var.inner;
19311 if (ret_var.is_owned) {
19317 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) {
19318 LDKAccess *chain_access_conv_ptr = NULL;
19319 if (chain_access != 0) {
19320 LDKAccess chain_access_conv;
19321 chain_access_conv = *(LDKAccess*)(((uint64_t)chain_access) & ~1);
19322 if (chain_access_conv.free == LDKAccess_JCalls_free) {
19323 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
19324 LDKAccess_JCalls_clone(chain_access_conv.this_arg);
19326 chain_access_conv_ptr = MALLOC(sizeof(LDKAccess), "LDKAccess");
19327 *chain_access_conv_ptr = chain_access_conv;
19329 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
19330 if (logger_conv.free == LDKLogger_JCalls_free) {
19331 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
19332 LDKLogger_JCalls_clone(logger_conv.this_arg);
19334 LDKNetworkGraph network_graph_conv;
19335 network_graph_conv.inner = (void*)(network_graph & (~1));
19336 network_graph_conv.is_owned = (network_graph & 1) || (network_graph == 0);
19337 network_graph_conv = NetworkGraph_clone(&network_graph_conv);
19338 LDKNetGraphMsgHandler ret_var = NetGraphMsgHandler_from_net_graph(chain_access_conv_ptr, logger_conv, network_graph_conv);
19339 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19340 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19341 long ret_ref = (long)ret_var.inner;
19342 if (ret_var.is_owned) {
19348 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NetGraphMsgHandler_1add_1chain_1access(JNIEnv *env, jclass clz, int64_t this_arg, int64_t chain_access) {
19349 LDKNetGraphMsgHandler this_arg_conv;
19350 this_arg_conv.inner = (void*)(this_arg & (~1));
19351 this_arg_conv.is_owned = false;
19352 LDKAccess *chain_access_conv_ptr = NULL;
19353 if (chain_access != 0) {
19354 LDKAccess chain_access_conv;
19355 chain_access_conv = *(LDKAccess*)(((uint64_t)chain_access) & ~1);
19356 if (chain_access_conv.free == LDKAccess_JCalls_free) {
19357 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
19358 LDKAccess_JCalls_clone(chain_access_conv.this_arg);
19360 chain_access_conv_ptr = MALLOC(sizeof(LDKAccess), "LDKAccess");
19361 *chain_access_conv_ptr = chain_access_conv;
19363 NetGraphMsgHandler_add_chain_access(&this_arg_conv, chain_access_conv_ptr);
19366 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetGraphMsgHandler_1read_1locked_1graph(JNIEnv *env, jclass clz, int64_t this_arg) {
19367 LDKNetGraphMsgHandler this_arg_conv;
19368 this_arg_conv.inner = (void*)(this_arg & (~1));
19369 this_arg_conv.is_owned = false;
19370 LDKLockedNetworkGraph ret_var = NetGraphMsgHandler_read_locked_graph(&this_arg_conv);
19371 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19372 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19373 long ret_ref = (long)ret_var.inner;
19374 if (ret_var.is_owned) {
19380 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LockedNetworkGraph_1graph(JNIEnv *env, jclass clz, int64_t this_arg) {
19381 LDKLockedNetworkGraph this_arg_conv;
19382 this_arg_conv.inner = (void*)(this_arg & (~1));
19383 this_arg_conv.is_owned = false;
19384 LDKNetworkGraph ret_var = LockedNetworkGraph_graph(&this_arg_conv);
19385 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19386 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19387 long ret_ref = (long)ret_var.inner;
19388 if (ret_var.is_owned) {
19394 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetGraphMsgHandler_1as_1RoutingMessageHandler(JNIEnv *env, jclass clz, int64_t this_arg) {
19395 LDKNetGraphMsgHandler this_arg_conv;
19396 this_arg_conv.inner = (void*)(this_arg & (~1));
19397 this_arg_conv.is_owned = false;
19398 LDKRoutingMessageHandler* ret = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
19399 *ret = NetGraphMsgHandler_as_RoutingMessageHandler(&this_arg_conv);
19403 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetGraphMsgHandler_1as_1MessageSendEventsProvider(JNIEnv *env, jclass clz, int64_t this_arg) {
19404 LDKNetGraphMsgHandler this_arg_conv;
19405 this_arg_conv.inner = (void*)(this_arg & (~1));
19406 this_arg_conv.is_owned = false;
19407 LDKMessageSendEventsProvider* ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
19408 *ret = NetGraphMsgHandler_as_MessageSendEventsProvider(&this_arg_conv);
19412 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
19413 LDKDirectionalChannelInfo this_obj_conv;
19414 this_obj_conv.inner = (void*)(this_obj & (~1));
19415 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
19416 DirectionalChannelInfo_free(this_obj_conv);
19419 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1get_1last_1update(JNIEnv *env, jclass clz, int64_t this_ptr) {
19420 LDKDirectionalChannelInfo this_ptr_conv;
19421 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19422 this_ptr_conv.is_owned = false;
19423 int32_t ret_val = DirectionalChannelInfo_get_last_update(&this_ptr_conv);
19427 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1set_1last_1update(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
19428 LDKDirectionalChannelInfo this_ptr_conv;
19429 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19430 this_ptr_conv.is_owned = false;
19431 DirectionalChannelInfo_set_last_update(&this_ptr_conv, val);
19434 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1get_1enabled(JNIEnv *env, jclass clz, int64_t this_ptr) {
19435 LDKDirectionalChannelInfo this_ptr_conv;
19436 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19437 this_ptr_conv.is_owned = false;
19438 jboolean ret_val = DirectionalChannelInfo_get_enabled(&this_ptr_conv);
19442 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1set_1enabled(JNIEnv *env, jclass clz, int64_t this_ptr, jboolean val) {
19443 LDKDirectionalChannelInfo this_ptr_conv;
19444 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19445 this_ptr_conv.is_owned = false;
19446 DirectionalChannelInfo_set_enabled(&this_ptr_conv, val);
19449 JNIEXPORT int16_t JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1get_1cltv_1expiry_1delta(JNIEnv *env, jclass clz, int64_t this_ptr) {
19450 LDKDirectionalChannelInfo this_ptr_conv;
19451 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19452 this_ptr_conv.is_owned = false;
19453 int16_t ret_val = DirectionalChannelInfo_get_cltv_expiry_delta(&this_ptr_conv);
19457 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1set_1cltv_1expiry_1delta(JNIEnv *env, jclass clz, int64_t this_ptr, int16_t val) {
19458 LDKDirectionalChannelInfo this_ptr_conv;
19459 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19460 this_ptr_conv.is_owned = false;
19461 DirectionalChannelInfo_set_cltv_expiry_delta(&this_ptr_conv, val);
19464 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1get_1htlc_1minimum_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
19465 LDKDirectionalChannelInfo this_ptr_conv;
19466 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19467 this_ptr_conv.is_owned = false;
19468 int64_t ret_val = DirectionalChannelInfo_get_htlc_minimum_msat(&this_ptr_conv);
19472 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1set_1htlc_1minimum_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
19473 LDKDirectionalChannelInfo this_ptr_conv;
19474 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19475 this_ptr_conv.is_owned = false;
19476 DirectionalChannelInfo_set_htlc_minimum_msat(&this_ptr_conv, val);
19479 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1get_1fees(JNIEnv *env, jclass clz, int64_t this_ptr) {
19480 LDKDirectionalChannelInfo this_ptr_conv;
19481 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19482 this_ptr_conv.is_owned = false;
19483 LDKRoutingFees ret_var = DirectionalChannelInfo_get_fees(&this_ptr_conv);
19484 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19485 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19486 long ret_ref = (long)ret_var.inner;
19487 if (ret_var.is_owned) {
19493 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1set_1fees(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
19494 LDKDirectionalChannelInfo this_ptr_conv;
19495 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19496 this_ptr_conv.is_owned = false;
19497 LDKRoutingFees val_conv;
19498 val_conv.inner = (void*)(val & (~1));
19499 val_conv.is_owned = (val & 1) || (val == 0);
19500 val_conv = RoutingFees_clone(&val_conv);
19501 DirectionalChannelInfo_set_fees(&this_ptr_conv, val_conv);
19504 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1get_1last_1update_1message(JNIEnv *env, jclass clz, int64_t this_ptr) {
19505 LDKDirectionalChannelInfo this_ptr_conv;
19506 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19507 this_ptr_conv.is_owned = false;
19508 LDKChannelUpdate ret_var = DirectionalChannelInfo_get_last_update_message(&this_ptr_conv);
19509 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19510 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19511 long ret_ref = (long)ret_var.inner;
19512 if (ret_var.is_owned) {
19518 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1set_1last_1update_1message(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
19519 LDKDirectionalChannelInfo this_ptr_conv;
19520 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19521 this_ptr_conv.is_owned = false;
19522 LDKChannelUpdate val_conv;
19523 val_conv.inner = (void*)(val & (~1));
19524 val_conv.is_owned = (val & 1) || (val == 0);
19525 val_conv = ChannelUpdate_clone(&val_conv);
19526 DirectionalChannelInfo_set_last_update_message(&this_ptr_conv, val_conv);
19529 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1clone(JNIEnv *env, jclass clz, int64_t orig) {
19530 LDKDirectionalChannelInfo orig_conv;
19531 orig_conv.inner = (void*)(orig & (~1));
19532 orig_conv.is_owned = false;
19533 LDKDirectionalChannelInfo ret_var = DirectionalChannelInfo_clone(&orig_conv);
19534 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19535 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19536 long ret_ref = (long)ret_var.inner;
19537 if (ret_var.is_owned) {
19543 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1write(JNIEnv *env, jclass clz, int64_t obj) {
19544 LDKDirectionalChannelInfo obj_conv;
19545 obj_conv.inner = (void*)(obj & (~1));
19546 obj_conv.is_owned = false;
19547 LDKCVec_u8Z ret_var = DirectionalChannelInfo_write(&obj_conv);
19548 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
19549 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
19550 CVec_u8Z_free(ret_var);
19554 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
19555 LDKu8slice ser_ref;
19556 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
19557 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
19558 LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ");
19559 *ret_conv = DirectionalChannelInfo_read(ser_ref);
19560 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
19561 return (long)ret_conv;
19564 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
19565 LDKChannelInfo this_obj_conv;
19566 this_obj_conv.inner = (void*)(this_obj & (~1));
19567 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
19568 ChannelInfo_free(this_obj_conv);
19571 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1get_1features(JNIEnv *env, jclass clz, int64_t this_ptr) {
19572 LDKChannelInfo this_ptr_conv;
19573 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19574 this_ptr_conv.is_owned = false;
19575 LDKChannelFeatures ret_var = ChannelInfo_get_features(&this_ptr_conv);
19576 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19577 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19578 long ret_ref = (long)ret_var.inner;
19579 if (ret_var.is_owned) {
19585 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1set_1features(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
19586 LDKChannelInfo this_ptr_conv;
19587 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19588 this_ptr_conv.is_owned = false;
19589 LDKChannelFeatures val_conv;
19590 val_conv.inner = (void*)(val & (~1));
19591 val_conv.is_owned = (val & 1) || (val == 0);
19592 val_conv = ChannelFeatures_clone(&val_conv);
19593 ChannelInfo_set_features(&this_ptr_conv, val_conv);
19596 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1get_1node_1one(JNIEnv *env, jclass clz, int64_t this_ptr) {
19597 LDKChannelInfo this_ptr_conv;
19598 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19599 this_ptr_conv.is_owned = false;
19600 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
19601 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ChannelInfo_get_node_one(&this_ptr_conv).compressed_form);
19605 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1set_1node_1one(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
19606 LDKChannelInfo this_ptr_conv;
19607 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19608 this_ptr_conv.is_owned = false;
19609 LDKPublicKey val_ref;
19610 CHECK((*env)->GetArrayLength(env, val) == 33);
19611 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
19612 ChannelInfo_set_node_one(&this_ptr_conv, val_ref);
19615 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1get_1one_1to_1two(JNIEnv *env, jclass clz, int64_t this_ptr) {
19616 LDKChannelInfo this_ptr_conv;
19617 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19618 this_ptr_conv.is_owned = false;
19619 LDKDirectionalChannelInfo ret_var = ChannelInfo_get_one_to_two(&this_ptr_conv);
19620 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19621 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19622 long ret_ref = (long)ret_var.inner;
19623 if (ret_var.is_owned) {
19629 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1set_1one_1to_1two(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
19630 LDKChannelInfo this_ptr_conv;
19631 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19632 this_ptr_conv.is_owned = false;
19633 LDKDirectionalChannelInfo val_conv;
19634 val_conv.inner = (void*)(val & (~1));
19635 val_conv.is_owned = (val & 1) || (val == 0);
19636 val_conv = DirectionalChannelInfo_clone(&val_conv);
19637 ChannelInfo_set_one_to_two(&this_ptr_conv, val_conv);
19640 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1get_1node_1two(JNIEnv *env, jclass clz, int64_t this_ptr) {
19641 LDKChannelInfo this_ptr_conv;
19642 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19643 this_ptr_conv.is_owned = false;
19644 int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
19645 (*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ChannelInfo_get_node_two(&this_ptr_conv).compressed_form);
19649 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1set_1node_1two(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
19650 LDKChannelInfo this_ptr_conv;
19651 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19652 this_ptr_conv.is_owned = false;
19653 LDKPublicKey val_ref;
19654 CHECK((*env)->GetArrayLength(env, val) == 33);
19655 (*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
19656 ChannelInfo_set_node_two(&this_ptr_conv, val_ref);
19659 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1get_1two_1to_1one(JNIEnv *env, jclass clz, int64_t this_ptr) {
19660 LDKChannelInfo this_ptr_conv;
19661 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19662 this_ptr_conv.is_owned = false;
19663 LDKDirectionalChannelInfo ret_var = ChannelInfo_get_two_to_one(&this_ptr_conv);
19664 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19665 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19666 long ret_ref = (long)ret_var.inner;
19667 if (ret_var.is_owned) {
19673 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1set_1two_1to_1one(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
19674 LDKChannelInfo this_ptr_conv;
19675 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19676 this_ptr_conv.is_owned = false;
19677 LDKDirectionalChannelInfo val_conv;
19678 val_conv.inner = (void*)(val & (~1));
19679 val_conv.is_owned = (val & 1) || (val == 0);
19680 val_conv = DirectionalChannelInfo_clone(&val_conv);
19681 ChannelInfo_set_two_to_one(&this_ptr_conv, val_conv);
19684 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1get_1announcement_1message(JNIEnv *env, jclass clz, int64_t this_ptr) {
19685 LDKChannelInfo this_ptr_conv;
19686 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19687 this_ptr_conv.is_owned = false;
19688 LDKChannelAnnouncement ret_var = ChannelInfo_get_announcement_message(&this_ptr_conv);
19689 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19690 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19691 long ret_ref = (long)ret_var.inner;
19692 if (ret_var.is_owned) {
19698 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1set_1announcement_1message(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
19699 LDKChannelInfo this_ptr_conv;
19700 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19701 this_ptr_conv.is_owned = false;
19702 LDKChannelAnnouncement val_conv;
19703 val_conv.inner = (void*)(val & (~1));
19704 val_conv.is_owned = (val & 1) || (val == 0);
19705 val_conv = ChannelAnnouncement_clone(&val_conv);
19706 ChannelInfo_set_announcement_message(&this_ptr_conv, val_conv);
19709 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1clone(JNIEnv *env, jclass clz, int64_t orig) {
19710 LDKChannelInfo orig_conv;
19711 orig_conv.inner = (void*)(orig & (~1));
19712 orig_conv.is_owned = false;
19713 LDKChannelInfo ret_var = ChannelInfo_clone(&orig_conv);
19714 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19715 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19716 long ret_ref = (long)ret_var.inner;
19717 if (ret_var.is_owned) {
19723 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1write(JNIEnv *env, jclass clz, int64_t obj) {
19724 LDKChannelInfo obj_conv;
19725 obj_conv.inner = (void*)(obj & (~1));
19726 obj_conv.is_owned = false;
19727 LDKCVec_u8Z ret_var = ChannelInfo_write(&obj_conv);
19728 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
19729 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
19730 CVec_u8Z_free(ret_var);
19734 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
19735 LDKu8slice ser_ref;
19736 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
19737 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
19738 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
19739 *ret_conv = ChannelInfo_read(ser_ref);
19740 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
19741 return (long)ret_conv;
19744 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RoutingFees_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
19745 LDKRoutingFees this_obj_conv;
19746 this_obj_conv.inner = (void*)(this_obj & (~1));
19747 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
19748 RoutingFees_free(this_obj_conv);
19751 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_RoutingFees_1get_1base_1msat(JNIEnv *env, jclass clz, int64_t this_ptr) {
19752 LDKRoutingFees this_ptr_conv;
19753 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19754 this_ptr_conv.is_owned = false;
19755 int32_t ret_val = RoutingFees_get_base_msat(&this_ptr_conv);
19759 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RoutingFees_1set_1base_1msat(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
19760 LDKRoutingFees this_ptr_conv;
19761 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19762 this_ptr_conv.is_owned = false;
19763 RoutingFees_set_base_msat(&this_ptr_conv, val);
19766 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_RoutingFees_1get_1proportional_1millionths(JNIEnv *env, jclass clz, int64_t this_ptr) {
19767 LDKRoutingFees this_ptr_conv;
19768 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19769 this_ptr_conv.is_owned = false;
19770 int32_t ret_val = RoutingFees_get_proportional_millionths(&this_ptr_conv);
19774 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_RoutingFees_1set_1proportional_1millionths(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
19775 LDKRoutingFees this_ptr_conv;
19776 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19777 this_ptr_conv.is_owned = false;
19778 RoutingFees_set_proportional_millionths(&this_ptr_conv, val);
19781 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) {
19782 LDKRoutingFees ret_var = RoutingFees_new(base_msat_arg, proportional_millionths_arg);
19783 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19784 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19785 long ret_ref = (long)ret_var.inner;
19786 if (ret_var.is_owned) {
19792 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RoutingFees_1clone(JNIEnv *env, jclass clz, int64_t orig) {
19793 LDKRoutingFees orig_conv;
19794 orig_conv.inner = (void*)(orig & (~1));
19795 orig_conv.is_owned = false;
19796 LDKRoutingFees ret_var = RoutingFees_clone(&orig_conv);
19797 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19798 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19799 long ret_ref = (long)ret_var.inner;
19800 if (ret_var.is_owned) {
19806 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RoutingFees_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
19807 LDKu8slice ser_ref;
19808 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
19809 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
19810 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
19811 *ret_conv = RoutingFees_read(ser_ref);
19812 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
19813 return (long)ret_conv;
19816 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_RoutingFees_1write(JNIEnv *env, jclass clz, int64_t obj) {
19817 LDKRoutingFees obj_conv;
19818 obj_conv.inner = (void*)(obj & (~1));
19819 obj_conv.is_owned = false;
19820 LDKCVec_u8Z ret_var = RoutingFees_write(&obj_conv);
19821 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
19822 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
19823 CVec_u8Z_free(ret_var);
19827 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
19828 LDKNodeAnnouncementInfo this_obj_conv;
19829 this_obj_conv.inner = (void*)(this_obj & (~1));
19830 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
19831 NodeAnnouncementInfo_free(this_obj_conv);
19834 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1get_1features(JNIEnv *env, jclass clz, int64_t this_ptr) {
19835 LDKNodeAnnouncementInfo this_ptr_conv;
19836 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19837 this_ptr_conv.is_owned = false;
19838 LDKNodeFeatures ret_var = NodeAnnouncementInfo_get_features(&this_ptr_conv);
19839 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19840 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19841 long ret_ref = (long)ret_var.inner;
19842 if (ret_var.is_owned) {
19848 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1set_1features(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
19849 LDKNodeAnnouncementInfo this_ptr_conv;
19850 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19851 this_ptr_conv.is_owned = false;
19852 LDKNodeFeatures val_conv;
19853 val_conv.inner = (void*)(val & (~1));
19854 val_conv.is_owned = (val & 1) || (val == 0);
19855 val_conv = NodeFeatures_clone(&val_conv);
19856 NodeAnnouncementInfo_set_features(&this_ptr_conv, val_conv);
19859 JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1get_1last_1update(JNIEnv *env, jclass clz, int64_t this_ptr) {
19860 LDKNodeAnnouncementInfo this_ptr_conv;
19861 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19862 this_ptr_conv.is_owned = false;
19863 int32_t ret_val = NodeAnnouncementInfo_get_last_update(&this_ptr_conv);
19867 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1set_1last_1update(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
19868 LDKNodeAnnouncementInfo this_ptr_conv;
19869 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19870 this_ptr_conv.is_owned = false;
19871 NodeAnnouncementInfo_set_last_update(&this_ptr_conv, val);
19874 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1get_1rgb(JNIEnv *env, jclass clz, int64_t this_ptr) {
19875 LDKNodeAnnouncementInfo this_ptr_conv;
19876 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19877 this_ptr_conv.is_owned = false;
19878 int8_tArray ret_arr = (*env)->NewByteArray(env, 3);
19879 (*env)->SetByteArrayRegion(env, ret_arr, 0, 3, *NodeAnnouncementInfo_get_rgb(&this_ptr_conv));
19883 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1set_1rgb(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
19884 LDKNodeAnnouncementInfo this_ptr_conv;
19885 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19886 this_ptr_conv.is_owned = false;
19887 LDKThreeBytes val_ref;
19888 CHECK((*env)->GetArrayLength(env, val) == 3);
19889 (*env)->GetByteArrayRegion(env, val, 0, 3, val_ref.data);
19890 NodeAnnouncementInfo_set_rgb(&this_ptr_conv, val_ref);
19893 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1get_1alias(JNIEnv *env, jclass clz, int64_t this_ptr) {
19894 LDKNodeAnnouncementInfo this_ptr_conv;
19895 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19896 this_ptr_conv.is_owned = false;
19897 int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
19898 (*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *NodeAnnouncementInfo_get_alias(&this_ptr_conv));
19902 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1set_1alias(JNIEnv *env, jclass clz, int64_t this_ptr, int8_tArray val) {
19903 LDKNodeAnnouncementInfo this_ptr_conv;
19904 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19905 this_ptr_conv.is_owned = false;
19906 LDKThirtyTwoBytes val_ref;
19907 CHECK((*env)->GetArrayLength(env, val) == 32);
19908 (*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
19909 NodeAnnouncementInfo_set_alias(&this_ptr_conv, val_ref);
19912 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1set_1addresses(JNIEnv *env, jclass clz, int64_t this_ptr, int64_tArray val) {
19913 LDKNodeAnnouncementInfo this_ptr_conv;
19914 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19915 this_ptr_conv.is_owned = false;
19916 LDKCVec_NetAddressZ val_constr;
19917 val_constr.datalen = (*env)->GetArrayLength(env, val);
19918 if (val_constr.datalen > 0)
19919 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
19921 val_constr.data = NULL;
19922 int64_t* val_vals = (*env)->GetLongArrayElements (env, val, NULL);
19923 for (size_t m = 0; m < val_constr.datalen; m++) {
19924 int64_t val_conv_12 = val_vals[m];
19925 LDKNetAddress val_conv_12_conv = *(LDKNetAddress*)(((uint64_t)val_conv_12) & ~1);
19926 FREE((void*)val_conv_12);
19927 val_constr.data[m] = val_conv_12_conv;
19929 (*env)->ReleaseLongArrayElements(env, val, val_vals, 0);
19930 NodeAnnouncementInfo_set_addresses(&this_ptr_conv, val_constr);
19933 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1get_1announcement_1message(JNIEnv *env, jclass clz, int64_t this_ptr) {
19934 LDKNodeAnnouncementInfo this_ptr_conv;
19935 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19936 this_ptr_conv.is_owned = false;
19937 LDKNodeAnnouncement ret_var = NodeAnnouncementInfo_get_announcement_message(&this_ptr_conv);
19938 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19939 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19940 long ret_ref = (long)ret_var.inner;
19941 if (ret_var.is_owned) {
19947 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1set_1announcement_1message(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
19948 LDKNodeAnnouncementInfo this_ptr_conv;
19949 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19950 this_ptr_conv.is_owned = false;
19951 LDKNodeAnnouncement val_conv;
19952 val_conv.inner = (void*)(val & (~1));
19953 val_conv.is_owned = (val & 1) || (val == 0);
19954 val_conv = NodeAnnouncement_clone(&val_conv);
19955 NodeAnnouncementInfo_set_announcement_message(&this_ptr_conv, val_conv);
19958 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) {
19959 LDKNodeFeatures features_arg_conv;
19960 features_arg_conv.inner = (void*)(features_arg & (~1));
19961 features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0);
19962 features_arg_conv = NodeFeatures_clone(&features_arg_conv);
19963 LDKThreeBytes rgb_arg_ref;
19964 CHECK((*env)->GetArrayLength(env, rgb_arg) == 3);
19965 (*env)->GetByteArrayRegion(env, rgb_arg, 0, 3, rgb_arg_ref.data);
19966 LDKThirtyTwoBytes alias_arg_ref;
19967 CHECK((*env)->GetArrayLength(env, alias_arg) == 32);
19968 (*env)->GetByteArrayRegion(env, alias_arg, 0, 32, alias_arg_ref.data);
19969 LDKCVec_NetAddressZ addresses_arg_constr;
19970 addresses_arg_constr.datalen = (*env)->GetArrayLength(env, addresses_arg);
19971 if (addresses_arg_constr.datalen > 0)
19972 addresses_arg_constr.data = MALLOC(addresses_arg_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
19974 addresses_arg_constr.data = NULL;
19975 int64_t* addresses_arg_vals = (*env)->GetLongArrayElements (env, addresses_arg, NULL);
19976 for (size_t m = 0; m < addresses_arg_constr.datalen; m++) {
19977 int64_t addresses_arg_conv_12 = addresses_arg_vals[m];
19978 LDKNetAddress addresses_arg_conv_12_conv = *(LDKNetAddress*)(((uint64_t)addresses_arg_conv_12) & ~1);
19979 FREE((void*)addresses_arg_conv_12);
19980 addresses_arg_constr.data[m] = addresses_arg_conv_12_conv;
19982 (*env)->ReleaseLongArrayElements(env, addresses_arg, addresses_arg_vals, 0);
19983 LDKNodeAnnouncement announcement_message_arg_conv;
19984 announcement_message_arg_conv.inner = (void*)(announcement_message_arg & (~1));
19985 announcement_message_arg_conv.is_owned = (announcement_message_arg & 1) || (announcement_message_arg == 0);
19986 announcement_message_arg_conv = NodeAnnouncement_clone(&announcement_message_arg_conv);
19987 LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_new(features_arg_conv, last_update_arg, rgb_arg_ref, alias_arg_ref, addresses_arg_constr, announcement_message_arg_conv);
19988 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19989 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19990 long ret_ref = (long)ret_var.inner;
19991 if (ret_var.is_owned) {
19997 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1clone(JNIEnv *env, jclass clz, int64_t orig) {
19998 LDKNodeAnnouncementInfo orig_conv;
19999 orig_conv.inner = (void*)(orig & (~1));
20000 orig_conv.is_owned = false;
20001 LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_clone(&orig_conv);
20002 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20003 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20004 long ret_ref = (long)ret_var.inner;
20005 if (ret_var.is_owned) {
20011 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1write(JNIEnv *env, jclass clz, int64_t obj) {
20012 LDKNodeAnnouncementInfo obj_conv;
20013 obj_conv.inner = (void*)(obj & (~1));
20014 obj_conv.is_owned = false;
20015 LDKCVec_u8Z ret_var = NodeAnnouncementInfo_write(&obj_conv);
20016 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
20017 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
20018 CVec_u8Z_free(ret_var);
20022 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
20023 LDKu8slice ser_ref;
20024 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
20025 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
20026 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
20027 *ret_conv = NodeAnnouncementInfo_read(ser_ref);
20028 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
20029 return (long)ret_conv;
20032 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NodeInfo_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
20033 LDKNodeInfo this_obj_conv;
20034 this_obj_conv.inner = (void*)(this_obj & (~1));
20035 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
20036 NodeInfo_free(this_obj_conv);
20039 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NodeInfo_1set_1channels(JNIEnv *env, jclass clz, int64_t this_ptr, int64_tArray val) {
20040 LDKNodeInfo this_ptr_conv;
20041 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20042 this_ptr_conv.is_owned = false;
20043 LDKCVec_u64Z val_constr;
20044 val_constr.datalen = (*env)->GetArrayLength(env, val);
20045 if (val_constr.datalen > 0)
20046 val_constr.data = MALLOC(val_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
20048 val_constr.data = NULL;
20049 int64_t* val_vals = (*env)->GetLongArrayElements (env, val, NULL);
20050 for (size_t g = 0; g < val_constr.datalen; g++) {
20051 int64_t val_conv_6 = val_vals[g];
20052 val_constr.data[g] = val_conv_6;
20054 (*env)->ReleaseLongArrayElements(env, val, val_vals, 0);
20055 NodeInfo_set_channels(&this_ptr_conv, val_constr);
20058 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeInfo_1get_1lowest_1inbound_1channel_1fees(JNIEnv *env, jclass clz, int64_t this_ptr) {
20059 LDKNodeInfo this_ptr_conv;
20060 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20061 this_ptr_conv.is_owned = false;
20062 LDKRoutingFees ret_var = NodeInfo_get_lowest_inbound_channel_fees(&this_ptr_conv);
20063 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20064 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20065 long ret_ref = (long)ret_var.inner;
20066 if (ret_var.is_owned) {
20072 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) {
20073 LDKNodeInfo this_ptr_conv;
20074 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20075 this_ptr_conv.is_owned = false;
20076 LDKRoutingFees val_conv;
20077 val_conv.inner = (void*)(val & (~1));
20078 val_conv.is_owned = (val & 1) || (val == 0);
20079 val_conv = RoutingFees_clone(&val_conv);
20080 NodeInfo_set_lowest_inbound_channel_fees(&this_ptr_conv, val_conv);
20083 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeInfo_1get_1announcement_1info(JNIEnv *env, jclass clz, int64_t this_ptr) {
20084 LDKNodeInfo this_ptr_conv;
20085 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20086 this_ptr_conv.is_owned = false;
20087 LDKNodeAnnouncementInfo ret_var = NodeInfo_get_announcement_info(&this_ptr_conv);
20088 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20089 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20090 long ret_ref = (long)ret_var.inner;
20091 if (ret_var.is_owned) {
20097 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NodeInfo_1set_1announcement_1info(JNIEnv *env, jclass clz, int64_t this_ptr, int64_t val) {
20098 LDKNodeInfo this_ptr_conv;
20099 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20100 this_ptr_conv.is_owned = false;
20101 LDKNodeAnnouncementInfo val_conv;
20102 val_conv.inner = (void*)(val & (~1));
20103 val_conv.is_owned = (val & 1) || (val == 0);
20104 val_conv = NodeAnnouncementInfo_clone(&val_conv);
20105 NodeInfo_set_announcement_info(&this_ptr_conv, val_conv);
20108 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) {
20109 LDKCVec_u64Z channels_arg_constr;
20110 channels_arg_constr.datalen = (*env)->GetArrayLength(env, channels_arg);
20111 if (channels_arg_constr.datalen > 0)
20112 channels_arg_constr.data = MALLOC(channels_arg_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
20114 channels_arg_constr.data = NULL;
20115 int64_t* channels_arg_vals = (*env)->GetLongArrayElements (env, channels_arg, NULL);
20116 for (size_t g = 0; g < channels_arg_constr.datalen; g++) {
20117 int64_t channels_arg_conv_6 = channels_arg_vals[g];
20118 channels_arg_constr.data[g] = channels_arg_conv_6;
20120 (*env)->ReleaseLongArrayElements(env, channels_arg, channels_arg_vals, 0);
20121 LDKRoutingFees lowest_inbound_channel_fees_arg_conv;
20122 lowest_inbound_channel_fees_arg_conv.inner = (void*)(lowest_inbound_channel_fees_arg & (~1));
20123 lowest_inbound_channel_fees_arg_conv.is_owned = (lowest_inbound_channel_fees_arg & 1) || (lowest_inbound_channel_fees_arg == 0);
20124 lowest_inbound_channel_fees_arg_conv = RoutingFees_clone(&lowest_inbound_channel_fees_arg_conv);
20125 LDKNodeAnnouncementInfo announcement_info_arg_conv;
20126 announcement_info_arg_conv.inner = (void*)(announcement_info_arg & (~1));
20127 announcement_info_arg_conv.is_owned = (announcement_info_arg & 1) || (announcement_info_arg == 0);
20128 announcement_info_arg_conv = NodeAnnouncementInfo_clone(&announcement_info_arg_conv);
20129 LDKNodeInfo ret_var = NodeInfo_new(channels_arg_constr, lowest_inbound_channel_fees_arg_conv, announcement_info_arg_conv);
20130 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20131 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20132 long ret_ref = (long)ret_var.inner;
20133 if (ret_var.is_owned) {
20139 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeInfo_1clone(JNIEnv *env, jclass clz, int64_t orig) {
20140 LDKNodeInfo orig_conv;
20141 orig_conv.inner = (void*)(orig & (~1));
20142 orig_conv.is_owned = false;
20143 LDKNodeInfo ret_var = NodeInfo_clone(&orig_conv);
20144 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20145 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20146 long ret_ref = (long)ret_var.inner;
20147 if (ret_var.is_owned) {
20153 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_NodeInfo_1write(JNIEnv *env, jclass clz, int64_t obj) {
20154 LDKNodeInfo obj_conv;
20155 obj_conv.inner = (void*)(obj & (~1));
20156 obj_conv.is_owned = false;
20157 LDKCVec_u8Z ret_var = NodeInfo_write(&obj_conv);
20158 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
20159 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
20160 CVec_u8Z_free(ret_var);
20164 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeInfo_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
20165 LDKu8slice ser_ref;
20166 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
20167 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
20168 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
20169 *ret_conv = NodeInfo_read(ser_ref);
20170 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
20171 return (long)ret_conv;
20174 JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_NetworkGraph_1write(JNIEnv *env, jclass clz, int64_t obj) {
20175 LDKNetworkGraph obj_conv;
20176 obj_conv.inner = (void*)(obj & (~1));
20177 obj_conv.is_owned = false;
20178 LDKCVec_u8Z ret_var = NetworkGraph_write(&obj_conv);
20179 int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
20180 (*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
20181 CVec_u8Z_free(ret_var);
20185 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetworkGraph_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
20186 LDKu8slice ser_ref;
20187 ser_ref.datalen = (*env)->GetArrayLength(env, ser);
20188 ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
20189 LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
20190 *ret_conv = NetworkGraph_read(ser_ref);
20191 (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
20192 return (long)ret_conv;
20195 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetworkGraph_1new(JNIEnv *env, jclass clz, int8_tArray genesis_hash) {
20196 LDKThirtyTwoBytes genesis_hash_ref;
20197 CHECK((*env)->GetArrayLength(env, genesis_hash) == 32);
20198 (*env)->GetByteArrayRegion(env, genesis_hash, 0, 32, genesis_hash_ref.data);
20199 LDKNetworkGraph ret_var = NetworkGraph_new(genesis_hash_ref);
20200 CHECK((((long)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20201 CHECK((((long)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20202 long ret_ref = (long)ret_var.inner;
20203 if (ret_var.is_owned) {
20209 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) {
20210 LDKNetworkGraph this_arg_conv;
20211 this_arg_conv.inner = (void*)(this_arg & (~1));
20212 this_arg_conv.is_owned = false;
20213 LDKNodeAnnouncement msg_conv;
20214 msg_conv.inner = (void*)(msg & (~1));
20215 msg_conv.is_owned = false;
20216 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
20217 *ret_conv = NetworkGraph_update_node_from_announcement(&this_arg_conv, &msg_conv);
20218 return (long)ret_conv;
20221 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) {
20222 LDKNetworkGraph this_arg_conv;
20223 this_arg_conv.inner = (void*)(this_arg & (~1));
20224 this_arg_conv.is_owned = false;
20225 LDKUnsignedNodeAnnouncement msg_conv;
20226 msg_conv.inner = (void*)(msg & (~1));
20227 msg_conv.is_owned = false;
20228 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
20229 *ret_conv = NetworkGraph_update_node_from_unsigned_announcement(&this_arg_conv, &msg_conv);
20230 return (long)ret_conv;
20233 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) {
20234 LDKNetworkGraph this_arg_conv;
20235 this_arg_conv.inner = (void*)(this_arg & (~1));
20236 this_arg_conv.is_owned = false;
20237 LDKChannelAnnouncement msg_conv;
20238 msg_conv.inner = (void*)(msg & (~1));
20239 msg_conv.is_owned = false;
20240 LDKAccess *chain_access_conv_ptr = NULL;
20241 if (chain_access != 0) {
20242 LDKAccess chain_access_conv;
20243 chain_access_conv = *(LDKAccess*)(((uint64_t)chain_access) & ~1);
20244 if (chain_access_conv.free == LDKAccess_JCalls_free) {
20245 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
20246 LDKAccess_JCalls_clone(chain_access_conv.this_arg);
20248 chain_access_conv_ptr = MALLOC(sizeof(LDKAccess), "LDKAccess");
20249 *chain_access_conv_ptr = chain_access_conv;
20251 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
20252 *ret_conv = NetworkGraph_update_channel_from_announcement(&this_arg_conv, &msg_conv, chain_access_conv_ptr);
20253 return (long)ret_conv;
20256 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) {
20257 LDKNetworkGraph this_arg_conv;
20258 this_arg_conv.inner = (void*)(this_arg & (~1));
20259 this_arg_conv.is_owned = false;
20260 LDKUnsignedChannelAnnouncement msg_conv;
20261 msg_conv.inner = (void*)(msg & (~1));
20262 msg_conv.is_owned = false;
20263 LDKAccess *chain_access_conv_ptr = NULL;
20264 if (chain_access != 0) {
20265 LDKAccess chain_access_conv;
20266 chain_access_conv = *(LDKAccess*)(((uint64_t)chain_access) & ~1);
20267 if (chain_access_conv.free == LDKAccess_JCalls_free) {
20268 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
20269 LDKAccess_JCalls_clone(chain_access_conv.this_arg);
20271 chain_access_conv_ptr = MALLOC(sizeof(LDKAccess), "LDKAccess");
20272 *chain_access_conv_ptr = chain_access_conv;
20274 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
20275 *ret_conv = NetworkGraph_update_channel_from_unsigned_announcement(&this_arg_conv, &msg_conv, chain_access_conv_ptr);
20276 return (long)ret_conv;
20279 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) {
20280 LDKNetworkGraph this_arg_conv;
20281 this_arg_conv.inner = (void*)(this_arg & (~1));
20282 this_arg_conv.is_owned = false;
20283 NetworkGraph_close_channel_from_update(&this_arg_conv, short_channel_id, is_permanent);
20286 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetworkGraph_1update_1channel(JNIEnv *env, jclass clz, int64_t this_arg, int64_t msg) {
20287 LDKNetworkGraph this_arg_conv;
20288 this_arg_conv.inner = (void*)(this_arg & (~1));
20289 this_arg_conv.is_owned = false;
20290 LDKChannelUpdate msg_conv;
20291 msg_conv.inner = (void*)(msg & (~1));
20292 msg_conv.is_owned = false;
20293 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
20294 *ret_conv = NetworkGraph_update_channel(&this_arg_conv, &msg_conv);
20295 return (long)ret_conv;
20298 JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetworkGraph_1update_1channel_1unsigned(JNIEnv *env, jclass clz, int64_t this_arg, int64_t msg) {
20299 LDKNetworkGraph this_arg_conv;
20300 this_arg_conv.inner = (void*)(this_arg & (~1));
20301 this_arg_conv.is_owned = false;
20302 LDKUnsignedChannelUpdate msg_conv;
20303 msg_conv.inner = (void*)(msg & (~1));
20304 msg_conv.is_owned = false;
20305 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
20306 *ret_conv = NetworkGraph_update_channel_unsigned(&this_arg_conv, &msg_conv);
20307 return (long)ret_conv;