1 #define LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ LDKCVec_TransactionOutputsZ
2 #define CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free CVec_TransactionOutputsZ_free
7 // These should be provided...somehow...
8 void *memset(void *s, int c, size_t n);
9 void *memcpy(void *dest, const void *src, size_t n);
10 int memcmp(const void *s1, const void *s2, size_t n);
12 extern void __attribute__((noreturn)) abort(void);
13 static inline void assert(bool expression) {
14 if (!expression) { abort(); }
17 uint32_t __attribute__((export_name("test_bigint_pass_deadbeef0badf00d"))) test_bigint_pass_deadbeef0badf00d(uint64_t val) {
18 return val == 0xdeadbeef0badf00dULL;
22 void *malloc(size_t size);
25 #define MALLOC(a, _) malloc(a)
26 #define do_MALLOC(a, _b, _c) malloc(a)
27 #define FREE(p) if ((unsigned long)(p) > 4096) { free(p); }
28 #define DO_ASSERT(a) (void)(a)
30 #define CHECK_ACCESS(p)
31 #define CHECK_INNER_FIELD_ACCESS_OR_NULL(v)
33 // We assume that CVec_u8Z and u8slice are the same size and layout (and thus pointers to the two can be mixed)
34 _Static_assert(sizeof(LDKCVec_u8Z) == sizeof(LDKu8slice), "Vec<u8> and [u8] need to have been mapped identically");
35 _Static_assert(offsetof(LDKCVec_u8Z, data) == offsetof(LDKu8slice, data), "Vec<u8> and [u8] need to have been mapped identically");
36 _Static_assert(offsetof(LDKCVec_u8Z, datalen) == offsetof(LDKu8slice, datalen), "Vec<u8> and [u8] need to have been mapped identically");
38 _Static_assert(sizeof(void*) == 4, "Pointers mut be 32 bits");
40 #define DECL_ARR_TYPE(ty, name) \
41 struct name##array { \
42 uint64_t arr_len; /* uint32_t would suffice but we want to align uint64_ts as well */ \
45 typedef struct name##array * name##Array; \
46 static inline name##Array init_##name##Array(size_t arr_len, int lineno) { \
47 name##Array arr = (name##Array)do_MALLOC(arr_len * sizeof(ty) + sizeof(uint64_t), #name" array init", lineno); \
48 arr->arr_len = arr_len; \
52 DECL_ARR_TYPE(int64_t, int64_t);
53 DECL_ARR_TYPE(uint64_t, uint64_t);
54 DECL_ARR_TYPE(int8_t, int8_t);
55 DECL_ARR_TYPE(uint32_t, uint32_t);
56 DECL_ARR_TYPE(void*, ptr);
57 DECL_ARR_TYPE(char, char);
58 typedef charArray jstring;
60 static inline jstring str_ref_to_ts(const char* chars, size_t len) {
61 charArray arr = init_charArray(len, __LINE__);
62 memcpy(arr->elems, chars, len);
65 static inline LDKStr str_ref_to_owned_c(const jstring str) {
66 char* newchars = MALLOC(str->arr_len + 1, "String chars");
67 memcpy(newchars, str->elems, str->arr_len);
68 newchars[str->arr_len] = 0;
72 .chars_is_owned = true
77 typedef bool jboolean;
79 uint32_t __attribute__((export_name("TS_malloc"))) TS_malloc(uint32_t size) {
80 return (uint32_t)MALLOC(size, "JS-Called malloc");
82 void __attribute__((export_name("TS_free"))) TS_free(uint32_t ptr) {
86 jstring __attribute__((export_name("TS_get_ldk_c_bindings_version"))) TS_get_ldk_c_bindings_version() {
87 const char *res = check_get_ldk_bindings_version();
88 if (res == NULL) return NULL;
89 return str_ref_to_ts(res, strlen(res));
91 jstring __attribute__((export_name("TS_get_ldk_version"))) get_ldk_version() {
92 const char *res = check_get_ldk_version();
93 if (res == NULL) return NULL;
94 return str_ref_to_ts(res, strlen(res));
97 static inline struct LDKThirtyTwoBytes ThirtyTwoBytes_clone(const struct LDKThirtyTwoBytes *orig) { struct LDKThirtyTwoBytes ret; memcpy(ret.data, orig->data, 32); return ret; }
99 static inline void* untag_ptr(uint64_t ptr) {
100 if (ptr < 4096) return (void*)ptr;
101 if (sizeof(void*) == 4) {
102 // For 32-bit systems, store pointers as 64-bit ints and use the 31st bit
103 return (void*)(uintptr_t)ptr;
105 // For 64-bit systems, assume the top byte is used for tagging, then
106 // use bit 9 ^ bit 10.
107 uint64_t tenth_bit = (((uintptr_t)ptr) & (1ULL << 54)) >> 54;
108 uintptr_t p = (ptr & ~(1ULL << 55)) | (tenth_bit << 55);
109 #ifdef LDK_DEBUG_BUILD
110 // On debug builds we also use the 11th bit as a debug flag
111 uintptr_t eleventh_bit = (((uintptr_t)ptr) & (1ULL << 53)) >> 53;
112 CHECK(tenth_bit != eleventh_bit);
118 static inline bool ptr_is_owned(uint64_t ptr) {
119 if(ptr < 4096) return true;
120 if (sizeof(void*) == 4) {
121 return ptr & (1ULL << 32);
123 uintptr_t ninth_bit = (((uintptr_t)ptr) & (1ULL << 55)) >> 55;
124 uintptr_t tenth_bit = (((uintptr_t)ptr) & (1ULL << 54)) >> 54;
125 #ifdef LDK_DEBUG_BUILD
126 // On debug builds we also use the 11th bit as a debug flag
127 uintptr_t eleventh_bit = (((uintptr_t)ptr) & (1ULL << 53)) >> 53;
128 CHECK(tenth_bit != eleventh_bit);
130 return (ninth_bit ^ tenth_bit) ? true : false;
133 static inline uint64_t tag_ptr(const void* ptr, bool is_owned) {
134 if ((uintptr_t)ptr < 4096) return (uint64_t)ptr;
135 if (sizeof(void*) == 4) {
136 return (((uint64_t)ptr) | ((is_owned ? 1ULL : 0) << 32));
138 CHECK(sizeof(uintptr_t) == 8);
139 uintptr_t tenth_bit = (((uintptr_t)ptr) & (1ULL << 54)) >> 54;
140 uintptr_t t = (((uintptr_t)ptr) | (((is_owned ? 1ULL : 0ULL) ^ tenth_bit) << 55));
141 #ifdef LDK_DEBUG_BUILD
142 uintptr_t ninth_bit = (((uintptr_t)ptr) & (1ULL << 55)) >> 55;
143 uintptr_t eleventh_bit = (((uintptr_t)ptr) & (1ULL << 53)) >> 53;
144 CHECK(ninth_bit == tenth_bit);
145 CHECK(ninth_bit == eleventh_bit);
148 CHECK(ptr_is_owned(t) == is_owned);
149 CHECK(untag_ptr(t) == ptr);
154 static inline LDKAccessError LDKAccessError_from_js(int32_t ord) {
156 case 0: return LDKAccessError_UnknownChain;
157 case 1: return LDKAccessError_UnknownTx;
161 static inline int32_t LDKAccessError_to_js(LDKAccessError val) {
163 case LDKAccessError_UnknownChain: return 0;
164 case LDKAccessError_UnknownTx: return 1;
168 static inline LDKCOption_NoneZ LDKCOption_NoneZ_from_js(int32_t ord) {
170 case 0: return LDKCOption_NoneZ_Some;
171 case 1: return LDKCOption_NoneZ_None;
175 static inline int32_t LDKCOption_NoneZ_to_js(LDKCOption_NoneZ val) {
177 case LDKCOption_NoneZ_Some: return 0;
178 case LDKCOption_NoneZ_None: return 1;
182 static inline LDKChannelMonitorUpdateStatus LDKChannelMonitorUpdateStatus_from_js(int32_t ord) {
184 case 0: return LDKChannelMonitorUpdateStatus_Completed;
185 case 1: return LDKChannelMonitorUpdateStatus_InProgress;
186 case 2: return LDKChannelMonitorUpdateStatus_PermanentFailure;
190 static inline int32_t LDKChannelMonitorUpdateStatus_to_js(LDKChannelMonitorUpdateStatus val) {
192 case LDKChannelMonitorUpdateStatus_Completed: return 0;
193 case LDKChannelMonitorUpdateStatus_InProgress: return 1;
194 case LDKChannelMonitorUpdateStatus_PermanentFailure: return 2;
198 static inline LDKConfirmationTarget LDKConfirmationTarget_from_js(int32_t ord) {
200 case 0: return LDKConfirmationTarget_Background;
201 case 1: return LDKConfirmationTarget_Normal;
202 case 2: return LDKConfirmationTarget_HighPriority;
206 static inline int32_t LDKConfirmationTarget_to_js(LDKConfirmationTarget val) {
208 case LDKConfirmationTarget_Background: return 0;
209 case LDKConfirmationTarget_Normal: return 1;
210 case LDKConfirmationTarget_HighPriority: return 2;
214 static inline LDKCreationError LDKCreationError_from_js(int32_t ord) {
216 case 0: return LDKCreationError_DescriptionTooLong;
217 case 1: return LDKCreationError_RouteTooLong;
218 case 2: return LDKCreationError_TimestampOutOfBounds;
219 case 3: return LDKCreationError_InvalidAmount;
220 case 4: return LDKCreationError_MissingRouteHints;
224 static inline int32_t LDKCreationError_to_js(LDKCreationError val) {
226 case LDKCreationError_DescriptionTooLong: return 0;
227 case LDKCreationError_RouteTooLong: return 1;
228 case LDKCreationError_TimestampOutOfBounds: return 2;
229 case LDKCreationError_InvalidAmount: return 3;
230 case LDKCreationError_MissingRouteHints: return 4;
234 static inline LDKCurrency LDKCurrency_from_js(int32_t ord) {
236 case 0: return LDKCurrency_Bitcoin;
237 case 1: return LDKCurrency_BitcoinTestnet;
238 case 2: return LDKCurrency_Regtest;
239 case 3: return LDKCurrency_Simnet;
240 case 4: return LDKCurrency_Signet;
244 static inline int32_t LDKCurrency_to_js(LDKCurrency val) {
246 case LDKCurrency_Bitcoin: return 0;
247 case LDKCurrency_BitcoinTestnet: return 1;
248 case LDKCurrency_Regtest: return 2;
249 case LDKCurrency_Simnet: return 3;
250 case LDKCurrency_Signet: return 4;
254 static inline LDKHTLCClaim LDKHTLCClaim_from_js(int32_t ord) {
256 case 0: return LDKHTLCClaim_OfferedTimeout;
257 case 1: return LDKHTLCClaim_OfferedPreimage;
258 case 2: return LDKHTLCClaim_AcceptedTimeout;
259 case 3: return LDKHTLCClaim_AcceptedPreimage;
260 case 4: return LDKHTLCClaim_Revocation;
264 static inline int32_t LDKHTLCClaim_to_js(LDKHTLCClaim val) {
266 case LDKHTLCClaim_OfferedTimeout: return 0;
267 case LDKHTLCClaim_OfferedPreimage: return 1;
268 case LDKHTLCClaim_AcceptedTimeout: return 2;
269 case LDKHTLCClaim_AcceptedPreimage: return 3;
270 case LDKHTLCClaim_Revocation: return 4;
274 static inline LDKIOError LDKIOError_from_js(int32_t ord) {
276 case 0: return LDKIOError_NotFound;
277 case 1: return LDKIOError_PermissionDenied;
278 case 2: return LDKIOError_ConnectionRefused;
279 case 3: return LDKIOError_ConnectionReset;
280 case 4: return LDKIOError_ConnectionAborted;
281 case 5: return LDKIOError_NotConnected;
282 case 6: return LDKIOError_AddrInUse;
283 case 7: return LDKIOError_AddrNotAvailable;
284 case 8: return LDKIOError_BrokenPipe;
285 case 9: return LDKIOError_AlreadyExists;
286 case 10: return LDKIOError_WouldBlock;
287 case 11: return LDKIOError_InvalidInput;
288 case 12: return LDKIOError_InvalidData;
289 case 13: return LDKIOError_TimedOut;
290 case 14: return LDKIOError_WriteZero;
291 case 15: return LDKIOError_Interrupted;
292 case 16: return LDKIOError_Other;
293 case 17: return LDKIOError_UnexpectedEof;
297 static inline int32_t LDKIOError_to_js(LDKIOError val) {
299 case LDKIOError_NotFound: return 0;
300 case LDKIOError_PermissionDenied: return 1;
301 case LDKIOError_ConnectionRefused: return 2;
302 case LDKIOError_ConnectionReset: return 3;
303 case LDKIOError_ConnectionAborted: return 4;
304 case LDKIOError_NotConnected: return 5;
305 case LDKIOError_AddrInUse: return 6;
306 case LDKIOError_AddrNotAvailable: return 7;
307 case LDKIOError_BrokenPipe: return 8;
308 case LDKIOError_AlreadyExists: return 9;
309 case LDKIOError_WouldBlock: return 10;
310 case LDKIOError_InvalidInput: return 11;
311 case LDKIOError_InvalidData: return 12;
312 case LDKIOError_TimedOut: return 13;
313 case LDKIOError_WriteZero: return 14;
314 case LDKIOError_Interrupted: return 15;
315 case LDKIOError_Other: return 16;
316 case LDKIOError_UnexpectedEof: return 17;
320 static inline LDKLevel LDKLevel_from_js(int32_t ord) {
322 case 0: return LDKLevel_Gossip;
323 case 1: return LDKLevel_Trace;
324 case 2: return LDKLevel_Debug;
325 case 3: return LDKLevel_Info;
326 case 4: return LDKLevel_Warn;
327 case 5: return LDKLevel_Error;
331 static inline int32_t LDKLevel_to_js(LDKLevel val) {
333 case LDKLevel_Gossip: return 0;
334 case LDKLevel_Trace: return 1;
335 case LDKLevel_Debug: return 2;
336 case LDKLevel_Info: return 3;
337 case LDKLevel_Warn: return 4;
338 case LDKLevel_Error: return 5;
342 static inline LDKNetwork LDKNetwork_from_js(int32_t ord) {
344 case 0: return LDKNetwork_Bitcoin;
345 case 1: return LDKNetwork_Testnet;
346 case 2: return LDKNetwork_Regtest;
347 case 3: return LDKNetwork_Signet;
351 static inline int32_t LDKNetwork_to_js(LDKNetwork val) {
353 case LDKNetwork_Bitcoin: return 0;
354 case LDKNetwork_Testnet: return 1;
355 case LDKNetwork_Regtest: return 2;
356 case LDKNetwork_Signet: return 3;
360 static inline LDKRecipient LDKRecipient_from_js(int32_t ord) {
362 case 0: return LDKRecipient_Node;
363 case 1: return LDKRecipient_PhantomNode;
367 static inline int32_t LDKRecipient_to_js(LDKRecipient val) {
369 case LDKRecipient_Node: return 0;
370 case LDKRecipient_PhantomNode: return 1;
374 static inline LDKSecp256k1Error LDKSecp256k1Error_from_js(int32_t ord) {
376 case 0: return LDKSecp256k1Error_IncorrectSignature;
377 case 1: return LDKSecp256k1Error_InvalidMessage;
378 case 2: return LDKSecp256k1Error_InvalidPublicKey;
379 case 3: return LDKSecp256k1Error_InvalidSignature;
380 case 4: return LDKSecp256k1Error_InvalidSecretKey;
381 case 5: return LDKSecp256k1Error_InvalidSharedSecret;
382 case 6: return LDKSecp256k1Error_InvalidRecoveryId;
383 case 7: return LDKSecp256k1Error_InvalidTweak;
384 case 8: return LDKSecp256k1Error_NotEnoughMemory;
385 case 9: return LDKSecp256k1Error_InvalidPublicKeySum;
386 case 10: return LDKSecp256k1Error_InvalidParityValue;
390 static inline int32_t LDKSecp256k1Error_to_js(LDKSecp256k1Error val) {
392 case LDKSecp256k1Error_IncorrectSignature: return 0;
393 case LDKSecp256k1Error_InvalidMessage: return 1;
394 case LDKSecp256k1Error_InvalidPublicKey: return 2;
395 case LDKSecp256k1Error_InvalidSignature: return 3;
396 case LDKSecp256k1Error_InvalidSecretKey: return 4;
397 case LDKSecp256k1Error_InvalidSharedSecret: return 5;
398 case LDKSecp256k1Error_InvalidRecoveryId: return 6;
399 case LDKSecp256k1Error_InvalidTweak: return 7;
400 case LDKSecp256k1Error_NotEnoughMemory: return 8;
401 case LDKSecp256k1Error_InvalidPublicKeySum: return 9;
402 case LDKSecp256k1Error_InvalidParityValue: return 10;
406 static inline LDKSemanticError LDKSemanticError_from_js(int32_t ord) {
408 case 0: return LDKSemanticError_NoPaymentHash;
409 case 1: return LDKSemanticError_MultiplePaymentHashes;
410 case 2: return LDKSemanticError_NoDescription;
411 case 3: return LDKSemanticError_MultipleDescriptions;
412 case 4: return LDKSemanticError_NoPaymentSecret;
413 case 5: return LDKSemanticError_MultiplePaymentSecrets;
414 case 6: return LDKSemanticError_InvalidFeatures;
415 case 7: return LDKSemanticError_InvalidRecoveryId;
416 case 8: return LDKSemanticError_InvalidSignature;
417 case 9: return LDKSemanticError_ImpreciseAmount;
421 static inline int32_t LDKSemanticError_to_js(LDKSemanticError val) {
423 case LDKSemanticError_NoPaymentHash: return 0;
424 case LDKSemanticError_MultiplePaymentHashes: return 1;
425 case LDKSemanticError_NoDescription: return 2;
426 case LDKSemanticError_MultipleDescriptions: return 3;
427 case LDKSemanticError_NoPaymentSecret: return 4;
428 case LDKSemanticError_MultiplePaymentSecrets: return 5;
429 case LDKSemanticError_InvalidFeatures: return 6;
430 case LDKSemanticError_InvalidRecoveryId: return 7;
431 case LDKSemanticError_InvalidSignature: return 8;
432 case LDKSemanticError_ImpreciseAmount: return 9;
436 static inline LDKSiPrefix LDKSiPrefix_from_js(int32_t ord) {
438 case 0: return LDKSiPrefix_Milli;
439 case 1: return LDKSiPrefix_Micro;
440 case 2: return LDKSiPrefix_Nano;
441 case 3: return LDKSiPrefix_Pico;
445 static inline int32_t LDKSiPrefix_to_js(LDKSiPrefix val) {
447 case LDKSiPrefix_Milli: return 0;
448 case LDKSiPrefix_Micro: return 1;
449 case LDKSiPrefix_Nano: return 2;
450 case LDKSiPrefix_Pico: return 3;
454 struct LDKThirtyTwoBytes BigEndianScalar_get_bytes (struct LDKBigEndianScalar* thing) {
455 LDKThirtyTwoBytes ret = { .data = *thing->big_endian_bytes };
458 int8_tArray __attribute__((export_name("TS_BigEndianScalar_get_bytes"))) TS_BigEndianScalar_get_bytes(uint64_t thing) {
459 LDKBigEndianScalar* thing_conv = (LDKBigEndianScalar*)untag_ptr(thing);
460 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
461 memcpy(ret_arr->elems, BigEndianScalar_get_bytes(thing_conv).data, 32);
465 static void BigEndianScalar_free (struct LDKBigEndianScalar thing) {}
466 void __attribute__((export_name("TS_BigEndianScalar_free"))) TS_BigEndianScalar_free(uint64_t thing) {
467 if (!ptr_is_owned(thing)) return;
468 void* thing_ptr = untag_ptr(thing);
469 CHECK_ACCESS(thing_ptr);
470 LDKBigEndianScalar thing_conv = *(LDKBigEndianScalar*)(thing_ptr);
471 FREE(untag_ptr(thing));
472 BigEndianScalar_free(thing_conv);
475 uint32_t __attribute__((export_name("TS_LDKBech32Error_ty_from_ptr"))) TS_LDKBech32Error_ty_from_ptr(uint64_t ptr) {
476 LDKBech32Error *obj = (LDKBech32Error*)untag_ptr(ptr);
478 case LDKBech32Error_MissingSeparator: return 0;
479 case LDKBech32Error_InvalidChecksum: return 1;
480 case LDKBech32Error_InvalidLength: return 2;
481 case LDKBech32Error_InvalidChar: return 3;
482 case LDKBech32Error_InvalidData: return 4;
483 case LDKBech32Error_InvalidPadding: return 5;
484 case LDKBech32Error_MixedCase: return 6;
488 int32_t __attribute__((export_name("TS_LDKBech32Error_InvalidChar_get_invalid_char"))) TS_LDKBech32Error_InvalidChar_get_invalid_char(uint64_t ptr) {
489 LDKBech32Error *obj = (LDKBech32Error*)untag_ptr(ptr);
490 assert(obj->tag == LDKBech32Error_InvalidChar);
491 int32_t invalid_char_conv = obj->invalid_char;
492 return invalid_char_conv;
494 int8_t __attribute__((export_name("TS_LDKBech32Error_InvalidData_get_invalid_data"))) TS_LDKBech32Error_InvalidData_get_invalid_data(uint64_t ptr) {
495 LDKBech32Error *obj = (LDKBech32Error*)untag_ptr(ptr);
496 assert(obj->tag == LDKBech32Error_InvalidData);
497 int8_t invalid_data_conv = obj->invalid_data;
498 return invalid_data_conv;
500 static inline LDKCVec_u8Z CVec_u8Z_clone(const LDKCVec_u8Z *orig) {
501 LDKCVec_u8Z ret = { .data = MALLOC(sizeof(int8_t) * orig->datalen, "LDKCVec_u8Z clone bytes"), .datalen = orig->datalen };
502 memcpy(ret.data, orig->data, sizeof(int8_t) * ret.datalen);
505 struct LDKCVec_u8Z TxOut_get_script_pubkey (struct LDKTxOut* thing) { return CVec_u8Z_clone(&thing->script_pubkey);}int8_tArray __attribute__((export_name("TS_TxOut_get_script_pubkey"))) TS_TxOut_get_script_pubkey(uint64_t thing) {
506 LDKTxOut* thing_conv = (LDKTxOut*)untag_ptr(thing);
507 LDKCVec_u8Z ret_var = TxOut_get_script_pubkey(thing_conv);
508 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
509 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
510 CVec_u8Z_free(ret_var);
514 uint64_t TxOut_get_value (struct LDKTxOut* thing) { return thing->value;}int64_t __attribute__((export_name("TS_TxOut_get_value"))) TS_TxOut_get_value(uint64_t thing) {
515 LDKTxOut* thing_conv = (LDKTxOut*)untag_ptr(thing);
516 int64_t ret_conv = TxOut_get_value(thing_conv);
520 uint32_t __attribute__((export_name("TS_LDKCOption_HTLCClaimZ_ty_from_ptr"))) TS_LDKCOption_HTLCClaimZ_ty_from_ptr(uint64_t ptr) {
521 LDKCOption_HTLCClaimZ *obj = (LDKCOption_HTLCClaimZ*)untag_ptr(ptr);
523 case LDKCOption_HTLCClaimZ_Some: return 0;
524 case LDKCOption_HTLCClaimZ_None: return 1;
528 uint32_t __attribute__((export_name("TS_LDKCOption_HTLCClaimZ_Some_get_some"))) TS_LDKCOption_HTLCClaimZ_Some_get_some(uint64_t ptr) {
529 LDKCOption_HTLCClaimZ *obj = (LDKCOption_HTLCClaimZ*)untag_ptr(ptr);
530 assert(obj->tag == LDKCOption_HTLCClaimZ_Some);
531 uint32_t some_conv = LDKHTLCClaim_to_js(obj->some);
534 static inline void CResult_NoneNoneZ_get_ok(LDKCResult_NoneNoneZ *NONNULL_PTR owner){
535 CHECK(owner->result_ok);
536 return *owner->contents.result;
538 void __attribute__((export_name("TS_CResult_NoneNoneZ_get_ok"))) TS_CResult_NoneNoneZ_get_ok(uint64_t owner) {
539 LDKCResult_NoneNoneZ* owner_conv = (LDKCResult_NoneNoneZ*)untag_ptr(owner);
540 CResult_NoneNoneZ_get_ok(owner_conv);
543 static inline void CResult_NoneNoneZ_get_err(LDKCResult_NoneNoneZ *NONNULL_PTR owner){
544 CHECK(!owner->result_ok);
545 return *owner->contents.err;
547 void __attribute__((export_name("TS_CResult_NoneNoneZ_get_err"))) TS_CResult_NoneNoneZ_get_err(uint64_t owner) {
548 LDKCResult_NoneNoneZ* owner_conv = (LDKCResult_NoneNoneZ*)untag_ptr(owner);
549 CResult_NoneNoneZ_get_err(owner_conv);
552 uint32_t __attribute__((export_name("TS_LDKDecodeError_ty_from_ptr"))) TS_LDKDecodeError_ty_from_ptr(uint64_t ptr) {
553 LDKDecodeError *obj = (LDKDecodeError*)untag_ptr(ptr);
555 case LDKDecodeError_UnknownVersion: return 0;
556 case LDKDecodeError_UnknownRequiredFeature: return 1;
557 case LDKDecodeError_InvalidValue: return 2;
558 case LDKDecodeError_ShortRead: return 3;
559 case LDKDecodeError_BadLengthDescriptor: return 4;
560 case LDKDecodeError_Io: return 5;
561 case LDKDecodeError_UnsupportedCompression: return 6;
565 uint32_t __attribute__((export_name("TS_LDKDecodeError_Io_get_io"))) TS_LDKDecodeError_Io_get_io(uint64_t ptr) {
566 LDKDecodeError *obj = (LDKDecodeError*)untag_ptr(ptr);
567 assert(obj->tag == LDKDecodeError_Io);
568 uint32_t io_conv = LDKIOError_to_js(obj->io);
571 static inline struct LDKCounterpartyCommitmentSecrets CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner){
572 LDKCounterpartyCommitmentSecrets ret = *owner->contents.result;
573 ret.is_owned = false;
576 uint64_t __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(uint64_t owner) {
577 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* owner_conv = (LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ*)untag_ptr(owner);
578 LDKCounterpartyCommitmentSecrets ret_var = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner_conv);
579 uint64_t ret_ref = 0;
580 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
581 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
585 static inline struct LDKDecodeError CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner){
586 CHECK(!owner->result_ok);
587 return DecodeError_clone(&*owner->contents.err);
589 uint64_t __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(uint64_t owner) {
590 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* owner_conv = (LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ*)untag_ptr(owner);
591 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
592 *ret_copy = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner_conv);
593 uint64_t ret_ref = tag_ptr(ret_copy, true);
597 static inline struct LDKTxCreationKeys CResult_TxCreationKeysDecodeErrorZ_get_ok(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner){
598 LDKTxCreationKeys ret = *owner->contents.result;
599 ret.is_owned = false;
602 uint64_t __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_get_ok"))) TS_CResult_TxCreationKeysDecodeErrorZ_get_ok(uint64_t owner) {
603 LDKCResult_TxCreationKeysDecodeErrorZ* owner_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)untag_ptr(owner);
604 LDKTxCreationKeys ret_var = CResult_TxCreationKeysDecodeErrorZ_get_ok(owner_conv);
605 uint64_t ret_ref = 0;
606 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
607 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
611 static inline struct LDKDecodeError CResult_TxCreationKeysDecodeErrorZ_get_err(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner){
612 CHECK(!owner->result_ok);
613 return DecodeError_clone(&*owner->contents.err);
615 uint64_t __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_get_err"))) TS_CResult_TxCreationKeysDecodeErrorZ_get_err(uint64_t owner) {
616 LDKCResult_TxCreationKeysDecodeErrorZ* owner_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)untag_ptr(owner);
617 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
618 *ret_copy = CResult_TxCreationKeysDecodeErrorZ_get_err(owner_conv);
619 uint64_t ret_ref = tag_ptr(ret_copy, true);
623 static inline struct LDKChannelPublicKeys CResult_ChannelPublicKeysDecodeErrorZ_get_ok(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner){
624 LDKChannelPublicKeys ret = *owner->contents.result;
625 ret.is_owned = false;
628 uint64_t __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_get_ok"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_get_ok(uint64_t owner) {
629 LDKCResult_ChannelPublicKeysDecodeErrorZ* owner_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)untag_ptr(owner);
630 LDKChannelPublicKeys ret_var = CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner_conv);
631 uint64_t ret_ref = 0;
632 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
633 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
637 static inline struct LDKDecodeError CResult_ChannelPublicKeysDecodeErrorZ_get_err(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner){
638 CHECK(!owner->result_ok);
639 return DecodeError_clone(&*owner->contents.err);
641 uint64_t __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_get_err"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_get_err(uint64_t owner) {
642 LDKCResult_ChannelPublicKeysDecodeErrorZ* owner_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)untag_ptr(owner);
643 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
644 *ret_copy = CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner_conv);
645 uint64_t ret_ref = tag_ptr(ret_copy, true);
649 uint32_t __attribute__((export_name("TS_LDKCOption_u32Z_ty_from_ptr"))) TS_LDKCOption_u32Z_ty_from_ptr(uint64_t ptr) {
650 LDKCOption_u32Z *obj = (LDKCOption_u32Z*)untag_ptr(ptr);
652 case LDKCOption_u32Z_Some: return 0;
653 case LDKCOption_u32Z_None: return 1;
657 int32_t __attribute__((export_name("TS_LDKCOption_u32Z_Some_get_some"))) TS_LDKCOption_u32Z_Some_get_some(uint64_t ptr) {
658 LDKCOption_u32Z *obj = (LDKCOption_u32Z*)untag_ptr(ptr);
659 assert(obj->tag == LDKCOption_u32Z_Some);
660 int32_t some_conv = obj->some;
663 static inline struct LDKHTLCOutputInCommitment CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner){
664 LDKHTLCOutputInCommitment ret = *owner->contents.result;
665 ret.is_owned = false;
668 uint64_t __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(uint64_t owner) {
669 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* owner_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)untag_ptr(owner);
670 LDKHTLCOutputInCommitment ret_var = CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner_conv);
671 uint64_t ret_ref = 0;
672 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
673 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
677 static inline struct LDKDecodeError CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner){
678 CHECK(!owner->result_ok);
679 return DecodeError_clone(&*owner->contents.err);
681 uint64_t __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(uint64_t owner) {
682 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* owner_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)untag_ptr(owner);
683 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
684 *ret_copy = CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner_conv);
685 uint64_t ret_ref = tag_ptr(ret_copy, true);
689 static inline struct LDKCounterpartyChannelTransactionParameters CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner){
690 LDKCounterpartyChannelTransactionParameters ret = *owner->contents.result;
691 ret.is_owned = false;
694 uint64_t __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(uint64_t owner) {
695 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* owner_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)untag_ptr(owner);
696 LDKCounterpartyChannelTransactionParameters ret_var = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner_conv);
697 uint64_t ret_ref = 0;
698 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
699 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
703 static inline struct LDKDecodeError CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner){
704 CHECK(!owner->result_ok);
705 return DecodeError_clone(&*owner->contents.err);
707 uint64_t __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(uint64_t owner) {
708 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* owner_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)untag_ptr(owner);
709 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
710 *ret_copy = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner_conv);
711 uint64_t ret_ref = tag_ptr(ret_copy, true);
715 static inline struct LDKChannelTransactionParameters CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner){
716 LDKChannelTransactionParameters ret = *owner->contents.result;
717 ret.is_owned = false;
720 uint64_t __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_ok"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(uint64_t owner) {
721 LDKCResult_ChannelTransactionParametersDecodeErrorZ* owner_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)untag_ptr(owner);
722 LDKChannelTransactionParameters ret_var = CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner_conv);
723 uint64_t ret_ref = 0;
724 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
725 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
729 static inline struct LDKDecodeError CResult_ChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner){
730 CHECK(!owner->result_ok);
731 return DecodeError_clone(&*owner->contents.err);
733 uint64_t __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_err"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_err(uint64_t owner) {
734 LDKCResult_ChannelTransactionParametersDecodeErrorZ* owner_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)untag_ptr(owner);
735 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
736 *ret_copy = CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner_conv);
737 uint64_t ret_ref = tag_ptr(ret_copy, true);
741 static inline struct LDKHolderCommitmentTransaction CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner){
742 LDKHolderCommitmentTransaction ret = *owner->contents.result;
743 ret.is_owned = false;
746 uint64_t __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(uint64_t owner) {
747 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* owner_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)untag_ptr(owner);
748 LDKHolderCommitmentTransaction ret_var = CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner_conv);
749 uint64_t ret_ref = 0;
750 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
751 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
755 static inline struct LDKDecodeError CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner){
756 CHECK(!owner->result_ok);
757 return DecodeError_clone(&*owner->contents.err);
759 uint64_t __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_err"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(uint64_t owner) {
760 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* owner_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)untag_ptr(owner);
761 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
762 *ret_copy = CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner_conv);
763 uint64_t ret_ref = tag_ptr(ret_copy, true);
767 static inline struct LDKBuiltCommitmentTransaction CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner){
768 LDKBuiltCommitmentTransaction ret = *owner->contents.result;
769 ret.is_owned = false;
772 uint64_t __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(uint64_t owner) {
773 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* owner_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)untag_ptr(owner);
774 LDKBuiltCommitmentTransaction ret_var = CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner_conv);
775 uint64_t ret_ref = 0;
776 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
777 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
781 static inline struct LDKDecodeError CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner){
782 CHECK(!owner->result_ok);
783 return DecodeError_clone(&*owner->contents.err);
785 uint64_t __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(uint64_t owner) {
786 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* owner_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)untag_ptr(owner);
787 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
788 *ret_copy = CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner_conv);
789 uint64_t ret_ref = tag_ptr(ret_copy, true);
793 static inline struct LDKTrustedClosingTransaction CResult_TrustedClosingTransactionNoneZ_get_ok(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner){
794 LDKTrustedClosingTransaction ret = *owner->contents.result;
795 ret.is_owned = false;
798 uint64_t __attribute__((export_name("TS_CResult_TrustedClosingTransactionNoneZ_get_ok"))) TS_CResult_TrustedClosingTransactionNoneZ_get_ok(uint64_t owner) {
799 LDKCResult_TrustedClosingTransactionNoneZ* owner_conv = (LDKCResult_TrustedClosingTransactionNoneZ*)untag_ptr(owner);
800 LDKTrustedClosingTransaction ret_var = CResult_TrustedClosingTransactionNoneZ_get_ok(owner_conv);
801 uint64_t ret_ref = 0;
802 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
803 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
807 static inline void CResult_TrustedClosingTransactionNoneZ_get_err(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner){
808 CHECK(!owner->result_ok);
809 return *owner->contents.err;
811 void __attribute__((export_name("TS_CResult_TrustedClosingTransactionNoneZ_get_err"))) TS_CResult_TrustedClosingTransactionNoneZ_get_err(uint64_t owner) {
812 LDKCResult_TrustedClosingTransactionNoneZ* owner_conv = (LDKCResult_TrustedClosingTransactionNoneZ*)untag_ptr(owner);
813 CResult_TrustedClosingTransactionNoneZ_get_err(owner_conv);
816 static inline struct LDKCommitmentTransaction CResult_CommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner){
817 LDKCommitmentTransaction ret = *owner->contents.result;
818 ret.is_owned = false;
821 uint64_t __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_get_ok"))) TS_CResult_CommitmentTransactionDecodeErrorZ_get_ok(uint64_t owner) {
822 LDKCResult_CommitmentTransactionDecodeErrorZ* owner_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)untag_ptr(owner);
823 LDKCommitmentTransaction ret_var = CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner_conv);
824 uint64_t ret_ref = 0;
825 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
826 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
830 static inline struct LDKDecodeError CResult_CommitmentTransactionDecodeErrorZ_get_err(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner){
831 CHECK(!owner->result_ok);
832 return DecodeError_clone(&*owner->contents.err);
834 uint64_t __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_get_err"))) TS_CResult_CommitmentTransactionDecodeErrorZ_get_err(uint64_t owner) {
835 LDKCResult_CommitmentTransactionDecodeErrorZ* owner_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)untag_ptr(owner);
836 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
837 *ret_copy = CResult_CommitmentTransactionDecodeErrorZ_get_err(owner_conv);
838 uint64_t ret_ref = tag_ptr(ret_copy, true);
842 static inline struct LDKTrustedCommitmentTransaction CResult_TrustedCommitmentTransactionNoneZ_get_ok(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner){
843 LDKTrustedCommitmentTransaction ret = *owner->contents.result;
844 ret.is_owned = false;
847 uint64_t __attribute__((export_name("TS_CResult_TrustedCommitmentTransactionNoneZ_get_ok"))) TS_CResult_TrustedCommitmentTransactionNoneZ_get_ok(uint64_t owner) {
848 LDKCResult_TrustedCommitmentTransactionNoneZ* owner_conv = (LDKCResult_TrustedCommitmentTransactionNoneZ*)untag_ptr(owner);
849 LDKTrustedCommitmentTransaction ret_var = CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner_conv);
850 uint64_t ret_ref = 0;
851 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
852 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
856 static inline void CResult_TrustedCommitmentTransactionNoneZ_get_err(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner){
857 CHECK(!owner->result_ok);
858 return *owner->contents.err;
860 void __attribute__((export_name("TS_CResult_TrustedCommitmentTransactionNoneZ_get_err"))) TS_CResult_TrustedCommitmentTransactionNoneZ_get_err(uint64_t owner) {
861 LDKCResult_TrustedCommitmentTransactionNoneZ* owner_conv = (LDKCResult_TrustedCommitmentTransactionNoneZ*)untag_ptr(owner);
862 CResult_TrustedCommitmentTransactionNoneZ_get_err(owner_conv);
865 static inline struct LDKCVec_SignatureZ CResult_CVec_SignatureZNoneZ_get_ok(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner){
866 CHECK(owner->result_ok);
867 return *owner->contents.result;
869 ptrArray __attribute__((export_name("TS_CResult_CVec_SignatureZNoneZ_get_ok"))) TS_CResult_CVec_SignatureZNoneZ_get_ok(uint64_t owner) {
870 LDKCResult_CVec_SignatureZNoneZ* owner_conv = (LDKCResult_CVec_SignatureZNoneZ*)untag_ptr(owner);
871 LDKCVec_SignatureZ ret_var = CResult_CVec_SignatureZNoneZ_get_ok(owner_conv);
872 ptrArray ret_arr = NULL;
873 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
874 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 8);
875 for (size_t m = 0; m < ret_var.datalen; m++) {
876 int8_tArray ret_conv_12_arr = init_int8_tArray(64, __LINE__);
877 memcpy(ret_conv_12_arr->elems, ret_var.data[m].compact_form, 64);
878 ret_arr_ptr[m] = ret_conv_12_arr;
884 static inline void CResult_CVec_SignatureZNoneZ_get_err(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner){
885 CHECK(!owner->result_ok);
886 return *owner->contents.err;
888 void __attribute__((export_name("TS_CResult_CVec_SignatureZNoneZ_get_err"))) TS_CResult_CVec_SignatureZNoneZ_get_err(uint64_t owner) {
889 LDKCResult_CVec_SignatureZNoneZ* owner_conv = (LDKCResult_CVec_SignatureZNoneZ*)untag_ptr(owner);
890 CResult_CVec_SignatureZNoneZ_get_err(owner_conv);
893 static inline struct LDKShutdownScript CResult_ShutdownScriptDecodeErrorZ_get_ok(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner){
894 LDKShutdownScript ret = *owner->contents.result;
895 ret.is_owned = false;
898 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_get_ok"))) TS_CResult_ShutdownScriptDecodeErrorZ_get_ok(uint64_t owner) {
899 LDKCResult_ShutdownScriptDecodeErrorZ* owner_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)untag_ptr(owner);
900 LDKShutdownScript ret_var = CResult_ShutdownScriptDecodeErrorZ_get_ok(owner_conv);
901 uint64_t ret_ref = 0;
902 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
903 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
907 static inline struct LDKDecodeError CResult_ShutdownScriptDecodeErrorZ_get_err(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner){
908 CHECK(!owner->result_ok);
909 return DecodeError_clone(&*owner->contents.err);
911 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_get_err"))) TS_CResult_ShutdownScriptDecodeErrorZ_get_err(uint64_t owner) {
912 LDKCResult_ShutdownScriptDecodeErrorZ* owner_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)untag_ptr(owner);
913 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
914 *ret_copy = CResult_ShutdownScriptDecodeErrorZ_get_err(owner_conv);
915 uint64_t ret_ref = tag_ptr(ret_copy, true);
919 static inline struct LDKShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner){
920 LDKShutdownScript ret = *owner->contents.result;
921 ret.is_owned = false;
924 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(uint64_t owner) {
925 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* owner_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)untag_ptr(owner);
926 LDKShutdownScript ret_var = CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner_conv);
927 uint64_t ret_ref = 0;
928 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
929 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
933 static inline struct LDKInvalidShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner){
934 LDKInvalidShutdownScript ret = *owner->contents.err;
935 ret.is_owned = false;
938 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_err"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(uint64_t owner) {
939 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* owner_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)untag_ptr(owner);
940 LDKInvalidShutdownScript ret_var = CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner_conv);
941 uint64_t ret_ref = 0;
942 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
943 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
947 static inline struct LDKBlindedPath CResult_BlindedPathNoneZ_get_ok(LDKCResult_BlindedPathNoneZ *NONNULL_PTR owner){
948 LDKBlindedPath ret = *owner->contents.result;
949 ret.is_owned = false;
952 uint64_t __attribute__((export_name("TS_CResult_BlindedPathNoneZ_get_ok"))) TS_CResult_BlindedPathNoneZ_get_ok(uint64_t owner) {
953 LDKCResult_BlindedPathNoneZ* owner_conv = (LDKCResult_BlindedPathNoneZ*)untag_ptr(owner);
954 LDKBlindedPath ret_var = CResult_BlindedPathNoneZ_get_ok(owner_conv);
955 uint64_t ret_ref = 0;
956 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
957 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
961 static inline void CResult_BlindedPathNoneZ_get_err(LDKCResult_BlindedPathNoneZ *NONNULL_PTR owner){
962 CHECK(!owner->result_ok);
963 return *owner->contents.err;
965 void __attribute__((export_name("TS_CResult_BlindedPathNoneZ_get_err"))) TS_CResult_BlindedPathNoneZ_get_err(uint64_t owner) {
966 LDKCResult_BlindedPathNoneZ* owner_conv = (LDKCResult_BlindedPathNoneZ*)untag_ptr(owner);
967 CResult_BlindedPathNoneZ_get_err(owner_conv);
970 static inline struct LDKBlindedPath CResult_BlindedPathDecodeErrorZ_get_ok(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR owner){
971 LDKBlindedPath ret = *owner->contents.result;
972 ret.is_owned = false;
975 uint64_t __attribute__((export_name("TS_CResult_BlindedPathDecodeErrorZ_get_ok"))) TS_CResult_BlindedPathDecodeErrorZ_get_ok(uint64_t owner) {
976 LDKCResult_BlindedPathDecodeErrorZ* owner_conv = (LDKCResult_BlindedPathDecodeErrorZ*)untag_ptr(owner);
977 LDKBlindedPath ret_var = CResult_BlindedPathDecodeErrorZ_get_ok(owner_conv);
978 uint64_t ret_ref = 0;
979 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
980 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
984 static inline struct LDKDecodeError CResult_BlindedPathDecodeErrorZ_get_err(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR owner){
985 CHECK(!owner->result_ok);
986 return DecodeError_clone(&*owner->contents.err);
988 uint64_t __attribute__((export_name("TS_CResult_BlindedPathDecodeErrorZ_get_err"))) TS_CResult_BlindedPathDecodeErrorZ_get_err(uint64_t owner) {
989 LDKCResult_BlindedPathDecodeErrorZ* owner_conv = (LDKCResult_BlindedPathDecodeErrorZ*)untag_ptr(owner);
990 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
991 *ret_copy = CResult_BlindedPathDecodeErrorZ_get_err(owner_conv);
992 uint64_t ret_ref = tag_ptr(ret_copy, true);
996 static inline struct LDKBlindedHop CResult_BlindedHopDecodeErrorZ_get_ok(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner){
997 LDKBlindedHop ret = *owner->contents.result;
998 ret.is_owned = false;
1001 uint64_t __attribute__((export_name("TS_CResult_BlindedHopDecodeErrorZ_get_ok"))) TS_CResult_BlindedHopDecodeErrorZ_get_ok(uint64_t owner) {
1002 LDKCResult_BlindedHopDecodeErrorZ* owner_conv = (LDKCResult_BlindedHopDecodeErrorZ*)untag_ptr(owner);
1003 LDKBlindedHop ret_var = CResult_BlindedHopDecodeErrorZ_get_ok(owner_conv);
1004 uint64_t ret_ref = 0;
1005 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1006 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1010 static inline struct LDKDecodeError CResult_BlindedHopDecodeErrorZ_get_err(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner){
1011 CHECK(!owner->result_ok);
1012 return DecodeError_clone(&*owner->contents.err);
1014 uint64_t __attribute__((export_name("TS_CResult_BlindedHopDecodeErrorZ_get_err"))) TS_CResult_BlindedHopDecodeErrorZ_get_err(uint64_t owner) {
1015 LDKCResult_BlindedHopDecodeErrorZ* owner_conv = (LDKCResult_BlindedHopDecodeErrorZ*)untag_ptr(owner);
1016 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1017 *ret_copy = CResult_BlindedHopDecodeErrorZ_get_err(owner_conv);
1018 uint64_t ret_ref = tag_ptr(ret_copy, true);
1022 static inline LDKCVec_ChannelDetailsZ CVec_ChannelDetailsZ_clone(const LDKCVec_ChannelDetailsZ *orig) {
1023 LDKCVec_ChannelDetailsZ ret = { .data = MALLOC(sizeof(LDKChannelDetails) * orig->datalen, "LDKCVec_ChannelDetailsZ clone bytes"), .datalen = orig->datalen };
1024 for (size_t i = 0; i < ret.datalen; i++) {
1025 ret.data[i] = ChannelDetails_clone(&orig->data[i]);
1029 static inline struct LDKRoute CResult_RouteLightningErrorZ_get_ok(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner){
1030 LDKRoute ret = *owner->contents.result;
1031 ret.is_owned = false;
1034 uint64_t __attribute__((export_name("TS_CResult_RouteLightningErrorZ_get_ok"))) TS_CResult_RouteLightningErrorZ_get_ok(uint64_t owner) {
1035 LDKCResult_RouteLightningErrorZ* owner_conv = (LDKCResult_RouteLightningErrorZ*)untag_ptr(owner);
1036 LDKRoute ret_var = CResult_RouteLightningErrorZ_get_ok(owner_conv);
1037 uint64_t ret_ref = 0;
1038 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1039 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1043 static inline struct LDKLightningError CResult_RouteLightningErrorZ_get_err(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner){
1044 LDKLightningError ret = *owner->contents.err;
1045 ret.is_owned = false;
1048 uint64_t __attribute__((export_name("TS_CResult_RouteLightningErrorZ_get_err"))) TS_CResult_RouteLightningErrorZ_get_err(uint64_t owner) {
1049 LDKCResult_RouteLightningErrorZ* owner_conv = (LDKCResult_RouteLightningErrorZ*)untag_ptr(owner);
1050 LDKLightningError ret_var = CResult_RouteLightningErrorZ_get_err(owner_conv);
1051 uint64_t ret_ref = 0;
1052 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1053 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1057 static inline LDKCVec_RouteHopZ CVec_RouteHopZ_clone(const LDKCVec_RouteHopZ *orig) {
1058 LDKCVec_RouteHopZ ret = { .data = MALLOC(sizeof(LDKRouteHop) * orig->datalen, "LDKCVec_RouteHopZ clone bytes"), .datalen = orig->datalen };
1059 for (size_t i = 0; i < ret.datalen; i++) {
1060 ret.data[i] = RouteHop_clone(&orig->data[i]);
1064 uint32_t __attribute__((export_name("TS_LDKCOption_u64Z_ty_from_ptr"))) TS_LDKCOption_u64Z_ty_from_ptr(uint64_t ptr) {
1065 LDKCOption_u64Z *obj = (LDKCOption_u64Z*)untag_ptr(ptr);
1067 case LDKCOption_u64Z_Some: return 0;
1068 case LDKCOption_u64Z_None: return 1;
1072 int64_t __attribute__((export_name("TS_LDKCOption_u64Z_Some_get_some"))) TS_LDKCOption_u64Z_Some_get_some(uint64_t ptr) {
1073 LDKCOption_u64Z *obj = (LDKCOption_u64Z*)untag_ptr(ptr);
1074 assert(obj->tag == LDKCOption_u64Z_Some);
1075 int64_t some_conv = obj->some;
1078 static inline struct LDKInFlightHtlcs CResult_InFlightHtlcsDecodeErrorZ_get_ok(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR owner){
1079 LDKInFlightHtlcs ret = *owner->contents.result;
1080 ret.is_owned = false;
1083 uint64_t __attribute__((export_name("TS_CResult_InFlightHtlcsDecodeErrorZ_get_ok"))) TS_CResult_InFlightHtlcsDecodeErrorZ_get_ok(uint64_t owner) {
1084 LDKCResult_InFlightHtlcsDecodeErrorZ* owner_conv = (LDKCResult_InFlightHtlcsDecodeErrorZ*)untag_ptr(owner);
1085 LDKInFlightHtlcs ret_var = CResult_InFlightHtlcsDecodeErrorZ_get_ok(owner_conv);
1086 uint64_t ret_ref = 0;
1087 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1088 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1092 static inline struct LDKDecodeError CResult_InFlightHtlcsDecodeErrorZ_get_err(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR owner){
1093 CHECK(!owner->result_ok);
1094 return DecodeError_clone(&*owner->contents.err);
1096 uint64_t __attribute__((export_name("TS_CResult_InFlightHtlcsDecodeErrorZ_get_err"))) TS_CResult_InFlightHtlcsDecodeErrorZ_get_err(uint64_t owner) {
1097 LDKCResult_InFlightHtlcsDecodeErrorZ* owner_conv = (LDKCResult_InFlightHtlcsDecodeErrorZ*)untag_ptr(owner);
1098 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1099 *ret_copy = CResult_InFlightHtlcsDecodeErrorZ_get_err(owner_conv);
1100 uint64_t ret_ref = tag_ptr(ret_copy, true);
1104 static inline struct LDKRouteHop CResult_RouteHopDecodeErrorZ_get_ok(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner){
1105 LDKRouteHop ret = *owner->contents.result;
1106 ret.is_owned = false;
1109 uint64_t __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_get_ok"))) TS_CResult_RouteHopDecodeErrorZ_get_ok(uint64_t owner) {
1110 LDKCResult_RouteHopDecodeErrorZ* owner_conv = (LDKCResult_RouteHopDecodeErrorZ*)untag_ptr(owner);
1111 LDKRouteHop ret_var = CResult_RouteHopDecodeErrorZ_get_ok(owner_conv);
1112 uint64_t ret_ref = 0;
1113 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1114 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1118 static inline struct LDKDecodeError CResult_RouteHopDecodeErrorZ_get_err(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner){
1119 CHECK(!owner->result_ok);
1120 return DecodeError_clone(&*owner->contents.err);
1122 uint64_t __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_get_err"))) TS_CResult_RouteHopDecodeErrorZ_get_err(uint64_t owner) {
1123 LDKCResult_RouteHopDecodeErrorZ* owner_conv = (LDKCResult_RouteHopDecodeErrorZ*)untag_ptr(owner);
1124 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1125 *ret_copy = CResult_RouteHopDecodeErrorZ_get_err(owner_conv);
1126 uint64_t ret_ref = tag_ptr(ret_copy, true);
1130 static inline LDKCVec_CVec_RouteHopZZ CVec_CVec_RouteHopZZ_clone(const LDKCVec_CVec_RouteHopZZ *orig) {
1131 LDKCVec_CVec_RouteHopZZ ret = { .data = MALLOC(sizeof(LDKCVec_RouteHopZ) * orig->datalen, "LDKCVec_CVec_RouteHopZZ clone bytes"), .datalen = orig->datalen };
1132 for (size_t i = 0; i < ret.datalen; i++) {
1133 ret.data[i] = CVec_RouteHopZ_clone(&orig->data[i]);
1137 static inline struct LDKRoute CResult_RouteDecodeErrorZ_get_ok(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner){
1138 LDKRoute ret = *owner->contents.result;
1139 ret.is_owned = false;
1142 uint64_t __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_get_ok"))) TS_CResult_RouteDecodeErrorZ_get_ok(uint64_t owner) {
1143 LDKCResult_RouteDecodeErrorZ* owner_conv = (LDKCResult_RouteDecodeErrorZ*)untag_ptr(owner);
1144 LDKRoute ret_var = CResult_RouteDecodeErrorZ_get_ok(owner_conv);
1145 uint64_t ret_ref = 0;
1146 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1147 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1151 static inline struct LDKDecodeError CResult_RouteDecodeErrorZ_get_err(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner){
1152 CHECK(!owner->result_ok);
1153 return DecodeError_clone(&*owner->contents.err);
1155 uint64_t __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_get_err"))) TS_CResult_RouteDecodeErrorZ_get_err(uint64_t owner) {
1156 LDKCResult_RouteDecodeErrorZ* owner_conv = (LDKCResult_RouteDecodeErrorZ*)untag_ptr(owner);
1157 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1158 *ret_copy = CResult_RouteDecodeErrorZ_get_err(owner_conv);
1159 uint64_t ret_ref = tag_ptr(ret_copy, true);
1163 static inline struct LDKRouteParameters CResult_RouteParametersDecodeErrorZ_get_ok(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner){
1164 LDKRouteParameters ret = *owner->contents.result;
1165 ret.is_owned = false;
1168 uint64_t __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_get_ok"))) TS_CResult_RouteParametersDecodeErrorZ_get_ok(uint64_t owner) {
1169 LDKCResult_RouteParametersDecodeErrorZ* owner_conv = (LDKCResult_RouteParametersDecodeErrorZ*)untag_ptr(owner);
1170 LDKRouteParameters ret_var = CResult_RouteParametersDecodeErrorZ_get_ok(owner_conv);
1171 uint64_t ret_ref = 0;
1172 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1173 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1177 static inline struct LDKDecodeError CResult_RouteParametersDecodeErrorZ_get_err(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner){
1178 CHECK(!owner->result_ok);
1179 return DecodeError_clone(&*owner->contents.err);
1181 uint64_t __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_get_err"))) TS_CResult_RouteParametersDecodeErrorZ_get_err(uint64_t owner) {
1182 LDKCResult_RouteParametersDecodeErrorZ* owner_conv = (LDKCResult_RouteParametersDecodeErrorZ*)untag_ptr(owner);
1183 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1184 *ret_copy = CResult_RouteParametersDecodeErrorZ_get_err(owner_conv);
1185 uint64_t ret_ref = tag_ptr(ret_copy, true);
1189 static inline LDKCVec_RouteHintZ CVec_RouteHintZ_clone(const LDKCVec_RouteHintZ *orig) {
1190 LDKCVec_RouteHintZ ret = { .data = MALLOC(sizeof(LDKRouteHint) * orig->datalen, "LDKCVec_RouteHintZ clone bytes"), .datalen = orig->datalen };
1191 for (size_t i = 0; i < ret.datalen; i++) {
1192 ret.data[i] = RouteHint_clone(&orig->data[i]);
1196 static inline LDKCVec_u64Z CVec_u64Z_clone(const LDKCVec_u64Z *orig) {
1197 LDKCVec_u64Z ret = { .data = MALLOC(sizeof(int64_t) * orig->datalen, "LDKCVec_u64Z clone bytes"), .datalen = orig->datalen };
1198 memcpy(ret.data, orig->data, sizeof(int64_t) * ret.datalen);
1201 static inline struct LDKPaymentParameters CResult_PaymentParametersDecodeErrorZ_get_ok(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner){
1202 LDKPaymentParameters ret = *owner->contents.result;
1203 ret.is_owned = false;
1206 uint64_t __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_get_ok"))) TS_CResult_PaymentParametersDecodeErrorZ_get_ok(uint64_t owner) {
1207 LDKCResult_PaymentParametersDecodeErrorZ* owner_conv = (LDKCResult_PaymentParametersDecodeErrorZ*)untag_ptr(owner);
1208 LDKPaymentParameters ret_var = CResult_PaymentParametersDecodeErrorZ_get_ok(owner_conv);
1209 uint64_t ret_ref = 0;
1210 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1211 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1215 static inline struct LDKDecodeError CResult_PaymentParametersDecodeErrorZ_get_err(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner){
1216 CHECK(!owner->result_ok);
1217 return DecodeError_clone(&*owner->contents.err);
1219 uint64_t __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_get_err"))) TS_CResult_PaymentParametersDecodeErrorZ_get_err(uint64_t owner) {
1220 LDKCResult_PaymentParametersDecodeErrorZ* owner_conv = (LDKCResult_PaymentParametersDecodeErrorZ*)untag_ptr(owner);
1221 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1222 *ret_copy = CResult_PaymentParametersDecodeErrorZ_get_err(owner_conv);
1223 uint64_t ret_ref = tag_ptr(ret_copy, true);
1227 static inline LDKCVec_RouteHintHopZ CVec_RouteHintHopZ_clone(const LDKCVec_RouteHintHopZ *orig) {
1228 LDKCVec_RouteHintHopZ ret = { .data = MALLOC(sizeof(LDKRouteHintHop) * orig->datalen, "LDKCVec_RouteHintHopZ clone bytes"), .datalen = orig->datalen };
1229 for (size_t i = 0; i < ret.datalen; i++) {
1230 ret.data[i] = RouteHintHop_clone(&orig->data[i]);
1234 static inline struct LDKRouteHint CResult_RouteHintDecodeErrorZ_get_ok(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner){
1235 LDKRouteHint ret = *owner->contents.result;
1236 ret.is_owned = false;
1239 uint64_t __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_get_ok"))) TS_CResult_RouteHintDecodeErrorZ_get_ok(uint64_t owner) {
1240 LDKCResult_RouteHintDecodeErrorZ* owner_conv = (LDKCResult_RouteHintDecodeErrorZ*)untag_ptr(owner);
1241 LDKRouteHint ret_var = CResult_RouteHintDecodeErrorZ_get_ok(owner_conv);
1242 uint64_t ret_ref = 0;
1243 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1244 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1248 static inline struct LDKDecodeError CResult_RouteHintDecodeErrorZ_get_err(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner){
1249 CHECK(!owner->result_ok);
1250 return DecodeError_clone(&*owner->contents.err);
1252 uint64_t __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_get_err"))) TS_CResult_RouteHintDecodeErrorZ_get_err(uint64_t owner) {
1253 LDKCResult_RouteHintDecodeErrorZ* owner_conv = (LDKCResult_RouteHintDecodeErrorZ*)untag_ptr(owner);
1254 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1255 *ret_copy = CResult_RouteHintDecodeErrorZ_get_err(owner_conv);
1256 uint64_t ret_ref = tag_ptr(ret_copy, true);
1260 static inline struct LDKRouteHintHop CResult_RouteHintHopDecodeErrorZ_get_ok(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner){
1261 LDKRouteHintHop ret = *owner->contents.result;
1262 ret.is_owned = false;
1265 uint64_t __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_get_ok"))) TS_CResult_RouteHintHopDecodeErrorZ_get_ok(uint64_t owner) {
1266 LDKCResult_RouteHintHopDecodeErrorZ* owner_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)untag_ptr(owner);
1267 LDKRouteHintHop ret_var = CResult_RouteHintHopDecodeErrorZ_get_ok(owner_conv);
1268 uint64_t ret_ref = 0;
1269 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1270 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1274 static inline struct LDKDecodeError CResult_RouteHintHopDecodeErrorZ_get_err(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner){
1275 CHECK(!owner->result_ok);
1276 return DecodeError_clone(&*owner->contents.err);
1278 uint64_t __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_get_err"))) TS_CResult_RouteHintHopDecodeErrorZ_get_err(uint64_t owner) {
1279 LDKCResult_RouteHintHopDecodeErrorZ* owner_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)untag_ptr(owner);
1280 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1281 *ret_copy = CResult_RouteHintHopDecodeErrorZ_get_err(owner_conv);
1282 uint64_t ret_ref = tag_ptr(ret_copy, true);
1286 uint32_t __attribute__((export_name("TS_LDKPaymentPurpose_ty_from_ptr"))) TS_LDKPaymentPurpose_ty_from_ptr(uint64_t ptr) {
1287 LDKPaymentPurpose *obj = (LDKPaymentPurpose*)untag_ptr(ptr);
1289 case LDKPaymentPurpose_InvoicePayment: return 0;
1290 case LDKPaymentPurpose_SpontaneousPayment: return 1;
1294 int8_tArray __attribute__((export_name("TS_LDKPaymentPurpose_InvoicePayment_get_payment_preimage"))) TS_LDKPaymentPurpose_InvoicePayment_get_payment_preimage(uint64_t ptr) {
1295 LDKPaymentPurpose *obj = (LDKPaymentPurpose*)untag_ptr(ptr);
1296 assert(obj->tag == LDKPaymentPurpose_InvoicePayment);
1297 int8_tArray payment_preimage_arr = init_int8_tArray(32, __LINE__);
1298 memcpy(payment_preimage_arr->elems, obj->invoice_payment.payment_preimage.data, 32);
1299 return payment_preimage_arr;
1301 int8_tArray __attribute__((export_name("TS_LDKPaymentPurpose_InvoicePayment_get_payment_secret"))) TS_LDKPaymentPurpose_InvoicePayment_get_payment_secret(uint64_t ptr) {
1302 LDKPaymentPurpose *obj = (LDKPaymentPurpose*)untag_ptr(ptr);
1303 assert(obj->tag == LDKPaymentPurpose_InvoicePayment);
1304 int8_tArray payment_secret_arr = init_int8_tArray(32, __LINE__);
1305 memcpy(payment_secret_arr->elems, obj->invoice_payment.payment_secret.data, 32);
1306 return payment_secret_arr;
1308 int8_tArray __attribute__((export_name("TS_LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment"))) TS_LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(uint64_t ptr) {
1309 LDKPaymentPurpose *obj = (LDKPaymentPurpose*)untag_ptr(ptr);
1310 assert(obj->tag == LDKPaymentPurpose_SpontaneousPayment);
1311 int8_tArray spontaneous_payment_arr = init_int8_tArray(32, __LINE__);
1312 memcpy(spontaneous_payment_arr->elems, obj->spontaneous_payment.data, 32);
1313 return spontaneous_payment_arr;
1315 static inline struct LDKPaymentPurpose CResult_PaymentPurposeDecodeErrorZ_get_ok(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner){
1316 CHECK(owner->result_ok);
1317 return PaymentPurpose_clone(&*owner->contents.result);
1319 uint64_t __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_get_ok"))) TS_CResult_PaymentPurposeDecodeErrorZ_get_ok(uint64_t owner) {
1320 LDKCResult_PaymentPurposeDecodeErrorZ* owner_conv = (LDKCResult_PaymentPurposeDecodeErrorZ*)untag_ptr(owner);
1321 LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
1322 *ret_copy = CResult_PaymentPurposeDecodeErrorZ_get_ok(owner_conv);
1323 uint64_t ret_ref = tag_ptr(ret_copy, true);
1327 static inline struct LDKDecodeError CResult_PaymentPurposeDecodeErrorZ_get_err(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner){
1328 CHECK(!owner->result_ok);
1329 return DecodeError_clone(&*owner->contents.err);
1331 uint64_t __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_get_err"))) TS_CResult_PaymentPurposeDecodeErrorZ_get_err(uint64_t owner) {
1332 LDKCResult_PaymentPurposeDecodeErrorZ* owner_conv = (LDKCResult_PaymentPurposeDecodeErrorZ*)untag_ptr(owner);
1333 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1334 *ret_copy = CResult_PaymentPurposeDecodeErrorZ_get_err(owner_conv);
1335 uint64_t ret_ref = tag_ptr(ret_copy, true);
1339 uint32_t __attribute__((export_name("TS_LDKClosureReason_ty_from_ptr"))) TS_LDKClosureReason_ty_from_ptr(uint64_t ptr) {
1340 LDKClosureReason *obj = (LDKClosureReason*)untag_ptr(ptr);
1342 case LDKClosureReason_CounterpartyForceClosed: return 0;
1343 case LDKClosureReason_HolderForceClosed: return 1;
1344 case LDKClosureReason_CooperativeClosure: return 2;
1345 case LDKClosureReason_CommitmentTxConfirmed: return 3;
1346 case LDKClosureReason_FundingTimedOut: return 4;
1347 case LDKClosureReason_ProcessingError: return 5;
1348 case LDKClosureReason_DisconnectedPeer: return 6;
1349 case LDKClosureReason_OutdatedChannelManager: return 7;
1353 jstring __attribute__((export_name("TS_LDKClosureReason_CounterpartyForceClosed_get_peer_msg"))) TS_LDKClosureReason_CounterpartyForceClosed_get_peer_msg(uint64_t ptr) {
1354 LDKClosureReason *obj = (LDKClosureReason*)untag_ptr(ptr);
1355 assert(obj->tag == LDKClosureReason_CounterpartyForceClosed);
1356 LDKStr peer_msg_str = obj->counterparty_force_closed.peer_msg;
1357 jstring peer_msg_conv = str_ref_to_ts(peer_msg_str.chars, peer_msg_str.len);
1358 return peer_msg_conv;
1360 jstring __attribute__((export_name("TS_LDKClosureReason_ProcessingError_get_err"))) TS_LDKClosureReason_ProcessingError_get_err(uint64_t ptr) {
1361 LDKClosureReason *obj = (LDKClosureReason*)untag_ptr(ptr);
1362 assert(obj->tag == LDKClosureReason_ProcessingError);
1363 LDKStr err_str = obj->processing_error.err;
1364 jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len);
1367 uint32_t __attribute__((export_name("TS_LDKCOption_ClosureReasonZ_ty_from_ptr"))) TS_LDKCOption_ClosureReasonZ_ty_from_ptr(uint64_t ptr) {
1368 LDKCOption_ClosureReasonZ *obj = (LDKCOption_ClosureReasonZ*)untag_ptr(ptr);
1370 case LDKCOption_ClosureReasonZ_Some: return 0;
1371 case LDKCOption_ClosureReasonZ_None: return 1;
1375 uint64_t __attribute__((export_name("TS_LDKCOption_ClosureReasonZ_Some_get_some"))) TS_LDKCOption_ClosureReasonZ_Some_get_some(uint64_t ptr) {
1376 LDKCOption_ClosureReasonZ *obj = (LDKCOption_ClosureReasonZ*)untag_ptr(ptr);
1377 assert(obj->tag == LDKCOption_ClosureReasonZ_Some);
1378 uint64_t some_ref = tag_ptr(&obj->some, false);
1381 static inline struct LDKCOption_ClosureReasonZ CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner){
1382 CHECK(owner->result_ok);
1383 return COption_ClosureReasonZ_clone(&*owner->contents.result);
1385 uint64_t __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_ok"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(uint64_t owner) {
1386 LDKCResult_COption_ClosureReasonZDecodeErrorZ* owner_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)untag_ptr(owner);
1387 LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
1388 *ret_copy = CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner_conv);
1389 uint64_t ret_ref = tag_ptr(ret_copy, true);
1393 static inline struct LDKDecodeError CResult_COption_ClosureReasonZDecodeErrorZ_get_err(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner){
1394 CHECK(!owner->result_ok);
1395 return DecodeError_clone(&*owner->contents.err);
1397 uint64_t __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_err"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_err(uint64_t owner) {
1398 LDKCResult_COption_ClosureReasonZDecodeErrorZ* owner_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)untag_ptr(owner);
1399 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1400 *ret_copy = CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner_conv);
1401 uint64_t ret_ref = tag_ptr(ret_copy, true);
1405 uint32_t __attribute__((export_name("TS_LDKHTLCDestination_ty_from_ptr"))) TS_LDKHTLCDestination_ty_from_ptr(uint64_t ptr) {
1406 LDKHTLCDestination *obj = (LDKHTLCDestination*)untag_ptr(ptr);
1408 case LDKHTLCDestination_NextHopChannel: return 0;
1409 case LDKHTLCDestination_UnknownNextHop: return 1;
1410 case LDKHTLCDestination_InvalidForward: return 2;
1411 case LDKHTLCDestination_FailedPayment: return 3;
1415 int8_tArray __attribute__((export_name("TS_LDKHTLCDestination_NextHopChannel_get_node_id"))) TS_LDKHTLCDestination_NextHopChannel_get_node_id(uint64_t ptr) {
1416 LDKHTLCDestination *obj = (LDKHTLCDestination*)untag_ptr(ptr);
1417 assert(obj->tag == LDKHTLCDestination_NextHopChannel);
1418 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
1419 memcpy(node_id_arr->elems, obj->next_hop_channel.node_id.compressed_form, 33);
1422 int8_tArray __attribute__((export_name("TS_LDKHTLCDestination_NextHopChannel_get_channel_id"))) TS_LDKHTLCDestination_NextHopChannel_get_channel_id(uint64_t ptr) {
1423 LDKHTLCDestination *obj = (LDKHTLCDestination*)untag_ptr(ptr);
1424 assert(obj->tag == LDKHTLCDestination_NextHopChannel);
1425 int8_tArray channel_id_arr = init_int8_tArray(32, __LINE__);
1426 memcpy(channel_id_arr->elems, obj->next_hop_channel.channel_id.data, 32);
1427 return channel_id_arr;
1429 int64_t __attribute__((export_name("TS_LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid"))) TS_LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid(uint64_t ptr) {
1430 LDKHTLCDestination *obj = (LDKHTLCDestination*)untag_ptr(ptr);
1431 assert(obj->tag == LDKHTLCDestination_UnknownNextHop);
1432 int64_t requested_forward_scid_conv = obj->unknown_next_hop.requested_forward_scid;
1433 return requested_forward_scid_conv;
1435 int64_t __attribute__((export_name("TS_LDKHTLCDestination_InvalidForward_get_requested_forward_scid"))) TS_LDKHTLCDestination_InvalidForward_get_requested_forward_scid(uint64_t ptr) {
1436 LDKHTLCDestination *obj = (LDKHTLCDestination*)untag_ptr(ptr);
1437 assert(obj->tag == LDKHTLCDestination_InvalidForward);
1438 int64_t requested_forward_scid_conv = obj->invalid_forward.requested_forward_scid;
1439 return requested_forward_scid_conv;
1441 int8_tArray __attribute__((export_name("TS_LDKHTLCDestination_FailedPayment_get_payment_hash"))) TS_LDKHTLCDestination_FailedPayment_get_payment_hash(uint64_t ptr) {
1442 LDKHTLCDestination *obj = (LDKHTLCDestination*)untag_ptr(ptr);
1443 assert(obj->tag == LDKHTLCDestination_FailedPayment);
1444 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
1445 memcpy(payment_hash_arr->elems, obj->failed_payment.payment_hash.data, 32);
1446 return payment_hash_arr;
1448 uint32_t __attribute__((export_name("TS_LDKCOption_HTLCDestinationZ_ty_from_ptr"))) TS_LDKCOption_HTLCDestinationZ_ty_from_ptr(uint64_t ptr) {
1449 LDKCOption_HTLCDestinationZ *obj = (LDKCOption_HTLCDestinationZ*)untag_ptr(ptr);
1451 case LDKCOption_HTLCDestinationZ_Some: return 0;
1452 case LDKCOption_HTLCDestinationZ_None: return 1;
1456 uint64_t __attribute__((export_name("TS_LDKCOption_HTLCDestinationZ_Some_get_some"))) TS_LDKCOption_HTLCDestinationZ_Some_get_some(uint64_t ptr) {
1457 LDKCOption_HTLCDestinationZ *obj = (LDKCOption_HTLCDestinationZ*)untag_ptr(ptr);
1458 assert(obj->tag == LDKCOption_HTLCDestinationZ_Some);
1459 uint64_t some_ref = tag_ptr(&obj->some, false);
1462 static inline struct LDKCOption_HTLCDestinationZ CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner){
1463 CHECK(owner->result_ok);
1464 return COption_HTLCDestinationZ_clone(&*owner->contents.result);
1466 uint64_t __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(uint64_t owner) {
1467 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* owner_conv = (LDKCResult_COption_HTLCDestinationZDecodeErrorZ*)untag_ptr(owner);
1468 LDKCOption_HTLCDestinationZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCDestinationZ), "LDKCOption_HTLCDestinationZ");
1469 *ret_copy = CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(owner_conv);
1470 uint64_t ret_ref = tag_ptr(ret_copy, true);
1474 static inline struct LDKDecodeError CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner){
1475 CHECK(!owner->result_ok);
1476 return DecodeError_clone(&*owner->contents.err);
1478 uint64_t __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_err"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(uint64_t owner) {
1479 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* owner_conv = (LDKCResult_COption_HTLCDestinationZDecodeErrorZ*)untag_ptr(owner);
1480 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1481 *ret_copy = CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(owner_conv);
1482 uint64_t ret_ref = tag_ptr(ret_copy, true);
1486 uint32_t __attribute__((export_name("TS_LDKCOption_u128Z_ty_from_ptr"))) TS_LDKCOption_u128Z_ty_from_ptr(uint64_t ptr) {
1487 LDKCOption_u128Z *obj = (LDKCOption_u128Z*)untag_ptr(ptr);
1489 case LDKCOption_u128Z_Some: return 0;
1490 case LDKCOption_u128Z_None: return 1;
1494 int8_tArray __attribute__((export_name("TS_LDKCOption_u128Z_Some_get_some"))) TS_LDKCOption_u128Z_Some_get_some(uint64_t ptr) {
1495 LDKCOption_u128Z *obj = (LDKCOption_u128Z*)untag_ptr(ptr);
1496 assert(obj->tag == LDKCOption_u128Z_Some);
1497 int8_tArray some_arr = init_int8_tArray(16, __LINE__);
1498 memcpy(some_arr->elems, obj->some.le_bytes, 16);
1501 uint32_t __attribute__((export_name("TS_LDKNetworkUpdate_ty_from_ptr"))) TS_LDKNetworkUpdate_ty_from_ptr(uint64_t ptr) {
1502 LDKNetworkUpdate *obj = (LDKNetworkUpdate*)untag_ptr(ptr);
1504 case LDKNetworkUpdate_ChannelUpdateMessage: return 0;
1505 case LDKNetworkUpdate_ChannelFailure: return 1;
1506 case LDKNetworkUpdate_NodeFailure: return 2;
1510 uint64_t __attribute__((export_name("TS_LDKNetworkUpdate_ChannelUpdateMessage_get_msg"))) TS_LDKNetworkUpdate_ChannelUpdateMessage_get_msg(uint64_t ptr) {
1511 LDKNetworkUpdate *obj = (LDKNetworkUpdate*)untag_ptr(ptr);
1512 assert(obj->tag == LDKNetworkUpdate_ChannelUpdateMessage);
1513 LDKChannelUpdate msg_var = obj->channel_update_message.msg;
1514 uint64_t msg_ref = 0;
1515 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
1516 msg_ref = tag_ptr(msg_var.inner, false);
1519 int64_t __attribute__((export_name("TS_LDKNetworkUpdate_ChannelFailure_get_short_channel_id"))) TS_LDKNetworkUpdate_ChannelFailure_get_short_channel_id(uint64_t ptr) {
1520 LDKNetworkUpdate *obj = (LDKNetworkUpdate*)untag_ptr(ptr);
1521 assert(obj->tag == LDKNetworkUpdate_ChannelFailure);
1522 int64_t short_channel_id_conv = obj->channel_failure.short_channel_id;
1523 return short_channel_id_conv;
1525 jboolean __attribute__((export_name("TS_LDKNetworkUpdate_ChannelFailure_get_is_permanent"))) TS_LDKNetworkUpdate_ChannelFailure_get_is_permanent(uint64_t ptr) {
1526 LDKNetworkUpdate *obj = (LDKNetworkUpdate*)untag_ptr(ptr);
1527 assert(obj->tag == LDKNetworkUpdate_ChannelFailure);
1528 jboolean is_permanent_conv = obj->channel_failure.is_permanent;
1529 return is_permanent_conv;
1531 int8_tArray __attribute__((export_name("TS_LDKNetworkUpdate_NodeFailure_get_node_id"))) TS_LDKNetworkUpdate_NodeFailure_get_node_id(uint64_t ptr) {
1532 LDKNetworkUpdate *obj = (LDKNetworkUpdate*)untag_ptr(ptr);
1533 assert(obj->tag == LDKNetworkUpdate_NodeFailure);
1534 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
1535 memcpy(node_id_arr->elems, obj->node_failure.node_id.compressed_form, 33);
1538 jboolean __attribute__((export_name("TS_LDKNetworkUpdate_NodeFailure_get_is_permanent"))) TS_LDKNetworkUpdate_NodeFailure_get_is_permanent(uint64_t ptr) {
1539 LDKNetworkUpdate *obj = (LDKNetworkUpdate*)untag_ptr(ptr);
1540 assert(obj->tag == LDKNetworkUpdate_NodeFailure);
1541 jboolean is_permanent_conv = obj->node_failure.is_permanent;
1542 return is_permanent_conv;
1544 uint32_t __attribute__((export_name("TS_LDKCOption_NetworkUpdateZ_ty_from_ptr"))) TS_LDKCOption_NetworkUpdateZ_ty_from_ptr(uint64_t ptr) {
1545 LDKCOption_NetworkUpdateZ *obj = (LDKCOption_NetworkUpdateZ*)untag_ptr(ptr);
1547 case LDKCOption_NetworkUpdateZ_Some: return 0;
1548 case LDKCOption_NetworkUpdateZ_None: return 1;
1552 uint64_t __attribute__((export_name("TS_LDKCOption_NetworkUpdateZ_Some_get_some"))) TS_LDKCOption_NetworkUpdateZ_Some_get_some(uint64_t ptr) {
1553 LDKCOption_NetworkUpdateZ *obj = (LDKCOption_NetworkUpdateZ*)untag_ptr(ptr);
1554 assert(obj->tag == LDKCOption_NetworkUpdateZ_Some);
1555 uint64_t some_ref = tag_ptr(&obj->some, false);
1558 uint32_t __attribute__((export_name("TS_LDKSpendableOutputDescriptor_ty_from_ptr"))) TS_LDKSpendableOutputDescriptor_ty_from_ptr(uint64_t ptr) {
1559 LDKSpendableOutputDescriptor *obj = (LDKSpendableOutputDescriptor*)untag_ptr(ptr);
1561 case LDKSpendableOutputDescriptor_StaticOutput: return 0;
1562 case LDKSpendableOutputDescriptor_DelayedPaymentOutput: return 1;
1563 case LDKSpendableOutputDescriptor_StaticPaymentOutput: return 2;
1567 uint64_t __attribute__((export_name("TS_LDKSpendableOutputDescriptor_StaticOutput_get_outpoint"))) TS_LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(uint64_t ptr) {
1568 LDKSpendableOutputDescriptor *obj = (LDKSpendableOutputDescriptor*)untag_ptr(ptr);
1569 assert(obj->tag == LDKSpendableOutputDescriptor_StaticOutput);
1570 LDKOutPoint outpoint_var = obj->static_output.outpoint;
1571 uint64_t outpoint_ref = 0;
1572 CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_var);
1573 outpoint_ref = tag_ptr(outpoint_var.inner, false);
1574 return outpoint_ref;
1576 uint64_t __attribute__((export_name("TS_LDKSpendableOutputDescriptor_StaticOutput_get_output"))) TS_LDKSpendableOutputDescriptor_StaticOutput_get_output(uint64_t ptr) {
1577 LDKSpendableOutputDescriptor *obj = (LDKSpendableOutputDescriptor*)untag_ptr(ptr);
1578 assert(obj->tag == LDKSpendableOutputDescriptor_StaticOutput);
1579 LDKTxOut* output_ref = &obj->static_output.output;
1580 return tag_ptr(output_ref, false);
1582 uint64_t __attribute__((export_name("TS_LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output"))) TS_LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(uint64_t ptr) {
1583 LDKSpendableOutputDescriptor *obj = (LDKSpendableOutputDescriptor*)untag_ptr(ptr);
1584 assert(obj->tag == LDKSpendableOutputDescriptor_DelayedPaymentOutput);
1585 LDKDelayedPaymentOutputDescriptor delayed_payment_output_var = obj->delayed_payment_output;
1586 uint64_t delayed_payment_output_ref = 0;
1587 CHECK_INNER_FIELD_ACCESS_OR_NULL(delayed_payment_output_var);
1588 delayed_payment_output_ref = tag_ptr(delayed_payment_output_var.inner, false);
1589 return delayed_payment_output_ref;
1591 uint64_t __attribute__((export_name("TS_LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output"))) TS_LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(uint64_t ptr) {
1592 LDKSpendableOutputDescriptor *obj = (LDKSpendableOutputDescriptor*)untag_ptr(ptr);
1593 assert(obj->tag == LDKSpendableOutputDescriptor_StaticPaymentOutput);
1594 LDKStaticPaymentOutputDescriptor static_payment_output_var = obj->static_payment_output;
1595 uint64_t static_payment_output_ref = 0;
1596 CHECK_INNER_FIELD_ACCESS_OR_NULL(static_payment_output_var);
1597 static_payment_output_ref = tag_ptr(static_payment_output_var.inner, false);
1598 return static_payment_output_ref;
1600 static inline LDKCVec_SpendableOutputDescriptorZ CVec_SpendableOutputDescriptorZ_clone(const LDKCVec_SpendableOutputDescriptorZ *orig) {
1601 LDKCVec_SpendableOutputDescriptorZ ret = { .data = MALLOC(sizeof(LDKSpendableOutputDescriptor) * orig->datalen, "LDKCVec_SpendableOutputDescriptorZ clone bytes"), .datalen = orig->datalen };
1602 for (size_t i = 0; i < ret.datalen; i++) {
1603 ret.data[i] = SpendableOutputDescriptor_clone(&orig->data[i]);
1607 uint32_t __attribute__((export_name("TS_LDKEvent_ty_from_ptr"))) TS_LDKEvent_ty_from_ptr(uint64_t ptr) {
1608 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1610 case LDKEvent_FundingGenerationReady: return 0;
1611 case LDKEvent_PaymentClaimable: return 1;
1612 case LDKEvent_PaymentClaimed: return 2;
1613 case LDKEvent_PaymentSent: return 3;
1614 case LDKEvent_PaymentFailed: return 4;
1615 case LDKEvent_PaymentPathSuccessful: return 5;
1616 case LDKEvent_PaymentPathFailed: return 6;
1617 case LDKEvent_ProbeSuccessful: return 7;
1618 case LDKEvent_ProbeFailed: return 8;
1619 case LDKEvent_PendingHTLCsForwardable: return 9;
1620 case LDKEvent_HTLCIntercepted: return 10;
1621 case LDKEvent_SpendableOutputs: return 11;
1622 case LDKEvent_PaymentForwarded: return 12;
1623 case LDKEvent_ChannelReady: return 13;
1624 case LDKEvent_ChannelClosed: return 14;
1625 case LDKEvent_DiscardFunding: return 15;
1626 case LDKEvent_OpenChannelRequest: return 16;
1627 case LDKEvent_HTLCHandlingFailed: return 17;
1631 int8_tArray __attribute__((export_name("TS_LDKEvent_FundingGenerationReady_get_temporary_channel_id"))) TS_LDKEvent_FundingGenerationReady_get_temporary_channel_id(uint64_t ptr) {
1632 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1633 assert(obj->tag == LDKEvent_FundingGenerationReady);
1634 int8_tArray temporary_channel_id_arr = init_int8_tArray(32, __LINE__);
1635 memcpy(temporary_channel_id_arr->elems, obj->funding_generation_ready.temporary_channel_id.data, 32);
1636 return temporary_channel_id_arr;
1638 int8_tArray __attribute__((export_name("TS_LDKEvent_FundingGenerationReady_get_counterparty_node_id"))) TS_LDKEvent_FundingGenerationReady_get_counterparty_node_id(uint64_t ptr) {
1639 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1640 assert(obj->tag == LDKEvent_FundingGenerationReady);
1641 int8_tArray counterparty_node_id_arr = init_int8_tArray(33, __LINE__);
1642 memcpy(counterparty_node_id_arr->elems, obj->funding_generation_ready.counterparty_node_id.compressed_form, 33);
1643 return counterparty_node_id_arr;
1645 int64_t __attribute__((export_name("TS_LDKEvent_FundingGenerationReady_get_channel_value_satoshis"))) TS_LDKEvent_FundingGenerationReady_get_channel_value_satoshis(uint64_t ptr) {
1646 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1647 assert(obj->tag == LDKEvent_FundingGenerationReady);
1648 int64_t channel_value_satoshis_conv = obj->funding_generation_ready.channel_value_satoshis;
1649 return channel_value_satoshis_conv;
1651 int8_tArray __attribute__((export_name("TS_LDKEvent_FundingGenerationReady_get_output_script"))) TS_LDKEvent_FundingGenerationReady_get_output_script(uint64_t ptr) {
1652 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1653 assert(obj->tag == LDKEvent_FundingGenerationReady);
1654 LDKCVec_u8Z output_script_var = obj->funding_generation_ready.output_script;
1655 int8_tArray output_script_arr = init_int8_tArray(output_script_var.datalen, __LINE__);
1656 memcpy(output_script_arr->elems, output_script_var.data, output_script_var.datalen);
1657 return output_script_arr;
1659 int8_tArray __attribute__((export_name("TS_LDKEvent_FundingGenerationReady_get_user_channel_id"))) TS_LDKEvent_FundingGenerationReady_get_user_channel_id(uint64_t ptr) {
1660 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1661 assert(obj->tag == LDKEvent_FundingGenerationReady);
1662 int8_tArray user_channel_id_arr = init_int8_tArray(16, __LINE__);
1663 memcpy(user_channel_id_arr->elems, obj->funding_generation_ready.user_channel_id.le_bytes, 16);
1664 return user_channel_id_arr;
1666 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentClaimable_get_receiver_node_id"))) TS_LDKEvent_PaymentClaimable_get_receiver_node_id(uint64_t ptr) {
1667 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1668 assert(obj->tag == LDKEvent_PaymentClaimable);
1669 int8_tArray receiver_node_id_arr = init_int8_tArray(33, __LINE__);
1670 memcpy(receiver_node_id_arr->elems, obj->payment_claimable.receiver_node_id.compressed_form, 33);
1671 return receiver_node_id_arr;
1673 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentClaimable_get_payment_hash"))) TS_LDKEvent_PaymentClaimable_get_payment_hash(uint64_t ptr) {
1674 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1675 assert(obj->tag == LDKEvent_PaymentClaimable);
1676 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
1677 memcpy(payment_hash_arr->elems, obj->payment_claimable.payment_hash.data, 32);
1678 return payment_hash_arr;
1680 int64_t __attribute__((export_name("TS_LDKEvent_PaymentClaimable_get_amount_msat"))) TS_LDKEvent_PaymentClaimable_get_amount_msat(uint64_t ptr) {
1681 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1682 assert(obj->tag == LDKEvent_PaymentClaimable);
1683 int64_t amount_msat_conv = obj->payment_claimable.amount_msat;
1684 return amount_msat_conv;
1686 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentClaimable_get_purpose"))) TS_LDKEvent_PaymentClaimable_get_purpose(uint64_t ptr) {
1687 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1688 assert(obj->tag == LDKEvent_PaymentClaimable);
1689 uint64_t purpose_ref = tag_ptr(&obj->payment_claimable.purpose, false);
1692 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentClaimable_get_via_channel_id"))) TS_LDKEvent_PaymentClaimable_get_via_channel_id(uint64_t ptr) {
1693 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1694 assert(obj->tag == LDKEvent_PaymentClaimable);
1695 int8_tArray via_channel_id_arr = init_int8_tArray(32, __LINE__);
1696 memcpy(via_channel_id_arr->elems, obj->payment_claimable.via_channel_id.data, 32);
1697 return via_channel_id_arr;
1699 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentClaimable_get_via_user_channel_id"))) TS_LDKEvent_PaymentClaimable_get_via_user_channel_id(uint64_t ptr) {
1700 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1701 assert(obj->tag == LDKEvent_PaymentClaimable);
1702 uint64_t via_user_channel_id_ref = tag_ptr(&obj->payment_claimable.via_user_channel_id, false);
1703 return via_user_channel_id_ref;
1705 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentClaimed_get_receiver_node_id"))) TS_LDKEvent_PaymentClaimed_get_receiver_node_id(uint64_t ptr) {
1706 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1707 assert(obj->tag == LDKEvent_PaymentClaimed);
1708 int8_tArray receiver_node_id_arr = init_int8_tArray(33, __LINE__);
1709 memcpy(receiver_node_id_arr->elems, obj->payment_claimed.receiver_node_id.compressed_form, 33);
1710 return receiver_node_id_arr;
1712 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentClaimed_get_payment_hash"))) TS_LDKEvent_PaymentClaimed_get_payment_hash(uint64_t ptr) {
1713 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1714 assert(obj->tag == LDKEvent_PaymentClaimed);
1715 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
1716 memcpy(payment_hash_arr->elems, obj->payment_claimed.payment_hash.data, 32);
1717 return payment_hash_arr;
1719 int64_t __attribute__((export_name("TS_LDKEvent_PaymentClaimed_get_amount_msat"))) TS_LDKEvent_PaymentClaimed_get_amount_msat(uint64_t ptr) {
1720 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1721 assert(obj->tag == LDKEvent_PaymentClaimed);
1722 int64_t amount_msat_conv = obj->payment_claimed.amount_msat;
1723 return amount_msat_conv;
1725 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentClaimed_get_purpose"))) TS_LDKEvent_PaymentClaimed_get_purpose(uint64_t ptr) {
1726 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1727 assert(obj->tag == LDKEvent_PaymentClaimed);
1728 uint64_t purpose_ref = tag_ptr(&obj->payment_claimed.purpose, false);
1731 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentSent_get_payment_id"))) TS_LDKEvent_PaymentSent_get_payment_id(uint64_t ptr) {
1732 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1733 assert(obj->tag == LDKEvent_PaymentSent);
1734 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
1735 memcpy(payment_id_arr->elems, obj->payment_sent.payment_id.data, 32);
1736 return payment_id_arr;
1738 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentSent_get_payment_preimage"))) TS_LDKEvent_PaymentSent_get_payment_preimage(uint64_t ptr) {
1739 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1740 assert(obj->tag == LDKEvent_PaymentSent);
1741 int8_tArray payment_preimage_arr = init_int8_tArray(32, __LINE__);
1742 memcpy(payment_preimage_arr->elems, obj->payment_sent.payment_preimage.data, 32);
1743 return payment_preimage_arr;
1745 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentSent_get_payment_hash"))) TS_LDKEvent_PaymentSent_get_payment_hash(uint64_t ptr) {
1746 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1747 assert(obj->tag == LDKEvent_PaymentSent);
1748 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
1749 memcpy(payment_hash_arr->elems, obj->payment_sent.payment_hash.data, 32);
1750 return payment_hash_arr;
1752 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentSent_get_fee_paid_msat"))) TS_LDKEvent_PaymentSent_get_fee_paid_msat(uint64_t ptr) {
1753 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1754 assert(obj->tag == LDKEvent_PaymentSent);
1755 uint64_t fee_paid_msat_ref = tag_ptr(&obj->payment_sent.fee_paid_msat, false);
1756 return fee_paid_msat_ref;
1758 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentFailed_get_payment_id"))) TS_LDKEvent_PaymentFailed_get_payment_id(uint64_t ptr) {
1759 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1760 assert(obj->tag == LDKEvent_PaymentFailed);
1761 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
1762 memcpy(payment_id_arr->elems, obj->payment_failed.payment_id.data, 32);
1763 return payment_id_arr;
1765 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentFailed_get_payment_hash"))) TS_LDKEvent_PaymentFailed_get_payment_hash(uint64_t ptr) {
1766 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1767 assert(obj->tag == LDKEvent_PaymentFailed);
1768 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
1769 memcpy(payment_hash_arr->elems, obj->payment_failed.payment_hash.data, 32);
1770 return payment_hash_arr;
1772 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentPathSuccessful_get_payment_id"))) TS_LDKEvent_PaymentPathSuccessful_get_payment_id(uint64_t ptr) {
1773 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1774 assert(obj->tag == LDKEvent_PaymentPathSuccessful);
1775 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
1776 memcpy(payment_id_arr->elems, obj->payment_path_successful.payment_id.data, 32);
1777 return payment_id_arr;
1779 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentPathSuccessful_get_payment_hash"))) TS_LDKEvent_PaymentPathSuccessful_get_payment_hash(uint64_t ptr) {
1780 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1781 assert(obj->tag == LDKEvent_PaymentPathSuccessful);
1782 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
1783 memcpy(payment_hash_arr->elems, obj->payment_path_successful.payment_hash.data, 32);
1784 return payment_hash_arr;
1786 uint64_tArray __attribute__((export_name("TS_LDKEvent_PaymentPathSuccessful_get_path"))) TS_LDKEvent_PaymentPathSuccessful_get_path(uint64_t ptr) {
1787 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1788 assert(obj->tag == LDKEvent_PaymentPathSuccessful);
1789 LDKCVec_RouteHopZ path_var = obj->payment_path_successful.path;
1790 uint64_tArray path_arr = NULL;
1791 path_arr = init_uint64_tArray(path_var.datalen, __LINE__);
1792 uint64_t *path_arr_ptr = (uint64_t*)(((uint8_t*)path_arr) + 8);
1793 for (size_t k = 0; k < path_var.datalen; k++) {
1794 LDKRouteHop path_conv_10_var = path_var.data[k];
1795 uint64_t path_conv_10_ref = 0;
1796 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
1797 path_conv_10_ref = tag_ptr(path_conv_10_var.inner, false);
1798 path_arr_ptr[k] = path_conv_10_ref;
1803 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_payment_id"))) TS_LDKEvent_PaymentPathFailed_get_payment_id(uint64_t ptr) {
1804 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1805 assert(obj->tag == LDKEvent_PaymentPathFailed);
1806 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
1807 memcpy(payment_id_arr->elems, obj->payment_path_failed.payment_id.data, 32);
1808 return payment_id_arr;
1810 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_payment_hash"))) TS_LDKEvent_PaymentPathFailed_get_payment_hash(uint64_t ptr) {
1811 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1812 assert(obj->tag == LDKEvent_PaymentPathFailed);
1813 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
1814 memcpy(payment_hash_arr->elems, obj->payment_path_failed.payment_hash.data, 32);
1815 return payment_hash_arr;
1817 jboolean __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_payment_failed_permanently"))) TS_LDKEvent_PaymentPathFailed_get_payment_failed_permanently(uint64_t ptr) {
1818 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1819 assert(obj->tag == LDKEvent_PaymentPathFailed);
1820 jboolean payment_failed_permanently_conv = obj->payment_path_failed.payment_failed_permanently;
1821 return payment_failed_permanently_conv;
1823 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_network_update"))) TS_LDKEvent_PaymentPathFailed_get_network_update(uint64_t ptr) {
1824 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1825 assert(obj->tag == LDKEvent_PaymentPathFailed);
1826 uint64_t network_update_ref = tag_ptr(&obj->payment_path_failed.network_update, false);
1827 return network_update_ref;
1829 jboolean __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_all_paths_failed"))) TS_LDKEvent_PaymentPathFailed_get_all_paths_failed(uint64_t ptr) {
1830 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1831 assert(obj->tag == LDKEvent_PaymentPathFailed);
1832 jboolean all_paths_failed_conv = obj->payment_path_failed.all_paths_failed;
1833 return all_paths_failed_conv;
1835 uint64_tArray __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_path"))) TS_LDKEvent_PaymentPathFailed_get_path(uint64_t ptr) {
1836 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1837 assert(obj->tag == LDKEvent_PaymentPathFailed);
1838 LDKCVec_RouteHopZ path_var = obj->payment_path_failed.path;
1839 uint64_tArray path_arr = NULL;
1840 path_arr = init_uint64_tArray(path_var.datalen, __LINE__);
1841 uint64_t *path_arr_ptr = (uint64_t*)(((uint8_t*)path_arr) + 8);
1842 for (size_t k = 0; k < path_var.datalen; k++) {
1843 LDKRouteHop path_conv_10_var = path_var.data[k];
1844 uint64_t path_conv_10_ref = 0;
1845 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
1846 path_conv_10_ref = tag_ptr(path_conv_10_var.inner, false);
1847 path_arr_ptr[k] = path_conv_10_ref;
1852 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_short_channel_id"))) TS_LDKEvent_PaymentPathFailed_get_short_channel_id(uint64_t ptr) {
1853 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1854 assert(obj->tag == LDKEvent_PaymentPathFailed);
1855 uint64_t short_channel_id_ref = tag_ptr(&obj->payment_path_failed.short_channel_id, false);
1856 return short_channel_id_ref;
1858 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_retry"))) TS_LDKEvent_PaymentPathFailed_get_retry(uint64_t ptr) {
1859 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1860 assert(obj->tag == LDKEvent_PaymentPathFailed);
1861 LDKRouteParameters retry_var = obj->payment_path_failed.retry;
1862 uint64_t retry_ref = 0;
1863 CHECK_INNER_FIELD_ACCESS_OR_NULL(retry_var);
1864 retry_ref = tag_ptr(retry_var.inner, false);
1867 int8_tArray __attribute__((export_name("TS_LDKEvent_ProbeSuccessful_get_payment_id"))) TS_LDKEvent_ProbeSuccessful_get_payment_id(uint64_t ptr) {
1868 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1869 assert(obj->tag == LDKEvent_ProbeSuccessful);
1870 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
1871 memcpy(payment_id_arr->elems, obj->probe_successful.payment_id.data, 32);
1872 return payment_id_arr;
1874 int8_tArray __attribute__((export_name("TS_LDKEvent_ProbeSuccessful_get_payment_hash"))) TS_LDKEvent_ProbeSuccessful_get_payment_hash(uint64_t ptr) {
1875 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1876 assert(obj->tag == LDKEvent_ProbeSuccessful);
1877 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
1878 memcpy(payment_hash_arr->elems, obj->probe_successful.payment_hash.data, 32);
1879 return payment_hash_arr;
1881 uint64_tArray __attribute__((export_name("TS_LDKEvent_ProbeSuccessful_get_path"))) TS_LDKEvent_ProbeSuccessful_get_path(uint64_t ptr) {
1882 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1883 assert(obj->tag == LDKEvent_ProbeSuccessful);
1884 LDKCVec_RouteHopZ path_var = obj->probe_successful.path;
1885 uint64_tArray path_arr = NULL;
1886 path_arr = init_uint64_tArray(path_var.datalen, __LINE__);
1887 uint64_t *path_arr_ptr = (uint64_t*)(((uint8_t*)path_arr) + 8);
1888 for (size_t k = 0; k < path_var.datalen; k++) {
1889 LDKRouteHop path_conv_10_var = path_var.data[k];
1890 uint64_t path_conv_10_ref = 0;
1891 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
1892 path_conv_10_ref = tag_ptr(path_conv_10_var.inner, false);
1893 path_arr_ptr[k] = path_conv_10_ref;
1898 int8_tArray __attribute__((export_name("TS_LDKEvent_ProbeFailed_get_payment_id"))) TS_LDKEvent_ProbeFailed_get_payment_id(uint64_t ptr) {
1899 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1900 assert(obj->tag == LDKEvent_ProbeFailed);
1901 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
1902 memcpy(payment_id_arr->elems, obj->probe_failed.payment_id.data, 32);
1903 return payment_id_arr;
1905 int8_tArray __attribute__((export_name("TS_LDKEvent_ProbeFailed_get_payment_hash"))) TS_LDKEvent_ProbeFailed_get_payment_hash(uint64_t ptr) {
1906 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1907 assert(obj->tag == LDKEvent_ProbeFailed);
1908 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
1909 memcpy(payment_hash_arr->elems, obj->probe_failed.payment_hash.data, 32);
1910 return payment_hash_arr;
1912 uint64_tArray __attribute__((export_name("TS_LDKEvent_ProbeFailed_get_path"))) TS_LDKEvent_ProbeFailed_get_path(uint64_t ptr) {
1913 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1914 assert(obj->tag == LDKEvent_ProbeFailed);
1915 LDKCVec_RouteHopZ path_var = obj->probe_failed.path;
1916 uint64_tArray path_arr = NULL;
1917 path_arr = init_uint64_tArray(path_var.datalen, __LINE__);
1918 uint64_t *path_arr_ptr = (uint64_t*)(((uint8_t*)path_arr) + 8);
1919 for (size_t k = 0; k < path_var.datalen; k++) {
1920 LDKRouteHop path_conv_10_var = path_var.data[k];
1921 uint64_t path_conv_10_ref = 0;
1922 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
1923 path_conv_10_ref = tag_ptr(path_conv_10_var.inner, false);
1924 path_arr_ptr[k] = path_conv_10_ref;
1929 uint64_t __attribute__((export_name("TS_LDKEvent_ProbeFailed_get_short_channel_id"))) TS_LDKEvent_ProbeFailed_get_short_channel_id(uint64_t ptr) {
1930 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1931 assert(obj->tag == LDKEvent_ProbeFailed);
1932 uint64_t short_channel_id_ref = tag_ptr(&obj->probe_failed.short_channel_id, false);
1933 return short_channel_id_ref;
1935 int64_t __attribute__((export_name("TS_LDKEvent_PendingHTLCsForwardable_get_time_forwardable"))) TS_LDKEvent_PendingHTLCsForwardable_get_time_forwardable(uint64_t ptr) {
1936 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1937 assert(obj->tag == LDKEvent_PendingHTLCsForwardable);
1938 int64_t time_forwardable_conv = obj->pending_htl_cs_forwardable.time_forwardable;
1939 return time_forwardable_conv;
1941 int8_tArray __attribute__((export_name("TS_LDKEvent_HTLCIntercepted_get_intercept_id"))) TS_LDKEvent_HTLCIntercepted_get_intercept_id(uint64_t ptr) {
1942 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1943 assert(obj->tag == LDKEvent_HTLCIntercepted);
1944 int8_tArray intercept_id_arr = init_int8_tArray(32, __LINE__);
1945 memcpy(intercept_id_arr->elems, obj->htlc_intercepted.intercept_id.data, 32);
1946 return intercept_id_arr;
1948 int64_t __attribute__((export_name("TS_LDKEvent_HTLCIntercepted_get_requested_next_hop_scid"))) TS_LDKEvent_HTLCIntercepted_get_requested_next_hop_scid(uint64_t ptr) {
1949 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1950 assert(obj->tag == LDKEvent_HTLCIntercepted);
1951 int64_t requested_next_hop_scid_conv = obj->htlc_intercepted.requested_next_hop_scid;
1952 return requested_next_hop_scid_conv;
1954 int8_tArray __attribute__((export_name("TS_LDKEvent_HTLCIntercepted_get_payment_hash"))) TS_LDKEvent_HTLCIntercepted_get_payment_hash(uint64_t ptr) {
1955 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1956 assert(obj->tag == LDKEvent_HTLCIntercepted);
1957 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
1958 memcpy(payment_hash_arr->elems, obj->htlc_intercepted.payment_hash.data, 32);
1959 return payment_hash_arr;
1961 int64_t __attribute__((export_name("TS_LDKEvent_HTLCIntercepted_get_inbound_amount_msat"))) TS_LDKEvent_HTLCIntercepted_get_inbound_amount_msat(uint64_t ptr) {
1962 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1963 assert(obj->tag == LDKEvent_HTLCIntercepted);
1964 int64_t inbound_amount_msat_conv = obj->htlc_intercepted.inbound_amount_msat;
1965 return inbound_amount_msat_conv;
1967 int64_t __attribute__((export_name("TS_LDKEvent_HTLCIntercepted_get_expected_outbound_amount_msat"))) TS_LDKEvent_HTLCIntercepted_get_expected_outbound_amount_msat(uint64_t ptr) {
1968 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1969 assert(obj->tag == LDKEvent_HTLCIntercepted);
1970 int64_t expected_outbound_amount_msat_conv = obj->htlc_intercepted.expected_outbound_amount_msat;
1971 return expected_outbound_amount_msat_conv;
1973 uint64_tArray __attribute__((export_name("TS_LDKEvent_SpendableOutputs_get_outputs"))) TS_LDKEvent_SpendableOutputs_get_outputs(uint64_t ptr) {
1974 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1975 assert(obj->tag == LDKEvent_SpendableOutputs);
1976 LDKCVec_SpendableOutputDescriptorZ outputs_var = obj->spendable_outputs.outputs;
1977 uint64_tArray outputs_arr = NULL;
1978 outputs_arr = init_uint64_tArray(outputs_var.datalen, __LINE__);
1979 uint64_t *outputs_arr_ptr = (uint64_t*)(((uint8_t*)outputs_arr) + 8);
1980 for (size_t b = 0; b < outputs_var.datalen; b++) {
1981 uint64_t outputs_conv_27_ref = tag_ptr(&outputs_var.data[b], false);
1982 outputs_arr_ptr[b] = outputs_conv_27_ref;
1987 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentForwarded_get_prev_channel_id"))) TS_LDKEvent_PaymentForwarded_get_prev_channel_id(uint64_t ptr) {
1988 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1989 assert(obj->tag == LDKEvent_PaymentForwarded);
1990 int8_tArray prev_channel_id_arr = init_int8_tArray(32, __LINE__);
1991 memcpy(prev_channel_id_arr->elems, obj->payment_forwarded.prev_channel_id.data, 32);
1992 return prev_channel_id_arr;
1994 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentForwarded_get_next_channel_id"))) TS_LDKEvent_PaymentForwarded_get_next_channel_id(uint64_t ptr) {
1995 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
1996 assert(obj->tag == LDKEvent_PaymentForwarded);
1997 int8_tArray next_channel_id_arr = init_int8_tArray(32, __LINE__);
1998 memcpy(next_channel_id_arr->elems, obj->payment_forwarded.next_channel_id.data, 32);
1999 return next_channel_id_arr;
2001 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentForwarded_get_fee_earned_msat"))) TS_LDKEvent_PaymentForwarded_get_fee_earned_msat(uint64_t ptr) {
2002 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2003 assert(obj->tag == LDKEvent_PaymentForwarded);
2004 uint64_t fee_earned_msat_ref = tag_ptr(&obj->payment_forwarded.fee_earned_msat, false);
2005 return fee_earned_msat_ref;
2007 jboolean __attribute__((export_name("TS_LDKEvent_PaymentForwarded_get_claim_from_onchain_tx"))) TS_LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(uint64_t ptr) {
2008 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2009 assert(obj->tag == LDKEvent_PaymentForwarded);
2010 jboolean claim_from_onchain_tx_conv = obj->payment_forwarded.claim_from_onchain_tx;
2011 return claim_from_onchain_tx_conv;
2013 int8_tArray __attribute__((export_name("TS_LDKEvent_ChannelReady_get_channel_id"))) TS_LDKEvent_ChannelReady_get_channel_id(uint64_t ptr) {
2014 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2015 assert(obj->tag == LDKEvent_ChannelReady);
2016 int8_tArray channel_id_arr = init_int8_tArray(32, __LINE__);
2017 memcpy(channel_id_arr->elems, obj->channel_ready.channel_id.data, 32);
2018 return channel_id_arr;
2020 int8_tArray __attribute__((export_name("TS_LDKEvent_ChannelReady_get_user_channel_id"))) TS_LDKEvent_ChannelReady_get_user_channel_id(uint64_t ptr) {
2021 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2022 assert(obj->tag == LDKEvent_ChannelReady);
2023 int8_tArray user_channel_id_arr = init_int8_tArray(16, __LINE__);
2024 memcpy(user_channel_id_arr->elems, obj->channel_ready.user_channel_id.le_bytes, 16);
2025 return user_channel_id_arr;
2027 int8_tArray __attribute__((export_name("TS_LDKEvent_ChannelReady_get_counterparty_node_id"))) TS_LDKEvent_ChannelReady_get_counterparty_node_id(uint64_t ptr) {
2028 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2029 assert(obj->tag == LDKEvent_ChannelReady);
2030 int8_tArray counterparty_node_id_arr = init_int8_tArray(33, __LINE__);
2031 memcpy(counterparty_node_id_arr->elems, obj->channel_ready.counterparty_node_id.compressed_form, 33);
2032 return counterparty_node_id_arr;
2034 uint64_t __attribute__((export_name("TS_LDKEvent_ChannelReady_get_channel_type"))) TS_LDKEvent_ChannelReady_get_channel_type(uint64_t ptr) {
2035 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2036 assert(obj->tag == LDKEvent_ChannelReady);
2037 LDKChannelTypeFeatures channel_type_var = obj->channel_ready.channel_type;
2038 uint64_t channel_type_ref = 0;
2039 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_var);
2040 channel_type_ref = tag_ptr(channel_type_var.inner, false);
2041 return channel_type_ref;
2043 int8_tArray __attribute__((export_name("TS_LDKEvent_ChannelClosed_get_channel_id"))) TS_LDKEvent_ChannelClosed_get_channel_id(uint64_t ptr) {
2044 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2045 assert(obj->tag == LDKEvent_ChannelClosed);
2046 int8_tArray channel_id_arr = init_int8_tArray(32, __LINE__);
2047 memcpy(channel_id_arr->elems, obj->channel_closed.channel_id.data, 32);
2048 return channel_id_arr;
2050 int8_tArray __attribute__((export_name("TS_LDKEvent_ChannelClosed_get_user_channel_id"))) TS_LDKEvent_ChannelClosed_get_user_channel_id(uint64_t ptr) {
2051 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2052 assert(obj->tag == LDKEvent_ChannelClosed);
2053 int8_tArray user_channel_id_arr = init_int8_tArray(16, __LINE__);
2054 memcpy(user_channel_id_arr->elems, obj->channel_closed.user_channel_id.le_bytes, 16);
2055 return user_channel_id_arr;
2057 uint64_t __attribute__((export_name("TS_LDKEvent_ChannelClosed_get_reason"))) TS_LDKEvent_ChannelClosed_get_reason(uint64_t ptr) {
2058 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2059 assert(obj->tag == LDKEvent_ChannelClosed);
2060 uint64_t reason_ref = tag_ptr(&obj->channel_closed.reason, false);
2063 int8_tArray __attribute__((export_name("TS_LDKEvent_DiscardFunding_get_channel_id"))) TS_LDKEvent_DiscardFunding_get_channel_id(uint64_t ptr) {
2064 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2065 assert(obj->tag == LDKEvent_DiscardFunding);
2066 int8_tArray channel_id_arr = init_int8_tArray(32, __LINE__);
2067 memcpy(channel_id_arr->elems, obj->discard_funding.channel_id.data, 32);
2068 return channel_id_arr;
2070 int8_tArray __attribute__((export_name("TS_LDKEvent_DiscardFunding_get_transaction"))) TS_LDKEvent_DiscardFunding_get_transaction(uint64_t ptr) {
2071 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2072 assert(obj->tag == LDKEvent_DiscardFunding);
2073 LDKTransaction transaction_var = obj->discard_funding.transaction;
2074 int8_tArray transaction_arr = init_int8_tArray(transaction_var.datalen, __LINE__);
2075 memcpy(transaction_arr->elems, transaction_var.data, transaction_var.datalen);
2076 return transaction_arr;
2078 int8_tArray __attribute__((export_name("TS_LDKEvent_OpenChannelRequest_get_temporary_channel_id"))) TS_LDKEvent_OpenChannelRequest_get_temporary_channel_id(uint64_t ptr) {
2079 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2080 assert(obj->tag == LDKEvent_OpenChannelRequest);
2081 int8_tArray temporary_channel_id_arr = init_int8_tArray(32, __LINE__);
2082 memcpy(temporary_channel_id_arr->elems, obj->open_channel_request.temporary_channel_id.data, 32);
2083 return temporary_channel_id_arr;
2085 int8_tArray __attribute__((export_name("TS_LDKEvent_OpenChannelRequest_get_counterparty_node_id"))) TS_LDKEvent_OpenChannelRequest_get_counterparty_node_id(uint64_t ptr) {
2086 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2087 assert(obj->tag == LDKEvent_OpenChannelRequest);
2088 int8_tArray counterparty_node_id_arr = init_int8_tArray(33, __LINE__);
2089 memcpy(counterparty_node_id_arr->elems, obj->open_channel_request.counterparty_node_id.compressed_form, 33);
2090 return counterparty_node_id_arr;
2092 int64_t __attribute__((export_name("TS_LDKEvent_OpenChannelRequest_get_funding_satoshis"))) TS_LDKEvent_OpenChannelRequest_get_funding_satoshis(uint64_t ptr) {
2093 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2094 assert(obj->tag == LDKEvent_OpenChannelRequest);
2095 int64_t funding_satoshis_conv = obj->open_channel_request.funding_satoshis;
2096 return funding_satoshis_conv;
2098 int64_t __attribute__((export_name("TS_LDKEvent_OpenChannelRequest_get_push_msat"))) TS_LDKEvent_OpenChannelRequest_get_push_msat(uint64_t ptr) {
2099 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2100 assert(obj->tag == LDKEvent_OpenChannelRequest);
2101 int64_t push_msat_conv = obj->open_channel_request.push_msat;
2102 return push_msat_conv;
2104 uint64_t __attribute__((export_name("TS_LDKEvent_OpenChannelRequest_get_channel_type"))) TS_LDKEvent_OpenChannelRequest_get_channel_type(uint64_t ptr) {
2105 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2106 assert(obj->tag == LDKEvent_OpenChannelRequest);
2107 LDKChannelTypeFeatures channel_type_var = obj->open_channel_request.channel_type;
2108 uint64_t channel_type_ref = 0;
2109 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_var);
2110 channel_type_ref = tag_ptr(channel_type_var.inner, false);
2111 return channel_type_ref;
2113 int8_tArray __attribute__((export_name("TS_LDKEvent_HTLCHandlingFailed_get_prev_channel_id"))) TS_LDKEvent_HTLCHandlingFailed_get_prev_channel_id(uint64_t ptr) {
2114 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2115 assert(obj->tag == LDKEvent_HTLCHandlingFailed);
2116 int8_tArray prev_channel_id_arr = init_int8_tArray(32, __LINE__);
2117 memcpy(prev_channel_id_arr->elems, obj->htlc_handling_failed.prev_channel_id.data, 32);
2118 return prev_channel_id_arr;
2120 uint64_t __attribute__((export_name("TS_LDKEvent_HTLCHandlingFailed_get_failed_next_destination"))) TS_LDKEvent_HTLCHandlingFailed_get_failed_next_destination(uint64_t ptr) {
2121 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2122 assert(obj->tag == LDKEvent_HTLCHandlingFailed);
2123 uint64_t failed_next_destination_ref = tag_ptr(&obj->htlc_handling_failed.failed_next_destination, false);
2124 return failed_next_destination_ref;
2126 uint32_t __attribute__((export_name("TS_LDKCOption_EventZ_ty_from_ptr"))) TS_LDKCOption_EventZ_ty_from_ptr(uint64_t ptr) {
2127 LDKCOption_EventZ *obj = (LDKCOption_EventZ*)untag_ptr(ptr);
2129 case LDKCOption_EventZ_Some: return 0;
2130 case LDKCOption_EventZ_None: return 1;
2134 uint64_t __attribute__((export_name("TS_LDKCOption_EventZ_Some_get_some"))) TS_LDKCOption_EventZ_Some_get_some(uint64_t ptr) {
2135 LDKCOption_EventZ *obj = (LDKCOption_EventZ*)untag_ptr(ptr);
2136 assert(obj->tag == LDKCOption_EventZ_Some);
2137 uint64_t some_ref = tag_ptr(&obj->some, false);
2140 static inline struct LDKCOption_EventZ CResult_COption_EventZDecodeErrorZ_get_ok(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner){
2141 CHECK(owner->result_ok);
2142 return COption_EventZ_clone(&*owner->contents.result);
2144 uint64_t __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_get_ok"))) TS_CResult_COption_EventZDecodeErrorZ_get_ok(uint64_t owner) {
2145 LDKCResult_COption_EventZDecodeErrorZ* owner_conv = (LDKCResult_COption_EventZDecodeErrorZ*)untag_ptr(owner);
2146 LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
2147 *ret_copy = CResult_COption_EventZDecodeErrorZ_get_ok(owner_conv);
2148 uint64_t ret_ref = tag_ptr(ret_copy, true);
2152 static inline struct LDKDecodeError CResult_COption_EventZDecodeErrorZ_get_err(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner){
2153 CHECK(!owner->result_ok);
2154 return DecodeError_clone(&*owner->contents.err);
2156 uint64_t __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_get_err"))) TS_CResult_COption_EventZDecodeErrorZ_get_err(uint64_t owner) {
2157 LDKCResult_COption_EventZDecodeErrorZ* owner_conv = (LDKCResult_COption_EventZDecodeErrorZ*)untag_ptr(owner);
2158 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
2159 *ret_copy = CResult_COption_EventZDecodeErrorZ_get_err(owner_conv);
2160 uint64_t ret_ref = tag_ptr(ret_copy, true);
2164 uint32_t __attribute__((export_name("TS_LDKErrorAction_ty_from_ptr"))) TS_LDKErrorAction_ty_from_ptr(uint64_t ptr) {
2165 LDKErrorAction *obj = (LDKErrorAction*)untag_ptr(ptr);
2167 case LDKErrorAction_DisconnectPeer: return 0;
2168 case LDKErrorAction_IgnoreError: return 1;
2169 case LDKErrorAction_IgnoreAndLog: return 2;
2170 case LDKErrorAction_IgnoreDuplicateGossip: return 3;
2171 case LDKErrorAction_SendErrorMessage: return 4;
2172 case LDKErrorAction_SendWarningMessage: return 5;
2176 uint64_t __attribute__((export_name("TS_LDKErrorAction_DisconnectPeer_get_msg"))) TS_LDKErrorAction_DisconnectPeer_get_msg(uint64_t ptr) {
2177 LDKErrorAction *obj = (LDKErrorAction*)untag_ptr(ptr);
2178 assert(obj->tag == LDKErrorAction_DisconnectPeer);
2179 LDKErrorMessage msg_var = obj->disconnect_peer.msg;
2180 uint64_t msg_ref = 0;
2181 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2182 msg_ref = tag_ptr(msg_var.inner, false);
2185 uint32_t __attribute__((export_name("TS_LDKErrorAction_IgnoreAndLog_get_ignore_and_log"))) TS_LDKErrorAction_IgnoreAndLog_get_ignore_and_log(uint64_t ptr) {
2186 LDKErrorAction *obj = (LDKErrorAction*)untag_ptr(ptr);
2187 assert(obj->tag == LDKErrorAction_IgnoreAndLog);
2188 uint32_t ignore_and_log_conv = LDKLevel_to_js(obj->ignore_and_log);
2189 return ignore_and_log_conv;
2191 uint64_t __attribute__((export_name("TS_LDKErrorAction_SendErrorMessage_get_msg"))) TS_LDKErrorAction_SendErrorMessage_get_msg(uint64_t ptr) {
2192 LDKErrorAction *obj = (LDKErrorAction*)untag_ptr(ptr);
2193 assert(obj->tag == LDKErrorAction_SendErrorMessage);
2194 LDKErrorMessage msg_var = obj->send_error_message.msg;
2195 uint64_t msg_ref = 0;
2196 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2197 msg_ref = tag_ptr(msg_var.inner, false);
2200 uint64_t __attribute__((export_name("TS_LDKErrorAction_SendWarningMessage_get_msg"))) TS_LDKErrorAction_SendWarningMessage_get_msg(uint64_t ptr) {
2201 LDKErrorAction *obj = (LDKErrorAction*)untag_ptr(ptr);
2202 assert(obj->tag == LDKErrorAction_SendWarningMessage);
2203 LDKWarningMessage msg_var = obj->send_warning_message.msg;
2204 uint64_t msg_ref = 0;
2205 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2206 msg_ref = tag_ptr(msg_var.inner, false);
2209 uint32_t __attribute__((export_name("TS_LDKErrorAction_SendWarningMessage_get_log_level"))) TS_LDKErrorAction_SendWarningMessage_get_log_level(uint64_t ptr) {
2210 LDKErrorAction *obj = (LDKErrorAction*)untag_ptr(ptr);
2211 assert(obj->tag == LDKErrorAction_SendWarningMessage);
2212 uint32_t log_level_conv = LDKLevel_to_js(obj->send_warning_message.log_level);
2213 return log_level_conv;
2215 uint32_t __attribute__((export_name("TS_LDKMessageSendEvent_ty_from_ptr"))) TS_LDKMessageSendEvent_ty_from_ptr(uint64_t ptr) {
2216 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2218 case LDKMessageSendEvent_SendAcceptChannel: return 0;
2219 case LDKMessageSendEvent_SendOpenChannel: return 1;
2220 case LDKMessageSendEvent_SendFundingCreated: return 2;
2221 case LDKMessageSendEvent_SendFundingSigned: return 3;
2222 case LDKMessageSendEvent_SendChannelReady: return 4;
2223 case LDKMessageSendEvent_SendAnnouncementSignatures: return 5;
2224 case LDKMessageSendEvent_UpdateHTLCs: return 6;
2225 case LDKMessageSendEvent_SendRevokeAndACK: return 7;
2226 case LDKMessageSendEvent_SendClosingSigned: return 8;
2227 case LDKMessageSendEvent_SendShutdown: return 9;
2228 case LDKMessageSendEvent_SendChannelReestablish: return 10;
2229 case LDKMessageSendEvent_SendChannelAnnouncement: return 11;
2230 case LDKMessageSendEvent_BroadcastChannelAnnouncement: return 12;
2231 case LDKMessageSendEvent_BroadcastChannelUpdate: return 13;
2232 case LDKMessageSendEvent_SendChannelUpdate: return 14;
2233 case LDKMessageSendEvent_HandleError: return 15;
2234 case LDKMessageSendEvent_SendChannelRangeQuery: return 16;
2235 case LDKMessageSendEvent_SendShortIdsQuery: return 17;
2236 case LDKMessageSendEvent_SendReplyChannelRange: return 18;
2237 case LDKMessageSendEvent_SendGossipTimestampFilter: return 19;
2241 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendAcceptChannel_get_node_id"))) TS_LDKMessageSendEvent_SendAcceptChannel_get_node_id(uint64_t ptr) {
2242 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2243 assert(obj->tag == LDKMessageSendEvent_SendAcceptChannel);
2244 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2245 memcpy(node_id_arr->elems, obj->send_accept_channel.node_id.compressed_form, 33);
2248 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendAcceptChannel_get_msg"))) TS_LDKMessageSendEvent_SendAcceptChannel_get_msg(uint64_t ptr) {
2249 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2250 assert(obj->tag == LDKMessageSendEvent_SendAcceptChannel);
2251 LDKAcceptChannel msg_var = obj->send_accept_channel.msg;
2252 uint64_t msg_ref = 0;
2253 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2254 msg_ref = tag_ptr(msg_var.inner, false);
2257 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendOpenChannel_get_node_id"))) TS_LDKMessageSendEvent_SendOpenChannel_get_node_id(uint64_t ptr) {
2258 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2259 assert(obj->tag == LDKMessageSendEvent_SendOpenChannel);
2260 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2261 memcpy(node_id_arr->elems, obj->send_open_channel.node_id.compressed_form, 33);
2264 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendOpenChannel_get_msg"))) TS_LDKMessageSendEvent_SendOpenChannel_get_msg(uint64_t ptr) {
2265 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2266 assert(obj->tag == LDKMessageSendEvent_SendOpenChannel);
2267 LDKOpenChannel msg_var = obj->send_open_channel.msg;
2268 uint64_t msg_ref = 0;
2269 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2270 msg_ref = tag_ptr(msg_var.inner, false);
2273 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendFundingCreated_get_node_id"))) TS_LDKMessageSendEvent_SendFundingCreated_get_node_id(uint64_t ptr) {
2274 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2275 assert(obj->tag == LDKMessageSendEvent_SendFundingCreated);
2276 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2277 memcpy(node_id_arr->elems, obj->send_funding_created.node_id.compressed_form, 33);
2280 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendFundingCreated_get_msg"))) TS_LDKMessageSendEvent_SendFundingCreated_get_msg(uint64_t ptr) {
2281 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2282 assert(obj->tag == LDKMessageSendEvent_SendFundingCreated);
2283 LDKFundingCreated msg_var = obj->send_funding_created.msg;
2284 uint64_t msg_ref = 0;
2285 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2286 msg_ref = tag_ptr(msg_var.inner, false);
2289 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendFundingSigned_get_node_id"))) TS_LDKMessageSendEvent_SendFundingSigned_get_node_id(uint64_t ptr) {
2290 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2291 assert(obj->tag == LDKMessageSendEvent_SendFundingSigned);
2292 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2293 memcpy(node_id_arr->elems, obj->send_funding_signed.node_id.compressed_form, 33);
2296 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendFundingSigned_get_msg"))) TS_LDKMessageSendEvent_SendFundingSigned_get_msg(uint64_t ptr) {
2297 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2298 assert(obj->tag == LDKMessageSendEvent_SendFundingSigned);
2299 LDKFundingSigned msg_var = obj->send_funding_signed.msg;
2300 uint64_t msg_ref = 0;
2301 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2302 msg_ref = tag_ptr(msg_var.inner, false);
2305 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelReady_get_node_id"))) TS_LDKMessageSendEvent_SendChannelReady_get_node_id(uint64_t ptr) {
2306 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2307 assert(obj->tag == LDKMessageSendEvent_SendChannelReady);
2308 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2309 memcpy(node_id_arr->elems, obj->send_channel_ready.node_id.compressed_form, 33);
2312 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelReady_get_msg"))) TS_LDKMessageSendEvent_SendChannelReady_get_msg(uint64_t ptr) {
2313 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2314 assert(obj->tag == LDKMessageSendEvent_SendChannelReady);
2315 LDKChannelReady msg_var = obj->send_channel_ready.msg;
2316 uint64_t msg_ref = 0;
2317 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2318 msg_ref = tag_ptr(msg_var.inner, false);
2321 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id"))) TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(uint64_t ptr) {
2322 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2323 assert(obj->tag == LDKMessageSendEvent_SendAnnouncementSignatures);
2324 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2325 memcpy(node_id_arr->elems, obj->send_announcement_signatures.node_id.compressed_form, 33);
2328 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_msg"))) TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(uint64_t ptr) {
2329 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2330 assert(obj->tag == LDKMessageSendEvent_SendAnnouncementSignatures);
2331 LDKAnnouncementSignatures msg_var = obj->send_announcement_signatures.msg;
2332 uint64_t msg_ref = 0;
2333 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2334 msg_ref = tag_ptr(msg_var.inner, false);
2337 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_UpdateHTLCs_get_node_id"))) TS_LDKMessageSendEvent_UpdateHTLCs_get_node_id(uint64_t ptr) {
2338 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2339 assert(obj->tag == LDKMessageSendEvent_UpdateHTLCs);
2340 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2341 memcpy(node_id_arr->elems, obj->update_htl_cs.node_id.compressed_form, 33);
2344 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_UpdateHTLCs_get_updates"))) TS_LDKMessageSendEvent_UpdateHTLCs_get_updates(uint64_t ptr) {
2345 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2346 assert(obj->tag == LDKMessageSendEvent_UpdateHTLCs);
2347 LDKCommitmentUpdate updates_var = obj->update_htl_cs.updates;
2348 uint64_t updates_ref = 0;
2349 CHECK_INNER_FIELD_ACCESS_OR_NULL(updates_var);
2350 updates_ref = tag_ptr(updates_var.inner, false);
2353 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendRevokeAndACK_get_node_id"))) TS_LDKMessageSendEvent_SendRevokeAndACK_get_node_id(uint64_t ptr) {
2354 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2355 assert(obj->tag == LDKMessageSendEvent_SendRevokeAndACK);
2356 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2357 memcpy(node_id_arr->elems, obj->send_revoke_and_ack.node_id.compressed_form, 33);
2360 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendRevokeAndACK_get_msg"))) TS_LDKMessageSendEvent_SendRevokeAndACK_get_msg(uint64_t ptr) {
2361 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2362 assert(obj->tag == LDKMessageSendEvent_SendRevokeAndACK);
2363 LDKRevokeAndACK msg_var = obj->send_revoke_and_ack.msg;
2364 uint64_t msg_ref = 0;
2365 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2366 msg_ref = tag_ptr(msg_var.inner, false);
2369 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendClosingSigned_get_node_id"))) TS_LDKMessageSendEvent_SendClosingSigned_get_node_id(uint64_t ptr) {
2370 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2371 assert(obj->tag == LDKMessageSendEvent_SendClosingSigned);
2372 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2373 memcpy(node_id_arr->elems, obj->send_closing_signed.node_id.compressed_form, 33);
2376 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendClosingSigned_get_msg"))) TS_LDKMessageSendEvent_SendClosingSigned_get_msg(uint64_t ptr) {
2377 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2378 assert(obj->tag == LDKMessageSendEvent_SendClosingSigned);
2379 LDKClosingSigned msg_var = obj->send_closing_signed.msg;
2380 uint64_t msg_ref = 0;
2381 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2382 msg_ref = tag_ptr(msg_var.inner, false);
2385 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendShutdown_get_node_id"))) TS_LDKMessageSendEvent_SendShutdown_get_node_id(uint64_t ptr) {
2386 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2387 assert(obj->tag == LDKMessageSendEvent_SendShutdown);
2388 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2389 memcpy(node_id_arr->elems, obj->send_shutdown.node_id.compressed_form, 33);
2392 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendShutdown_get_msg"))) TS_LDKMessageSendEvent_SendShutdown_get_msg(uint64_t ptr) {
2393 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2394 assert(obj->tag == LDKMessageSendEvent_SendShutdown);
2395 LDKShutdown msg_var = obj->send_shutdown.msg;
2396 uint64_t msg_ref = 0;
2397 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2398 msg_ref = tag_ptr(msg_var.inner, false);
2401 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelReestablish_get_node_id"))) TS_LDKMessageSendEvent_SendChannelReestablish_get_node_id(uint64_t ptr) {
2402 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2403 assert(obj->tag == LDKMessageSendEvent_SendChannelReestablish);
2404 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2405 memcpy(node_id_arr->elems, obj->send_channel_reestablish.node_id.compressed_form, 33);
2408 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelReestablish_get_msg"))) TS_LDKMessageSendEvent_SendChannelReestablish_get_msg(uint64_t ptr) {
2409 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2410 assert(obj->tag == LDKMessageSendEvent_SendChannelReestablish);
2411 LDKChannelReestablish msg_var = obj->send_channel_reestablish.msg;
2412 uint64_t msg_ref = 0;
2413 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2414 msg_ref = tag_ptr(msg_var.inner, false);
2417 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelAnnouncement_get_node_id"))) TS_LDKMessageSendEvent_SendChannelAnnouncement_get_node_id(uint64_t ptr) {
2418 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2419 assert(obj->tag == LDKMessageSendEvent_SendChannelAnnouncement);
2420 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2421 memcpy(node_id_arr->elems, obj->send_channel_announcement.node_id.compressed_form, 33);
2424 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelAnnouncement_get_msg"))) TS_LDKMessageSendEvent_SendChannelAnnouncement_get_msg(uint64_t ptr) {
2425 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2426 assert(obj->tag == LDKMessageSendEvent_SendChannelAnnouncement);
2427 LDKChannelAnnouncement msg_var = obj->send_channel_announcement.msg;
2428 uint64_t msg_ref = 0;
2429 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2430 msg_ref = tag_ptr(msg_var.inner, false);
2433 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelAnnouncement_get_update_msg"))) TS_LDKMessageSendEvent_SendChannelAnnouncement_get_update_msg(uint64_t ptr) {
2434 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2435 assert(obj->tag == LDKMessageSendEvent_SendChannelAnnouncement);
2436 LDKChannelUpdate update_msg_var = obj->send_channel_announcement.update_msg;
2437 uint64_t update_msg_ref = 0;
2438 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_msg_var);
2439 update_msg_ref = tag_ptr(update_msg_var.inner, false);
2440 return update_msg_ref;
2442 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg"))) TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(uint64_t ptr) {
2443 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2444 assert(obj->tag == LDKMessageSendEvent_BroadcastChannelAnnouncement);
2445 LDKChannelAnnouncement msg_var = obj->broadcast_channel_announcement.msg;
2446 uint64_t msg_ref = 0;
2447 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2448 msg_ref = tag_ptr(msg_var.inner, false);
2451 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg"))) TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(uint64_t ptr) {
2452 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2453 assert(obj->tag == LDKMessageSendEvent_BroadcastChannelAnnouncement);
2454 LDKChannelUpdate update_msg_var = obj->broadcast_channel_announcement.update_msg;
2455 uint64_t update_msg_ref = 0;
2456 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_msg_var);
2457 update_msg_ref = tag_ptr(update_msg_var.inner, false);
2458 return update_msg_ref;
2460 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_BroadcastChannelUpdate_get_msg"))) TS_LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(uint64_t ptr) {
2461 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2462 assert(obj->tag == LDKMessageSendEvent_BroadcastChannelUpdate);
2463 LDKChannelUpdate msg_var = obj->broadcast_channel_update.msg;
2464 uint64_t msg_ref = 0;
2465 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2466 msg_ref = tag_ptr(msg_var.inner, false);
2469 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelUpdate_get_node_id"))) TS_LDKMessageSendEvent_SendChannelUpdate_get_node_id(uint64_t ptr) {
2470 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2471 assert(obj->tag == LDKMessageSendEvent_SendChannelUpdate);
2472 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2473 memcpy(node_id_arr->elems, obj->send_channel_update.node_id.compressed_form, 33);
2476 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelUpdate_get_msg"))) TS_LDKMessageSendEvent_SendChannelUpdate_get_msg(uint64_t ptr) {
2477 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2478 assert(obj->tag == LDKMessageSendEvent_SendChannelUpdate);
2479 LDKChannelUpdate msg_var = obj->send_channel_update.msg;
2480 uint64_t msg_ref = 0;
2481 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2482 msg_ref = tag_ptr(msg_var.inner, false);
2485 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_HandleError_get_node_id"))) TS_LDKMessageSendEvent_HandleError_get_node_id(uint64_t ptr) {
2486 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2487 assert(obj->tag == LDKMessageSendEvent_HandleError);
2488 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2489 memcpy(node_id_arr->elems, obj->handle_error.node_id.compressed_form, 33);
2492 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_HandleError_get_action"))) TS_LDKMessageSendEvent_HandleError_get_action(uint64_t ptr) {
2493 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2494 assert(obj->tag == LDKMessageSendEvent_HandleError);
2495 uint64_t action_ref = tag_ptr(&obj->handle_error.action, false);
2498 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelRangeQuery_get_node_id"))) TS_LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(uint64_t ptr) {
2499 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2500 assert(obj->tag == LDKMessageSendEvent_SendChannelRangeQuery);
2501 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2502 memcpy(node_id_arr->elems, obj->send_channel_range_query.node_id.compressed_form, 33);
2505 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelRangeQuery_get_msg"))) TS_LDKMessageSendEvent_SendChannelRangeQuery_get_msg(uint64_t ptr) {
2506 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2507 assert(obj->tag == LDKMessageSendEvent_SendChannelRangeQuery);
2508 LDKQueryChannelRange msg_var = obj->send_channel_range_query.msg;
2509 uint64_t msg_ref = 0;
2510 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2511 msg_ref = tag_ptr(msg_var.inner, false);
2514 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendShortIdsQuery_get_node_id"))) TS_LDKMessageSendEvent_SendShortIdsQuery_get_node_id(uint64_t ptr) {
2515 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2516 assert(obj->tag == LDKMessageSendEvent_SendShortIdsQuery);
2517 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2518 memcpy(node_id_arr->elems, obj->send_short_ids_query.node_id.compressed_form, 33);
2521 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendShortIdsQuery_get_msg"))) TS_LDKMessageSendEvent_SendShortIdsQuery_get_msg(uint64_t ptr) {
2522 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2523 assert(obj->tag == LDKMessageSendEvent_SendShortIdsQuery);
2524 LDKQueryShortChannelIds msg_var = obj->send_short_ids_query.msg;
2525 uint64_t msg_ref = 0;
2526 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2527 msg_ref = tag_ptr(msg_var.inner, false);
2530 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendReplyChannelRange_get_node_id"))) TS_LDKMessageSendEvent_SendReplyChannelRange_get_node_id(uint64_t ptr) {
2531 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2532 assert(obj->tag == LDKMessageSendEvent_SendReplyChannelRange);
2533 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2534 memcpy(node_id_arr->elems, obj->send_reply_channel_range.node_id.compressed_form, 33);
2537 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendReplyChannelRange_get_msg"))) TS_LDKMessageSendEvent_SendReplyChannelRange_get_msg(uint64_t ptr) {
2538 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2539 assert(obj->tag == LDKMessageSendEvent_SendReplyChannelRange);
2540 LDKReplyChannelRange msg_var = obj->send_reply_channel_range.msg;
2541 uint64_t msg_ref = 0;
2542 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2543 msg_ref = tag_ptr(msg_var.inner, false);
2546 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id"))) TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(uint64_t ptr) {
2547 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2548 assert(obj->tag == LDKMessageSendEvent_SendGossipTimestampFilter);
2549 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2550 memcpy(node_id_arr->elems, obj->send_gossip_timestamp_filter.node_id.compressed_form, 33);
2553 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_msg"))) TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(uint64_t ptr) {
2554 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
2555 assert(obj->tag == LDKMessageSendEvent_SendGossipTimestampFilter);
2556 LDKGossipTimestampFilter msg_var = obj->send_gossip_timestamp_filter.msg;
2557 uint64_t msg_ref = 0;
2558 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2559 msg_ref = tag_ptr(msg_var.inner, false);
2562 static inline LDKCVec_MessageSendEventZ CVec_MessageSendEventZ_clone(const LDKCVec_MessageSendEventZ *orig) {
2563 LDKCVec_MessageSendEventZ ret = { .data = MALLOC(sizeof(LDKMessageSendEvent) * orig->datalen, "LDKCVec_MessageSendEventZ clone bytes"), .datalen = orig->datalen };
2564 for (size_t i = 0; i < ret.datalen; i++) {
2565 ret.data[i] = MessageSendEvent_clone(&orig->data[i]);
2569 static inline struct LDKTxOut CResult_TxOutAccessErrorZ_get_ok(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR owner){
2570 CHECK(owner->result_ok);
2571 return TxOut_clone(&*owner->contents.result);
2573 uint64_t __attribute__((export_name("TS_CResult_TxOutAccessErrorZ_get_ok"))) TS_CResult_TxOutAccessErrorZ_get_ok(uint64_t owner) {
2574 LDKCResult_TxOutAccessErrorZ* owner_conv = (LDKCResult_TxOutAccessErrorZ*)untag_ptr(owner);
2575 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
2576 *ret_ref = CResult_TxOutAccessErrorZ_get_ok(owner_conv);
2577 return tag_ptr(ret_ref, true);
2580 static inline enum LDKAccessError CResult_TxOutAccessErrorZ_get_err(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR owner){
2581 CHECK(!owner->result_ok);
2582 return AccessError_clone(&*owner->contents.err);
2584 uint32_t __attribute__((export_name("TS_CResult_TxOutAccessErrorZ_get_err"))) TS_CResult_TxOutAccessErrorZ_get_err(uint64_t owner) {
2585 LDKCResult_TxOutAccessErrorZ* owner_conv = (LDKCResult_TxOutAccessErrorZ*)untag_ptr(owner);
2586 uint32_t ret_conv = LDKAccessError_to_js(CResult_TxOutAccessErrorZ_get_err(owner_conv));
2590 static inline uintptr_t C2Tuple_usizeTransactionZ_get_a(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner){
2593 uint32_t __attribute__((export_name("TS_C2Tuple_usizeTransactionZ_get_a"))) TS_C2Tuple_usizeTransactionZ_get_a(uint64_t owner) {
2594 LDKC2Tuple_usizeTransactionZ* owner_conv = (LDKC2Tuple_usizeTransactionZ*)untag_ptr(owner);
2595 uint32_t ret_conv = C2Tuple_usizeTransactionZ_get_a(owner_conv);
2599 static inline struct LDKTransaction C2Tuple_usizeTransactionZ_get_b(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner){
2602 int8_tArray __attribute__((export_name("TS_C2Tuple_usizeTransactionZ_get_b"))) TS_C2Tuple_usizeTransactionZ_get_b(uint64_t owner) {
2603 LDKC2Tuple_usizeTransactionZ* owner_conv = (LDKC2Tuple_usizeTransactionZ*)untag_ptr(owner);
2604 LDKTransaction ret_var = C2Tuple_usizeTransactionZ_get_b(owner_conv);
2605 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
2606 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
2610 static inline LDKCVec_C2Tuple_usizeTransactionZZ CVec_C2Tuple_usizeTransactionZZ_clone(const LDKCVec_C2Tuple_usizeTransactionZZ *orig) {
2611 LDKCVec_C2Tuple_usizeTransactionZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ) * orig->datalen, "LDKCVec_C2Tuple_usizeTransactionZZ clone bytes"), .datalen = orig->datalen };
2612 for (size_t i = 0; i < ret.datalen; i++) {
2613 ret.data[i] = C2Tuple_usizeTransactionZ_clone(&orig->data[i]);
2617 static inline struct LDKThirtyTwoBytes C2Tuple_TxidBlockHashZ_get_a(LDKC2Tuple_TxidBlockHashZ *NONNULL_PTR owner){
2618 return ThirtyTwoBytes_clone(&owner->a);
2620 int8_tArray __attribute__((export_name("TS_C2Tuple_TxidBlockHashZ_get_a"))) TS_C2Tuple_TxidBlockHashZ_get_a(uint64_t owner) {
2621 LDKC2Tuple_TxidBlockHashZ* owner_conv = (LDKC2Tuple_TxidBlockHashZ*)untag_ptr(owner);
2622 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
2623 memcpy(ret_arr->elems, C2Tuple_TxidBlockHashZ_get_a(owner_conv).data, 32);
2627 static inline struct LDKThirtyTwoBytes C2Tuple_TxidBlockHashZ_get_b(LDKC2Tuple_TxidBlockHashZ *NONNULL_PTR owner){
2628 return ThirtyTwoBytes_clone(&owner->b);
2630 int8_tArray __attribute__((export_name("TS_C2Tuple_TxidBlockHashZ_get_b"))) TS_C2Tuple_TxidBlockHashZ_get_b(uint64_t owner) {
2631 LDKC2Tuple_TxidBlockHashZ* owner_conv = (LDKC2Tuple_TxidBlockHashZ*)untag_ptr(owner);
2632 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
2633 memcpy(ret_arr->elems, C2Tuple_TxidBlockHashZ_get_b(owner_conv).data, 32);
2637 static inline LDKCVec_C2Tuple_TxidBlockHashZZ CVec_C2Tuple_TxidBlockHashZZ_clone(const LDKCVec_C2Tuple_TxidBlockHashZZ *orig) {
2638 LDKCVec_C2Tuple_TxidBlockHashZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_TxidBlockHashZ) * orig->datalen, "LDKCVec_C2Tuple_TxidBlockHashZZ clone bytes"), .datalen = orig->datalen };
2639 for (size_t i = 0; i < ret.datalen; i++) {
2640 ret.data[i] = C2Tuple_TxidBlockHashZ_clone(&orig->data[i]);
2644 uint32_t __attribute__((export_name("TS_LDKMonitorEvent_ty_from_ptr"))) TS_LDKMonitorEvent_ty_from_ptr(uint64_t ptr) {
2645 LDKMonitorEvent *obj = (LDKMonitorEvent*)untag_ptr(ptr);
2647 case LDKMonitorEvent_HTLCEvent: return 0;
2648 case LDKMonitorEvent_CommitmentTxConfirmed: return 1;
2649 case LDKMonitorEvent_Completed: return 2;
2650 case LDKMonitorEvent_UpdateFailed: return 3;
2654 uint64_t __attribute__((export_name("TS_LDKMonitorEvent_HTLCEvent_get_htlc_event"))) TS_LDKMonitorEvent_HTLCEvent_get_htlc_event(uint64_t ptr) {
2655 LDKMonitorEvent *obj = (LDKMonitorEvent*)untag_ptr(ptr);
2656 assert(obj->tag == LDKMonitorEvent_HTLCEvent);
2657 LDKHTLCUpdate htlc_event_var = obj->htlc_event;
2658 uint64_t htlc_event_ref = 0;
2659 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_event_var);
2660 htlc_event_ref = tag_ptr(htlc_event_var.inner, false);
2661 return htlc_event_ref;
2663 uint64_t __attribute__((export_name("TS_LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed"))) TS_LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(uint64_t ptr) {
2664 LDKMonitorEvent *obj = (LDKMonitorEvent*)untag_ptr(ptr);
2665 assert(obj->tag == LDKMonitorEvent_CommitmentTxConfirmed);
2666 LDKOutPoint commitment_tx_confirmed_var = obj->commitment_tx_confirmed;
2667 uint64_t commitment_tx_confirmed_ref = 0;
2668 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_confirmed_var);
2669 commitment_tx_confirmed_ref = tag_ptr(commitment_tx_confirmed_var.inner, false);
2670 return commitment_tx_confirmed_ref;
2672 uint64_t __attribute__((export_name("TS_LDKMonitorEvent_Completed_get_funding_txo"))) TS_LDKMonitorEvent_Completed_get_funding_txo(uint64_t ptr) {
2673 LDKMonitorEvent *obj = (LDKMonitorEvent*)untag_ptr(ptr);
2674 assert(obj->tag == LDKMonitorEvent_Completed);
2675 LDKOutPoint funding_txo_var = obj->completed.funding_txo;
2676 uint64_t funding_txo_ref = 0;
2677 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_var);
2678 funding_txo_ref = tag_ptr(funding_txo_var.inner, false);
2679 return funding_txo_ref;
2681 int64_t __attribute__((export_name("TS_LDKMonitorEvent_Completed_get_monitor_update_id"))) TS_LDKMonitorEvent_Completed_get_monitor_update_id(uint64_t ptr) {
2682 LDKMonitorEvent *obj = (LDKMonitorEvent*)untag_ptr(ptr);
2683 assert(obj->tag == LDKMonitorEvent_Completed);
2684 int64_t monitor_update_id_conv = obj->completed.monitor_update_id;
2685 return monitor_update_id_conv;
2687 uint64_t __attribute__((export_name("TS_LDKMonitorEvent_UpdateFailed_get_update_failed"))) TS_LDKMonitorEvent_UpdateFailed_get_update_failed(uint64_t ptr) {
2688 LDKMonitorEvent *obj = (LDKMonitorEvent*)untag_ptr(ptr);
2689 assert(obj->tag == LDKMonitorEvent_UpdateFailed);
2690 LDKOutPoint update_failed_var = obj->update_failed;
2691 uint64_t update_failed_ref = 0;
2692 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_failed_var);
2693 update_failed_ref = tag_ptr(update_failed_var.inner, false);
2694 return update_failed_ref;
2696 static inline LDKCVec_MonitorEventZ CVec_MonitorEventZ_clone(const LDKCVec_MonitorEventZ *orig) {
2697 LDKCVec_MonitorEventZ ret = { .data = MALLOC(sizeof(LDKMonitorEvent) * orig->datalen, "LDKCVec_MonitorEventZ clone bytes"), .datalen = orig->datalen };
2698 for (size_t i = 0; i < ret.datalen; i++) {
2699 ret.data[i] = MonitorEvent_clone(&orig->data[i]);
2703 static inline struct LDKOutPoint C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner){
2704 LDKOutPoint ret = owner->a;
2705 ret.is_owned = false;
2708 uint64_t __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(uint64_t owner) {
2709 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* owner_conv = (LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)untag_ptr(owner);
2710 LDKOutPoint ret_var = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(owner_conv);
2711 uint64_t ret_ref = 0;
2712 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2713 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
2717 static inline struct LDKCVec_MonitorEventZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner){
2718 return CVec_MonitorEventZ_clone(&owner->b);
2720 uint64_tArray __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(uint64_t owner) {
2721 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* owner_conv = (LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)untag_ptr(owner);
2722 LDKCVec_MonitorEventZ ret_var = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(owner_conv);
2723 uint64_tArray ret_arr = NULL;
2724 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
2725 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
2726 for (size_t o = 0; o < ret_var.datalen; o++) {
2727 LDKMonitorEvent *ret_conv_14_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
2728 *ret_conv_14_copy = ret_var.data[o];
2729 uint64_t ret_conv_14_ref = tag_ptr(ret_conv_14_copy, true);
2730 ret_arr_ptr[o] = ret_conv_14_ref;
2737 static inline struct LDKPublicKey C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner){
2740 int8_tArray __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(uint64_t owner) {
2741 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* owner_conv = (LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)untag_ptr(owner);
2742 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
2743 memcpy(ret_arr->elems, C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(owner_conv).compressed_form, 33);
2747 static inline LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_clone(const LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ *orig) {
2748 LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ ret = { .data = MALLOC(sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ) * orig->datalen, "LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ clone bytes"), .datalen = orig->datalen };
2749 for (size_t i = 0; i < ret.datalen; i++) {
2750 ret.data[i] = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(&orig->data[i]);
2754 static inline struct LDKFixedPenaltyScorer CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner){
2755 LDKFixedPenaltyScorer ret = *owner->contents.result;
2756 ret.is_owned = false;
2759 uint64_t __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_ok"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(uint64_t owner) {
2760 LDKCResult_FixedPenaltyScorerDecodeErrorZ* owner_conv = (LDKCResult_FixedPenaltyScorerDecodeErrorZ*)untag_ptr(owner);
2761 LDKFixedPenaltyScorer ret_var = CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner_conv);
2762 uint64_t ret_ref = 0;
2763 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2764 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
2768 static inline struct LDKDecodeError CResult_FixedPenaltyScorerDecodeErrorZ_get_err(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner){
2769 CHECK(!owner->result_ok);
2770 return DecodeError_clone(&*owner->contents.err);
2772 uint64_t __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_err"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_err(uint64_t owner) {
2773 LDKCResult_FixedPenaltyScorerDecodeErrorZ* owner_conv = (LDKCResult_FixedPenaltyScorerDecodeErrorZ*)untag_ptr(owner);
2774 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
2775 *ret_copy = CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner_conv);
2776 uint64_t ret_ref = tag_ptr(ret_copy, true);
2780 static inline uint64_t C2Tuple_u64u64Z_get_a(LDKC2Tuple_u64u64Z *NONNULL_PTR owner){
2783 int64_t __attribute__((export_name("TS_C2Tuple_u64u64Z_get_a"))) TS_C2Tuple_u64u64Z_get_a(uint64_t owner) {
2784 LDKC2Tuple_u64u64Z* owner_conv = (LDKC2Tuple_u64u64Z*)untag_ptr(owner);
2785 int64_t ret_conv = C2Tuple_u64u64Z_get_a(owner_conv);
2789 static inline uint64_t C2Tuple_u64u64Z_get_b(LDKC2Tuple_u64u64Z *NONNULL_PTR owner){
2792 int64_t __attribute__((export_name("TS_C2Tuple_u64u64Z_get_b"))) TS_C2Tuple_u64u64Z_get_b(uint64_t owner) {
2793 LDKC2Tuple_u64u64Z* owner_conv = (LDKC2Tuple_u64u64Z*)untag_ptr(owner);
2794 int64_t ret_conv = C2Tuple_u64u64Z_get_b(owner_conv);
2798 uint32_t __attribute__((export_name("TS_LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr"))) TS_LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(uint64_t ptr) {
2799 LDKCOption_C2Tuple_u64u64ZZ *obj = (LDKCOption_C2Tuple_u64u64ZZ*)untag_ptr(ptr);
2801 case LDKCOption_C2Tuple_u64u64ZZ_Some: return 0;
2802 case LDKCOption_C2Tuple_u64u64ZZ_None: return 1;
2806 uint64_t __attribute__((export_name("TS_LDKCOption_C2Tuple_u64u64ZZ_Some_get_some"))) TS_LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(uint64_t ptr) {
2807 LDKCOption_C2Tuple_u64u64ZZ *obj = (LDKCOption_C2Tuple_u64u64ZZ*)untag_ptr(ptr);
2808 assert(obj->tag == LDKCOption_C2Tuple_u64u64ZZ_Some);
2809 LDKC2Tuple_u64u64Z* some_conv = MALLOC(sizeof(LDKC2Tuple_u64u64Z), "LDKC2Tuple_u64u64Z");
2810 *some_conv = obj->some;
2811 *some_conv = C2Tuple_u64u64Z_clone(some_conv);
2812 return tag_ptr(some_conv, true);
2814 static inline LDKCVec_NodeIdZ CVec_NodeIdZ_clone(const LDKCVec_NodeIdZ *orig) {
2815 LDKCVec_NodeIdZ ret = { .data = MALLOC(sizeof(LDKNodeId) * orig->datalen, "LDKCVec_NodeIdZ clone bytes"), .datalen = orig->datalen };
2816 for (size_t i = 0; i < ret.datalen; i++) {
2817 ret.data[i] = NodeId_clone(&orig->data[i]);
2821 typedef struct LDKLogger_JCalls {
2822 atomic_size_t refcnt;
2823 uint32_t instance_ptr;
2825 static void LDKLogger_JCalls_free(void* this_arg) {
2826 LDKLogger_JCalls *j_calls = (LDKLogger_JCalls*) this_arg;
2827 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
2831 void log_LDKLogger_jcall(const void* this_arg, const LDKRecord * record) {
2832 LDKLogger_JCalls *j_calls = (LDKLogger_JCalls*) this_arg;
2833 LDKRecord record_var = *record;
2834 uint64_t record_ref = 0;
2835 record_var = Record_clone(&record_var);
2836 CHECK_INNER_FIELD_ACCESS_OR_NULL(record_var);
2837 record_ref = tag_ptr(record_var.inner, record_var.is_owned);
2838 js_invoke_function_buuuuu(j_calls->instance_ptr, 0, record_ref, 0, 0, 0, 0, 0);
2840 static void LDKLogger_JCalls_cloned(LDKLogger* new_obj) {
2841 LDKLogger_JCalls *j_calls = (LDKLogger_JCalls*) new_obj->this_arg;
2842 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
2844 static inline LDKLogger LDKLogger_init (JSValue o) {
2845 LDKLogger_JCalls *calls = MALLOC(sizeof(LDKLogger_JCalls), "LDKLogger_JCalls");
2846 atomic_init(&calls->refcnt, 1);
2847 calls->instance_ptr = o;
2850 .this_arg = (void*) calls,
2851 .log = log_LDKLogger_jcall,
2852 .free = LDKLogger_JCalls_free,
2856 uint64_t __attribute__((export_name("TS_LDKLogger_new"))) TS_LDKLogger_new(JSValue o) {
2857 LDKLogger *res_ptr = MALLOC(sizeof(LDKLogger), "LDKLogger");
2858 *res_ptr = LDKLogger_init(o);
2859 return tag_ptr(res_ptr, true);
2861 static inline struct LDKProbabilisticScorer CResult_ProbabilisticScorerDecodeErrorZ_get_ok(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner){
2862 LDKProbabilisticScorer ret = *owner->contents.result;
2863 ret.is_owned = false;
2866 uint64_t __attribute__((export_name("TS_CResult_ProbabilisticScorerDecodeErrorZ_get_ok"))) TS_CResult_ProbabilisticScorerDecodeErrorZ_get_ok(uint64_t owner) {
2867 LDKCResult_ProbabilisticScorerDecodeErrorZ* owner_conv = (LDKCResult_ProbabilisticScorerDecodeErrorZ*)untag_ptr(owner);
2868 LDKProbabilisticScorer ret_var = CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner_conv);
2869 uint64_t ret_ref = 0;
2870 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2871 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
2875 static inline struct LDKDecodeError CResult_ProbabilisticScorerDecodeErrorZ_get_err(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner){
2876 CHECK(!owner->result_ok);
2877 return DecodeError_clone(&*owner->contents.err);
2879 uint64_t __attribute__((export_name("TS_CResult_ProbabilisticScorerDecodeErrorZ_get_err"))) TS_CResult_ProbabilisticScorerDecodeErrorZ_get_err(uint64_t owner) {
2880 LDKCResult_ProbabilisticScorerDecodeErrorZ* owner_conv = (LDKCResult_ProbabilisticScorerDecodeErrorZ*)untag_ptr(owner);
2881 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
2882 *ret_copy = CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner_conv);
2883 uint64_t ret_ref = tag_ptr(ret_copy, true);
2887 static inline struct LDKInitFeatures CResult_InitFeaturesDecodeErrorZ_get_ok(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner){
2888 LDKInitFeatures ret = *owner->contents.result;
2889 ret.is_owned = false;
2892 uint64_t __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_get_ok"))) TS_CResult_InitFeaturesDecodeErrorZ_get_ok(uint64_t owner) {
2893 LDKCResult_InitFeaturesDecodeErrorZ* owner_conv = (LDKCResult_InitFeaturesDecodeErrorZ*)untag_ptr(owner);
2894 LDKInitFeatures ret_var = CResult_InitFeaturesDecodeErrorZ_get_ok(owner_conv);
2895 uint64_t ret_ref = 0;
2896 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2897 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
2901 static inline struct LDKDecodeError CResult_InitFeaturesDecodeErrorZ_get_err(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner){
2902 CHECK(!owner->result_ok);
2903 return DecodeError_clone(&*owner->contents.err);
2905 uint64_t __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_get_err"))) TS_CResult_InitFeaturesDecodeErrorZ_get_err(uint64_t owner) {
2906 LDKCResult_InitFeaturesDecodeErrorZ* owner_conv = (LDKCResult_InitFeaturesDecodeErrorZ*)untag_ptr(owner);
2907 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
2908 *ret_copy = CResult_InitFeaturesDecodeErrorZ_get_err(owner_conv);
2909 uint64_t ret_ref = tag_ptr(ret_copy, true);
2913 static inline struct LDKChannelFeatures CResult_ChannelFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner){
2914 LDKChannelFeatures ret = *owner->contents.result;
2915 ret.is_owned = false;
2918 uint64_t __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_get_ok"))) TS_CResult_ChannelFeaturesDecodeErrorZ_get_ok(uint64_t owner) {
2919 LDKCResult_ChannelFeaturesDecodeErrorZ* owner_conv = (LDKCResult_ChannelFeaturesDecodeErrorZ*)untag_ptr(owner);
2920 LDKChannelFeatures ret_var = CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner_conv);
2921 uint64_t ret_ref = 0;
2922 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2923 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
2927 static inline struct LDKDecodeError CResult_ChannelFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner){
2928 CHECK(!owner->result_ok);
2929 return DecodeError_clone(&*owner->contents.err);
2931 uint64_t __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_get_err"))) TS_CResult_ChannelFeaturesDecodeErrorZ_get_err(uint64_t owner) {
2932 LDKCResult_ChannelFeaturesDecodeErrorZ* owner_conv = (LDKCResult_ChannelFeaturesDecodeErrorZ*)untag_ptr(owner);
2933 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
2934 *ret_copy = CResult_ChannelFeaturesDecodeErrorZ_get_err(owner_conv);
2935 uint64_t ret_ref = tag_ptr(ret_copy, true);
2939 static inline struct LDKNodeFeatures CResult_NodeFeaturesDecodeErrorZ_get_ok(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner){
2940 LDKNodeFeatures ret = *owner->contents.result;
2941 ret.is_owned = false;
2944 uint64_t __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_get_ok"))) TS_CResult_NodeFeaturesDecodeErrorZ_get_ok(uint64_t owner) {
2945 LDKCResult_NodeFeaturesDecodeErrorZ* owner_conv = (LDKCResult_NodeFeaturesDecodeErrorZ*)untag_ptr(owner);
2946 LDKNodeFeatures ret_var = CResult_NodeFeaturesDecodeErrorZ_get_ok(owner_conv);
2947 uint64_t ret_ref = 0;
2948 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2949 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
2953 static inline struct LDKDecodeError CResult_NodeFeaturesDecodeErrorZ_get_err(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner){
2954 CHECK(!owner->result_ok);
2955 return DecodeError_clone(&*owner->contents.err);
2957 uint64_t __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_get_err"))) TS_CResult_NodeFeaturesDecodeErrorZ_get_err(uint64_t owner) {
2958 LDKCResult_NodeFeaturesDecodeErrorZ* owner_conv = (LDKCResult_NodeFeaturesDecodeErrorZ*)untag_ptr(owner);
2959 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
2960 *ret_copy = CResult_NodeFeaturesDecodeErrorZ_get_err(owner_conv);
2961 uint64_t ret_ref = tag_ptr(ret_copy, true);
2965 static inline struct LDKInvoiceFeatures CResult_InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner){
2966 LDKInvoiceFeatures ret = *owner->contents.result;
2967 ret.is_owned = false;
2970 uint64_t __attribute__((export_name("TS_CResult_InvoiceFeaturesDecodeErrorZ_get_ok"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_get_ok(uint64_t owner) {
2971 LDKCResult_InvoiceFeaturesDecodeErrorZ* owner_conv = (LDKCResult_InvoiceFeaturesDecodeErrorZ*)untag_ptr(owner);
2972 LDKInvoiceFeatures ret_var = CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner_conv);
2973 uint64_t ret_ref = 0;
2974 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2975 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
2979 static inline struct LDKDecodeError CResult_InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner){
2980 CHECK(!owner->result_ok);
2981 return DecodeError_clone(&*owner->contents.err);
2983 uint64_t __attribute__((export_name("TS_CResult_InvoiceFeaturesDecodeErrorZ_get_err"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_get_err(uint64_t owner) {
2984 LDKCResult_InvoiceFeaturesDecodeErrorZ* owner_conv = (LDKCResult_InvoiceFeaturesDecodeErrorZ*)untag_ptr(owner);
2985 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
2986 *ret_copy = CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner_conv);
2987 uint64_t ret_ref = tag_ptr(ret_copy, true);
2991 static inline struct LDKChannelTypeFeatures CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner){
2992 LDKChannelTypeFeatures ret = *owner->contents.result;
2993 ret.is_owned = false;
2996 uint64_t __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(uint64_t owner) {
2997 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* owner_conv = (LDKCResult_ChannelTypeFeaturesDecodeErrorZ*)untag_ptr(owner);
2998 LDKChannelTypeFeatures ret_var = CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner_conv);
2999 uint64_t ret_ref = 0;
3000 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3001 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3005 static inline struct LDKDecodeError CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner){
3006 CHECK(!owner->result_ok);
3007 return DecodeError_clone(&*owner->contents.err);
3009 uint64_t __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_err"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(uint64_t owner) {
3010 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* owner_conv = (LDKCResult_ChannelTypeFeaturesDecodeErrorZ*)untag_ptr(owner);
3011 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3012 *ret_copy = CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner_conv);
3013 uint64_t ret_ref = tag_ptr(ret_copy, true);
3017 static inline struct LDKOfferFeatures CResult_OfferFeaturesDecodeErrorZ_get_ok(LDKCResult_OfferFeaturesDecodeErrorZ *NONNULL_PTR owner){
3018 LDKOfferFeatures ret = *owner->contents.result;
3019 ret.is_owned = false;
3022 uint64_t __attribute__((export_name("TS_CResult_OfferFeaturesDecodeErrorZ_get_ok"))) TS_CResult_OfferFeaturesDecodeErrorZ_get_ok(uint64_t owner) {
3023 LDKCResult_OfferFeaturesDecodeErrorZ* owner_conv = (LDKCResult_OfferFeaturesDecodeErrorZ*)untag_ptr(owner);
3024 LDKOfferFeatures ret_var = CResult_OfferFeaturesDecodeErrorZ_get_ok(owner_conv);
3025 uint64_t ret_ref = 0;
3026 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3027 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3031 static inline struct LDKDecodeError CResult_OfferFeaturesDecodeErrorZ_get_err(LDKCResult_OfferFeaturesDecodeErrorZ *NONNULL_PTR owner){
3032 CHECK(!owner->result_ok);
3033 return DecodeError_clone(&*owner->contents.err);
3035 uint64_t __attribute__((export_name("TS_CResult_OfferFeaturesDecodeErrorZ_get_err"))) TS_CResult_OfferFeaturesDecodeErrorZ_get_err(uint64_t owner) {
3036 LDKCResult_OfferFeaturesDecodeErrorZ* owner_conv = (LDKCResult_OfferFeaturesDecodeErrorZ*)untag_ptr(owner);
3037 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3038 *ret_copy = CResult_OfferFeaturesDecodeErrorZ_get_err(owner_conv);
3039 uint64_t ret_ref = tag_ptr(ret_copy, true);
3043 static inline struct LDKInvoiceRequestFeatures CResult_InvoiceRequestFeaturesDecodeErrorZ_get_ok(LDKCResult_InvoiceRequestFeaturesDecodeErrorZ *NONNULL_PTR owner){
3044 LDKInvoiceRequestFeatures ret = *owner->contents.result;
3045 ret.is_owned = false;
3048 uint64_t __attribute__((export_name("TS_CResult_InvoiceRequestFeaturesDecodeErrorZ_get_ok"))) TS_CResult_InvoiceRequestFeaturesDecodeErrorZ_get_ok(uint64_t owner) {
3049 LDKCResult_InvoiceRequestFeaturesDecodeErrorZ* owner_conv = (LDKCResult_InvoiceRequestFeaturesDecodeErrorZ*)untag_ptr(owner);
3050 LDKInvoiceRequestFeatures ret_var = CResult_InvoiceRequestFeaturesDecodeErrorZ_get_ok(owner_conv);
3051 uint64_t ret_ref = 0;
3052 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3053 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3057 static inline struct LDKDecodeError CResult_InvoiceRequestFeaturesDecodeErrorZ_get_err(LDKCResult_InvoiceRequestFeaturesDecodeErrorZ *NONNULL_PTR owner){
3058 CHECK(!owner->result_ok);
3059 return DecodeError_clone(&*owner->contents.err);
3061 uint64_t __attribute__((export_name("TS_CResult_InvoiceRequestFeaturesDecodeErrorZ_get_err"))) TS_CResult_InvoiceRequestFeaturesDecodeErrorZ_get_err(uint64_t owner) {
3062 LDKCResult_InvoiceRequestFeaturesDecodeErrorZ* owner_conv = (LDKCResult_InvoiceRequestFeaturesDecodeErrorZ*)untag_ptr(owner);
3063 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3064 *ret_copy = CResult_InvoiceRequestFeaturesDecodeErrorZ_get_err(owner_conv);
3065 uint64_t ret_ref = tag_ptr(ret_copy, true);
3069 static inline struct LDKNodeId CResult_NodeIdDecodeErrorZ_get_ok(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner){
3070 LDKNodeId ret = *owner->contents.result;
3071 ret.is_owned = false;
3074 uint64_t __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_get_ok"))) TS_CResult_NodeIdDecodeErrorZ_get_ok(uint64_t owner) {
3075 LDKCResult_NodeIdDecodeErrorZ* owner_conv = (LDKCResult_NodeIdDecodeErrorZ*)untag_ptr(owner);
3076 LDKNodeId ret_var = CResult_NodeIdDecodeErrorZ_get_ok(owner_conv);
3077 uint64_t ret_ref = 0;
3078 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3079 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3083 static inline struct LDKDecodeError CResult_NodeIdDecodeErrorZ_get_err(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner){
3084 CHECK(!owner->result_ok);
3085 return DecodeError_clone(&*owner->contents.err);
3087 uint64_t __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_get_err"))) TS_CResult_NodeIdDecodeErrorZ_get_err(uint64_t owner) {
3088 LDKCResult_NodeIdDecodeErrorZ* owner_conv = (LDKCResult_NodeIdDecodeErrorZ*)untag_ptr(owner);
3089 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3090 *ret_copy = CResult_NodeIdDecodeErrorZ_get_err(owner_conv);
3091 uint64_t ret_ref = tag_ptr(ret_copy, true);
3095 static inline struct LDKCOption_NetworkUpdateZ CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner){
3096 CHECK(owner->result_ok);
3097 return COption_NetworkUpdateZ_clone(&*owner->contents.result);
3099 uint64_t __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(uint64_t owner) {
3100 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* owner_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)untag_ptr(owner);
3101 LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
3102 *ret_copy = CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner_conv);
3103 uint64_t ret_ref = tag_ptr(ret_copy, true);
3107 static inline struct LDKDecodeError CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner){
3108 CHECK(!owner->result_ok);
3109 return DecodeError_clone(&*owner->contents.err);
3111 uint64_t __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_err"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(uint64_t owner) {
3112 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* owner_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)untag_ptr(owner);
3113 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3114 *ret_copy = CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner_conv);
3115 uint64_t ret_ref = tag_ptr(ret_copy, true);
3119 typedef struct LDKAccess_JCalls {
3120 atomic_size_t refcnt;
3121 uint32_t instance_ptr;
3123 static void LDKAccess_JCalls_free(void* this_arg) {
3124 LDKAccess_JCalls *j_calls = (LDKAccess_JCalls*) this_arg;
3125 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
3129 LDKCResult_TxOutAccessErrorZ get_utxo_LDKAccess_jcall(const void* this_arg, const uint8_t (* genesis_hash)[32], uint64_t short_channel_id) {
3130 LDKAccess_JCalls *j_calls = (LDKAccess_JCalls*) this_arg;
3131 int8_tArray genesis_hash_arr = init_int8_tArray(32, __LINE__);
3132 memcpy(genesis_hash_arr->elems, *genesis_hash, 32);
3133 int64_t short_channel_id_conv = short_channel_id;
3134 uint64_t ret = js_invoke_function_ubuuuu(j_calls->instance_ptr, 1, (uint32_t)genesis_hash_arr, short_channel_id_conv, 0, 0, 0, 0);
3135 void* ret_ptr = untag_ptr(ret);
3136 CHECK_ACCESS(ret_ptr);
3137 LDKCResult_TxOutAccessErrorZ ret_conv = *(LDKCResult_TxOutAccessErrorZ*)(ret_ptr);
3138 FREE(untag_ptr(ret));
3141 static void LDKAccess_JCalls_cloned(LDKAccess* new_obj) {
3142 LDKAccess_JCalls *j_calls = (LDKAccess_JCalls*) new_obj->this_arg;
3143 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
3145 static inline LDKAccess LDKAccess_init (JSValue o) {
3146 LDKAccess_JCalls *calls = MALLOC(sizeof(LDKAccess_JCalls), "LDKAccess_JCalls");
3147 atomic_init(&calls->refcnt, 1);
3148 calls->instance_ptr = o;
3151 .this_arg = (void*) calls,
3152 .get_utxo = get_utxo_LDKAccess_jcall,
3153 .free = LDKAccess_JCalls_free,
3157 uint64_t __attribute__((export_name("TS_LDKAccess_new"))) TS_LDKAccess_new(JSValue o) {
3158 LDKAccess *res_ptr = MALLOC(sizeof(LDKAccess), "LDKAccess");
3159 *res_ptr = LDKAccess_init(o);
3160 return tag_ptr(res_ptr, true);
3162 uint64_t __attribute__((export_name("TS_Access_get_utxo"))) TS_Access_get_utxo(uint64_t this_arg, int8_tArray genesis_hash, int64_t short_channel_id) {
3163 void* this_arg_ptr = untag_ptr(this_arg);
3164 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
3165 LDKAccess* this_arg_conv = (LDKAccess*)this_arg_ptr;
3166 unsigned char genesis_hash_arr[32];
3167 CHECK(genesis_hash->arr_len == 32);
3168 memcpy(genesis_hash_arr, genesis_hash->elems, 32); FREE(genesis_hash);
3169 unsigned char (*genesis_hash_ref)[32] = &genesis_hash_arr;
3170 LDKCResult_TxOutAccessErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutAccessErrorZ), "LDKCResult_TxOutAccessErrorZ");
3171 *ret_conv = (this_arg_conv->get_utxo)(this_arg_conv->this_arg, genesis_hash_ref, short_channel_id);
3172 return tag_ptr(ret_conv, true);
3175 uint32_t __attribute__((export_name("TS_LDKCOption_AccessZ_ty_from_ptr"))) TS_LDKCOption_AccessZ_ty_from_ptr(uint64_t ptr) {
3176 LDKCOption_AccessZ *obj = (LDKCOption_AccessZ*)untag_ptr(ptr);
3178 case LDKCOption_AccessZ_Some: return 0;
3179 case LDKCOption_AccessZ_None: return 1;
3183 uint64_t __attribute__((export_name("TS_LDKCOption_AccessZ_Some_get_some"))) TS_LDKCOption_AccessZ_Some_get_some(uint64_t ptr) {
3184 LDKCOption_AccessZ *obj = (LDKCOption_AccessZ*)untag_ptr(ptr);
3185 assert(obj->tag == LDKCOption_AccessZ_Some);
3186 LDKAccess* some_ret = MALLOC(sizeof(LDKAccess), "LDKAccess");
3187 *some_ret = obj->some;
3188 // WARNING: We likely need to clone here, but no clone is available, so we just do it for Java instances
3189 if ((*some_ret).free == LDKAccess_JCalls_free) {
3190 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
3191 LDKAccess_JCalls_cloned(&(*some_ret));
3193 return tag_ptr(some_ret, true);
3195 static inline bool CResult_boolLightningErrorZ_get_ok(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner){
3196 CHECK(owner->result_ok);
3197 return *owner->contents.result;
3199 jboolean __attribute__((export_name("TS_CResult_boolLightningErrorZ_get_ok"))) TS_CResult_boolLightningErrorZ_get_ok(uint64_t owner) {
3200 LDKCResult_boolLightningErrorZ* owner_conv = (LDKCResult_boolLightningErrorZ*)untag_ptr(owner);
3201 jboolean ret_conv = CResult_boolLightningErrorZ_get_ok(owner_conv);
3205 static inline struct LDKLightningError CResult_boolLightningErrorZ_get_err(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner){
3206 LDKLightningError ret = *owner->contents.err;
3207 ret.is_owned = false;
3210 uint64_t __attribute__((export_name("TS_CResult_boolLightningErrorZ_get_err"))) TS_CResult_boolLightningErrorZ_get_err(uint64_t owner) {
3211 LDKCResult_boolLightningErrorZ* owner_conv = (LDKCResult_boolLightningErrorZ*)untag_ptr(owner);
3212 LDKLightningError ret_var = CResult_boolLightningErrorZ_get_err(owner_conv);
3213 uint64_t ret_ref = 0;
3214 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3215 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3219 static inline struct LDKChannelAnnouncement C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner){
3220 LDKChannelAnnouncement ret = owner->a;
3221 ret.is_owned = false;
3224 uint64_t __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(uint64_t owner) {
3225 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* owner_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)untag_ptr(owner);
3226 LDKChannelAnnouncement ret_var = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner_conv);
3227 uint64_t ret_ref = 0;
3228 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3229 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3233 static inline struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner){
3234 LDKChannelUpdate ret = owner->b;
3235 ret.is_owned = false;
3238 uint64_t __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(uint64_t owner) {
3239 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* owner_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)untag_ptr(owner);
3240 LDKChannelUpdate ret_var = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner_conv);
3241 uint64_t ret_ref = 0;
3242 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3243 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3247 static inline struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner){
3248 LDKChannelUpdate ret = owner->c;
3249 ret.is_owned = false;
3252 uint64_t __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(uint64_t owner) {
3253 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* owner_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)untag_ptr(owner);
3254 LDKChannelUpdate ret_var = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner_conv);
3255 uint64_t ret_ref = 0;
3256 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3257 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3261 uint32_t __attribute__((export_name("TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_ty_from_ptr"))) TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_ty_from_ptr(uint64_t ptr) {
3262 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *obj = (LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ*)untag_ptr(ptr);
3264 case LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some: return 0;
3265 case LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_None: return 1;
3269 uint64_t __attribute__((export_name("TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_get_some"))) TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_get_some(uint64_t ptr) {
3270 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *obj = (LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ*)untag_ptr(ptr);
3271 assert(obj->tag == LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some);
3272 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* some_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
3273 *some_conv = obj->some;
3274 *some_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(some_conv);
3275 return tag_ptr(some_conv, true);
3277 static inline void CResult_NoneLightningErrorZ_get_ok(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner){
3278 CHECK(owner->result_ok);
3279 return *owner->contents.result;
3281 void __attribute__((export_name("TS_CResult_NoneLightningErrorZ_get_ok"))) TS_CResult_NoneLightningErrorZ_get_ok(uint64_t owner) {
3282 LDKCResult_NoneLightningErrorZ* owner_conv = (LDKCResult_NoneLightningErrorZ*)untag_ptr(owner);
3283 CResult_NoneLightningErrorZ_get_ok(owner_conv);
3286 static inline struct LDKLightningError CResult_NoneLightningErrorZ_get_err(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner){
3287 LDKLightningError ret = *owner->contents.err;
3288 ret.is_owned = false;
3291 uint64_t __attribute__((export_name("TS_CResult_NoneLightningErrorZ_get_err"))) TS_CResult_NoneLightningErrorZ_get_err(uint64_t owner) {
3292 LDKCResult_NoneLightningErrorZ* owner_conv = (LDKCResult_NoneLightningErrorZ*)untag_ptr(owner);
3293 LDKLightningError ret_var = CResult_NoneLightningErrorZ_get_err(owner_conv);
3294 uint64_t ret_ref = 0;
3295 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3296 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3300 static inline struct LDKChannelUpdateInfo CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner){
3301 LDKChannelUpdateInfo ret = *owner->contents.result;
3302 ret.is_owned = false;
3305 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_ok"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(uint64_t owner) {
3306 LDKCResult_ChannelUpdateInfoDecodeErrorZ* owner_conv = (LDKCResult_ChannelUpdateInfoDecodeErrorZ*)untag_ptr(owner);
3307 LDKChannelUpdateInfo ret_var = CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner_conv);
3308 uint64_t ret_ref = 0;
3309 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3310 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3314 static inline struct LDKDecodeError CResult_ChannelUpdateInfoDecodeErrorZ_get_err(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner){
3315 CHECK(!owner->result_ok);
3316 return DecodeError_clone(&*owner->contents.err);
3318 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_err"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_err(uint64_t owner) {
3319 LDKCResult_ChannelUpdateInfoDecodeErrorZ* owner_conv = (LDKCResult_ChannelUpdateInfoDecodeErrorZ*)untag_ptr(owner);
3320 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3321 *ret_copy = CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner_conv);
3322 uint64_t ret_ref = tag_ptr(ret_copy, true);
3326 static inline struct LDKChannelInfo CResult_ChannelInfoDecodeErrorZ_get_ok(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner){
3327 LDKChannelInfo ret = *owner->contents.result;
3328 ret.is_owned = false;
3331 uint64_t __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_get_ok"))) TS_CResult_ChannelInfoDecodeErrorZ_get_ok(uint64_t owner) {
3332 LDKCResult_ChannelInfoDecodeErrorZ* owner_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)untag_ptr(owner);
3333 LDKChannelInfo ret_var = CResult_ChannelInfoDecodeErrorZ_get_ok(owner_conv);
3334 uint64_t ret_ref = 0;
3335 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3336 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3340 static inline struct LDKDecodeError CResult_ChannelInfoDecodeErrorZ_get_err(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner){
3341 CHECK(!owner->result_ok);
3342 return DecodeError_clone(&*owner->contents.err);
3344 uint64_t __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_get_err"))) TS_CResult_ChannelInfoDecodeErrorZ_get_err(uint64_t owner) {
3345 LDKCResult_ChannelInfoDecodeErrorZ* owner_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)untag_ptr(owner);
3346 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3347 *ret_copy = CResult_ChannelInfoDecodeErrorZ_get_err(owner_conv);
3348 uint64_t ret_ref = tag_ptr(ret_copy, true);
3352 static inline struct LDKRoutingFees CResult_RoutingFeesDecodeErrorZ_get_ok(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner){
3353 LDKRoutingFees ret = *owner->contents.result;
3354 ret.is_owned = false;
3357 uint64_t __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_get_ok"))) TS_CResult_RoutingFeesDecodeErrorZ_get_ok(uint64_t owner) {
3358 LDKCResult_RoutingFeesDecodeErrorZ* owner_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)untag_ptr(owner);
3359 LDKRoutingFees ret_var = CResult_RoutingFeesDecodeErrorZ_get_ok(owner_conv);
3360 uint64_t ret_ref = 0;
3361 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3362 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3366 static inline struct LDKDecodeError CResult_RoutingFeesDecodeErrorZ_get_err(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner){
3367 CHECK(!owner->result_ok);
3368 return DecodeError_clone(&*owner->contents.err);
3370 uint64_t __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_get_err"))) TS_CResult_RoutingFeesDecodeErrorZ_get_err(uint64_t owner) {
3371 LDKCResult_RoutingFeesDecodeErrorZ* owner_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)untag_ptr(owner);
3372 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3373 *ret_copy = CResult_RoutingFeesDecodeErrorZ_get_err(owner_conv);
3374 uint64_t ret_ref = tag_ptr(ret_copy, true);
3378 uint32_t __attribute__((export_name("TS_LDKNetAddress_ty_from_ptr"))) TS_LDKNetAddress_ty_from_ptr(uint64_t ptr) {
3379 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3381 case LDKNetAddress_IPv4: return 0;
3382 case LDKNetAddress_IPv6: return 1;
3383 case LDKNetAddress_OnionV2: return 2;
3384 case LDKNetAddress_OnionV3: return 3;
3385 case LDKNetAddress_Hostname: return 4;
3389 int8_tArray __attribute__((export_name("TS_LDKNetAddress_IPv4_get_addr"))) TS_LDKNetAddress_IPv4_get_addr(uint64_t ptr) {
3390 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3391 assert(obj->tag == LDKNetAddress_IPv4);
3392 int8_tArray addr_arr = init_int8_tArray(4, __LINE__);
3393 memcpy(addr_arr->elems, obj->i_pv4.addr.data, 4);
3396 int16_t __attribute__((export_name("TS_LDKNetAddress_IPv4_get_port"))) TS_LDKNetAddress_IPv4_get_port(uint64_t ptr) {
3397 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3398 assert(obj->tag == LDKNetAddress_IPv4);
3399 int16_t port_conv = obj->i_pv4.port;
3402 int8_tArray __attribute__((export_name("TS_LDKNetAddress_IPv6_get_addr"))) TS_LDKNetAddress_IPv6_get_addr(uint64_t ptr) {
3403 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3404 assert(obj->tag == LDKNetAddress_IPv6);
3405 int8_tArray addr_arr = init_int8_tArray(16, __LINE__);
3406 memcpy(addr_arr->elems, obj->i_pv6.addr.data, 16);
3409 int16_t __attribute__((export_name("TS_LDKNetAddress_IPv6_get_port"))) TS_LDKNetAddress_IPv6_get_port(uint64_t ptr) {
3410 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3411 assert(obj->tag == LDKNetAddress_IPv6);
3412 int16_t port_conv = obj->i_pv6.port;
3415 int8_tArray __attribute__((export_name("TS_LDKNetAddress_OnionV2_get_onion_v2"))) TS_LDKNetAddress_OnionV2_get_onion_v2(uint64_t ptr) {
3416 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3417 assert(obj->tag == LDKNetAddress_OnionV2);
3418 int8_tArray onion_v2_arr = init_int8_tArray(12, __LINE__);
3419 memcpy(onion_v2_arr->elems, obj->onion_v2.data, 12);
3420 return onion_v2_arr;
3422 int8_tArray __attribute__((export_name("TS_LDKNetAddress_OnionV3_get_ed25519_pubkey"))) TS_LDKNetAddress_OnionV3_get_ed25519_pubkey(uint64_t ptr) {
3423 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3424 assert(obj->tag == LDKNetAddress_OnionV3);
3425 int8_tArray ed25519_pubkey_arr = init_int8_tArray(32, __LINE__);
3426 memcpy(ed25519_pubkey_arr->elems, obj->onion_v3.ed25519_pubkey.data, 32);
3427 return ed25519_pubkey_arr;
3429 int16_t __attribute__((export_name("TS_LDKNetAddress_OnionV3_get_checksum"))) TS_LDKNetAddress_OnionV3_get_checksum(uint64_t ptr) {
3430 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3431 assert(obj->tag == LDKNetAddress_OnionV3);
3432 int16_t checksum_conv = obj->onion_v3.checksum;
3433 return checksum_conv;
3435 int8_t __attribute__((export_name("TS_LDKNetAddress_OnionV3_get_version"))) TS_LDKNetAddress_OnionV3_get_version(uint64_t ptr) {
3436 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3437 assert(obj->tag == LDKNetAddress_OnionV3);
3438 int8_t version_conv = obj->onion_v3.version;
3439 return version_conv;
3441 int16_t __attribute__((export_name("TS_LDKNetAddress_OnionV3_get_port"))) TS_LDKNetAddress_OnionV3_get_port(uint64_t ptr) {
3442 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3443 assert(obj->tag == LDKNetAddress_OnionV3);
3444 int16_t port_conv = obj->onion_v3.port;
3447 uint64_t __attribute__((export_name("TS_LDKNetAddress_Hostname_get_hostname"))) TS_LDKNetAddress_Hostname_get_hostname(uint64_t ptr) {
3448 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3449 assert(obj->tag == LDKNetAddress_Hostname);
3450 LDKHostname hostname_var = obj->hostname.hostname;
3451 uint64_t hostname_ref = 0;
3452 CHECK_INNER_FIELD_ACCESS_OR_NULL(hostname_var);
3453 hostname_ref = tag_ptr(hostname_var.inner, false);
3454 return hostname_ref;
3456 int16_t __attribute__((export_name("TS_LDKNetAddress_Hostname_get_port"))) TS_LDKNetAddress_Hostname_get_port(uint64_t ptr) {
3457 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3458 assert(obj->tag == LDKNetAddress_Hostname);
3459 int16_t port_conv = obj->hostname.port;
3462 static inline LDKCVec_NetAddressZ CVec_NetAddressZ_clone(const LDKCVec_NetAddressZ *orig) {
3463 LDKCVec_NetAddressZ ret = { .data = MALLOC(sizeof(LDKNetAddress) * orig->datalen, "LDKCVec_NetAddressZ clone bytes"), .datalen = orig->datalen };
3464 for (size_t i = 0; i < ret.datalen; i++) {
3465 ret.data[i] = NetAddress_clone(&orig->data[i]);
3469 static inline struct LDKNodeAnnouncementInfo CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner){
3470 LDKNodeAnnouncementInfo ret = *owner->contents.result;
3471 ret.is_owned = false;
3474 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(uint64_t owner) {
3475 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* owner_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)untag_ptr(owner);
3476 LDKNodeAnnouncementInfo ret_var = CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner_conv);
3477 uint64_t ret_ref = 0;
3478 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3479 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3483 static inline struct LDKDecodeError CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner){
3484 CHECK(!owner->result_ok);
3485 return DecodeError_clone(&*owner->contents.err);
3487 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_err"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(uint64_t owner) {
3488 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* owner_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)untag_ptr(owner);
3489 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3490 *ret_copy = CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner_conv);
3491 uint64_t ret_ref = tag_ptr(ret_copy, true);
3495 static inline struct LDKNodeAlias CResult_NodeAliasDecodeErrorZ_get_ok(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner){
3496 LDKNodeAlias ret = *owner->contents.result;
3497 ret.is_owned = false;
3500 uint64_t __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_get_ok"))) TS_CResult_NodeAliasDecodeErrorZ_get_ok(uint64_t owner) {
3501 LDKCResult_NodeAliasDecodeErrorZ* owner_conv = (LDKCResult_NodeAliasDecodeErrorZ*)untag_ptr(owner);
3502 LDKNodeAlias ret_var = CResult_NodeAliasDecodeErrorZ_get_ok(owner_conv);
3503 uint64_t ret_ref = 0;
3504 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3505 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3509 static inline struct LDKDecodeError CResult_NodeAliasDecodeErrorZ_get_err(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner){
3510 CHECK(!owner->result_ok);
3511 return DecodeError_clone(&*owner->contents.err);
3513 uint64_t __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_get_err"))) TS_CResult_NodeAliasDecodeErrorZ_get_err(uint64_t owner) {
3514 LDKCResult_NodeAliasDecodeErrorZ* owner_conv = (LDKCResult_NodeAliasDecodeErrorZ*)untag_ptr(owner);
3515 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3516 *ret_copy = CResult_NodeAliasDecodeErrorZ_get_err(owner_conv);
3517 uint64_t ret_ref = tag_ptr(ret_copy, true);
3521 static inline struct LDKNodeInfo CResult_NodeInfoDecodeErrorZ_get_ok(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner){
3522 LDKNodeInfo ret = *owner->contents.result;
3523 ret.is_owned = false;
3526 uint64_t __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_get_ok"))) TS_CResult_NodeInfoDecodeErrorZ_get_ok(uint64_t owner) {
3527 LDKCResult_NodeInfoDecodeErrorZ* owner_conv = (LDKCResult_NodeInfoDecodeErrorZ*)untag_ptr(owner);
3528 LDKNodeInfo ret_var = CResult_NodeInfoDecodeErrorZ_get_ok(owner_conv);
3529 uint64_t ret_ref = 0;
3530 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3531 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3535 static inline struct LDKDecodeError CResult_NodeInfoDecodeErrorZ_get_err(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner){
3536 CHECK(!owner->result_ok);
3537 return DecodeError_clone(&*owner->contents.err);
3539 uint64_t __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_get_err"))) TS_CResult_NodeInfoDecodeErrorZ_get_err(uint64_t owner) {
3540 LDKCResult_NodeInfoDecodeErrorZ* owner_conv = (LDKCResult_NodeInfoDecodeErrorZ*)untag_ptr(owner);
3541 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3542 *ret_copy = CResult_NodeInfoDecodeErrorZ_get_err(owner_conv);
3543 uint64_t ret_ref = tag_ptr(ret_copy, true);
3547 static inline struct LDKNetworkGraph CResult_NetworkGraphDecodeErrorZ_get_ok(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner){
3548 LDKNetworkGraph ret = *owner->contents.result;
3549 ret.is_owned = false;
3552 uint64_t __attribute__((export_name("TS_CResult_NetworkGraphDecodeErrorZ_get_ok"))) TS_CResult_NetworkGraphDecodeErrorZ_get_ok(uint64_t owner) {
3553 LDKCResult_NetworkGraphDecodeErrorZ* owner_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)untag_ptr(owner);
3554 LDKNetworkGraph ret_var = CResult_NetworkGraphDecodeErrorZ_get_ok(owner_conv);
3555 uint64_t ret_ref = 0;
3556 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3557 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3561 static inline struct LDKDecodeError CResult_NetworkGraphDecodeErrorZ_get_err(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner){
3562 CHECK(!owner->result_ok);
3563 return DecodeError_clone(&*owner->contents.err);
3565 uint64_t __attribute__((export_name("TS_CResult_NetworkGraphDecodeErrorZ_get_err"))) TS_CResult_NetworkGraphDecodeErrorZ_get_err(uint64_t owner) {
3566 LDKCResult_NetworkGraphDecodeErrorZ* owner_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)untag_ptr(owner);
3567 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3568 *ret_copy = CResult_NetworkGraphDecodeErrorZ_get_err(owner_conv);
3569 uint64_t ret_ref = tag_ptr(ret_copy, true);
3573 uint32_t __attribute__((export_name("TS_LDKCOption_CVec_NetAddressZZ_ty_from_ptr"))) TS_LDKCOption_CVec_NetAddressZZ_ty_from_ptr(uint64_t ptr) {
3574 LDKCOption_CVec_NetAddressZZ *obj = (LDKCOption_CVec_NetAddressZZ*)untag_ptr(ptr);
3576 case LDKCOption_CVec_NetAddressZZ_Some: return 0;
3577 case LDKCOption_CVec_NetAddressZZ_None: return 1;
3581 uint64_tArray __attribute__((export_name("TS_LDKCOption_CVec_NetAddressZZ_Some_get_some"))) TS_LDKCOption_CVec_NetAddressZZ_Some_get_some(uint64_t ptr) {
3582 LDKCOption_CVec_NetAddressZZ *obj = (LDKCOption_CVec_NetAddressZZ*)untag_ptr(ptr);
3583 assert(obj->tag == LDKCOption_CVec_NetAddressZZ_Some);
3584 LDKCVec_NetAddressZ some_var = obj->some;
3585 uint64_tArray some_arr = NULL;
3586 some_arr = init_uint64_tArray(some_var.datalen, __LINE__);
3587 uint64_t *some_arr_ptr = (uint64_t*)(((uint8_t*)some_arr) + 8);
3588 for (size_t m = 0; m < some_var.datalen; m++) {
3589 uint64_t some_conv_12_ref = tag_ptr(&some_var.data[m], false);
3590 some_arr_ptr[m] = some_conv_12_ref;
3595 static inline struct LDKDelayedPaymentOutputDescriptor CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner){
3596 LDKDelayedPaymentOutputDescriptor ret = *owner->contents.result;
3597 ret.is_owned = false;
3600 uint64_t __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(uint64_t owner) {
3601 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* owner_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(owner);
3602 LDKDelayedPaymentOutputDescriptor ret_var = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner_conv);
3603 uint64_t ret_ref = 0;
3604 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3605 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3609 static inline struct LDKDecodeError CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner){
3610 CHECK(!owner->result_ok);
3611 return DecodeError_clone(&*owner->contents.err);
3613 uint64_t __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(uint64_t owner) {
3614 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* owner_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(owner);
3615 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3616 *ret_copy = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner_conv);
3617 uint64_t ret_ref = tag_ptr(ret_copy, true);
3621 static inline struct LDKStaticPaymentOutputDescriptor CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner){
3622 LDKStaticPaymentOutputDescriptor ret = *owner->contents.result;
3623 ret.is_owned = false;
3626 uint64_t __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(uint64_t owner) {
3627 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* owner_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(owner);
3628 LDKStaticPaymentOutputDescriptor ret_var = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner_conv);
3629 uint64_t ret_ref = 0;
3630 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3631 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3635 static inline struct LDKDecodeError CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner){
3636 CHECK(!owner->result_ok);
3637 return DecodeError_clone(&*owner->contents.err);
3639 uint64_t __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(uint64_t owner) {
3640 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* owner_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(owner);
3641 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3642 *ret_copy = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner_conv);
3643 uint64_t ret_ref = tag_ptr(ret_copy, true);
3647 static inline struct LDKSpendableOutputDescriptor CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner){
3648 CHECK(owner->result_ok);
3649 return SpendableOutputDescriptor_clone(&*owner->contents.result);
3651 uint64_t __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(uint64_t owner) {
3652 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* owner_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)untag_ptr(owner);
3653 LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
3654 *ret_copy = CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner_conv);
3655 uint64_t ret_ref = tag_ptr(ret_copy, true);
3659 static inline struct LDKDecodeError CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner){
3660 CHECK(!owner->result_ok);
3661 return DecodeError_clone(&*owner->contents.err);
3663 uint64_t __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_err"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(uint64_t owner) {
3664 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* owner_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)untag_ptr(owner);
3665 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3666 *ret_copy = CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner_conv);
3667 uint64_t ret_ref = tag_ptr(ret_copy, true);
3671 static inline LDKCVec_PaymentPreimageZ CVec_PaymentPreimageZ_clone(const LDKCVec_PaymentPreimageZ *orig) {
3672 LDKCVec_PaymentPreimageZ ret = { .data = MALLOC(sizeof(LDKThirtyTwoBytes) * orig->datalen, "LDKCVec_PaymentPreimageZ clone bytes"), .datalen = orig->datalen };
3673 for (size_t i = 0; i < ret.datalen; i++) {
3674 ret.data[i] = ThirtyTwoBytes_clone(&orig->data[i]);
3678 static inline struct LDKSignature C2Tuple_SignatureCVec_SignatureZZ_get_a(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner){
3681 int8_tArray __attribute__((export_name("TS_C2Tuple_SignatureCVec_SignatureZZ_get_a"))) TS_C2Tuple_SignatureCVec_SignatureZZ_get_a(uint64_t owner) {
3682 LDKC2Tuple_SignatureCVec_SignatureZZ* owner_conv = (LDKC2Tuple_SignatureCVec_SignatureZZ*)untag_ptr(owner);
3683 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
3684 memcpy(ret_arr->elems, C2Tuple_SignatureCVec_SignatureZZ_get_a(owner_conv).compact_form, 64);
3688 static inline struct LDKCVec_SignatureZ C2Tuple_SignatureCVec_SignatureZZ_get_b(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner){
3691 ptrArray __attribute__((export_name("TS_C2Tuple_SignatureCVec_SignatureZZ_get_b"))) TS_C2Tuple_SignatureCVec_SignatureZZ_get_b(uint64_t owner) {
3692 LDKC2Tuple_SignatureCVec_SignatureZZ* owner_conv = (LDKC2Tuple_SignatureCVec_SignatureZZ*)untag_ptr(owner);
3693 LDKCVec_SignatureZ ret_var = C2Tuple_SignatureCVec_SignatureZZ_get_b(owner_conv);
3694 ptrArray ret_arr = NULL;
3695 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
3696 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 8);
3697 for (size_t m = 0; m < ret_var.datalen; m++) {
3698 int8_tArray ret_conv_12_arr = init_int8_tArray(64, __LINE__);
3699 memcpy(ret_conv_12_arr->elems, ret_var.data[m].compact_form, 64);
3700 ret_arr_ptr[m] = ret_conv_12_arr;
3706 static inline struct LDKC2Tuple_SignatureCVec_SignatureZZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner){
3707 CHECK(owner->result_ok);
3708 return C2Tuple_SignatureCVec_SignatureZZ_clone(&*owner->contents.result);
3710 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(uint64_t owner) {
3711 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* owner_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)untag_ptr(owner);
3712 LDKC2Tuple_SignatureCVec_SignatureZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
3713 *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner_conv);
3714 return tag_ptr(ret_conv, true);
3717 static inline void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner){
3718 CHECK(!owner->result_ok);
3719 return *owner->contents.err;
3721 void __attribute__((export_name("TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(uint64_t owner) {
3722 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* owner_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)untag_ptr(owner);
3723 CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner_conv);
3726 static inline struct LDKSignature CResult_SignatureNoneZ_get_ok(LDKCResult_SignatureNoneZ *NONNULL_PTR owner){
3727 CHECK(owner->result_ok);
3728 return *owner->contents.result;
3730 int8_tArray __attribute__((export_name("TS_CResult_SignatureNoneZ_get_ok"))) TS_CResult_SignatureNoneZ_get_ok(uint64_t owner) {
3731 LDKCResult_SignatureNoneZ* owner_conv = (LDKCResult_SignatureNoneZ*)untag_ptr(owner);
3732 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
3733 memcpy(ret_arr->elems, CResult_SignatureNoneZ_get_ok(owner_conv).compact_form, 64);
3737 static inline void CResult_SignatureNoneZ_get_err(LDKCResult_SignatureNoneZ *NONNULL_PTR owner){
3738 CHECK(!owner->result_ok);
3739 return *owner->contents.err;
3741 void __attribute__((export_name("TS_CResult_SignatureNoneZ_get_err"))) TS_CResult_SignatureNoneZ_get_err(uint64_t owner) {
3742 LDKCResult_SignatureNoneZ* owner_conv = (LDKCResult_SignatureNoneZ*)untag_ptr(owner);
3743 CResult_SignatureNoneZ_get_err(owner_conv);
3746 static inline struct LDKSignature C2Tuple_SignatureSignatureZ_get_a(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR owner){
3749 int8_tArray __attribute__((export_name("TS_C2Tuple_SignatureSignatureZ_get_a"))) TS_C2Tuple_SignatureSignatureZ_get_a(uint64_t owner) {
3750 LDKC2Tuple_SignatureSignatureZ* owner_conv = (LDKC2Tuple_SignatureSignatureZ*)untag_ptr(owner);
3751 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
3752 memcpy(ret_arr->elems, C2Tuple_SignatureSignatureZ_get_a(owner_conv).compact_form, 64);
3756 static inline struct LDKSignature C2Tuple_SignatureSignatureZ_get_b(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR owner){
3759 int8_tArray __attribute__((export_name("TS_C2Tuple_SignatureSignatureZ_get_b"))) TS_C2Tuple_SignatureSignatureZ_get_b(uint64_t owner) {
3760 LDKC2Tuple_SignatureSignatureZ* owner_conv = (LDKC2Tuple_SignatureSignatureZ*)untag_ptr(owner);
3761 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
3762 memcpy(ret_arr->elems, C2Tuple_SignatureSignatureZ_get_b(owner_conv).compact_form, 64);
3766 static inline struct LDKC2Tuple_SignatureSignatureZ CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR owner){
3767 CHECK(owner->result_ok);
3768 return C2Tuple_SignatureSignatureZ_clone(&*owner->contents.result);
3770 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok"))) TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(uint64_t owner) {
3771 LDKCResult_C2Tuple_SignatureSignatureZNoneZ* owner_conv = (LDKCResult_C2Tuple_SignatureSignatureZNoneZ*)untag_ptr(owner);
3772 LDKC2Tuple_SignatureSignatureZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureSignatureZ), "LDKC2Tuple_SignatureSignatureZ");
3773 *ret_conv = CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(owner_conv);
3774 return tag_ptr(ret_conv, true);
3777 static inline void CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR owner){
3778 CHECK(!owner->result_ok);
3779 return *owner->contents.err;
3781 void __attribute__((export_name("TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_err"))) TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(uint64_t owner) {
3782 LDKCResult_C2Tuple_SignatureSignatureZNoneZ* owner_conv = (LDKCResult_C2Tuple_SignatureSignatureZNoneZ*)untag_ptr(owner);
3783 CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(owner_conv);
3786 static inline struct LDKSecretKey CResult_SecretKeyNoneZ_get_ok(LDKCResult_SecretKeyNoneZ *NONNULL_PTR owner){
3787 CHECK(owner->result_ok);
3788 return *owner->contents.result;
3790 int8_tArray __attribute__((export_name("TS_CResult_SecretKeyNoneZ_get_ok"))) TS_CResult_SecretKeyNoneZ_get_ok(uint64_t owner) {
3791 LDKCResult_SecretKeyNoneZ* owner_conv = (LDKCResult_SecretKeyNoneZ*)untag_ptr(owner);
3792 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
3793 memcpy(ret_arr->elems, CResult_SecretKeyNoneZ_get_ok(owner_conv).bytes, 32);
3797 static inline void CResult_SecretKeyNoneZ_get_err(LDKCResult_SecretKeyNoneZ *NONNULL_PTR owner){
3798 CHECK(!owner->result_ok);
3799 return *owner->contents.err;
3801 void __attribute__((export_name("TS_CResult_SecretKeyNoneZ_get_err"))) TS_CResult_SecretKeyNoneZ_get_err(uint64_t owner) {
3802 LDKCResult_SecretKeyNoneZ* owner_conv = (LDKCResult_SecretKeyNoneZ*)untag_ptr(owner);
3803 CResult_SecretKeyNoneZ_get_err(owner_conv);
3806 static inline struct LDKPublicKey CResult_PublicKeyNoneZ_get_ok(LDKCResult_PublicKeyNoneZ *NONNULL_PTR owner){
3807 CHECK(owner->result_ok);
3808 return *owner->contents.result;
3810 int8_tArray __attribute__((export_name("TS_CResult_PublicKeyNoneZ_get_ok"))) TS_CResult_PublicKeyNoneZ_get_ok(uint64_t owner) {
3811 LDKCResult_PublicKeyNoneZ* owner_conv = (LDKCResult_PublicKeyNoneZ*)untag_ptr(owner);
3812 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
3813 memcpy(ret_arr->elems, CResult_PublicKeyNoneZ_get_ok(owner_conv).compressed_form, 33);
3817 static inline void CResult_PublicKeyNoneZ_get_err(LDKCResult_PublicKeyNoneZ *NONNULL_PTR owner){
3818 CHECK(!owner->result_ok);
3819 return *owner->contents.err;
3821 void __attribute__((export_name("TS_CResult_PublicKeyNoneZ_get_err"))) TS_CResult_PublicKeyNoneZ_get_err(uint64_t owner) {
3822 LDKCResult_PublicKeyNoneZ* owner_conv = (LDKCResult_PublicKeyNoneZ*)untag_ptr(owner);
3823 CResult_PublicKeyNoneZ_get_err(owner_conv);
3826 uint32_t __attribute__((export_name("TS_LDKCOption_ScalarZ_ty_from_ptr"))) TS_LDKCOption_ScalarZ_ty_from_ptr(uint64_t ptr) {
3827 LDKCOption_ScalarZ *obj = (LDKCOption_ScalarZ*)untag_ptr(ptr);
3829 case LDKCOption_ScalarZ_Some: return 0;
3830 case LDKCOption_ScalarZ_None: return 1;
3834 uint64_t __attribute__((export_name("TS_LDKCOption_ScalarZ_Some_get_some"))) TS_LDKCOption_ScalarZ_Some_get_some(uint64_t ptr) {
3835 LDKCOption_ScalarZ *obj = (LDKCOption_ScalarZ*)untag_ptr(ptr);
3836 assert(obj->tag == LDKCOption_ScalarZ_Some);
3837 LDKBigEndianScalar* some_ref = &obj->some;
3838 return tag_ptr(some_ref, false);
3840 static inline struct LDKThirtyTwoBytes CResult_SharedSecretNoneZ_get_ok(LDKCResult_SharedSecretNoneZ *NONNULL_PTR owner){
3841 CHECK(owner->result_ok);
3842 return ThirtyTwoBytes_clone(&*owner->contents.result);
3844 int8_tArray __attribute__((export_name("TS_CResult_SharedSecretNoneZ_get_ok"))) TS_CResult_SharedSecretNoneZ_get_ok(uint64_t owner) {
3845 LDKCResult_SharedSecretNoneZ* owner_conv = (LDKCResult_SharedSecretNoneZ*)untag_ptr(owner);
3846 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
3847 memcpy(ret_arr->elems, CResult_SharedSecretNoneZ_get_ok(owner_conv).data, 32);
3851 static inline void CResult_SharedSecretNoneZ_get_err(LDKCResult_SharedSecretNoneZ *NONNULL_PTR owner){
3852 CHECK(!owner->result_ok);
3853 return *owner->contents.err;
3855 void __attribute__((export_name("TS_CResult_SharedSecretNoneZ_get_err"))) TS_CResult_SharedSecretNoneZ_get_err(uint64_t owner) {
3856 LDKCResult_SharedSecretNoneZ* owner_conv = (LDKCResult_SharedSecretNoneZ*)untag_ptr(owner);
3857 CResult_SharedSecretNoneZ_get_err(owner_conv);
3860 typedef struct LDKBaseSign_JCalls {
3861 atomic_size_t refcnt;
3862 uint32_t instance_ptr;
3863 } LDKBaseSign_JCalls;
3864 static void LDKBaseSign_JCalls_free(void* this_arg) {
3865 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
3866 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
3870 LDKPublicKey get_per_commitment_point_LDKBaseSign_jcall(const void* this_arg, uint64_t idx) {
3871 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
3872 int64_t idx_conv = idx;
3873 int8_tArray ret = (int8_tArray)js_invoke_function_buuuuu(j_calls->instance_ptr, 2, idx_conv, 0, 0, 0, 0, 0);
3874 LDKPublicKey ret_ref;
3875 CHECK(ret->arr_len == 33);
3876 memcpy(ret_ref.compressed_form, ret->elems, 33); FREE(ret);
3879 LDKThirtyTwoBytes release_commitment_secret_LDKBaseSign_jcall(const void* this_arg, uint64_t idx) {
3880 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
3881 int64_t idx_conv = idx;
3882 int8_tArray ret = (int8_tArray)js_invoke_function_buuuuu(j_calls->instance_ptr, 3, idx_conv, 0, 0, 0, 0, 0);
3883 LDKThirtyTwoBytes ret_ref;
3884 CHECK(ret->arr_len == 32);
3885 memcpy(ret_ref.data, ret->elems, 32); FREE(ret);
3888 LDKCResult_NoneNoneZ validate_holder_commitment_LDKBaseSign_jcall(const void* this_arg, const LDKHolderCommitmentTransaction * holder_tx, LDKCVec_PaymentPreimageZ preimages) {
3889 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
3890 LDKHolderCommitmentTransaction holder_tx_var = *holder_tx;
3891 uint64_t holder_tx_ref = 0;
3892 holder_tx_var = HolderCommitmentTransaction_clone(&holder_tx_var);
3893 CHECK_INNER_FIELD_ACCESS_OR_NULL(holder_tx_var);
3894 holder_tx_ref = tag_ptr(holder_tx_var.inner, holder_tx_var.is_owned);
3895 LDKCVec_PaymentPreimageZ preimages_var = preimages;
3896 ptrArray preimages_arr = NULL;
3897 preimages_arr = init_ptrArray(preimages_var.datalen, __LINE__);
3898 int8_tArray *preimages_arr_ptr = (int8_tArray*)(((uint8_t*)preimages_arr) + 8);
3899 for (size_t m = 0; m < preimages_var.datalen; m++) {
3900 int8_tArray preimages_conv_12_arr = init_int8_tArray(32, __LINE__);
3901 memcpy(preimages_conv_12_arr->elems, preimages_var.data[m].data, 32);
3902 preimages_arr_ptr[m] = preimages_conv_12_arr;
3905 FREE(preimages_var.data);
3906 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 4, holder_tx_ref, (uint32_t)preimages_arr, 0, 0, 0, 0);
3907 void* ret_ptr = untag_ptr(ret);
3908 CHECK_ACCESS(ret_ptr);
3909 LDKCResult_NoneNoneZ ret_conv = *(LDKCResult_NoneNoneZ*)(ret_ptr);
3910 FREE(untag_ptr(ret));
3913 LDKThirtyTwoBytes channel_keys_id_LDKBaseSign_jcall(const void* this_arg) {
3914 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
3915 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 5, 0, 0, 0, 0, 0, 0);
3916 LDKThirtyTwoBytes ret_ref;
3917 CHECK(ret->arr_len == 32);
3918 memcpy(ret_ref.data, ret->elems, 32); FREE(ret);
3921 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_counterparty_commitment_LDKBaseSign_jcall(const void* this_arg, const LDKCommitmentTransaction * commitment_tx, LDKCVec_PaymentPreimageZ preimages) {
3922 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
3923 LDKCommitmentTransaction commitment_tx_var = *commitment_tx;
3924 uint64_t commitment_tx_ref = 0;
3925 commitment_tx_var = CommitmentTransaction_clone(&commitment_tx_var);
3926 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_var);
3927 commitment_tx_ref = tag_ptr(commitment_tx_var.inner, commitment_tx_var.is_owned);
3928 LDKCVec_PaymentPreimageZ preimages_var = preimages;
3929 ptrArray preimages_arr = NULL;
3930 preimages_arr = init_ptrArray(preimages_var.datalen, __LINE__);
3931 int8_tArray *preimages_arr_ptr = (int8_tArray*)(((uint8_t*)preimages_arr) + 8);
3932 for (size_t m = 0; m < preimages_var.datalen; m++) {
3933 int8_tArray preimages_conv_12_arr = init_int8_tArray(32, __LINE__);
3934 memcpy(preimages_conv_12_arr->elems, preimages_var.data[m].data, 32);
3935 preimages_arr_ptr[m] = preimages_conv_12_arr;
3938 FREE(preimages_var.data);
3939 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 6, commitment_tx_ref, (uint32_t)preimages_arr, 0, 0, 0, 0);
3940 void* ret_ptr = untag_ptr(ret);
3941 CHECK_ACCESS(ret_ptr);
3942 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ret_conv = *(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(ret_ptr);
3943 FREE(untag_ptr(ret));
3946 LDKCResult_NoneNoneZ validate_counterparty_revocation_LDKBaseSign_jcall(const void* this_arg, uint64_t idx, const uint8_t (* secret)[32]) {
3947 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
3948 int64_t idx_conv = idx;
3949 int8_tArray secret_arr = init_int8_tArray(32, __LINE__);
3950 memcpy(secret_arr->elems, *secret, 32);
3951 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 7, idx_conv, (uint32_t)secret_arr, 0, 0, 0, 0);
3952 void* ret_ptr = untag_ptr(ret);
3953 CHECK_ACCESS(ret_ptr);
3954 LDKCResult_NoneNoneZ ret_conv = *(LDKCResult_NoneNoneZ*)(ret_ptr);
3955 FREE(untag_ptr(ret));
3958 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_holder_commitment_and_htlcs_LDKBaseSign_jcall(const void* this_arg, const LDKHolderCommitmentTransaction * commitment_tx) {
3959 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
3960 LDKHolderCommitmentTransaction commitment_tx_var = *commitment_tx;
3961 uint64_t commitment_tx_ref = 0;
3962 commitment_tx_var = HolderCommitmentTransaction_clone(&commitment_tx_var);
3963 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_var);
3964 commitment_tx_ref = tag_ptr(commitment_tx_var.inner, commitment_tx_var.is_owned);
3965 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 8, commitment_tx_ref, 0, 0, 0, 0, 0);
3966 void* ret_ptr = untag_ptr(ret);
3967 CHECK_ACCESS(ret_ptr);
3968 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ret_conv = *(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(ret_ptr);
3969 FREE(untag_ptr(ret));
3972 LDKCResult_SignatureNoneZ sign_justice_revoked_output_LDKBaseSign_jcall(const void* this_arg, LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (* per_commitment_key)[32]) {
3973 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
3974 LDKTransaction justice_tx_var = justice_tx;
3975 int8_tArray justice_tx_arr = init_int8_tArray(justice_tx_var.datalen, __LINE__);
3976 memcpy(justice_tx_arr->elems, justice_tx_var.data, justice_tx_var.datalen);
3977 Transaction_free(justice_tx_var);
3978 uint32_t input_conv = input;
3979 int64_t amount_conv = amount;
3980 int8_tArray per_commitment_key_arr = init_int8_tArray(32, __LINE__);
3981 memcpy(per_commitment_key_arr->elems, *per_commitment_key, 32);
3982 uint64_t ret = js_invoke_function_uubuuu(j_calls->instance_ptr, 9, (uint32_t)justice_tx_arr, input_conv, amount_conv, (uint32_t)per_commitment_key_arr, 0, 0);
3983 void* ret_ptr = untag_ptr(ret);
3984 CHECK_ACCESS(ret_ptr);
3985 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
3986 FREE(untag_ptr(ret));
3989 LDKCResult_SignatureNoneZ sign_justice_revoked_htlc_LDKBaseSign_jcall(const void* this_arg, LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (* per_commitment_key)[32], const LDKHTLCOutputInCommitment * htlc) {
3990 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
3991 LDKTransaction justice_tx_var = justice_tx;
3992 int8_tArray justice_tx_arr = init_int8_tArray(justice_tx_var.datalen, __LINE__);
3993 memcpy(justice_tx_arr->elems, justice_tx_var.data, justice_tx_var.datalen);
3994 Transaction_free(justice_tx_var);
3995 uint32_t input_conv = input;
3996 int64_t amount_conv = amount;
3997 int8_tArray per_commitment_key_arr = init_int8_tArray(32, __LINE__);
3998 memcpy(per_commitment_key_arr->elems, *per_commitment_key, 32);
3999 LDKHTLCOutputInCommitment htlc_var = *htlc;
4000 uint64_t htlc_ref = 0;
4001 htlc_var = HTLCOutputInCommitment_clone(&htlc_var);
4002 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_var);
4003 htlc_ref = tag_ptr(htlc_var.inner, htlc_var.is_owned);
4004 uint64_t ret = js_invoke_function_uububu(j_calls->instance_ptr, 10, (uint32_t)justice_tx_arr, input_conv, amount_conv, (uint32_t)per_commitment_key_arr, htlc_ref, 0);
4005 void* ret_ptr = untag_ptr(ret);
4006 CHECK_ACCESS(ret_ptr);
4007 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
4008 FREE(untag_ptr(ret));
4011 LDKCResult_SignatureNoneZ sign_counterparty_htlc_transaction_LDKBaseSign_jcall(const void* this_arg, LDKTransaction htlc_tx, uintptr_t input, uint64_t amount, LDKPublicKey per_commitment_point, const LDKHTLCOutputInCommitment * htlc) {
4012 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
4013 LDKTransaction htlc_tx_var = htlc_tx;
4014 int8_tArray htlc_tx_arr = init_int8_tArray(htlc_tx_var.datalen, __LINE__);
4015 memcpy(htlc_tx_arr->elems, htlc_tx_var.data, htlc_tx_var.datalen);
4016 Transaction_free(htlc_tx_var);
4017 uint32_t input_conv = input;
4018 int64_t amount_conv = amount;
4019 int8_tArray per_commitment_point_arr = init_int8_tArray(33, __LINE__);
4020 memcpy(per_commitment_point_arr->elems, per_commitment_point.compressed_form, 33);
4021 LDKHTLCOutputInCommitment htlc_var = *htlc;
4022 uint64_t htlc_ref = 0;
4023 htlc_var = HTLCOutputInCommitment_clone(&htlc_var);
4024 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_var);
4025 htlc_ref = tag_ptr(htlc_var.inner, htlc_var.is_owned);
4026 uint64_t ret = js_invoke_function_uububu(j_calls->instance_ptr, 11, (uint32_t)htlc_tx_arr, input_conv, amount_conv, (uint32_t)per_commitment_point_arr, htlc_ref, 0);
4027 void* ret_ptr = untag_ptr(ret);
4028 CHECK_ACCESS(ret_ptr);
4029 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
4030 FREE(untag_ptr(ret));
4033 LDKCResult_SignatureNoneZ sign_closing_transaction_LDKBaseSign_jcall(const void* this_arg, const LDKClosingTransaction * closing_tx) {
4034 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
4035 LDKClosingTransaction closing_tx_var = *closing_tx;
4036 uint64_t closing_tx_ref = 0;
4037 closing_tx_var = ClosingTransaction_clone(&closing_tx_var);
4038 CHECK_INNER_FIELD_ACCESS_OR_NULL(closing_tx_var);
4039 closing_tx_ref = tag_ptr(closing_tx_var.inner, closing_tx_var.is_owned);
4040 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 12, closing_tx_ref, 0, 0, 0, 0, 0);
4041 void* ret_ptr = untag_ptr(ret);
4042 CHECK_ACCESS(ret_ptr);
4043 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
4044 FREE(untag_ptr(ret));
4047 LDKCResult_SignatureNoneZ sign_holder_anchor_input_LDKBaseSign_jcall(const void* this_arg, LDKTransaction anchor_tx, uintptr_t input) {
4048 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
4049 LDKTransaction anchor_tx_var = anchor_tx;
4050 int8_tArray anchor_tx_arr = init_int8_tArray(anchor_tx_var.datalen, __LINE__);
4051 memcpy(anchor_tx_arr->elems, anchor_tx_var.data, anchor_tx_var.datalen);
4052 Transaction_free(anchor_tx_var);
4053 uint32_t input_conv = input;
4054 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 13, (uint32_t)anchor_tx_arr, input_conv, 0, 0, 0, 0);
4055 void* ret_ptr = untag_ptr(ret);
4056 CHECK_ACCESS(ret_ptr);
4057 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
4058 FREE(untag_ptr(ret));
4061 LDKCResult_C2Tuple_SignatureSignatureZNoneZ sign_channel_announcement_LDKBaseSign_jcall(const void* this_arg, const LDKUnsignedChannelAnnouncement * msg) {
4062 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
4063 LDKUnsignedChannelAnnouncement msg_var = *msg;
4064 uint64_t msg_ref = 0;
4065 msg_var = UnsignedChannelAnnouncement_clone(&msg_var);
4066 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
4067 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
4068 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 14, msg_ref, 0, 0, 0, 0, 0);
4069 void* ret_ptr = untag_ptr(ret);
4070 CHECK_ACCESS(ret_ptr);
4071 LDKCResult_C2Tuple_SignatureSignatureZNoneZ ret_conv = *(LDKCResult_C2Tuple_SignatureSignatureZNoneZ*)(ret_ptr);
4072 FREE(untag_ptr(ret));
4075 void provide_channel_parameters_LDKBaseSign_jcall(void* this_arg, const LDKChannelTransactionParameters * channel_parameters) {
4076 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
4077 LDKChannelTransactionParameters channel_parameters_var = *channel_parameters;
4078 uint64_t channel_parameters_ref = 0;
4079 channel_parameters_var = ChannelTransactionParameters_clone(&channel_parameters_var);
4080 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_var);
4081 channel_parameters_ref = tag_ptr(channel_parameters_var.inner, channel_parameters_var.is_owned);
4082 js_invoke_function_buuuuu(j_calls->instance_ptr, 15, channel_parameters_ref, 0, 0, 0, 0, 0);
4084 static void LDKBaseSign_JCalls_cloned(LDKBaseSign* new_obj) {
4085 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) new_obj->this_arg;
4086 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
4088 static inline LDKBaseSign LDKBaseSign_init (JSValue o, uint64_t pubkeys) {
4089 LDKBaseSign_JCalls *calls = MALLOC(sizeof(LDKBaseSign_JCalls), "LDKBaseSign_JCalls");
4090 atomic_init(&calls->refcnt, 1);
4091 calls->instance_ptr = o;
4093 LDKChannelPublicKeys pubkeys_conv;
4094 pubkeys_conv.inner = untag_ptr(pubkeys);
4095 pubkeys_conv.is_owned = ptr_is_owned(pubkeys);
4096 CHECK_INNER_FIELD_ACCESS_OR_NULL(pubkeys_conv);
4099 .this_arg = (void*) calls,
4100 .get_per_commitment_point = get_per_commitment_point_LDKBaseSign_jcall,
4101 .release_commitment_secret = release_commitment_secret_LDKBaseSign_jcall,
4102 .validate_holder_commitment = validate_holder_commitment_LDKBaseSign_jcall,
4103 .channel_keys_id = channel_keys_id_LDKBaseSign_jcall,
4104 .sign_counterparty_commitment = sign_counterparty_commitment_LDKBaseSign_jcall,
4105 .validate_counterparty_revocation = validate_counterparty_revocation_LDKBaseSign_jcall,
4106 .sign_holder_commitment_and_htlcs = sign_holder_commitment_and_htlcs_LDKBaseSign_jcall,
4107 .sign_justice_revoked_output = sign_justice_revoked_output_LDKBaseSign_jcall,
4108 .sign_justice_revoked_htlc = sign_justice_revoked_htlc_LDKBaseSign_jcall,
4109 .sign_counterparty_htlc_transaction = sign_counterparty_htlc_transaction_LDKBaseSign_jcall,
4110 .sign_closing_transaction = sign_closing_transaction_LDKBaseSign_jcall,
4111 .sign_holder_anchor_input = sign_holder_anchor_input_LDKBaseSign_jcall,
4112 .sign_channel_announcement = sign_channel_announcement_LDKBaseSign_jcall,
4113 .provide_channel_parameters = provide_channel_parameters_LDKBaseSign_jcall,
4114 .free = LDKBaseSign_JCalls_free,
4115 .pubkeys = pubkeys_conv,
4116 .set_pubkeys = NULL,
4120 uint64_t __attribute__((export_name("TS_LDKBaseSign_new"))) TS_LDKBaseSign_new(JSValue o, uint64_t pubkeys) {
4121 LDKBaseSign *res_ptr = MALLOC(sizeof(LDKBaseSign), "LDKBaseSign");
4122 *res_ptr = LDKBaseSign_init(o, pubkeys);
4123 return tag_ptr(res_ptr, true);
4125 int8_tArray __attribute__((export_name("TS_BaseSign_get_per_commitment_point"))) TS_BaseSign_get_per_commitment_point(uint64_t this_arg, int64_t idx) {
4126 void* this_arg_ptr = untag_ptr(this_arg);
4127 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4128 LDKBaseSign* this_arg_conv = (LDKBaseSign*)this_arg_ptr;
4129 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
4130 memcpy(ret_arr->elems, (this_arg_conv->get_per_commitment_point)(this_arg_conv->this_arg, idx).compressed_form, 33);
4134 int8_tArray __attribute__((export_name("TS_BaseSign_release_commitment_secret"))) TS_BaseSign_release_commitment_secret(uint64_t this_arg, int64_t idx) {
4135 void* this_arg_ptr = untag_ptr(this_arg);
4136 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4137 LDKBaseSign* this_arg_conv = (LDKBaseSign*)this_arg_ptr;
4138 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
4139 memcpy(ret_arr->elems, (this_arg_conv->release_commitment_secret)(this_arg_conv->this_arg, idx).data, 32);
4143 uint64_t __attribute__((export_name("TS_BaseSign_validate_holder_commitment"))) TS_BaseSign_validate_holder_commitment(uint64_t this_arg, uint64_t holder_tx, ptrArray preimages) {
4144 void* this_arg_ptr = untag_ptr(this_arg);
4145 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4146 LDKBaseSign* this_arg_conv = (LDKBaseSign*)this_arg_ptr;
4147 LDKHolderCommitmentTransaction holder_tx_conv;
4148 holder_tx_conv.inner = untag_ptr(holder_tx);
4149 holder_tx_conv.is_owned = ptr_is_owned(holder_tx);
4150 CHECK_INNER_FIELD_ACCESS_OR_NULL(holder_tx_conv);
4151 holder_tx_conv.is_owned = false;
4152 LDKCVec_PaymentPreimageZ preimages_constr;
4153 preimages_constr.datalen = preimages->arr_len;
4154 if (preimages_constr.datalen > 0)
4155 preimages_constr.data = MALLOC(preimages_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_PaymentPreimageZ Elements");
4157 preimages_constr.data = NULL;
4158 int8_tArray* preimages_vals = (void*) preimages->elems;
4159 for (size_t m = 0; m < preimages_constr.datalen; m++) {
4160 int8_tArray preimages_conv_12 = preimages_vals[m];
4161 LDKThirtyTwoBytes preimages_conv_12_ref;
4162 CHECK(preimages_conv_12->arr_len == 32);
4163 memcpy(preimages_conv_12_ref.data, preimages_conv_12->elems, 32); FREE(preimages_conv_12);
4164 preimages_constr.data[m] = preimages_conv_12_ref;
4167 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
4168 *ret_conv = (this_arg_conv->validate_holder_commitment)(this_arg_conv->this_arg, &holder_tx_conv, preimages_constr);
4169 return tag_ptr(ret_conv, true);
4172 int8_tArray __attribute__((export_name("TS_BaseSign_channel_keys_id"))) TS_BaseSign_channel_keys_id(uint64_t this_arg) {
4173 void* this_arg_ptr = untag_ptr(this_arg);
4174 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4175 LDKBaseSign* this_arg_conv = (LDKBaseSign*)this_arg_ptr;
4176 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
4177 memcpy(ret_arr->elems, (this_arg_conv->channel_keys_id)(this_arg_conv->this_arg).data, 32);
4181 uint64_t __attribute__((export_name("TS_BaseSign_sign_counterparty_commitment"))) TS_BaseSign_sign_counterparty_commitment(uint64_t this_arg, uint64_t commitment_tx, ptrArray preimages) {
4182 void* this_arg_ptr = untag_ptr(this_arg);
4183 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4184 LDKBaseSign* this_arg_conv = (LDKBaseSign*)this_arg_ptr;
4185 LDKCommitmentTransaction commitment_tx_conv;
4186 commitment_tx_conv.inner = untag_ptr(commitment_tx);
4187 commitment_tx_conv.is_owned = ptr_is_owned(commitment_tx);
4188 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_conv);
4189 commitment_tx_conv.is_owned = false;
4190 LDKCVec_PaymentPreimageZ preimages_constr;
4191 preimages_constr.datalen = preimages->arr_len;
4192 if (preimages_constr.datalen > 0)
4193 preimages_constr.data = MALLOC(preimages_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_PaymentPreimageZ Elements");
4195 preimages_constr.data = NULL;
4196 int8_tArray* preimages_vals = (void*) preimages->elems;
4197 for (size_t m = 0; m < preimages_constr.datalen; m++) {
4198 int8_tArray preimages_conv_12 = preimages_vals[m];
4199 LDKThirtyTwoBytes preimages_conv_12_ref;
4200 CHECK(preimages_conv_12->arr_len == 32);
4201 memcpy(preimages_conv_12_ref.data, preimages_conv_12->elems, 32); FREE(preimages_conv_12);
4202 preimages_constr.data[m] = preimages_conv_12_ref;
4205 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
4206 *ret_conv = (this_arg_conv->sign_counterparty_commitment)(this_arg_conv->this_arg, &commitment_tx_conv, preimages_constr);
4207 return tag_ptr(ret_conv, true);
4210 uint64_t __attribute__((export_name("TS_BaseSign_validate_counterparty_revocation"))) TS_BaseSign_validate_counterparty_revocation(uint64_t this_arg, int64_t idx, int8_tArray secret) {
4211 void* this_arg_ptr = untag_ptr(this_arg);
4212 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4213 LDKBaseSign* this_arg_conv = (LDKBaseSign*)this_arg_ptr;
4214 unsigned char secret_arr[32];
4215 CHECK(secret->arr_len == 32);
4216 memcpy(secret_arr, secret->elems, 32); FREE(secret);
4217 unsigned char (*secret_ref)[32] = &secret_arr;
4218 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
4219 *ret_conv = (this_arg_conv->validate_counterparty_revocation)(this_arg_conv->this_arg, idx, secret_ref);
4220 return tag_ptr(ret_conv, true);
4223 uint64_t __attribute__((export_name("TS_BaseSign_sign_holder_commitment_and_htlcs"))) TS_BaseSign_sign_holder_commitment_and_htlcs(uint64_t this_arg, uint64_t commitment_tx) {
4224 void* this_arg_ptr = untag_ptr(this_arg);
4225 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4226 LDKBaseSign* this_arg_conv = (LDKBaseSign*)this_arg_ptr;
4227 LDKHolderCommitmentTransaction commitment_tx_conv;
4228 commitment_tx_conv.inner = untag_ptr(commitment_tx);
4229 commitment_tx_conv.is_owned = ptr_is_owned(commitment_tx);
4230 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_conv);
4231 commitment_tx_conv.is_owned = false;
4232 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
4233 *ret_conv = (this_arg_conv->sign_holder_commitment_and_htlcs)(this_arg_conv->this_arg, &commitment_tx_conv);
4234 return tag_ptr(ret_conv, true);
4237 uint64_t __attribute__((export_name("TS_BaseSign_sign_justice_revoked_output"))) TS_BaseSign_sign_justice_revoked_output(uint64_t this_arg, int8_tArray justice_tx, uint32_t input, int64_t amount, int8_tArray per_commitment_key) {
4238 void* this_arg_ptr = untag_ptr(this_arg);
4239 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4240 LDKBaseSign* this_arg_conv = (LDKBaseSign*)this_arg_ptr;
4241 LDKTransaction justice_tx_ref;
4242 justice_tx_ref.datalen = justice_tx->arr_len;
4243 justice_tx_ref.data = MALLOC(justice_tx_ref.datalen, "LDKTransaction Bytes");
4244 memcpy(justice_tx_ref.data, justice_tx->elems, justice_tx_ref.datalen); FREE(justice_tx);
4245 justice_tx_ref.data_is_owned = true;
4246 unsigned char per_commitment_key_arr[32];
4247 CHECK(per_commitment_key->arr_len == 32);
4248 memcpy(per_commitment_key_arr, per_commitment_key->elems, 32); FREE(per_commitment_key);
4249 unsigned char (*per_commitment_key_ref)[32] = &per_commitment_key_arr;
4250 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
4251 *ret_conv = (this_arg_conv->sign_justice_revoked_output)(this_arg_conv->this_arg, justice_tx_ref, input, amount, per_commitment_key_ref);
4252 return tag_ptr(ret_conv, true);
4255 uint64_t __attribute__((export_name("TS_BaseSign_sign_justice_revoked_htlc"))) TS_BaseSign_sign_justice_revoked_htlc(uint64_t this_arg, int8_tArray justice_tx, uint32_t input, int64_t amount, int8_tArray per_commitment_key, uint64_t htlc) {
4256 void* this_arg_ptr = untag_ptr(this_arg);
4257 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4258 LDKBaseSign* this_arg_conv = (LDKBaseSign*)this_arg_ptr;
4259 LDKTransaction justice_tx_ref;
4260 justice_tx_ref.datalen = justice_tx->arr_len;
4261 justice_tx_ref.data = MALLOC(justice_tx_ref.datalen, "LDKTransaction Bytes");
4262 memcpy(justice_tx_ref.data, justice_tx->elems, justice_tx_ref.datalen); FREE(justice_tx);
4263 justice_tx_ref.data_is_owned = true;
4264 unsigned char per_commitment_key_arr[32];
4265 CHECK(per_commitment_key->arr_len == 32);
4266 memcpy(per_commitment_key_arr, per_commitment_key->elems, 32); FREE(per_commitment_key);
4267 unsigned char (*per_commitment_key_ref)[32] = &per_commitment_key_arr;
4268 LDKHTLCOutputInCommitment htlc_conv;
4269 htlc_conv.inner = untag_ptr(htlc);
4270 htlc_conv.is_owned = ptr_is_owned(htlc);
4271 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
4272 htlc_conv.is_owned = false;
4273 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
4274 *ret_conv = (this_arg_conv->sign_justice_revoked_htlc)(this_arg_conv->this_arg, justice_tx_ref, input, amount, per_commitment_key_ref, &htlc_conv);
4275 return tag_ptr(ret_conv, true);
4278 uint64_t __attribute__((export_name("TS_BaseSign_sign_counterparty_htlc_transaction"))) TS_BaseSign_sign_counterparty_htlc_transaction(uint64_t this_arg, int8_tArray htlc_tx, uint32_t input, int64_t amount, int8_tArray per_commitment_point, uint64_t htlc) {
4279 void* this_arg_ptr = untag_ptr(this_arg);
4280 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4281 LDKBaseSign* this_arg_conv = (LDKBaseSign*)this_arg_ptr;
4282 LDKTransaction htlc_tx_ref;
4283 htlc_tx_ref.datalen = htlc_tx->arr_len;
4284 htlc_tx_ref.data = MALLOC(htlc_tx_ref.datalen, "LDKTransaction Bytes");
4285 memcpy(htlc_tx_ref.data, htlc_tx->elems, htlc_tx_ref.datalen); FREE(htlc_tx);
4286 htlc_tx_ref.data_is_owned = true;
4287 LDKPublicKey per_commitment_point_ref;
4288 CHECK(per_commitment_point->arr_len == 33);
4289 memcpy(per_commitment_point_ref.compressed_form, per_commitment_point->elems, 33); FREE(per_commitment_point);
4290 LDKHTLCOutputInCommitment htlc_conv;
4291 htlc_conv.inner = untag_ptr(htlc);
4292 htlc_conv.is_owned = ptr_is_owned(htlc);
4293 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
4294 htlc_conv.is_owned = false;
4295 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
4296 *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);
4297 return tag_ptr(ret_conv, true);
4300 uint64_t __attribute__((export_name("TS_BaseSign_sign_closing_transaction"))) TS_BaseSign_sign_closing_transaction(uint64_t this_arg, uint64_t closing_tx) {
4301 void* this_arg_ptr = untag_ptr(this_arg);
4302 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4303 LDKBaseSign* this_arg_conv = (LDKBaseSign*)this_arg_ptr;
4304 LDKClosingTransaction closing_tx_conv;
4305 closing_tx_conv.inner = untag_ptr(closing_tx);
4306 closing_tx_conv.is_owned = ptr_is_owned(closing_tx);
4307 CHECK_INNER_FIELD_ACCESS_OR_NULL(closing_tx_conv);
4308 closing_tx_conv.is_owned = false;
4309 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
4310 *ret_conv = (this_arg_conv->sign_closing_transaction)(this_arg_conv->this_arg, &closing_tx_conv);
4311 return tag_ptr(ret_conv, true);
4314 uint64_t __attribute__((export_name("TS_BaseSign_sign_holder_anchor_input"))) TS_BaseSign_sign_holder_anchor_input(uint64_t this_arg, int8_tArray anchor_tx, uint32_t input) {
4315 void* this_arg_ptr = untag_ptr(this_arg);
4316 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4317 LDKBaseSign* this_arg_conv = (LDKBaseSign*)this_arg_ptr;
4318 LDKTransaction anchor_tx_ref;
4319 anchor_tx_ref.datalen = anchor_tx->arr_len;
4320 anchor_tx_ref.data = MALLOC(anchor_tx_ref.datalen, "LDKTransaction Bytes");
4321 memcpy(anchor_tx_ref.data, anchor_tx->elems, anchor_tx_ref.datalen); FREE(anchor_tx);
4322 anchor_tx_ref.data_is_owned = true;
4323 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
4324 *ret_conv = (this_arg_conv->sign_holder_anchor_input)(this_arg_conv->this_arg, anchor_tx_ref, input);
4325 return tag_ptr(ret_conv, true);
4328 uint64_t __attribute__((export_name("TS_BaseSign_sign_channel_announcement"))) TS_BaseSign_sign_channel_announcement(uint64_t this_arg, uint64_t msg) {
4329 void* this_arg_ptr = untag_ptr(this_arg);
4330 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4331 LDKBaseSign* this_arg_conv = (LDKBaseSign*)this_arg_ptr;
4332 LDKUnsignedChannelAnnouncement msg_conv;
4333 msg_conv.inner = untag_ptr(msg);
4334 msg_conv.is_owned = ptr_is_owned(msg);
4335 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
4336 msg_conv.is_owned = false;
4337 LDKCResult_C2Tuple_SignatureSignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureSignatureZNoneZ), "LDKCResult_C2Tuple_SignatureSignatureZNoneZ");
4338 *ret_conv = (this_arg_conv->sign_channel_announcement)(this_arg_conv->this_arg, &msg_conv);
4339 return tag_ptr(ret_conv, true);
4342 void __attribute__((export_name("TS_BaseSign_provide_channel_parameters"))) TS_BaseSign_provide_channel_parameters(uint64_t this_arg, uint64_t channel_parameters) {
4343 void* this_arg_ptr = untag_ptr(this_arg);
4344 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4345 LDKBaseSign* this_arg_conv = (LDKBaseSign*)this_arg_ptr;
4346 LDKChannelTransactionParameters channel_parameters_conv;
4347 channel_parameters_conv.inner = untag_ptr(channel_parameters);
4348 channel_parameters_conv.is_owned = ptr_is_owned(channel_parameters);
4349 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_conv);
4350 channel_parameters_conv.is_owned = false;
4351 (this_arg_conv->provide_channel_parameters)(this_arg_conv->this_arg, &channel_parameters_conv);
4354 LDKChannelPublicKeys LDKBaseSign_set_get_pubkeys(LDKBaseSign* this_arg) {
4355 if (this_arg->set_pubkeys != NULL)
4356 this_arg->set_pubkeys(this_arg);
4357 return this_arg->pubkeys;
4359 uint64_t __attribute__((export_name("TS_BaseSign_get_pubkeys"))) TS_BaseSign_get_pubkeys(uint64_t this_arg) {
4360 void* this_arg_ptr = untag_ptr(this_arg);
4361 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4362 LDKBaseSign* this_arg_conv = (LDKBaseSign*)this_arg_ptr;
4363 LDKChannelPublicKeys ret_var = LDKBaseSign_set_get_pubkeys(this_arg_conv);
4364 uint64_t ret_ref = 0;
4365 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
4366 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
4370 typedef struct LDKSign_JCalls {
4371 atomic_size_t refcnt;
4372 uint32_t instance_ptr;
4373 LDKBaseSign_JCalls* BaseSign;
4375 static void LDKSign_JCalls_free(void* this_arg) {
4376 LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
4377 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
4381 LDKCVec_u8Z write_LDKSign_jcall(const void* this_arg) {
4382 LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
4383 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 16, 0, 0, 0, 0, 0, 0);
4384 LDKCVec_u8Z ret_ref;
4385 ret_ref.datalen = ret->arr_len;
4386 ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
4387 memcpy(ret_ref.data, ret->elems, ret_ref.datalen); FREE(ret);
4390 static void LDKSign_JCalls_cloned(LDKSign* new_obj) {
4391 LDKSign_JCalls *j_calls = (LDKSign_JCalls*) new_obj->this_arg;
4392 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
4393 atomic_fetch_add_explicit(&j_calls->BaseSign->refcnt, 1, memory_order_release);
4395 static inline LDKSign LDKSign_init (JSValue o, JSValue BaseSign, uint64_t pubkeys) {
4396 LDKSign_JCalls *calls = MALLOC(sizeof(LDKSign_JCalls), "LDKSign_JCalls");
4397 atomic_init(&calls->refcnt, 1);
4398 calls->instance_ptr = o;
4400 LDKChannelPublicKeys pubkeys_conv;
4401 pubkeys_conv.inner = untag_ptr(pubkeys);
4402 pubkeys_conv.is_owned = ptr_is_owned(pubkeys);
4403 CHECK_INNER_FIELD_ACCESS_OR_NULL(pubkeys_conv);
4406 .this_arg = (void*) calls,
4407 .write = write_LDKSign_jcall,
4408 .cloned = LDKSign_JCalls_cloned,
4409 .free = LDKSign_JCalls_free,
4410 .BaseSign = LDKBaseSign_init(BaseSign, pubkeys),
4412 calls->BaseSign = ret.BaseSign.this_arg;
4415 uint64_t __attribute__((export_name("TS_LDKSign_new"))) TS_LDKSign_new(JSValue o, JSValue BaseSign, uint64_t pubkeys) {
4416 LDKSign *res_ptr = MALLOC(sizeof(LDKSign), "LDKSign");
4417 *res_ptr = LDKSign_init(o, BaseSign, pubkeys);
4418 return tag_ptr(res_ptr, true);
4420 int8_tArray __attribute__((export_name("TS_Sign_write"))) TS_Sign_write(uint64_t this_arg) {
4421 void* this_arg_ptr = untag_ptr(this_arg);
4422 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4423 LDKSign* this_arg_conv = (LDKSign*)this_arg_ptr;
4424 LDKCVec_u8Z ret_var = (this_arg_conv->write)(this_arg_conv->this_arg);
4425 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
4426 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
4427 CVec_u8Z_free(ret_var);
4431 static inline struct LDKSign CResult_SignDecodeErrorZ_get_ok(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner){
4432 CHECK(owner->result_ok);
4433 return Sign_clone(&*owner->contents.result);
4435 uint64_t __attribute__((export_name("TS_CResult_SignDecodeErrorZ_get_ok"))) TS_CResult_SignDecodeErrorZ_get_ok(uint64_t owner) {
4436 LDKCResult_SignDecodeErrorZ* owner_conv = (LDKCResult_SignDecodeErrorZ*)untag_ptr(owner);
4437 LDKSign* ret_ret = MALLOC(sizeof(LDKSign), "LDKSign");
4438 *ret_ret = CResult_SignDecodeErrorZ_get_ok(owner_conv);
4439 return tag_ptr(ret_ret, true);
4442 static inline struct LDKDecodeError CResult_SignDecodeErrorZ_get_err(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner){
4443 CHECK(!owner->result_ok);
4444 return DecodeError_clone(&*owner->contents.err);
4446 uint64_t __attribute__((export_name("TS_CResult_SignDecodeErrorZ_get_err"))) TS_CResult_SignDecodeErrorZ_get_err(uint64_t owner) {
4447 LDKCResult_SignDecodeErrorZ* owner_conv = (LDKCResult_SignDecodeErrorZ*)untag_ptr(owner);
4448 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
4449 *ret_copy = CResult_SignDecodeErrorZ_get_err(owner_conv);
4450 uint64_t ret_ref = tag_ptr(ret_copy, true);
4454 static inline struct LDKRecoverableSignature CResult_RecoverableSignatureNoneZ_get_ok(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner){
4455 CHECK(owner->result_ok);
4456 return *owner->contents.result;
4458 int8_tArray __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_get_ok"))) TS_CResult_RecoverableSignatureNoneZ_get_ok(uint64_t owner) {
4459 LDKCResult_RecoverableSignatureNoneZ* owner_conv = (LDKCResult_RecoverableSignatureNoneZ*)untag_ptr(owner);
4460 int8_tArray ret_arr = init_int8_tArray(68, __LINE__);
4461 memcpy(ret_arr->elems, CResult_RecoverableSignatureNoneZ_get_ok(owner_conv).serialized_form, 68);
4465 static inline void CResult_RecoverableSignatureNoneZ_get_err(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner){
4466 CHECK(!owner->result_ok);
4467 return *owner->contents.err;
4469 void __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_get_err"))) TS_CResult_RecoverableSignatureNoneZ_get_err(uint64_t owner) {
4470 LDKCResult_RecoverableSignatureNoneZ* owner_conv = (LDKCResult_RecoverableSignatureNoneZ*)untag_ptr(owner);
4471 CResult_RecoverableSignatureNoneZ_get_err(owner_conv);
4474 static inline LDKCVec_CVec_u8ZZ CVec_CVec_u8ZZ_clone(const LDKCVec_CVec_u8ZZ *orig) {
4475 LDKCVec_CVec_u8ZZ ret = { .data = MALLOC(sizeof(LDKCVec_u8Z) * orig->datalen, "LDKCVec_CVec_u8ZZ clone bytes"), .datalen = orig->datalen };
4476 for (size_t i = 0; i < ret.datalen; i++) {
4477 ret.data[i] = CVec_u8Z_clone(&orig->data[i]);
4481 static inline struct LDKCVec_CVec_u8ZZ CResult_CVec_CVec_u8ZZNoneZ_get_ok(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner){
4482 CHECK(owner->result_ok);
4483 return CVec_CVec_u8ZZ_clone(&*owner->contents.result);
4485 ptrArray __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_get_ok"))) TS_CResult_CVec_CVec_u8ZZNoneZ_get_ok(uint64_t owner) {
4486 LDKCResult_CVec_CVec_u8ZZNoneZ* owner_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)untag_ptr(owner);
4487 LDKCVec_CVec_u8ZZ ret_var = CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner_conv);
4488 ptrArray ret_arr = NULL;
4489 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
4490 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 8);
4491 for (size_t m = 0; m < ret_var.datalen; m++) {
4492 LDKCVec_u8Z ret_conv_12_var = ret_var.data[m];
4493 int8_tArray ret_conv_12_arr = init_int8_tArray(ret_conv_12_var.datalen, __LINE__);
4494 memcpy(ret_conv_12_arr->elems, ret_conv_12_var.data, ret_conv_12_var.datalen);
4495 CVec_u8Z_free(ret_conv_12_var);
4496 ret_arr_ptr[m] = ret_conv_12_arr;
4503 static inline void CResult_CVec_CVec_u8ZZNoneZ_get_err(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner){
4504 CHECK(!owner->result_ok);
4505 return *owner->contents.err;
4507 void __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_get_err"))) TS_CResult_CVec_CVec_u8ZZNoneZ_get_err(uint64_t owner) {
4508 LDKCResult_CVec_CVec_u8ZZNoneZ* owner_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)untag_ptr(owner);
4509 CResult_CVec_CVec_u8ZZNoneZ_get_err(owner_conv);
4512 static inline struct LDKInMemorySigner CResult_InMemorySignerDecodeErrorZ_get_ok(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner){
4513 LDKInMemorySigner ret = *owner->contents.result;
4514 ret.is_owned = false;
4517 uint64_t __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_get_ok"))) TS_CResult_InMemorySignerDecodeErrorZ_get_ok(uint64_t owner) {
4518 LDKCResult_InMemorySignerDecodeErrorZ* owner_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)untag_ptr(owner);
4519 LDKInMemorySigner ret_var = CResult_InMemorySignerDecodeErrorZ_get_ok(owner_conv);
4520 uint64_t ret_ref = 0;
4521 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
4522 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
4526 static inline struct LDKDecodeError CResult_InMemorySignerDecodeErrorZ_get_err(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner){
4527 CHECK(!owner->result_ok);
4528 return DecodeError_clone(&*owner->contents.err);
4530 uint64_t __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_get_err"))) TS_CResult_InMemorySignerDecodeErrorZ_get_err(uint64_t owner) {
4531 LDKCResult_InMemorySignerDecodeErrorZ* owner_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)untag_ptr(owner);
4532 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
4533 *ret_copy = CResult_InMemorySignerDecodeErrorZ_get_err(owner_conv);
4534 uint64_t ret_ref = tag_ptr(ret_copy, true);
4538 static inline LDKCVec_TxOutZ CVec_TxOutZ_clone(const LDKCVec_TxOutZ *orig) {
4539 LDKCVec_TxOutZ ret = { .data = MALLOC(sizeof(LDKTxOut) * orig->datalen, "LDKCVec_TxOutZ clone bytes"), .datalen = orig->datalen };
4540 for (size_t i = 0; i < ret.datalen; i++) {
4541 ret.data[i] = TxOut_clone(&orig->data[i]);
4545 static inline struct LDKTransaction CResult_TransactionNoneZ_get_ok(LDKCResult_TransactionNoneZ *NONNULL_PTR owner){
4546 CHECK(owner->result_ok);
4547 return *owner->contents.result;
4549 int8_tArray __attribute__((export_name("TS_CResult_TransactionNoneZ_get_ok"))) TS_CResult_TransactionNoneZ_get_ok(uint64_t owner) {
4550 LDKCResult_TransactionNoneZ* owner_conv = (LDKCResult_TransactionNoneZ*)untag_ptr(owner);
4551 LDKTransaction ret_var = CResult_TransactionNoneZ_get_ok(owner_conv);
4552 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
4553 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
4557 static inline void CResult_TransactionNoneZ_get_err(LDKCResult_TransactionNoneZ *NONNULL_PTR owner){
4558 CHECK(!owner->result_ok);
4559 return *owner->contents.err;
4561 void __attribute__((export_name("TS_CResult_TransactionNoneZ_get_err"))) TS_CResult_TransactionNoneZ_get_err(uint64_t owner) {
4562 LDKCResult_TransactionNoneZ* owner_conv = (LDKCResult_TransactionNoneZ*)untag_ptr(owner);
4563 CResult_TransactionNoneZ_get_err(owner_conv);
4566 uint32_t __attribute__((export_name("TS_LDKCOption_u16Z_ty_from_ptr"))) TS_LDKCOption_u16Z_ty_from_ptr(uint64_t ptr) {
4567 LDKCOption_u16Z *obj = (LDKCOption_u16Z*)untag_ptr(ptr);
4569 case LDKCOption_u16Z_Some: return 0;
4570 case LDKCOption_u16Z_None: return 1;
4574 int16_t __attribute__((export_name("TS_LDKCOption_u16Z_Some_get_some"))) TS_LDKCOption_u16Z_Some_get_some(uint64_t ptr) {
4575 LDKCOption_u16Z *obj = (LDKCOption_u16Z*)untag_ptr(ptr);
4576 assert(obj->tag == LDKCOption_u16Z_Some);
4577 int16_t some_conv = obj->some;
4580 uint32_t __attribute__((export_name("TS_LDKAPIError_ty_from_ptr"))) TS_LDKAPIError_ty_from_ptr(uint64_t ptr) {
4581 LDKAPIError *obj = (LDKAPIError*)untag_ptr(ptr);
4583 case LDKAPIError_APIMisuseError: return 0;
4584 case LDKAPIError_FeeRateTooHigh: return 1;
4585 case LDKAPIError_InvalidRoute: return 2;
4586 case LDKAPIError_ChannelUnavailable: return 3;
4587 case LDKAPIError_MonitorUpdateInProgress: return 4;
4588 case LDKAPIError_IncompatibleShutdownScript: return 5;
4592 jstring __attribute__((export_name("TS_LDKAPIError_APIMisuseError_get_err"))) TS_LDKAPIError_APIMisuseError_get_err(uint64_t ptr) {
4593 LDKAPIError *obj = (LDKAPIError*)untag_ptr(ptr);
4594 assert(obj->tag == LDKAPIError_APIMisuseError);
4595 LDKStr err_str = obj->api_misuse_error.err;
4596 jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len);
4599 jstring __attribute__((export_name("TS_LDKAPIError_FeeRateTooHigh_get_err"))) TS_LDKAPIError_FeeRateTooHigh_get_err(uint64_t ptr) {
4600 LDKAPIError *obj = (LDKAPIError*)untag_ptr(ptr);
4601 assert(obj->tag == LDKAPIError_FeeRateTooHigh);
4602 LDKStr err_str = obj->fee_rate_too_high.err;
4603 jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len);
4606 int32_t __attribute__((export_name("TS_LDKAPIError_FeeRateTooHigh_get_feerate"))) TS_LDKAPIError_FeeRateTooHigh_get_feerate(uint64_t ptr) {
4607 LDKAPIError *obj = (LDKAPIError*)untag_ptr(ptr);
4608 assert(obj->tag == LDKAPIError_FeeRateTooHigh);
4609 int32_t feerate_conv = obj->fee_rate_too_high.feerate;
4610 return feerate_conv;
4612 jstring __attribute__((export_name("TS_LDKAPIError_InvalidRoute_get_err"))) TS_LDKAPIError_InvalidRoute_get_err(uint64_t ptr) {
4613 LDKAPIError *obj = (LDKAPIError*)untag_ptr(ptr);
4614 assert(obj->tag == LDKAPIError_InvalidRoute);
4615 LDKStr err_str = obj->invalid_route.err;
4616 jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len);
4619 jstring __attribute__((export_name("TS_LDKAPIError_ChannelUnavailable_get_err"))) TS_LDKAPIError_ChannelUnavailable_get_err(uint64_t ptr) {
4620 LDKAPIError *obj = (LDKAPIError*)untag_ptr(ptr);
4621 assert(obj->tag == LDKAPIError_ChannelUnavailable);
4622 LDKStr err_str = obj->channel_unavailable.err;
4623 jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len);
4626 uint64_t __attribute__((export_name("TS_LDKAPIError_IncompatibleShutdownScript_get_script"))) TS_LDKAPIError_IncompatibleShutdownScript_get_script(uint64_t ptr) {
4627 LDKAPIError *obj = (LDKAPIError*)untag_ptr(ptr);
4628 assert(obj->tag == LDKAPIError_IncompatibleShutdownScript);
4629 LDKShutdownScript script_var = obj->incompatible_shutdown_script.script;
4630 uint64_t script_ref = 0;
4631 CHECK_INNER_FIELD_ACCESS_OR_NULL(script_var);
4632 script_ref = tag_ptr(script_var.inner, false);
4635 static inline void CResult_NoneAPIErrorZ_get_ok(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner){
4636 CHECK(owner->result_ok);
4637 return *owner->contents.result;
4639 void __attribute__((export_name("TS_CResult_NoneAPIErrorZ_get_ok"))) TS_CResult_NoneAPIErrorZ_get_ok(uint64_t owner) {
4640 LDKCResult_NoneAPIErrorZ* owner_conv = (LDKCResult_NoneAPIErrorZ*)untag_ptr(owner);
4641 CResult_NoneAPIErrorZ_get_ok(owner_conv);
4644 static inline struct LDKAPIError CResult_NoneAPIErrorZ_get_err(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner){
4645 CHECK(!owner->result_ok);
4646 return APIError_clone(&*owner->contents.err);
4648 uint64_t __attribute__((export_name("TS_CResult_NoneAPIErrorZ_get_err"))) TS_CResult_NoneAPIErrorZ_get_err(uint64_t owner) {
4649 LDKCResult_NoneAPIErrorZ* owner_conv = (LDKCResult_NoneAPIErrorZ*)untag_ptr(owner);
4650 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
4651 *ret_copy = CResult_NoneAPIErrorZ_get_err(owner_conv);
4652 uint64_t ret_ref = tag_ptr(ret_copy, true);
4656 static inline LDKCVec_CResult_NoneAPIErrorZZ CVec_CResult_NoneAPIErrorZZ_clone(const LDKCVec_CResult_NoneAPIErrorZZ *orig) {
4657 LDKCVec_CResult_NoneAPIErrorZZ ret = { .data = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ) * orig->datalen, "LDKCVec_CResult_NoneAPIErrorZZ clone bytes"), .datalen = orig->datalen };
4658 for (size_t i = 0; i < ret.datalen; i++) {
4659 ret.data[i] = CResult_NoneAPIErrorZ_clone(&orig->data[i]);
4663 static inline LDKCVec_APIErrorZ CVec_APIErrorZ_clone(const LDKCVec_APIErrorZ *orig) {
4664 LDKCVec_APIErrorZ ret = { .data = MALLOC(sizeof(LDKAPIError) * orig->datalen, "LDKCVec_APIErrorZ clone bytes"), .datalen = orig->datalen };
4665 for (size_t i = 0; i < ret.datalen; i++) {
4666 ret.data[i] = APIError_clone(&orig->data[i]);
4670 static inline struct LDKThirtyTwoBytes CResult__u832APIErrorZ_get_ok(LDKCResult__u832APIErrorZ *NONNULL_PTR owner){
4671 CHECK(owner->result_ok);
4672 return ThirtyTwoBytes_clone(&*owner->contents.result);
4674 int8_tArray __attribute__((export_name("TS_CResult__u832APIErrorZ_get_ok"))) TS_CResult__u832APIErrorZ_get_ok(uint64_t owner) {
4675 LDKCResult__u832APIErrorZ* owner_conv = (LDKCResult__u832APIErrorZ*)untag_ptr(owner);
4676 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
4677 memcpy(ret_arr->elems, CResult__u832APIErrorZ_get_ok(owner_conv).data, 32);
4681 static inline struct LDKAPIError CResult__u832APIErrorZ_get_err(LDKCResult__u832APIErrorZ *NONNULL_PTR owner){
4682 CHECK(!owner->result_ok);
4683 return APIError_clone(&*owner->contents.err);
4685 uint64_t __attribute__((export_name("TS_CResult__u832APIErrorZ_get_err"))) TS_CResult__u832APIErrorZ_get_err(uint64_t owner) {
4686 LDKCResult__u832APIErrorZ* owner_conv = (LDKCResult__u832APIErrorZ*)untag_ptr(owner);
4687 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
4688 *ret_copy = CResult__u832APIErrorZ_get_err(owner_conv);
4689 uint64_t ret_ref = tag_ptr(ret_copy, true);
4693 uint32_t __attribute__((export_name("TS_LDKPaymentSendFailure_ty_from_ptr"))) TS_LDKPaymentSendFailure_ty_from_ptr(uint64_t ptr) {
4694 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)untag_ptr(ptr);
4696 case LDKPaymentSendFailure_ParameterError: return 0;
4697 case LDKPaymentSendFailure_PathParameterError: return 1;
4698 case LDKPaymentSendFailure_AllFailedResendSafe: return 2;
4699 case LDKPaymentSendFailure_DuplicatePayment: return 3;
4700 case LDKPaymentSendFailure_PartialFailure: return 4;
4704 uint64_t __attribute__((export_name("TS_LDKPaymentSendFailure_ParameterError_get_parameter_error"))) TS_LDKPaymentSendFailure_ParameterError_get_parameter_error(uint64_t ptr) {
4705 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)untag_ptr(ptr);
4706 assert(obj->tag == LDKPaymentSendFailure_ParameterError);
4707 uint64_t parameter_error_ref = tag_ptr(&obj->parameter_error, false);
4708 return parameter_error_ref;
4710 uint64_tArray __attribute__((export_name("TS_LDKPaymentSendFailure_PathParameterError_get_path_parameter_error"))) TS_LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(uint64_t ptr) {
4711 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)untag_ptr(ptr);
4712 assert(obj->tag == LDKPaymentSendFailure_PathParameterError);
4713 LDKCVec_CResult_NoneAPIErrorZZ path_parameter_error_var = obj->path_parameter_error;
4714 uint64_tArray path_parameter_error_arr = NULL;
4715 path_parameter_error_arr = init_uint64_tArray(path_parameter_error_var.datalen, __LINE__);
4716 uint64_t *path_parameter_error_arr_ptr = (uint64_t*)(((uint8_t*)path_parameter_error_arr) + 8);
4717 for (size_t w = 0; w < path_parameter_error_var.datalen; w++) {
4718 LDKCResult_NoneAPIErrorZ* path_parameter_error_conv_22_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
4719 *path_parameter_error_conv_22_conv = path_parameter_error_var.data[w];
4720 *path_parameter_error_conv_22_conv = CResult_NoneAPIErrorZ_clone(path_parameter_error_conv_22_conv);
4721 path_parameter_error_arr_ptr[w] = tag_ptr(path_parameter_error_conv_22_conv, true);
4724 return path_parameter_error_arr;
4726 uint64_tArray __attribute__((export_name("TS_LDKPaymentSendFailure_AllFailedResendSafe_get_all_failed_resend_safe"))) TS_LDKPaymentSendFailure_AllFailedResendSafe_get_all_failed_resend_safe(uint64_t ptr) {
4727 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)untag_ptr(ptr);
4728 assert(obj->tag == LDKPaymentSendFailure_AllFailedResendSafe);
4729 LDKCVec_APIErrorZ all_failed_resend_safe_var = obj->all_failed_resend_safe;
4730 uint64_tArray all_failed_resend_safe_arr = NULL;
4731 all_failed_resend_safe_arr = init_uint64_tArray(all_failed_resend_safe_var.datalen, __LINE__);
4732 uint64_t *all_failed_resend_safe_arr_ptr = (uint64_t*)(((uint8_t*)all_failed_resend_safe_arr) + 8);
4733 for (size_t k = 0; k < all_failed_resend_safe_var.datalen; k++) {
4734 uint64_t all_failed_resend_safe_conv_10_ref = tag_ptr(&all_failed_resend_safe_var.data[k], false);
4735 all_failed_resend_safe_arr_ptr[k] = all_failed_resend_safe_conv_10_ref;
4738 return all_failed_resend_safe_arr;
4740 uint64_tArray __attribute__((export_name("TS_LDKPaymentSendFailure_PartialFailure_get_results"))) TS_LDKPaymentSendFailure_PartialFailure_get_results(uint64_t ptr) {
4741 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)untag_ptr(ptr);
4742 assert(obj->tag == LDKPaymentSendFailure_PartialFailure);
4743 LDKCVec_CResult_NoneAPIErrorZZ results_var = obj->partial_failure.results;
4744 uint64_tArray results_arr = NULL;
4745 results_arr = init_uint64_tArray(results_var.datalen, __LINE__);
4746 uint64_t *results_arr_ptr = (uint64_t*)(((uint8_t*)results_arr) + 8);
4747 for (size_t w = 0; w < results_var.datalen; w++) {
4748 LDKCResult_NoneAPIErrorZ* results_conv_22_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
4749 *results_conv_22_conv = results_var.data[w];
4750 *results_conv_22_conv = CResult_NoneAPIErrorZ_clone(results_conv_22_conv);
4751 results_arr_ptr[w] = tag_ptr(results_conv_22_conv, true);
4756 uint64_t __attribute__((export_name("TS_LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry"))) TS_LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(uint64_t ptr) {
4757 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)untag_ptr(ptr);
4758 assert(obj->tag == LDKPaymentSendFailure_PartialFailure);
4759 LDKRouteParameters failed_paths_retry_var = obj->partial_failure.failed_paths_retry;
4760 uint64_t failed_paths_retry_ref = 0;
4761 CHECK_INNER_FIELD_ACCESS_OR_NULL(failed_paths_retry_var);
4762 failed_paths_retry_ref = tag_ptr(failed_paths_retry_var.inner, false);
4763 return failed_paths_retry_ref;
4765 int8_tArray __attribute__((export_name("TS_LDKPaymentSendFailure_PartialFailure_get_payment_id"))) TS_LDKPaymentSendFailure_PartialFailure_get_payment_id(uint64_t ptr) {
4766 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)untag_ptr(ptr);
4767 assert(obj->tag == LDKPaymentSendFailure_PartialFailure);
4768 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
4769 memcpy(payment_id_arr->elems, obj->partial_failure.payment_id.data, 32);
4770 return payment_id_arr;
4772 static inline void CResult_NonePaymentSendFailureZ_get_ok(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner){
4773 CHECK(owner->result_ok);
4774 return *owner->contents.result;
4776 void __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_get_ok"))) TS_CResult_NonePaymentSendFailureZ_get_ok(uint64_t owner) {
4777 LDKCResult_NonePaymentSendFailureZ* owner_conv = (LDKCResult_NonePaymentSendFailureZ*)untag_ptr(owner);
4778 CResult_NonePaymentSendFailureZ_get_ok(owner_conv);
4781 static inline struct LDKPaymentSendFailure CResult_NonePaymentSendFailureZ_get_err(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner){
4782 CHECK(!owner->result_ok);
4783 return PaymentSendFailure_clone(&*owner->contents.err);
4785 uint64_t __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_get_err"))) TS_CResult_NonePaymentSendFailureZ_get_err(uint64_t owner) {
4786 LDKCResult_NonePaymentSendFailureZ* owner_conv = (LDKCResult_NonePaymentSendFailureZ*)untag_ptr(owner);
4787 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
4788 *ret_copy = CResult_NonePaymentSendFailureZ_get_err(owner_conv);
4789 uint64_t ret_ref = tag_ptr(ret_copy, true);
4793 static inline struct LDKThirtyTwoBytes CResult_PaymentHashPaymentSendFailureZ_get_ok(LDKCResult_PaymentHashPaymentSendFailureZ *NONNULL_PTR owner){
4794 CHECK(owner->result_ok);
4795 return ThirtyTwoBytes_clone(&*owner->contents.result);
4797 int8_tArray __attribute__((export_name("TS_CResult_PaymentHashPaymentSendFailureZ_get_ok"))) TS_CResult_PaymentHashPaymentSendFailureZ_get_ok(uint64_t owner) {
4798 LDKCResult_PaymentHashPaymentSendFailureZ* owner_conv = (LDKCResult_PaymentHashPaymentSendFailureZ*)untag_ptr(owner);
4799 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
4800 memcpy(ret_arr->elems, CResult_PaymentHashPaymentSendFailureZ_get_ok(owner_conv).data, 32);
4804 static inline struct LDKPaymentSendFailure CResult_PaymentHashPaymentSendFailureZ_get_err(LDKCResult_PaymentHashPaymentSendFailureZ *NONNULL_PTR owner){
4805 CHECK(!owner->result_ok);
4806 return PaymentSendFailure_clone(&*owner->contents.err);
4808 uint64_t __attribute__((export_name("TS_CResult_PaymentHashPaymentSendFailureZ_get_err"))) TS_CResult_PaymentHashPaymentSendFailureZ_get_err(uint64_t owner) {
4809 LDKCResult_PaymentHashPaymentSendFailureZ* owner_conv = (LDKCResult_PaymentHashPaymentSendFailureZ*)untag_ptr(owner);
4810 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
4811 *ret_copy = CResult_PaymentHashPaymentSendFailureZ_get_err(owner_conv);
4812 uint64_t ret_ref = tag_ptr(ret_copy, true);
4816 static inline struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_a(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner){
4817 return ThirtyTwoBytes_clone(&owner->a);
4819 int8_tArray __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentIdZ_get_a"))) TS_C2Tuple_PaymentHashPaymentIdZ_get_a(uint64_t owner) {
4820 LDKC2Tuple_PaymentHashPaymentIdZ* owner_conv = (LDKC2Tuple_PaymentHashPaymentIdZ*)untag_ptr(owner);
4821 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
4822 memcpy(ret_arr->elems, C2Tuple_PaymentHashPaymentIdZ_get_a(owner_conv).data, 32);
4826 static inline struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_b(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner){
4827 return ThirtyTwoBytes_clone(&owner->b);
4829 int8_tArray __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentIdZ_get_b"))) TS_C2Tuple_PaymentHashPaymentIdZ_get_b(uint64_t owner) {
4830 LDKC2Tuple_PaymentHashPaymentIdZ* owner_conv = (LDKC2Tuple_PaymentHashPaymentIdZ*)untag_ptr(owner);
4831 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
4832 memcpy(ret_arr->elems, C2Tuple_PaymentHashPaymentIdZ_get_b(owner_conv).data, 32);
4836 static inline struct LDKC2Tuple_PaymentHashPaymentIdZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner){
4837 CHECK(owner->result_ok);
4838 return C2Tuple_PaymentHashPaymentIdZ_clone(&*owner->contents.result);
4840 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(uint64_t owner) {
4841 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* owner_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)untag_ptr(owner);
4842 LDKC2Tuple_PaymentHashPaymentIdZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentIdZ), "LDKC2Tuple_PaymentHashPaymentIdZ");
4843 *ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner_conv);
4844 return tag_ptr(ret_conv, true);
4847 static inline struct LDKPaymentSendFailure CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner){
4848 CHECK(!owner->result_ok);
4849 return PaymentSendFailure_clone(&*owner->contents.err);
4851 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(uint64_t owner) {
4852 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* owner_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)untag_ptr(owner);
4853 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
4854 *ret_copy = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner_conv);
4855 uint64_t ret_ref = tag_ptr(ret_copy, true);
4859 static inline LDKCVec_ThirtyTwoBytesZ CVec_ThirtyTwoBytesZ_clone(const LDKCVec_ThirtyTwoBytesZ *orig) {
4860 LDKCVec_ThirtyTwoBytesZ ret = { .data = MALLOC(sizeof(LDKThirtyTwoBytes) * orig->datalen, "LDKCVec_ThirtyTwoBytesZ clone bytes"), .datalen = orig->datalen };
4861 for (size_t i = 0; i < ret.datalen; i++) {
4862 ret.data[i] = ThirtyTwoBytes_clone(&orig->data[i]);
4866 static inline struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_a(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner){
4867 return ThirtyTwoBytes_clone(&owner->a);
4869 int8_tArray __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentSecretZ_get_a"))) TS_C2Tuple_PaymentHashPaymentSecretZ_get_a(uint64_t owner) {
4870 LDKC2Tuple_PaymentHashPaymentSecretZ* owner_conv = (LDKC2Tuple_PaymentHashPaymentSecretZ*)untag_ptr(owner);
4871 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
4872 memcpy(ret_arr->elems, C2Tuple_PaymentHashPaymentSecretZ_get_a(owner_conv).data, 32);
4876 static inline struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_b(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner){
4877 return ThirtyTwoBytes_clone(&owner->b);
4879 int8_tArray __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentSecretZ_get_b"))) TS_C2Tuple_PaymentHashPaymentSecretZ_get_b(uint64_t owner) {
4880 LDKC2Tuple_PaymentHashPaymentSecretZ* owner_conv = (LDKC2Tuple_PaymentHashPaymentSecretZ*)untag_ptr(owner);
4881 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
4882 memcpy(ret_arr->elems, C2Tuple_PaymentHashPaymentSecretZ_get_b(owner_conv).data, 32);
4886 static inline struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner){
4887 CHECK(owner->result_ok);
4888 return C2Tuple_PaymentHashPaymentSecretZ_clone(&*owner->contents.result);
4890 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(uint64_t owner) {
4891 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* owner_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ*)untag_ptr(owner);
4892 LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
4893 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner_conv);
4894 return tag_ptr(ret_conv, true);
4897 static inline void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner){
4898 CHECK(!owner->result_ok);
4899 return *owner->contents.err;
4901 void __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(uint64_t owner) {
4902 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* owner_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ*)untag_ptr(owner);
4903 CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner_conv);
4906 static inline struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner){
4907 CHECK(owner->result_ok);
4908 return C2Tuple_PaymentHashPaymentSecretZ_clone(&*owner->contents.result);
4910 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(uint64_t owner) {
4911 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* owner_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ*)untag_ptr(owner);
4912 LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
4913 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner_conv);
4914 return tag_ptr(ret_conv, true);
4917 static inline struct LDKAPIError CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner){
4918 CHECK(!owner->result_ok);
4919 return APIError_clone(&*owner->contents.err);
4921 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(uint64_t owner) {
4922 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* owner_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ*)untag_ptr(owner);
4923 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
4924 *ret_copy = CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner_conv);
4925 uint64_t ret_ref = tag_ptr(ret_copy, true);
4929 static inline struct LDKThirtyTwoBytes CResult_PaymentSecretNoneZ_get_ok(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner){
4930 CHECK(owner->result_ok);
4931 return ThirtyTwoBytes_clone(&*owner->contents.result);
4933 int8_tArray __attribute__((export_name("TS_CResult_PaymentSecretNoneZ_get_ok"))) TS_CResult_PaymentSecretNoneZ_get_ok(uint64_t owner) {
4934 LDKCResult_PaymentSecretNoneZ* owner_conv = (LDKCResult_PaymentSecretNoneZ*)untag_ptr(owner);
4935 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
4936 memcpy(ret_arr->elems, CResult_PaymentSecretNoneZ_get_ok(owner_conv).data, 32);
4940 static inline void CResult_PaymentSecretNoneZ_get_err(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner){
4941 CHECK(!owner->result_ok);
4942 return *owner->contents.err;
4944 void __attribute__((export_name("TS_CResult_PaymentSecretNoneZ_get_err"))) TS_CResult_PaymentSecretNoneZ_get_err(uint64_t owner) {
4945 LDKCResult_PaymentSecretNoneZ* owner_conv = (LDKCResult_PaymentSecretNoneZ*)untag_ptr(owner);
4946 CResult_PaymentSecretNoneZ_get_err(owner_conv);
4949 static inline struct LDKThirtyTwoBytes CResult_PaymentSecretAPIErrorZ_get_ok(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner){
4950 CHECK(owner->result_ok);
4951 return ThirtyTwoBytes_clone(&*owner->contents.result);
4953 int8_tArray __attribute__((export_name("TS_CResult_PaymentSecretAPIErrorZ_get_ok"))) TS_CResult_PaymentSecretAPIErrorZ_get_ok(uint64_t owner) {
4954 LDKCResult_PaymentSecretAPIErrorZ* owner_conv = (LDKCResult_PaymentSecretAPIErrorZ*)untag_ptr(owner);
4955 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
4956 memcpy(ret_arr->elems, CResult_PaymentSecretAPIErrorZ_get_ok(owner_conv).data, 32);
4960 static inline struct LDKAPIError CResult_PaymentSecretAPIErrorZ_get_err(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner){
4961 CHECK(!owner->result_ok);
4962 return APIError_clone(&*owner->contents.err);
4964 uint64_t __attribute__((export_name("TS_CResult_PaymentSecretAPIErrorZ_get_err"))) TS_CResult_PaymentSecretAPIErrorZ_get_err(uint64_t owner) {
4965 LDKCResult_PaymentSecretAPIErrorZ* owner_conv = (LDKCResult_PaymentSecretAPIErrorZ*)untag_ptr(owner);
4966 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
4967 *ret_copy = CResult_PaymentSecretAPIErrorZ_get_err(owner_conv);
4968 uint64_t ret_ref = tag_ptr(ret_copy, true);
4972 static inline struct LDKThirtyTwoBytes CResult_PaymentPreimageAPIErrorZ_get_ok(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner){
4973 CHECK(owner->result_ok);
4974 return ThirtyTwoBytes_clone(&*owner->contents.result);
4976 int8_tArray __attribute__((export_name("TS_CResult_PaymentPreimageAPIErrorZ_get_ok"))) TS_CResult_PaymentPreimageAPIErrorZ_get_ok(uint64_t owner) {
4977 LDKCResult_PaymentPreimageAPIErrorZ* owner_conv = (LDKCResult_PaymentPreimageAPIErrorZ*)untag_ptr(owner);
4978 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
4979 memcpy(ret_arr->elems, CResult_PaymentPreimageAPIErrorZ_get_ok(owner_conv).data, 32);
4983 static inline struct LDKAPIError CResult_PaymentPreimageAPIErrorZ_get_err(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner){
4984 CHECK(!owner->result_ok);
4985 return APIError_clone(&*owner->contents.err);
4987 uint64_t __attribute__((export_name("TS_CResult_PaymentPreimageAPIErrorZ_get_err"))) TS_CResult_PaymentPreimageAPIErrorZ_get_err(uint64_t owner) {
4988 LDKCResult_PaymentPreimageAPIErrorZ* owner_conv = (LDKCResult_PaymentPreimageAPIErrorZ*)untag_ptr(owner);
4989 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
4990 *ret_copy = CResult_PaymentPreimageAPIErrorZ_get_err(owner_conv);
4991 uint64_t ret_ref = tag_ptr(ret_copy, true);
4995 static inline struct LDKCounterpartyForwardingInfo CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner){
4996 LDKCounterpartyForwardingInfo ret = *owner->contents.result;
4997 ret.is_owned = false;
5000 uint64_t __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(uint64_t owner) {
5001 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* owner_conv = (LDKCResult_CounterpartyForwardingInfoDecodeErrorZ*)untag_ptr(owner);
5002 LDKCounterpartyForwardingInfo ret_var = CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner_conv);
5003 uint64_t ret_ref = 0;
5004 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5005 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
5009 static inline struct LDKDecodeError CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner){
5010 CHECK(!owner->result_ok);
5011 return DecodeError_clone(&*owner->contents.err);
5013 uint64_t __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(uint64_t owner) {
5014 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* owner_conv = (LDKCResult_CounterpartyForwardingInfoDecodeErrorZ*)untag_ptr(owner);
5015 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
5016 *ret_copy = CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner_conv);
5017 uint64_t ret_ref = tag_ptr(ret_copy, true);
5021 static inline struct LDKChannelCounterparty CResult_ChannelCounterpartyDecodeErrorZ_get_ok(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner){
5022 LDKChannelCounterparty ret = *owner->contents.result;
5023 ret.is_owned = false;
5026 uint64_t __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_get_ok"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_get_ok(uint64_t owner) {
5027 LDKCResult_ChannelCounterpartyDecodeErrorZ* owner_conv = (LDKCResult_ChannelCounterpartyDecodeErrorZ*)untag_ptr(owner);
5028 LDKChannelCounterparty ret_var = CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner_conv);
5029 uint64_t ret_ref = 0;
5030 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5031 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
5035 static inline struct LDKDecodeError CResult_ChannelCounterpartyDecodeErrorZ_get_err(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner){
5036 CHECK(!owner->result_ok);
5037 return DecodeError_clone(&*owner->contents.err);
5039 uint64_t __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_get_err"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_get_err(uint64_t owner) {
5040 LDKCResult_ChannelCounterpartyDecodeErrorZ* owner_conv = (LDKCResult_ChannelCounterpartyDecodeErrorZ*)untag_ptr(owner);
5041 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
5042 *ret_copy = CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner_conv);
5043 uint64_t ret_ref = tag_ptr(ret_copy, true);
5047 static inline struct LDKChannelDetails CResult_ChannelDetailsDecodeErrorZ_get_ok(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner){
5048 LDKChannelDetails ret = *owner->contents.result;
5049 ret.is_owned = false;
5052 uint64_t __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_get_ok"))) TS_CResult_ChannelDetailsDecodeErrorZ_get_ok(uint64_t owner) {
5053 LDKCResult_ChannelDetailsDecodeErrorZ* owner_conv = (LDKCResult_ChannelDetailsDecodeErrorZ*)untag_ptr(owner);
5054 LDKChannelDetails ret_var = CResult_ChannelDetailsDecodeErrorZ_get_ok(owner_conv);
5055 uint64_t ret_ref = 0;
5056 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5057 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
5061 static inline struct LDKDecodeError CResult_ChannelDetailsDecodeErrorZ_get_err(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner){
5062 CHECK(!owner->result_ok);
5063 return DecodeError_clone(&*owner->contents.err);
5065 uint64_t __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_get_err"))) TS_CResult_ChannelDetailsDecodeErrorZ_get_err(uint64_t owner) {
5066 LDKCResult_ChannelDetailsDecodeErrorZ* owner_conv = (LDKCResult_ChannelDetailsDecodeErrorZ*)untag_ptr(owner);
5067 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
5068 *ret_copy = CResult_ChannelDetailsDecodeErrorZ_get_err(owner_conv);
5069 uint64_t ret_ref = tag_ptr(ret_copy, true);
5073 static inline struct LDKPhantomRouteHints CResult_PhantomRouteHintsDecodeErrorZ_get_ok(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner){
5074 LDKPhantomRouteHints ret = *owner->contents.result;
5075 ret.is_owned = false;
5078 uint64_t __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_get_ok"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_get_ok(uint64_t owner) {
5079 LDKCResult_PhantomRouteHintsDecodeErrorZ* owner_conv = (LDKCResult_PhantomRouteHintsDecodeErrorZ*)untag_ptr(owner);
5080 LDKPhantomRouteHints ret_var = CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner_conv);
5081 uint64_t ret_ref = 0;
5082 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5083 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
5087 static inline struct LDKDecodeError CResult_PhantomRouteHintsDecodeErrorZ_get_err(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner){
5088 CHECK(!owner->result_ok);
5089 return DecodeError_clone(&*owner->contents.err);
5091 uint64_t __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_get_err"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_get_err(uint64_t owner) {
5092 LDKCResult_PhantomRouteHintsDecodeErrorZ* owner_conv = (LDKCResult_PhantomRouteHintsDecodeErrorZ*)untag_ptr(owner);
5093 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
5094 *ret_copy = CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner_conv);
5095 uint64_t ret_ref = tag_ptr(ret_copy, true);
5099 static inline LDKCVec_ChannelMonitorZ CVec_ChannelMonitorZ_clone(const LDKCVec_ChannelMonitorZ *orig) {
5100 LDKCVec_ChannelMonitorZ ret = { .data = MALLOC(sizeof(LDKChannelMonitor) * orig->datalen, "LDKCVec_ChannelMonitorZ clone bytes"), .datalen = orig->datalen };
5101 for (size_t i = 0; i < ret.datalen; i++) {
5102 ret.data[i] = ChannelMonitor_clone(&orig->data[i]);
5106 typedef struct LDKWatch_JCalls {
5107 atomic_size_t refcnt;
5108 uint32_t instance_ptr;
5110 static void LDKWatch_JCalls_free(void* this_arg) {
5111 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
5112 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
5116 LDKChannelMonitorUpdateStatus watch_channel_LDKWatch_jcall(const void* this_arg, LDKOutPoint funding_txo, LDKChannelMonitor monitor) {
5117 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
5118 LDKOutPoint funding_txo_var = funding_txo;
5119 uint64_t funding_txo_ref = 0;
5120 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_var);
5121 funding_txo_ref = tag_ptr(funding_txo_var.inner, funding_txo_var.is_owned);
5122 LDKChannelMonitor monitor_var = monitor;
5123 uint64_t monitor_ref = 0;
5124 CHECK_INNER_FIELD_ACCESS_OR_NULL(monitor_var);
5125 monitor_ref = tag_ptr(monitor_var.inner, monitor_var.is_owned);
5126 uint64_t ret = js_invoke_function_bbuuuu(j_calls->instance_ptr, 17, funding_txo_ref, monitor_ref, 0, 0, 0, 0);
5127 LDKChannelMonitorUpdateStatus ret_conv = LDKChannelMonitorUpdateStatus_from_js(ret);
5130 LDKChannelMonitorUpdateStatus update_channel_LDKWatch_jcall(const void* this_arg, LDKOutPoint funding_txo, LDKChannelMonitorUpdate update) {
5131 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
5132 LDKOutPoint funding_txo_var = funding_txo;
5133 uint64_t funding_txo_ref = 0;
5134 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_var);
5135 funding_txo_ref = tag_ptr(funding_txo_var.inner, funding_txo_var.is_owned);
5136 LDKChannelMonitorUpdate update_var = update;
5137 uint64_t update_ref = 0;
5138 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_var);
5139 update_ref = tag_ptr(update_var.inner, update_var.is_owned);
5140 uint64_t ret = js_invoke_function_bbuuuu(j_calls->instance_ptr, 18, funding_txo_ref, update_ref, 0, 0, 0, 0);
5141 LDKChannelMonitorUpdateStatus ret_conv = LDKChannelMonitorUpdateStatus_from_js(ret);
5144 LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ release_pending_monitor_events_LDKWatch_jcall(const void* this_arg) {
5145 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
5146 uint64_tArray ret = (uint64_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 19, 0, 0, 0, 0, 0, 0);
5147 LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ ret_constr;
5148 ret_constr.datalen = ret->arr_len;
5149 if (ret_constr.datalen > 0)
5150 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ), "LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ Elements");
5152 ret_constr.data = NULL;
5153 uint64_t* ret_vals = ret->elems;
5154 for (size_t x = 0; x < ret_constr.datalen; x++) {
5155 uint64_t ret_conv_49 = ret_vals[x];
5156 void* ret_conv_49_ptr = untag_ptr(ret_conv_49);
5157 CHECK_ACCESS(ret_conv_49_ptr);
5158 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ ret_conv_49_conv = *(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)(ret_conv_49_ptr);
5159 FREE(untag_ptr(ret_conv_49));
5160 ret_constr.data[x] = ret_conv_49_conv;
5165 static void LDKWatch_JCalls_cloned(LDKWatch* new_obj) {
5166 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) new_obj->this_arg;
5167 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
5169 static inline LDKWatch LDKWatch_init (JSValue o) {
5170 LDKWatch_JCalls *calls = MALLOC(sizeof(LDKWatch_JCalls), "LDKWatch_JCalls");
5171 atomic_init(&calls->refcnt, 1);
5172 calls->instance_ptr = o;
5175 .this_arg = (void*) calls,
5176 .watch_channel = watch_channel_LDKWatch_jcall,
5177 .update_channel = update_channel_LDKWatch_jcall,
5178 .release_pending_monitor_events = release_pending_monitor_events_LDKWatch_jcall,
5179 .free = LDKWatch_JCalls_free,
5183 uint64_t __attribute__((export_name("TS_LDKWatch_new"))) TS_LDKWatch_new(JSValue o) {
5184 LDKWatch *res_ptr = MALLOC(sizeof(LDKWatch), "LDKWatch");
5185 *res_ptr = LDKWatch_init(o);
5186 return tag_ptr(res_ptr, true);
5188 uint32_t __attribute__((export_name("TS_Watch_watch_channel"))) TS_Watch_watch_channel(uint64_t this_arg, uint64_t funding_txo, uint64_t monitor) {
5189 void* this_arg_ptr = untag_ptr(this_arg);
5190 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5191 LDKWatch* this_arg_conv = (LDKWatch*)this_arg_ptr;
5192 LDKOutPoint funding_txo_conv;
5193 funding_txo_conv.inner = untag_ptr(funding_txo);
5194 funding_txo_conv.is_owned = ptr_is_owned(funding_txo);
5195 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
5196 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
5197 LDKChannelMonitor monitor_conv;
5198 monitor_conv.inner = untag_ptr(monitor);
5199 monitor_conv.is_owned = ptr_is_owned(monitor);
5200 CHECK_INNER_FIELD_ACCESS_OR_NULL(monitor_conv);
5201 monitor_conv = ChannelMonitor_clone(&monitor_conv);
5202 uint32_t ret_conv = LDKChannelMonitorUpdateStatus_to_js((this_arg_conv->watch_channel)(this_arg_conv->this_arg, funding_txo_conv, monitor_conv));
5206 uint32_t __attribute__((export_name("TS_Watch_update_channel"))) TS_Watch_update_channel(uint64_t this_arg, uint64_t funding_txo, uint64_t update) {
5207 void* this_arg_ptr = untag_ptr(this_arg);
5208 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5209 LDKWatch* this_arg_conv = (LDKWatch*)this_arg_ptr;
5210 LDKOutPoint funding_txo_conv;
5211 funding_txo_conv.inner = untag_ptr(funding_txo);
5212 funding_txo_conv.is_owned = ptr_is_owned(funding_txo);
5213 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
5214 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
5215 LDKChannelMonitorUpdate update_conv;
5216 update_conv.inner = untag_ptr(update);
5217 update_conv.is_owned = ptr_is_owned(update);
5218 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_conv);
5219 update_conv = ChannelMonitorUpdate_clone(&update_conv);
5220 uint32_t ret_conv = LDKChannelMonitorUpdateStatus_to_js((this_arg_conv->update_channel)(this_arg_conv->this_arg, funding_txo_conv, update_conv));
5224 uint64_tArray __attribute__((export_name("TS_Watch_release_pending_monitor_events"))) TS_Watch_release_pending_monitor_events(uint64_t this_arg) {
5225 void* this_arg_ptr = untag_ptr(this_arg);
5226 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5227 LDKWatch* this_arg_conv = (LDKWatch*)this_arg_ptr;
5228 LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ ret_var = (this_arg_conv->release_pending_monitor_events)(this_arg_conv->this_arg);
5229 uint64_tArray ret_arr = NULL;
5230 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
5231 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
5232 for (size_t x = 0; x < ret_var.datalen; x++) {
5233 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* ret_conv_49_conv = MALLOC(sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ), "LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ");
5234 *ret_conv_49_conv = ret_var.data[x];
5235 ret_arr_ptr[x] = tag_ptr(ret_conv_49_conv, true);
5242 typedef struct LDKBroadcasterInterface_JCalls {
5243 atomic_size_t refcnt;
5244 uint32_t instance_ptr;
5245 } LDKBroadcasterInterface_JCalls;
5246 static void LDKBroadcasterInterface_JCalls_free(void* this_arg) {
5247 LDKBroadcasterInterface_JCalls *j_calls = (LDKBroadcasterInterface_JCalls*) this_arg;
5248 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
5252 void broadcast_transaction_LDKBroadcasterInterface_jcall(const void* this_arg, LDKTransaction tx) {
5253 LDKBroadcasterInterface_JCalls *j_calls = (LDKBroadcasterInterface_JCalls*) this_arg;
5254 LDKTransaction tx_var = tx;
5255 int8_tArray tx_arr = init_int8_tArray(tx_var.datalen, __LINE__);
5256 memcpy(tx_arr->elems, tx_var.data, tx_var.datalen);
5257 Transaction_free(tx_var);
5258 js_invoke_function_uuuuuu(j_calls->instance_ptr, 20, (uint32_t)tx_arr, 0, 0, 0, 0, 0);
5260 static void LDKBroadcasterInterface_JCalls_cloned(LDKBroadcasterInterface* new_obj) {
5261 LDKBroadcasterInterface_JCalls *j_calls = (LDKBroadcasterInterface_JCalls*) new_obj->this_arg;
5262 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
5264 static inline LDKBroadcasterInterface LDKBroadcasterInterface_init (JSValue o) {
5265 LDKBroadcasterInterface_JCalls *calls = MALLOC(sizeof(LDKBroadcasterInterface_JCalls), "LDKBroadcasterInterface_JCalls");
5266 atomic_init(&calls->refcnt, 1);
5267 calls->instance_ptr = o;
5269 LDKBroadcasterInterface ret = {
5270 .this_arg = (void*) calls,
5271 .broadcast_transaction = broadcast_transaction_LDKBroadcasterInterface_jcall,
5272 .free = LDKBroadcasterInterface_JCalls_free,
5276 uint64_t __attribute__((export_name("TS_LDKBroadcasterInterface_new"))) TS_LDKBroadcasterInterface_new(JSValue o) {
5277 LDKBroadcasterInterface *res_ptr = MALLOC(sizeof(LDKBroadcasterInterface), "LDKBroadcasterInterface");
5278 *res_ptr = LDKBroadcasterInterface_init(o);
5279 return tag_ptr(res_ptr, true);
5281 void __attribute__((export_name("TS_BroadcasterInterface_broadcast_transaction"))) TS_BroadcasterInterface_broadcast_transaction(uint64_t this_arg, int8_tArray tx) {
5282 void* this_arg_ptr = untag_ptr(this_arg);
5283 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5284 LDKBroadcasterInterface* this_arg_conv = (LDKBroadcasterInterface*)this_arg_ptr;
5285 LDKTransaction tx_ref;
5286 tx_ref.datalen = tx->arr_len;
5287 tx_ref.data = MALLOC(tx_ref.datalen, "LDKTransaction Bytes");
5288 memcpy(tx_ref.data, tx->elems, tx_ref.datalen); FREE(tx);
5289 tx_ref.data_is_owned = true;
5290 (this_arg_conv->broadcast_transaction)(this_arg_conv->this_arg, tx_ref);
5293 typedef struct LDKKeysInterface_JCalls {
5294 atomic_size_t refcnt;
5295 uint32_t instance_ptr;
5296 } LDKKeysInterface_JCalls;
5297 static void LDKKeysInterface_JCalls_free(void* this_arg) {
5298 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
5299 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
5303 LDKCResult_SecretKeyNoneZ get_node_secret_LDKKeysInterface_jcall(const void* this_arg, LDKRecipient recipient) {
5304 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
5305 uint32_t recipient_conv = LDKRecipient_to_js(recipient);
5306 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 21, recipient_conv, 0, 0, 0, 0, 0);
5307 void* ret_ptr = untag_ptr(ret);
5308 CHECK_ACCESS(ret_ptr);
5309 LDKCResult_SecretKeyNoneZ ret_conv = *(LDKCResult_SecretKeyNoneZ*)(ret_ptr);
5310 FREE(untag_ptr(ret));
5313 LDKCResult_PublicKeyNoneZ get_node_id_LDKKeysInterface_jcall(const void* this_arg, LDKRecipient recipient) {
5314 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
5315 uint32_t recipient_conv = LDKRecipient_to_js(recipient);
5316 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 22, recipient_conv, 0, 0, 0, 0, 0);
5317 void* ret_ptr = untag_ptr(ret);
5318 CHECK_ACCESS(ret_ptr);
5319 LDKCResult_PublicKeyNoneZ ret_conv = *(LDKCResult_PublicKeyNoneZ*)(ret_ptr);
5320 FREE(untag_ptr(ret));
5323 LDKCResult_SharedSecretNoneZ ecdh_LDKKeysInterface_jcall(const void* this_arg, LDKRecipient recipient, LDKPublicKey other_key, LDKCOption_ScalarZ tweak) {
5324 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
5325 uint32_t recipient_conv = LDKRecipient_to_js(recipient);
5326 int8_tArray other_key_arr = init_int8_tArray(33, __LINE__);
5327 memcpy(other_key_arr->elems, other_key.compressed_form, 33);
5328 LDKCOption_ScalarZ *tweak_copy = MALLOC(sizeof(LDKCOption_ScalarZ), "LDKCOption_ScalarZ");
5329 *tweak_copy = tweak;
5330 uint64_t tweak_ref = tag_ptr(tweak_copy, true);
5331 uint64_t ret = js_invoke_function_uubuuu(j_calls->instance_ptr, 23, recipient_conv, (uint32_t)other_key_arr, tweak_ref, 0, 0, 0);
5332 void* ret_ptr = untag_ptr(ret);
5333 CHECK_ACCESS(ret_ptr);
5334 LDKCResult_SharedSecretNoneZ ret_conv = *(LDKCResult_SharedSecretNoneZ*)(ret_ptr);
5335 FREE(untag_ptr(ret));
5338 LDKCVec_u8Z get_destination_script_LDKKeysInterface_jcall(const void* this_arg) {
5339 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
5340 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 24, 0, 0, 0, 0, 0, 0);
5341 LDKCVec_u8Z ret_ref;
5342 ret_ref.datalen = ret->arr_len;
5343 ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
5344 memcpy(ret_ref.data, ret->elems, ret_ref.datalen); FREE(ret);
5347 LDKShutdownScript get_shutdown_scriptpubkey_LDKKeysInterface_jcall(const void* this_arg) {
5348 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
5349 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 25, 0, 0, 0, 0, 0, 0);
5350 LDKShutdownScript ret_conv;
5351 ret_conv.inner = untag_ptr(ret);
5352 ret_conv.is_owned = ptr_is_owned(ret);
5353 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
5356 LDKThirtyTwoBytes generate_channel_keys_id_LDKKeysInterface_jcall(const void* this_arg, bool inbound, uint64_t channel_value_satoshis, LDKU128 user_channel_id) {
5357 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
5358 jboolean inbound_conv = inbound;
5359 int64_t channel_value_satoshis_conv = channel_value_satoshis;
5360 int8_tArray user_channel_id_arr = init_int8_tArray(16, __LINE__);
5361 memcpy(user_channel_id_arr->elems, user_channel_id.le_bytes, 16);
5362 int8_tArray ret = (int8_tArray)js_invoke_function_ubuuuu(j_calls->instance_ptr, 26, inbound_conv, channel_value_satoshis_conv, (uint32_t)user_channel_id_arr, 0, 0, 0);
5363 LDKThirtyTwoBytes ret_ref;
5364 CHECK(ret->arr_len == 32);
5365 memcpy(ret_ref.data, ret->elems, 32); FREE(ret);
5368 LDKSign derive_channel_signer_LDKKeysInterface_jcall(const void* this_arg, uint64_t channel_value_satoshis, LDKThirtyTwoBytes channel_keys_id) {
5369 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
5370 int64_t channel_value_satoshis_conv = channel_value_satoshis;
5371 int8_tArray channel_keys_id_arr = init_int8_tArray(32, __LINE__);
5372 memcpy(channel_keys_id_arr->elems, channel_keys_id.data, 32);
5373 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 27, channel_value_satoshis_conv, (uint32_t)channel_keys_id_arr, 0, 0, 0, 0);
5374 void* ret_ptr = untag_ptr(ret);
5375 CHECK_ACCESS(ret_ptr);
5376 LDKSign ret_conv = *(LDKSign*)(ret_ptr);
5377 FREE(untag_ptr(ret));
5380 LDKThirtyTwoBytes get_secure_random_bytes_LDKKeysInterface_jcall(const void* this_arg) {
5381 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
5382 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 28, 0, 0, 0, 0, 0, 0);
5383 LDKThirtyTwoBytes ret_ref;
5384 CHECK(ret->arr_len == 32);
5385 memcpy(ret_ref.data, ret->elems, 32); FREE(ret);
5388 LDKCResult_SignDecodeErrorZ read_chan_signer_LDKKeysInterface_jcall(const void* this_arg, LDKu8slice reader) {
5389 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
5390 LDKu8slice reader_var = reader;
5391 int8_tArray reader_arr = init_int8_tArray(reader_var.datalen, __LINE__);
5392 memcpy(reader_arr->elems, reader_var.data, reader_var.datalen);
5393 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 29, (uint32_t)reader_arr, 0, 0, 0, 0, 0);
5394 void* ret_ptr = untag_ptr(ret);
5395 CHECK_ACCESS(ret_ptr);
5396 LDKCResult_SignDecodeErrorZ ret_conv = *(LDKCResult_SignDecodeErrorZ*)(ret_ptr);
5397 FREE(untag_ptr(ret));
5400 LDKCResult_RecoverableSignatureNoneZ sign_invoice_LDKKeysInterface_jcall(const void* this_arg, LDKu8slice hrp_bytes, LDKCVec_U5Z invoice_data, LDKRecipient receipient) {
5401 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
5402 LDKu8slice hrp_bytes_var = hrp_bytes;
5403 int8_tArray hrp_bytes_arr = init_int8_tArray(hrp_bytes_var.datalen, __LINE__);
5404 memcpy(hrp_bytes_arr->elems, hrp_bytes_var.data, hrp_bytes_var.datalen);
5405 LDKCVec_U5Z invoice_data_var = invoice_data;
5406 ptrArray invoice_data_arr = NULL;
5407 invoice_data_arr = init_ptrArray(invoice_data_var.datalen, __LINE__);
5408 int8_t *invoice_data_arr_ptr = (int8_t*)(((uint8_t*)invoice_data_arr) + 8);
5409 for (size_t h = 0; h < invoice_data_var.datalen; h++) {
5410 uint8_t invoice_data_conv_7_val = invoice_data_var.data[h]._0;
5411 invoice_data_arr_ptr[h] = invoice_data_conv_7_val;
5414 FREE(invoice_data_var.data);
5415 uint32_t receipient_conv = LDKRecipient_to_js(receipient);
5416 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 30, (uint32_t)hrp_bytes_arr, (uint32_t)invoice_data_arr, receipient_conv, 0, 0, 0);
5417 void* ret_ptr = untag_ptr(ret);
5418 CHECK_ACCESS(ret_ptr);
5419 LDKCResult_RecoverableSignatureNoneZ ret_conv = *(LDKCResult_RecoverableSignatureNoneZ*)(ret_ptr);
5420 FREE(untag_ptr(ret));
5423 LDKThirtyTwoBytes get_inbound_payment_key_material_LDKKeysInterface_jcall(const void* this_arg) {
5424 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
5425 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 31, 0, 0, 0, 0, 0, 0);
5426 LDKThirtyTwoBytes ret_ref;
5427 CHECK(ret->arr_len == 32);
5428 memcpy(ret_ref.data, ret->elems, 32); FREE(ret);
5431 static void LDKKeysInterface_JCalls_cloned(LDKKeysInterface* new_obj) {
5432 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) new_obj->this_arg;
5433 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
5435 static inline LDKKeysInterface LDKKeysInterface_init (JSValue o) {
5436 LDKKeysInterface_JCalls *calls = MALLOC(sizeof(LDKKeysInterface_JCalls), "LDKKeysInterface_JCalls");
5437 atomic_init(&calls->refcnt, 1);
5438 calls->instance_ptr = o;
5440 LDKKeysInterface ret = {
5441 .this_arg = (void*) calls,
5442 .get_node_secret = get_node_secret_LDKKeysInterface_jcall,
5443 .get_node_id = get_node_id_LDKKeysInterface_jcall,
5444 .ecdh = ecdh_LDKKeysInterface_jcall,
5445 .get_destination_script = get_destination_script_LDKKeysInterface_jcall,
5446 .get_shutdown_scriptpubkey = get_shutdown_scriptpubkey_LDKKeysInterface_jcall,
5447 .generate_channel_keys_id = generate_channel_keys_id_LDKKeysInterface_jcall,
5448 .derive_channel_signer = derive_channel_signer_LDKKeysInterface_jcall,
5449 .get_secure_random_bytes = get_secure_random_bytes_LDKKeysInterface_jcall,
5450 .read_chan_signer = read_chan_signer_LDKKeysInterface_jcall,
5451 .sign_invoice = sign_invoice_LDKKeysInterface_jcall,
5452 .get_inbound_payment_key_material = get_inbound_payment_key_material_LDKKeysInterface_jcall,
5453 .free = LDKKeysInterface_JCalls_free,
5457 uint64_t __attribute__((export_name("TS_LDKKeysInterface_new"))) TS_LDKKeysInterface_new(JSValue o) {
5458 LDKKeysInterface *res_ptr = MALLOC(sizeof(LDKKeysInterface), "LDKKeysInterface");
5459 *res_ptr = LDKKeysInterface_init(o);
5460 return tag_ptr(res_ptr, true);
5462 uint64_t __attribute__((export_name("TS_KeysInterface_get_node_secret"))) TS_KeysInterface_get_node_secret(uint64_t this_arg, uint32_t recipient) {
5463 void* this_arg_ptr = untag_ptr(this_arg);
5464 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5465 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)this_arg_ptr;
5466 LDKRecipient recipient_conv = LDKRecipient_from_js(recipient);
5467 LDKCResult_SecretKeyNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SecretKeyNoneZ), "LDKCResult_SecretKeyNoneZ");
5468 *ret_conv = (this_arg_conv->get_node_secret)(this_arg_conv->this_arg, recipient_conv);
5469 return tag_ptr(ret_conv, true);
5472 uint64_t __attribute__((export_name("TS_KeysInterface_get_node_id"))) TS_KeysInterface_get_node_id(uint64_t this_arg, uint32_t recipient) {
5473 void* this_arg_ptr = untag_ptr(this_arg);
5474 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5475 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)this_arg_ptr;
5476 LDKRecipient recipient_conv = LDKRecipient_from_js(recipient);
5477 LDKCResult_PublicKeyNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyNoneZ), "LDKCResult_PublicKeyNoneZ");
5478 *ret_conv = (this_arg_conv->get_node_id)(this_arg_conv->this_arg, recipient_conv);
5479 return tag_ptr(ret_conv, true);
5482 uint64_t __attribute__((export_name("TS_KeysInterface_ecdh"))) TS_KeysInterface_ecdh(uint64_t this_arg, uint32_t recipient, int8_tArray other_key, uint64_t tweak) {
5483 void* this_arg_ptr = untag_ptr(this_arg);
5484 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5485 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)this_arg_ptr;
5486 LDKRecipient recipient_conv = LDKRecipient_from_js(recipient);
5487 LDKPublicKey other_key_ref;
5488 CHECK(other_key->arr_len == 33);
5489 memcpy(other_key_ref.compressed_form, other_key->elems, 33); FREE(other_key);
5490 void* tweak_ptr = untag_ptr(tweak);
5491 CHECK_ACCESS(tweak_ptr);
5492 LDKCOption_ScalarZ tweak_conv = *(LDKCOption_ScalarZ*)(tweak_ptr);
5493 // WARNING: we may need a move here but no clone is available for LDKCOption_ScalarZ
5494 LDKCResult_SharedSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SharedSecretNoneZ), "LDKCResult_SharedSecretNoneZ");
5495 *ret_conv = (this_arg_conv->ecdh)(this_arg_conv->this_arg, recipient_conv, other_key_ref, tweak_conv);
5496 return tag_ptr(ret_conv, true);
5499 int8_tArray __attribute__((export_name("TS_KeysInterface_get_destination_script"))) TS_KeysInterface_get_destination_script(uint64_t this_arg) {
5500 void* this_arg_ptr = untag_ptr(this_arg);
5501 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5502 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)this_arg_ptr;
5503 LDKCVec_u8Z ret_var = (this_arg_conv->get_destination_script)(this_arg_conv->this_arg);
5504 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
5505 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
5506 CVec_u8Z_free(ret_var);
5510 uint64_t __attribute__((export_name("TS_KeysInterface_get_shutdown_scriptpubkey"))) TS_KeysInterface_get_shutdown_scriptpubkey(uint64_t this_arg) {
5511 void* this_arg_ptr = untag_ptr(this_arg);
5512 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5513 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)this_arg_ptr;
5514 LDKShutdownScript ret_var = (this_arg_conv->get_shutdown_scriptpubkey)(this_arg_conv->this_arg);
5515 uint64_t ret_ref = 0;
5516 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5517 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
5521 int8_tArray __attribute__((export_name("TS_KeysInterface_generate_channel_keys_id"))) TS_KeysInterface_generate_channel_keys_id(uint64_t this_arg, jboolean inbound, int64_t channel_value_satoshis, int8_tArray user_channel_id) {
5522 void* this_arg_ptr = untag_ptr(this_arg);
5523 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5524 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)this_arg_ptr;
5525 LDKU128 user_channel_id_ref;
5526 CHECK(user_channel_id->arr_len == 16);
5527 memcpy(user_channel_id_ref.le_bytes, user_channel_id->elems, 16); FREE(user_channel_id);
5528 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5529 memcpy(ret_arr->elems, (this_arg_conv->generate_channel_keys_id)(this_arg_conv->this_arg, inbound, channel_value_satoshis, user_channel_id_ref).data, 32);
5533 uint64_t __attribute__((export_name("TS_KeysInterface_derive_channel_signer"))) TS_KeysInterface_derive_channel_signer(uint64_t this_arg, int64_t channel_value_satoshis, int8_tArray channel_keys_id) {
5534 void* this_arg_ptr = untag_ptr(this_arg);
5535 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5536 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)this_arg_ptr;
5537 LDKThirtyTwoBytes channel_keys_id_ref;
5538 CHECK(channel_keys_id->arr_len == 32);
5539 memcpy(channel_keys_id_ref.data, channel_keys_id->elems, 32); FREE(channel_keys_id);
5540 LDKSign* ret_ret = MALLOC(sizeof(LDKSign), "LDKSign");
5541 *ret_ret = (this_arg_conv->derive_channel_signer)(this_arg_conv->this_arg, channel_value_satoshis, channel_keys_id_ref);
5542 return tag_ptr(ret_ret, true);
5545 int8_tArray __attribute__((export_name("TS_KeysInterface_get_secure_random_bytes"))) TS_KeysInterface_get_secure_random_bytes(uint64_t this_arg) {
5546 void* this_arg_ptr = untag_ptr(this_arg);
5547 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5548 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)this_arg_ptr;
5549 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5550 memcpy(ret_arr->elems, (this_arg_conv->get_secure_random_bytes)(this_arg_conv->this_arg).data, 32);
5554 uint64_t __attribute__((export_name("TS_KeysInterface_read_chan_signer"))) TS_KeysInterface_read_chan_signer(uint64_t this_arg, int8_tArray reader) {
5555 void* this_arg_ptr = untag_ptr(this_arg);
5556 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5557 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)this_arg_ptr;
5558 LDKu8slice reader_ref;
5559 reader_ref.datalen = reader->arr_len;
5560 reader_ref.data = reader->elems;
5561 LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
5562 *ret_conv = (this_arg_conv->read_chan_signer)(this_arg_conv->this_arg, reader_ref);
5564 return tag_ptr(ret_conv, true);
5567 uint64_t __attribute__((export_name("TS_KeysInterface_sign_invoice"))) TS_KeysInterface_sign_invoice(uint64_t this_arg, int8_tArray hrp_bytes, ptrArray invoice_data, uint32_t receipient) {
5568 void* this_arg_ptr = untag_ptr(this_arg);
5569 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5570 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)this_arg_ptr;
5571 LDKu8slice hrp_bytes_ref;
5572 hrp_bytes_ref.datalen = hrp_bytes->arr_len;
5573 hrp_bytes_ref.data = hrp_bytes->elems;
5574 LDKCVec_U5Z invoice_data_constr;
5575 invoice_data_constr.datalen = invoice_data->arr_len;
5576 if (invoice_data_constr.datalen > 0)
5577 invoice_data_constr.data = MALLOC(invoice_data_constr.datalen * sizeof(LDKU5), "LDKCVec_U5Z Elements");
5579 invoice_data_constr.data = NULL;
5580 int8_t* invoice_data_vals = (void*) invoice_data->elems;
5581 for (size_t h = 0; h < invoice_data_constr.datalen; h++) {
5582 int8_t invoice_data_conv_7 = invoice_data_vals[h];
5584 invoice_data_constr.data[h] = (LDKU5){ ._0 = invoice_data_conv_7 };
5587 LDKRecipient receipient_conv = LDKRecipient_from_js(receipient);
5588 LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
5589 *ret_conv = (this_arg_conv->sign_invoice)(this_arg_conv->this_arg, hrp_bytes_ref, invoice_data_constr, receipient_conv);
5591 return tag_ptr(ret_conv, true);
5594 int8_tArray __attribute__((export_name("TS_KeysInterface_get_inbound_payment_key_material"))) TS_KeysInterface_get_inbound_payment_key_material(uint64_t this_arg) {
5595 void* this_arg_ptr = untag_ptr(this_arg);
5596 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5597 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)this_arg_ptr;
5598 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5599 memcpy(ret_arr->elems, (this_arg_conv->get_inbound_payment_key_material)(this_arg_conv->this_arg).data, 32);
5603 typedef struct LDKFeeEstimator_JCalls {
5604 atomic_size_t refcnt;
5605 uint32_t instance_ptr;
5606 } LDKFeeEstimator_JCalls;
5607 static void LDKFeeEstimator_JCalls_free(void* this_arg) {
5608 LDKFeeEstimator_JCalls *j_calls = (LDKFeeEstimator_JCalls*) this_arg;
5609 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
5613 uint32_t get_est_sat_per_1000_weight_LDKFeeEstimator_jcall(const void* this_arg, LDKConfirmationTarget confirmation_target) {
5614 LDKFeeEstimator_JCalls *j_calls = (LDKFeeEstimator_JCalls*) this_arg;
5615 uint32_t confirmation_target_conv = LDKConfirmationTarget_to_js(confirmation_target);
5616 return js_invoke_function_uuuuuu(j_calls->instance_ptr, 32, confirmation_target_conv, 0, 0, 0, 0, 0);
5618 static void LDKFeeEstimator_JCalls_cloned(LDKFeeEstimator* new_obj) {
5619 LDKFeeEstimator_JCalls *j_calls = (LDKFeeEstimator_JCalls*) new_obj->this_arg;
5620 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
5622 static inline LDKFeeEstimator LDKFeeEstimator_init (JSValue o) {
5623 LDKFeeEstimator_JCalls *calls = MALLOC(sizeof(LDKFeeEstimator_JCalls), "LDKFeeEstimator_JCalls");
5624 atomic_init(&calls->refcnt, 1);
5625 calls->instance_ptr = o;
5627 LDKFeeEstimator ret = {
5628 .this_arg = (void*) calls,
5629 .get_est_sat_per_1000_weight = get_est_sat_per_1000_weight_LDKFeeEstimator_jcall,
5630 .free = LDKFeeEstimator_JCalls_free,
5634 uint64_t __attribute__((export_name("TS_LDKFeeEstimator_new"))) TS_LDKFeeEstimator_new(JSValue o) {
5635 LDKFeeEstimator *res_ptr = MALLOC(sizeof(LDKFeeEstimator), "LDKFeeEstimator");
5636 *res_ptr = LDKFeeEstimator_init(o);
5637 return tag_ptr(res_ptr, true);
5639 int32_t __attribute__((export_name("TS_FeeEstimator_get_est_sat_per_1000_weight"))) TS_FeeEstimator_get_est_sat_per_1000_weight(uint64_t this_arg, uint32_t confirmation_target) {
5640 void* this_arg_ptr = untag_ptr(this_arg);
5641 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5642 LDKFeeEstimator* this_arg_conv = (LDKFeeEstimator*)this_arg_ptr;
5643 LDKConfirmationTarget confirmation_target_conv = LDKConfirmationTarget_from_js(confirmation_target);
5644 int32_t ret_conv = (this_arg_conv->get_est_sat_per_1000_weight)(this_arg_conv->this_arg, confirmation_target_conv);
5648 static inline struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelManagerZ_get_a(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner){
5649 return ThirtyTwoBytes_clone(&owner->a);
5651 int8_tArray __attribute__((export_name("TS_C2Tuple_BlockHashChannelManagerZ_get_a"))) TS_C2Tuple_BlockHashChannelManagerZ_get_a(uint64_t owner) {
5652 LDKC2Tuple_BlockHashChannelManagerZ* owner_conv = (LDKC2Tuple_BlockHashChannelManagerZ*)untag_ptr(owner);
5653 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5654 memcpy(ret_arr->elems, C2Tuple_BlockHashChannelManagerZ_get_a(owner_conv).data, 32);
5658 static inline struct LDKChannelManager C2Tuple_BlockHashChannelManagerZ_get_b(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner){
5659 LDKChannelManager ret = owner->b;
5660 ret.is_owned = false;
5663 uint64_t __attribute__((export_name("TS_C2Tuple_BlockHashChannelManagerZ_get_b"))) TS_C2Tuple_BlockHashChannelManagerZ_get_b(uint64_t owner) {
5664 LDKC2Tuple_BlockHashChannelManagerZ* owner_conv = (LDKC2Tuple_BlockHashChannelManagerZ*)untag_ptr(owner);
5665 LDKChannelManager ret_var = C2Tuple_BlockHashChannelManagerZ_get_b(owner_conv);
5666 uint64_t ret_ref = 0;
5667 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5668 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
5672 static inline struct LDKC2Tuple_BlockHashChannelManagerZ *CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner){
5673 CHECK(owner->result_ok);
5674 return &*owner->contents.result;
5676 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(uint64_t owner) {
5677 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* owner_conv = (LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)untag_ptr(owner);
5678 uint64_t ret_ret = tag_ptr(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner_conv), false);
5682 static inline struct LDKDecodeError CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner){
5683 CHECK(!owner->result_ok);
5684 return DecodeError_clone(&*owner->contents.err);
5686 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(uint64_t owner) {
5687 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* owner_conv = (LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)untag_ptr(owner);
5688 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
5689 *ret_copy = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner_conv);
5690 uint64_t ret_ref = tag_ptr(ret_copy, true);
5694 static inline struct LDKChannelConfig CResult_ChannelConfigDecodeErrorZ_get_ok(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner){
5695 LDKChannelConfig ret = *owner->contents.result;
5696 ret.is_owned = false;
5699 uint64_t __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_get_ok"))) TS_CResult_ChannelConfigDecodeErrorZ_get_ok(uint64_t owner) {
5700 LDKCResult_ChannelConfigDecodeErrorZ* owner_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)untag_ptr(owner);
5701 LDKChannelConfig ret_var = CResult_ChannelConfigDecodeErrorZ_get_ok(owner_conv);
5702 uint64_t ret_ref = 0;
5703 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5704 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
5708 static inline struct LDKDecodeError CResult_ChannelConfigDecodeErrorZ_get_err(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner){
5709 CHECK(!owner->result_ok);
5710 return DecodeError_clone(&*owner->contents.err);
5712 uint64_t __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_get_err"))) TS_CResult_ChannelConfigDecodeErrorZ_get_err(uint64_t owner) {
5713 LDKCResult_ChannelConfigDecodeErrorZ* owner_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)untag_ptr(owner);
5714 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
5715 *ret_copy = CResult_ChannelConfigDecodeErrorZ_get_err(owner_conv);
5716 uint64_t ret_ref = tag_ptr(ret_copy, true);
5720 static inline struct LDKOutPoint CResult_OutPointDecodeErrorZ_get_ok(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner){
5721 LDKOutPoint ret = *owner->contents.result;
5722 ret.is_owned = false;
5725 uint64_t __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_get_ok"))) TS_CResult_OutPointDecodeErrorZ_get_ok(uint64_t owner) {
5726 LDKCResult_OutPointDecodeErrorZ* owner_conv = (LDKCResult_OutPointDecodeErrorZ*)untag_ptr(owner);
5727 LDKOutPoint ret_var = CResult_OutPointDecodeErrorZ_get_ok(owner_conv);
5728 uint64_t ret_ref = 0;
5729 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5730 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
5734 static inline struct LDKDecodeError CResult_OutPointDecodeErrorZ_get_err(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner){
5735 CHECK(!owner->result_ok);
5736 return DecodeError_clone(&*owner->contents.err);
5738 uint64_t __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_get_err"))) TS_CResult_OutPointDecodeErrorZ_get_err(uint64_t owner) {
5739 LDKCResult_OutPointDecodeErrorZ* owner_conv = (LDKCResult_OutPointDecodeErrorZ*)untag_ptr(owner);
5740 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
5741 *ret_copy = CResult_OutPointDecodeErrorZ_get_err(owner_conv);
5742 uint64_t ret_ref = tag_ptr(ret_copy, true);
5746 typedef struct LDKType_JCalls {
5747 atomic_size_t refcnt;
5748 uint32_t instance_ptr;
5750 static void LDKType_JCalls_free(void* this_arg) {
5751 LDKType_JCalls *j_calls = (LDKType_JCalls*) this_arg;
5752 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
5756 uint16_t type_id_LDKType_jcall(const void* this_arg) {
5757 LDKType_JCalls *j_calls = (LDKType_JCalls*) this_arg;
5758 return js_invoke_function_uuuuuu(j_calls->instance_ptr, 33, 0, 0, 0, 0, 0, 0);
5760 LDKStr debug_str_LDKType_jcall(const void* this_arg) {
5761 LDKType_JCalls *j_calls = (LDKType_JCalls*) this_arg;
5762 jstring ret = (jstring)js_invoke_function_uuuuuu(j_calls->instance_ptr, 34, 0, 0, 0, 0, 0, 0);
5763 LDKStr ret_conv = str_ref_to_owned_c(ret);
5766 LDKCVec_u8Z write_LDKType_jcall(const void* this_arg) {
5767 LDKType_JCalls *j_calls = (LDKType_JCalls*) this_arg;
5768 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 35, 0, 0, 0, 0, 0, 0);
5769 LDKCVec_u8Z ret_ref;
5770 ret_ref.datalen = ret->arr_len;
5771 ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
5772 memcpy(ret_ref.data, ret->elems, ret_ref.datalen); FREE(ret);
5775 static void LDKType_JCalls_cloned(LDKType* new_obj) {
5776 LDKType_JCalls *j_calls = (LDKType_JCalls*) new_obj->this_arg;
5777 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
5779 static inline LDKType LDKType_init (JSValue o) {
5780 LDKType_JCalls *calls = MALLOC(sizeof(LDKType_JCalls), "LDKType_JCalls");
5781 atomic_init(&calls->refcnt, 1);
5782 calls->instance_ptr = o;
5785 .this_arg = (void*) calls,
5786 .type_id = type_id_LDKType_jcall,
5787 .debug_str = debug_str_LDKType_jcall,
5788 .write = write_LDKType_jcall,
5789 .cloned = LDKType_JCalls_cloned,
5790 .free = LDKType_JCalls_free,
5794 uint64_t __attribute__((export_name("TS_LDKType_new"))) TS_LDKType_new(JSValue o) {
5795 LDKType *res_ptr = MALLOC(sizeof(LDKType), "LDKType");
5796 *res_ptr = LDKType_init(o);
5797 return tag_ptr(res_ptr, true);
5799 int16_t __attribute__((export_name("TS_Type_type_id"))) TS_Type_type_id(uint64_t this_arg) {
5800 void* this_arg_ptr = untag_ptr(this_arg);
5801 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5802 LDKType* this_arg_conv = (LDKType*)this_arg_ptr;
5803 int16_t ret_conv = (this_arg_conv->type_id)(this_arg_conv->this_arg);
5807 jstring __attribute__((export_name("TS_Type_debug_str"))) TS_Type_debug_str(uint64_t this_arg) {
5808 void* this_arg_ptr = untag_ptr(this_arg);
5809 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5810 LDKType* this_arg_conv = (LDKType*)this_arg_ptr;
5811 LDKStr ret_str = (this_arg_conv->debug_str)(this_arg_conv->this_arg);
5812 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
5817 int8_tArray __attribute__((export_name("TS_Type_write"))) TS_Type_write(uint64_t this_arg) {
5818 void* this_arg_ptr = untag_ptr(this_arg);
5819 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5820 LDKType* this_arg_conv = (LDKType*)this_arg_ptr;
5821 LDKCVec_u8Z ret_var = (this_arg_conv->write)(this_arg_conv->this_arg);
5822 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
5823 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
5824 CVec_u8Z_free(ret_var);
5828 uint32_t __attribute__((export_name("TS_LDKCOption_TypeZ_ty_from_ptr"))) TS_LDKCOption_TypeZ_ty_from_ptr(uint64_t ptr) {
5829 LDKCOption_TypeZ *obj = (LDKCOption_TypeZ*)untag_ptr(ptr);
5831 case LDKCOption_TypeZ_Some: return 0;
5832 case LDKCOption_TypeZ_None: return 1;
5836 uint64_t __attribute__((export_name("TS_LDKCOption_TypeZ_Some_get_some"))) TS_LDKCOption_TypeZ_Some_get_some(uint64_t ptr) {
5837 LDKCOption_TypeZ *obj = (LDKCOption_TypeZ*)untag_ptr(ptr);
5838 assert(obj->tag == LDKCOption_TypeZ_Some);
5839 LDKType* some_ret = MALLOC(sizeof(LDKType), "LDKType");
5840 *some_ret = Type_clone(&obj->some);
5841 return tag_ptr(some_ret, true);
5843 static inline struct LDKCOption_TypeZ CResult_COption_TypeZDecodeErrorZ_get_ok(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner){
5844 CHECK(owner->result_ok);
5845 return COption_TypeZ_clone(&*owner->contents.result);
5847 uint64_t __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_get_ok"))) TS_CResult_COption_TypeZDecodeErrorZ_get_ok(uint64_t owner) {
5848 LDKCResult_COption_TypeZDecodeErrorZ* owner_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)untag_ptr(owner);
5849 LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
5850 *ret_copy = CResult_COption_TypeZDecodeErrorZ_get_ok(owner_conv);
5851 uint64_t ret_ref = tag_ptr(ret_copy, true);
5855 static inline struct LDKDecodeError CResult_COption_TypeZDecodeErrorZ_get_err(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner){
5856 CHECK(!owner->result_ok);
5857 return DecodeError_clone(&*owner->contents.err);
5859 uint64_t __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_get_err"))) TS_CResult_COption_TypeZDecodeErrorZ_get_err(uint64_t owner) {
5860 LDKCResult_COption_TypeZDecodeErrorZ* owner_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)untag_ptr(owner);
5861 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
5862 *ret_copy = CResult_COption_TypeZDecodeErrorZ_get_err(owner_conv);
5863 uint64_t ret_ref = tag_ptr(ret_copy, true);
5867 uint32_t __attribute__((export_name("TS_LDKPaymentError_ty_from_ptr"))) TS_LDKPaymentError_ty_from_ptr(uint64_t ptr) {
5868 LDKPaymentError *obj = (LDKPaymentError*)untag_ptr(ptr);
5870 case LDKPaymentError_Invoice: return 0;
5871 case LDKPaymentError_Routing: return 1;
5872 case LDKPaymentError_Sending: return 2;
5876 jstring __attribute__((export_name("TS_LDKPaymentError_Invoice_get_invoice"))) TS_LDKPaymentError_Invoice_get_invoice(uint64_t ptr) {
5877 LDKPaymentError *obj = (LDKPaymentError*)untag_ptr(ptr);
5878 assert(obj->tag == LDKPaymentError_Invoice);
5879 LDKStr invoice_str = obj->invoice;
5880 jstring invoice_conv = str_ref_to_ts(invoice_str.chars, invoice_str.len);
5881 return invoice_conv;
5883 uint64_t __attribute__((export_name("TS_LDKPaymentError_Routing_get_routing"))) TS_LDKPaymentError_Routing_get_routing(uint64_t ptr) {
5884 LDKPaymentError *obj = (LDKPaymentError*)untag_ptr(ptr);
5885 assert(obj->tag == LDKPaymentError_Routing);
5886 LDKLightningError routing_var = obj->routing;
5887 uint64_t routing_ref = 0;
5888 CHECK_INNER_FIELD_ACCESS_OR_NULL(routing_var);
5889 routing_ref = tag_ptr(routing_var.inner, false);
5892 uint64_t __attribute__((export_name("TS_LDKPaymentError_Sending_get_sending"))) TS_LDKPaymentError_Sending_get_sending(uint64_t ptr) {
5893 LDKPaymentError *obj = (LDKPaymentError*)untag_ptr(ptr);
5894 assert(obj->tag == LDKPaymentError_Sending);
5895 uint64_t sending_ref = tag_ptr(&obj->sending, false);
5898 static inline struct LDKThirtyTwoBytes CResult_PaymentIdPaymentErrorZ_get_ok(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner){
5899 CHECK(owner->result_ok);
5900 return ThirtyTwoBytes_clone(&*owner->contents.result);
5902 int8_tArray __attribute__((export_name("TS_CResult_PaymentIdPaymentErrorZ_get_ok"))) TS_CResult_PaymentIdPaymentErrorZ_get_ok(uint64_t owner) {
5903 LDKCResult_PaymentIdPaymentErrorZ* owner_conv = (LDKCResult_PaymentIdPaymentErrorZ*)untag_ptr(owner);
5904 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5905 memcpy(ret_arr->elems, CResult_PaymentIdPaymentErrorZ_get_ok(owner_conv).data, 32);
5909 static inline struct LDKPaymentError CResult_PaymentIdPaymentErrorZ_get_err(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner){
5910 CHECK(!owner->result_ok);
5911 return PaymentError_clone(&*owner->contents.err);
5913 uint64_t __attribute__((export_name("TS_CResult_PaymentIdPaymentErrorZ_get_err"))) TS_CResult_PaymentIdPaymentErrorZ_get_err(uint64_t owner) {
5914 LDKCResult_PaymentIdPaymentErrorZ* owner_conv = (LDKCResult_PaymentIdPaymentErrorZ*)untag_ptr(owner);
5915 LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
5916 *ret_copy = CResult_PaymentIdPaymentErrorZ_get_err(owner_conv);
5917 uint64_t ret_ref = tag_ptr(ret_copy, true);
5921 static inline void CResult_NonePaymentErrorZ_get_ok(LDKCResult_NonePaymentErrorZ *NONNULL_PTR owner){
5922 CHECK(owner->result_ok);
5923 return *owner->contents.result;
5925 void __attribute__((export_name("TS_CResult_NonePaymentErrorZ_get_ok"))) TS_CResult_NonePaymentErrorZ_get_ok(uint64_t owner) {
5926 LDKCResult_NonePaymentErrorZ* owner_conv = (LDKCResult_NonePaymentErrorZ*)untag_ptr(owner);
5927 CResult_NonePaymentErrorZ_get_ok(owner_conv);
5930 static inline struct LDKPaymentError CResult_NonePaymentErrorZ_get_err(LDKCResult_NonePaymentErrorZ *NONNULL_PTR owner){
5931 CHECK(!owner->result_ok);
5932 return PaymentError_clone(&*owner->contents.err);
5934 uint64_t __attribute__((export_name("TS_CResult_NonePaymentErrorZ_get_err"))) TS_CResult_NonePaymentErrorZ_get_err(uint64_t owner) {
5935 LDKCResult_NonePaymentErrorZ* owner_conv = (LDKCResult_NonePaymentErrorZ*)untag_ptr(owner);
5936 LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
5937 *ret_copy = CResult_NonePaymentErrorZ_get_err(owner_conv);
5938 uint64_t ret_ref = tag_ptr(ret_copy, true);
5942 static inline struct LDKStr CResult_StringErrorZ_get_ok(LDKCResult_StringErrorZ *NONNULL_PTR owner){
5943 CHECK(owner->result_ok);
5944 return *owner->contents.result;
5946 jstring __attribute__((export_name("TS_CResult_StringErrorZ_get_ok"))) TS_CResult_StringErrorZ_get_ok(uint64_t owner) {
5947 LDKCResult_StringErrorZ* owner_conv = (LDKCResult_StringErrorZ*)untag_ptr(owner);
5948 LDKStr ret_str = CResult_StringErrorZ_get_ok(owner_conv);
5949 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
5953 static inline enum LDKSecp256k1Error CResult_StringErrorZ_get_err(LDKCResult_StringErrorZ *NONNULL_PTR owner){
5954 CHECK(!owner->result_ok);
5955 return *owner->contents.err;
5957 uint32_t __attribute__((export_name("TS_CResult_StringErrorZ_get_err"))) TS_CResult_StringErrorZ_get_err(uint64_t owner) {
5958 LDKCResult_StringErrorZ* owner_conv = (LDKCResult_StringErrorZ*)untag_ptr(owner);
5959 uint32_t ret_conv = LDKSecp256k1Error_to_js(CResult_StringErrorZ_get_err(owner_conv));
5963 static inline struct LDKPublicKey CResult_PublicKeyErrorZ_get_ok(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner){
5964 CHECK(owner->result_ok);
5965 return *owner->contents.result;
5967 int8_tArray __attribute__((export_name("TS_CResult_PublicKeyErrorZ_get_ok"))) TS_CResult_PublicKeyErrorZ_get_ok(uint64_t owner) {
5968 LDKCResult_PublicKeyErrorZ* owner_conv = (LDKCResult_PublicKeyErrorZ*)untag_ptr(owner);
5969 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
5970 memcpy(ret_arr->elems, CResult_PublicKeyErrorZ_get_ok(owner_conv).compressed_form, 33);
5974 static inline enum LDKSecp256k1Error CResult_PublicKeyErrorZ_get_err(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner){
5975 CHECK(!owner->result_ok);
5976 return *owner->contents.err;
5978 uint32_t __attribute__((export_name("TS_CResult_PublicKeyErrorZ_get_err"))) TS_CResult_PublicKeyErrorZ_get_err(uint64_t owner) {
5979 LDKCResult_PublicKeyErrorZ* owner_conv = (LDKCResult_PublicKeyErrorZ*)untag_ptr(owner);
5980 uint32_t ret_conv = LDKSecp256k1Error_to_js(CResult_PublicKeyErrorZ_get_err(owner_conv));
5984 static inline struct LDKChannelMonitorUpdate CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner){
5985 LDKChannelMonitorUpdate ret = *owner->contents.result;
5986 ret.is_owned = false;
5989 uint64_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(uint64_t owner) {
5990 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* owner_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)untag_ptr(owner);
5991 LDKChannelMonitorUpdate ret_var = CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner_conv);
5992 uint64_t ret_ref = 0;
5993 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5994 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
5998 static inline struct LDKDecodeError CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner){
5999 CHECK(!owner->result_ok);
6000 return DecodeError_clone(&*owner->contents.err);
6002 uint64_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_err"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(uint64_t owner) {
6003 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* owner_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)untag_ptr(owner);
6004 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
6005 *ret_copy = CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner_conv);
6006 uint64_t ret_ref = tag_ptr(ret_copy, true);
6010 uint32_t __attribute__((export_name("TS_LDKCOption_MonitorEventZ_ty_from_ptr"))) TS_LDKCOption_MonitorEventZ_ty_from_ptr(uint64_t ptr) {
6011 LDKCOption_MonitorEventZ *obj = (LDKCOption_MonitorEventZ*)untag_ptr(ptr);
6013 case LDKCOption_MonitorEventZ_Some: return 0;
6014 case LDKCOption_MonitorEventZ_None: return 1;
6018 uint64_t __attribute__((export_name("TS_LDKCOption_MonitorEventZ_Some_get_some"))) TS_LDKCOption_MonitorEventZ_Some_get_some(uint64_t ptr) {
6019 LDKCOption_MonitorEventZ *obj = (LDKCOption_MonitorEventZ*)untag_ptr(ptr);
6020 assert(obj->tag == LDKCOption_MonitorEventZ_Some);
6021 uint64_t some_ref = tag_ptr(&obj->some, false);
6024 static inline struct LDKCOption_MonitorEventZ CResult_COption_MonitorEventZDecodeErrorZ_get_ok(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner){
6025 CHECK(owner->result_ok);
6026 return COption_MonitorEventZ_clone(&*owner->contents.result);
6028 uint64_t __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_get_ok"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_get_ok(uint64_t owner) {
6029 LDKCResult_COption_MonitorEventZDecodeErrorZ* owner_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)untag_ptr(owner);
6030 LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
6031 *ret_copy = CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner_conv);
6032 uint64_t ret_ref = tag_ptr(ret_copy, true);
6036 static inline struct LDKDecodeError CResult_COption_MonitorEventZDecodeErrorZ_get_err(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner){
6037 CHECK(!owner->result_ok);
6038 return DecodeError_clone(&*owner->contents.err);
6040 uint64_t __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_get_err"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_get_err(uint64_t owner) {
6041 LDKCResult_COption_MonitorEventZDecodeErrorZ* owner_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)untag_ptr(owner);
6042 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
6043 *ret_copy = CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner_conv);
6044 uint64_t ret_ref = tag_ptr(ret_copy, true);
6048 static inline struct LDKHTLCUpdate CResult_HTLCUpdateDecodeErrorZ_get_ok(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner){
6049 LDKHTLCUpdate ret = *owner->contents.result;
6050 ret.is_owned = false;
6053 uint64_t __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_get_ok"))) TS_CResult_HTLCUpdateDecodeErrorZ_get_ok(uint64_t owner) {
6054 LDKCResult_HTLCUpdateDecodeErrorZ* owner_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)untag_ptr(owner);
6055 LDKHTLCUpdate ret_var = CResult_HTLCUpdateDecodeErrorZ_get_ok(owner_conv);
6056 uint64_t ret_ref = 0;
6057 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6058 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6062 static inline struct LDKDecodeError CResult_HTLCUpdateDecodeErrorZ_get_err(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner){
6063 CHECK(!owner->result_ok);
6064 return DecodeError_clone(&*owner->contents.err);
6066 uint64_t __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_get_err"))) TS_CResult_HTLCUpdateDecodeErrorZ_get_err(uint64_t owner) {
6067 LDKCResult_HTLCUpdateDecodeErrorZ* owner_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)untag_ptr(owner);
6068 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
6069 *ret_copy = CResult_HTLCUpdateDecodeErrorZ_get_err(owner_conv);
6070 uint64_t ret_ref = tag_ptr(ret_copy, true);
6074 static inline struct LDKOutPoint C2Tuple_OutPointScriptZ_get_a(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner){
6075 LDKOutPoint ret = owner->a;
6076 ret.is_owned = false;
6079 uint64_t __attribute__((export_name("TS_C2Tuple_OutPointScriptZ_get_a"))) TS_C2Tuple_OutPointScriptZ_get_a(uint64_t owner) {
6080 LDKC2Tuple_OutPointScriptZ* owner_conv = (LDKC2Tuple_OutPointScriptZ*)untag_ptr(owner);
6081 LDKOutPoint ret_var = C2Tuple_OutPointScriptZ_get_a(owner_conv);
6082 uint64_t ret_ref = 0;
6083 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6084 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6088 static inline struct LDKCVec_u8Z C2Tuple_OutPointScriptZ_get_b(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner){
6089 return CVec_u8Z_clone(&owner->b);
6091 int8_tArray __attribute__((export_name("TS_C2Tuple_OutPointScriptZ_get_b"))) TS_C2Tuple_OutPointScriptZ_get_b(uint64_t owner) {
6092 LDKC2Tuple_OutPointScriptZ* owner_conv = (LDKC2Tuple_OutPointScriptZ*)untag_ptr(owner);
6093 LDKCVec_u8Z ret_var = C2Tuple_OutPointScriptZ_get_b(owner_conv);
6094 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
6095 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
6096 CVec_u8Z_free(ret_var);
6100 static inline uint32_t C2Tuple_u32ScriptZ_get_a(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner){
6103 int32_t __attribute__((export_name("TS_C2Tuple_u32ScriptZ_get_a"))) TS_C2Tuple_u32ScriptZ_get_a(uint64_t owner) {
6104 LDKC2Tuple_u32ScriptZ* owner_conv = (LDKC2Tuple_u32ScriptZ*)untag_ptr(owner);
6105 int32_t ret_conv = C2Tuple_u32ScriptZ_get_a(owner_conv);
6109 static inline struct LDKCVec_u8Z C2Tuple_u32ScriptZ_get_b(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner){
6110 return CVec_u8Z_clone(&owner->b);
6112 int8_tArray __attribute__((export_name("TS_C2Tuple_u32ScriptZ_get_b"))) TS_C2Tuple_u32ScriptZ_get_b(uint64_t owner) {
6113 LDKC2Tuple_u32ScriptZ* owner_conv = (LDKC2Tuple_u32ScriptZ*)untag_ptr(owner);
6114 LDKCVec_u8Z ret_var = C2Tuple_u32ScriptZ_get_b(owner_conv);
6115 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
6116 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
6117 CVec_u8Z_free(ret_var);
6121 static inline LDKCVec_C2Tuple_u32ScriptZZ CVec_C2Tuple_u32ScriptZZ_clone(const LDKCVec_C2Tuple_u32ScriptZZ *orig) {
6122 LDKCVec_C2Tuple_u32ScriptZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ) * orig->datalen, "LDKCVec_C2Tuple_u32ScriptZZ clone bytes"), .datalen = orig->datalen };
6123 for (size_t i = 0; i < ret.datalen; i++) {
6124 ret.data[i] = C2Tuple_u32ScriptZ_clone(&orig->data[i]);
6128 static inline struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner){
6129 return ThirtyTwoBytes_clone(&owner->a);
6131 int8_tArray __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(uint64_t owner) {
6132 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* owner_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)untag_ptr(owner);
6133 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
6134 memcpy(ret_arr->elems, C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner_conv).data, 32);
6138 static inline struct LDKCVec_C2Tuple_u32ScriptZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner){
6139 return CVec_C2Tuple_u32ScriptZZ_clone(&owner->b);
6141 uint64_tArray __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(uint64_t owner) {
6142 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* owner_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)untag_ptr(owner);
6143 LDKCVec_C2Tuple_u32ScriptZZ ret_var = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner_conv);
6144 uint64_tArray ret_arr = NULL;
6145 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
6146 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
6147 for (size_t v = 0; v < ret_var.datalen; v++) {
6148 LDKC2Tuple_u32ScriptZ* ret_conv_21_conv = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
6149 *ret_conv_21_conv = ret_var.data[v];
6150 ret_arr_ptr[v] = tag_ptr(ret_conv_21_conv, true);
6157 static inline LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_clone(const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ *orig) {
6158 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ) * orig->datalen, "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ clone bytes"), .datalen = orig->datalen };
6159 for (size_t i = 0; i < ret.datalen; i++) {
6160 ret.data[i] = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(&orig->data[i]);
6164 static inline LDKCVec_EventZ CVec_EventZ_clone(const LDKCVec_EventZ *orig) {
6165 LDKCVec_EventZ ret = { .data = MALLOC(sizeof(LDKEvent) * orig->datalen, "LDKCVec_EventZ clone bytes"), .datalen = orig->datalen };
6166 for (size_t i = 0; i < ret.datalen; i++) {
6167 ret.data[i] = Event_clone(&orig->data[i]);
6171 static inline uint32_t C2Tuple_u32TxOutZ_get_a(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner){
6174 int32_t __attribute__((export_name("TS_C2Tuple_u32TxOutZ_get_a"))) TS_C2Tuple_u32TxOutZ_get_a(uint64_t owner) {
6175 LDKC2Tuple_u32TxOutZ* owner_conv = (LDKC2Tuple_u32TxOutZ*)untag_ptr(owner);
6176 int32_t ret_conv = C2Tuple_u32TxOutZ_get_a(owner_conv);
6180 static inline struct LDKTxOut C2Tuple_u32TxOutZ_get_b(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner){
6181 return TxOut_clone(&owner->b);
6183 uint64_t __attribute__((export_name("TS_C2Tuple_u32TxOutZ_get_b"))) TS_C2Tuple_u32TxOutZ_get_b(uint64_t owner) {
6184 LDKC2Tuple_u32TxOutZ* owner_conv = (LDKC2Tuple_u32TxOutZ*)untag_ptr(owner);
6185 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
6186 *ret_ref = C2Tuple_u32TxOutZ_get_b(owner_conv);
6187 return tag_ptr(ret_ref, true);
6190 static inline LDKCVec_C2Tuple_u32TxOutZZ CVec_C2Tuple_u32TxOutZZ_clone(const LDKCVec_C2Tuple_u32TxOutZZ *orig) {
6191 LDKCVec_C2Tuple_u32TxOutZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ) * orig->datalen, "LDKCVec_C2Tuple_u32TxOutZZ clone bytes"), .datalen = orig->datalen };
6192 for (size_t i = 0; i < ret.datalen; i++) {
6193 ret.data[i] = C2Tuple_u32TxOutZ_clone(&orig->data[i]);
6197 static inline struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner){
6198 return ThirtyTwoBytes_clone(&owner->a);
6200 int8_tArray __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(uint64_t owner) {
6201 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* owner_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)untag_ptr(owner);
6202 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
6203 memcpy(ret_arr->elems, C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner_conv).data, 32);
6207 static inline struct LDKCVec_C2Tuple_u32TxOutZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner){
6208 return CVec_C2Tuple_u32TxOutZZ_clone(&owner->b);
6210 uint64_tArray __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(uint64_t owner) {
6211 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* owner_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)untag_ptr(owner);
6212 LDKCVec_C2Tuple_u32TxOutZZ ret_var = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner_conv);
6213 uint64_tArray ret_arr = NULL;
6214 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
6215 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
6216 for (size_t u = 0; u < ret_var.datalen; u++) {
6217 LDKC2Tuple_u32TxOutZ* ret_conv_20_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
6218 *ret_conv_20_conv = ret_var.data[u];
6219 ret_arr_ptr[u] = tag_ptr(ret_conv_20_conv, true);
6226 static inline LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_clone(const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ *orig) {
6227 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ) * orig->datalen, "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ clone bytes"), .datalen = orig->datalen };
6228 for (size_t i = 0; i < ret.datalen; i++) {
6229 ret.data[i] = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(&orig->data[i]);
6233 uint32_t __attribute__((export_name("TS_LDKBalance_ty_from_ptr"))) TS_LDKBalance_ty_from_ptr(uint64_t ptr) {
6234 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
6236 case LDKBalance_ClaimableOnChannelClose: return 0;
6237 case LDKBalance_ClaimableAwaitingConfirmations: return 1;
6238 case LDKBalance_ContentiousClaimable: return 2;
6239 case LDKBalance_MaybeTimeoutClaimableHTLC: return 3;
6240 case LDKBalance_MaybePreimageClaimableHTLC: return 4;
6241 case LDKBalance_CounterpartyRevokedOutputClaimable: return 5;
6245 int64_t __attribute__((export_name("TS_LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis"))) TS_LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(uint64_t ptr) {
6246 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
6247 assert(obj->tag == LDKBalance_ClaimableOnChannelClose);
6248 int64_t claimable_amount_satoshis_conv = obj->claimable_on_channel_close.claimable_amount_satoshis;
6249 return claimable_amount_satoshis_conv;
6251 int64_t __attribute__((export_name("TS_LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis"))) TS_LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(uint64_t ptr) {
6252 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
6253 assert(obj->tag == LDKBalance_ClaimableAwaitingConfirmations);
6254 int64_t claimable_amount_satoshis_conv = obj->claimable_awaiting_confirmations.claimable_amount_satoshis;
6255 return claimable_amount_satoshis_conv;
6257 int32_t __attribute__((export_name("TS_LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height"))) TS_LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(uint64_t ptr) {
6258 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
6259 assert(obj->tag == LDKBalance_ClaimableAwaitingConfirmations);
6260 int32_t confirmation_height_conv = obj->claimable_awaiting_confirmations.confirmation_height;
6261 return confirmation_height_conv;
6263 int64_t __attribute__((export_name("TS_LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis"))) TS_LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(uint64_t ptr) {
6264 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
6265 assert(obj->tag == LDKBalance_ContentiousClaimable);
6266 int64_t claimable_amount_satoshis_conv = obj->contentious_claimable.claimable_amount_satoshis;
6267 return claimable_amount_satoshis_conv;
6269 int32_t __attribute__((export_name("TS_LDKBalance_ContentiousClaimable_get_timeout_height"))) TS_LDKBalance_ContentiousClaimable_get_timeout_height(uint64_t ptr) {
6270 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
6271 assert(obj->tag == LDKBalance_ContentiousClaimable);
6272 int32_t timeout_height_conv = obj->contentious_claimable.timeout_height;
6273 return timeout_height_conv;
6275 int64_t __attribute__((export_name("TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_amount_satoshis"))) TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_amount_satoshis(uint64_t ptr) {
6276 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
6277 assert(obj->tag == LDKBalance_MaybeTimeoutClaimableHTLC);
6278 int64_t claimable_amount_satoshis_conv = obj->maybe_timeout_claimable_htlc.claimable_amount_satoshis;
6279 return claimable_amount_satoshis_conv;
6281 int32_t __attribute__((export_name("TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_height"))) TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_height(uint64_t ptr) {
6282 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
6283 assert(obj->tag == LDKBalance_MaybeTimeoutClaimableHTLC);
6284 int32_t claimable_height_conv = obj->maybe_timeout_claimable_htlc.claimable_height;
6285 return claimable_height_conv;
6287 int64_t __attribute__((export_name("TS_LDKBalance_MaybePreimageClaimableHTLC_get_claimable_amount_satoshis"))) TS_LDKBalance_MaybePreimageClaimableHTLC_get_claimable_amount_satoshis(uint64_t ptr) {
6288 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
6289 assert(obj->tag == LDKBalance_MaybePreimageClaimableHTLC);
6290 int64_t claimable_amount_satoshis_conv = obj->maybe_preimage_claimable_htlc.claimable_amount_satoshis;
6291 return claimable_amount_satoshis_conv;
6293 int32_t __attribute__((export_name("TS_LDKBalance_MaybePreimageClaimableHTLC_get_expiry_height"))) TS_LDKBalance_MaybePreimageClaimableHTLC_get_expiry_height(uint64_t ptr) {
6294 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
6295 assert(obj->tag == LDKBalance_MaybePreimageClaimableHTLC);
6296 int32_t expiry_height_conv = obj->maybe_preimage_claimable_htlc.expiry_height;
6297 return expiry_height_conv;
6299 int64_t __attribute__((export_name("TS_LDKBalance_CounterpartyRevokedOutputClaimable_get_claimable_amount_satoshis"))) TS_LDKBalance_CounterpartyRevokedOutputClaimable_get_claimable_amount_satoshis(uint64_t ptr) {
6300 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
6301 assert(obj->tag == LDKBalance_CounterpartyRevokedOutputClaimable);
6302 int64_t claimable_amount_satoshis_conv = obj->counterparty_revoked_output_claimable.claimable_amount_satoshis;
6303 return claimable_amount_satoshis_conv;
6305 static inline LDKCVec_BalanceZ CVec_BalanceZ_clone(const LDKCVec_BalanceZ *orig) {
6306 LDKCVec_BalanceZ ret = { .data = MALLOC(sizeof(LDKBalance) * orig->datalen, "LDKCVec_BalanceZ clone bytes"), .datalen = orig->datalen };
6307 for (size_t i = 0; i < ret.datalen; i++) {
6308 ret.data[i] = Balance_clone(&orig->data[i]);
6312 static inline struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelMonitorZ_get_a(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner){
6313 return ThirtyTwoBytes_clone(&owner->a);
6315 int8_tArray __attribute__((export_name("TS_C2Tuple_BlockHashChannelMonitorZ_get_a"))) TS_C2Tuple_BlockHashChannelMonitorZ_get_a(uint64_t owner) {
6316 LDKC2Tuple_BlockHashChannelMonitorZ* owner_conv = (LDKC2Tuple_BlockHashChannelMonitorZ*)untag_ptr(owner);
6317 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
6318 memcpy(ret_arr->elems, C2Tuple_BlockHashChannelMonitorZ_get_a(owner_conv).data, 32);
6322 static inline struct LDKChannelMonitor C2Tuple_BlockHashChannelMonitorZ_get_b(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner){
6323 LDKChannelMonitor ret = owner->b;
6324 ret.is_owned = false;
6327 uint64_t __attribute__((export_name("TS_C2Tuple_BlockHashChannelMonitorZ_get_b"))) TS_C2Tuple_BlockHashChannelMonitorZ_get_b(uint64_t owner) {
6328 LDKC2Tuple_BlockHashChannelMonitorZ* owner_conv = (LDKC2Tuple_BlockHashChannelMonitorZ*)untag_ptr(owner);
6329 LDKChannelMonitor ret_var = C2Tuple_BlockHashChannelMonitorZ_get_b(owner_conv);
6330 uint64_t ret_ref = 0;
6331 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6332 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6336 static inline struct LDKC2Tuple_BlockHashChannelMonitorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner){
6337 CHECK(owner->result_ok);
6338 return C2Tuple_BlockHashChannelMonitorZ_clone(&*owner->contents.result);
6340 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(uint64_t owner) {
6341 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* owner_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)untag_ptr(owner);
6342 LDKC2Tuple_BlockHashChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
6343 *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner_conv);
6344 return tag_ptr(ret_conv, true);
6347 static inline struct LDKDecodeError CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner){
6348 CHECK(!owner->result_ok);
6349 return DecodeError_clone(&*owner->contents.err);
6351 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(uint64_t owner) {
6352 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* owner_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)untag_ptr(owner);
6353 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
6354 *ret_copy = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner_conv);
6355 uint64_t ret_ref = tag_ptr(ret_copy, true);
6359 static inline struct LDKPublicKey C2Tuple_PublicKeyTypeZ_get_a(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner){
6362 int8_tArray __attribute__((export_name("TS_C2Tuple_PublicKeyTypeZ_get_a"))) TS_C2Tuple_PublicKeyTypeZ_get_a(uint64_t owner) {
6363 LDKC2Tuple_PublicKeyTypeZ* owner_conv = (LDKC2Tuple_PublicKeyTypeZ*)untag_ptr(owner);
6364 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
6365 memcpy(ret_arr->elems, C2Tuple_PublicKeyTypeZ_get_a(owner_conv).compressed_form, 33);
6369 static inline struct LDKType C2Tuple_PublicKeyTypeZ_get_b(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner){
6370 return Type_clone(&owner->b);
6372 uint64_t __attribute__((export_name("TS_C2Tuple_PublicKeyTypeZ_get_b"))) TS_C2Tuple_PublicKeyTypeZ_get_b(uint64_t owner) {
6373 LDKC2Tuple_PublicKeyTypeZ* owner_conv = (LDKC2Tuple_PublicKeyTypeZ*)untag_ptr(owner);
6374 LDKType* ret_ret = MALLOC(sizeof(LDKType), "LDKType");
6375 *ret_ret = C2Tuple_PublicKeyTypeZ_get_b(owner_conv);
6376 return tag_ptr(ret_ret, true);
6379 static inline LDKCVec_C2Tuple_PublicKeyTypeZZ CVec_C2Tuple_PublicKeyTypeZZ_clone(const LDKCVec_C2Tuple_PublicKeyTypeZZ *orig) {
6380 LDKCVec_C2Tuple_PublicKeyTypeZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ) * orig->datalen, "LDKCVec_C2Tuple_PublicKeyTypeZZ clone bytes"), .datalen = orig->datalen };
6381 for (size_t i = 0; i < ret.datalen; i++) {
6382 ret.data[i] = C2Tuple_PublicKeyTypeZ_clone(&orig->data[i]);
6386 typedef struct LDKCustomOnionMessageContents_JCalls {
6387 atomic_size_t refcnt;
6388 uint32_t instance_ptr;
6389 } LDKCustomOnionMessageContents_JCalls;
6390 static void LDKCustomOnionMessageContents_JCalls_free(void* this_arg) {
6391 LDKCustomOnionMessageContents_JCalls *j_calls = (LDKCustomOnionMessageContents_JCalls*) this_arg;
6392 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
6396 uint64_t tlv_type_LDKCustomOnionMessageContents_jcall(const void* this_arg) {
6397 LDKCustomOnionMessageContents_JCalls *j_calls = (LDKCustomOnionMessageContents_JCalls*) this_arg;
6398 return js_invoke_function_uuuuuu(j_calls->instance_ptr, 36, 0, 0, 0, 0, 0, 0);
6400 LDKCVec_u8Z write_LDKCustomOnionMessageContents_jcall(const void* this_arg) {
6401 LDKCustomOnionMessageContents_JCalls *j_calls = (LDKCustomOnionMessageContents_JCalls*) this_arg;
6402 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 37, 0, 0, 0, 0, 0, 0);
6403 LDKCVec_u8Z ret_ref;
6404 ret_ref.datalen = ret->arr_len;
6405 ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
6406 memcpy(ret_ref.data, ret->elems, ret_ref.datalen); FREE(ret);
6409 static void LDKCustomOnionMessageContents_JCalls_cloned(LDKCustomOnionMessageContents* new_obj) {
6410 LDKCustomOnionMessageContents_JCalls *j_calls = (LDKCustomOnionMessageContents_JCalls*) new_obj->this_arg;
6411 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
6413 static inline LDKCustomOnionMessageContents LDKCustomOnionMessageContents_init (JSValue o) {
6414 LDKCustomOnionMessageContents_JCalls *calls = MALLOC(sizeof(LDKCustomOnionMessageContents_JCalls), "LDKCustomOnionMessageContents_JCalls");
6415 atomic_init(&calls->refcnt, 1);
6416 calls->instance_ptr = o;
6418 LDKCustomOnionMessageContents ret = {
6419 .this_arg = (void*) calls,
6420 .tlv_type = tlv_type_LDKCustomOnionMessageContents_jcall,
6421 .write = write_LDKCustomOnionMessageContents_jcall,
6422 .cloned = LDKCustomOnionMessageContents_JCalls_cloned,
6423 .free = LDKCustomOnionMessageContents_JCalls_free,
6427 uint64_t __attribute__((export_name("TS_LDKCustomOnionMessageContents_new"))) TS_LDKCustomOnionMessageContents_new(JSValue o) {
6428 LDKCustomOnionMessageContents *res_ptr = MALLOC(sizeof(LDKCustomOnionMessageContents), "LDKCustomOnionMessageContents");
6429 *res_ptr = LDKCustomOnionMessageContents_init(o);
6430 return tag_ptr(res_ptr, true);
6432 int64_t __attribute__((export_name("TS_CustomOnionMessageContents_tlv_type"))) TS_CustomOnionMessageContents_tlv_type(uint64_t this_arg) {
6433 void* this_arg_ptr = untag_ptr(this_arg);
6434 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
6435 LDKCustomOnionMessageContents* this_arg_conv = (LDKCustomOnionMessageContents*)this_arg_ptr;
6436 int64_t ret_conv = (this_arg_conv->tlv_type)(this_arg_conv->this_arg);
6440 int8_tArray __attribute__((export_name("TS_CustomOnionMessageContents_write"))) TS_CustomOnionMessageContents_write(uint64_t this_arg) {
6441 void* this_arg_ptr = untag_ptr(this_arg);
6442 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
6443 LDKCustomOnionMessageContents* this_arg_conv = (LDKCustomOnionMessageContents*)this_arg_ptr;
6444 LDKCVec_u8Z ret_var = (this_arg_conv->write)(this_arg_conv->this_arg);
6445 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
6446 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
6447 CVec_u8Z_free(ret_var);
6451 uint32_t __attribute__((export_name("TS_LDKCOption_CustomOnionMessageContentsZ_ty_from_ptr"))) TS_LDKCOption_CustomOnionMessageContentsZ_ty_from_ptr(uint64_t ptr) {
6452 LDKCOption_CustomOnionMessageContentsZ *obj = (LDKCOption_CustomOnionMessageContentsZ*)untag_ptr(ptr);
6454 case LDKCOption_CustomOnionMessageContentsZ_Some: return 0;
6455 case LDKCOption_CustomOnionMessageContentsZ_None: return 1;
6459 uint64_t __attribute__((export_name("TS_LDKCOption_CustomOnionMessageContentsZ_Some_get_some"))) TS_LDKCOption_CustomOnionMessageContentsZ_Some_get_some(uint64_t ptr) {
6460 LDKCOption_CustomOnionMessageContentsZ *obj = (LDKCOption_CustomOnionMessageContentsZ*)untag_ptr(ptr);
6461 assert(obj->tag == LDKCOption_CustomOnionMessageContentsZ_Some);
6462 LDKCustomOnionMessageContents* some_ret = MALLOC(sizeof(LDKCustomOnionMessageContents), "LDKCustomOnionMessageContents");
6463 *some_ret = CustomOnionMessageContents_clone(&obj->some);
6464 return tag_ptr(some_ret, true);
6466 static inline struct LDKCOption_CustomOnionMessageContentsZ CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_ok(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR owner){
6467 CHECK(owner->result_ok);
6468 return COption_CustomOnionMessageContentsZ_clone(&*owner->contents.result);
6470 uint64_t __attribute__((export_name("TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_ok"))) TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_ok(uint64_t owner) {
6471 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* owner_conv = (LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ*)untag_ptr(owner);
6472 LDKCOption_CustomOnionMessageContentsZ *ret_copy = MALLOC(sizeof(LDKCOption_CustomOnionMessageContentsZ), "LDKCOption_CustomOnionMessageContentsZ");
6473 *ret_copy = CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_ok(owner_conv);
6474 uint64_t ret_ref = tag_ptr(ret_copy, true);
6478 static inline struct LDKDecodeError CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_err(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR owner){
6479 CHECK(!owner->result_ok);
6480 return DecodeError_clone(&*owner->contents.err);
6482 uint64_t __attribute__((export_name("TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_err"))) TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_err(uint64_t owner) {
6483 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* owner_conv = (LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ*)untag_ptr(owner);
6484 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
6485 *ret_copy = CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_err(owner_conv);
6486 uint64_t ret_ref = tag_ptr(ret_copy, true);
6490 uint32_t __attribute__((export_name("TS_LDKCOption_NetAddressZ_ty_from_ptr"))) TS_LDKCOption_NetAddressZ_ty_from_ptr(uint64_t ptr) {
6491 LDKCOption_NetAddressZ *obj = (LDKCOption_NetAddressZ*)untag_ptr(ptr);
6493 case LDKCOption_NetAddressZ_Some: return 0;
6494 case LDKCOption_NetAddressZ_None: return 1;
6498 uint64_t __attribute__((export_name("TS_LDKCOption_NetAddressZ_Some_get_some"))) TS_LDKCOption_NetAddressZ_Some_get_some(uint64_t ptr) {
6499 LDKCOption_NetAddressZ *obj = (LDKCOption_NetAddressZ*)untag_ptr(ptr);
6500 assert(obj->tag == LDKCOption_NetAddressZ_Some);
6501 uint64_t some_ref = tag_ptr(&obj->some, false);
6504 static inline struct LDKCVec_u8Z CResult_CVec_u8ZPeerHandleErrorZ_get_ok(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner){
6505 CHECK(owner->result_ok);
6506 return CVec_u8Z_clone(&*owner->contents.result);
6508 int8_tArray __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_get_ok"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_get_ok(uint64_t owner) {
6509 LDKCResult_CVec_u8ZPeerHandleErrorZ* owner_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)untag_ptr(owner);
6510 LDKCVec_u8Z ret_var = CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner_conv);
6511 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
6512 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
6513 CVec_u8Z_free(ret_var);
6517 static inline struct LDKPeerHandleError CResult_CVec_u8ZPeerHandleErrorZ_get_err(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner){
6518 LDKPeerHandleError ret = *owner->contents.err;
6519 ret.is_owned = false;
6522 uint64_t __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_get_err"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_get_err(uint64_t owner) {
6523 LDKCResult_CVec_u8ZPeerHandleErrorZ* owner_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)untag_ptr(owner);
6524 LDKPeerHandleError ret_var = CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner_conv);
6525 uint64_t ret_ref = 0;
6526 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6527 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6531 static inline void CResult_NonePeerHandleErrorZ_get_ok(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner){
6532 CHECK(owner->result_ok);
6533 return *owner->contents.result;
6535 void __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_get_ok"))) TS_CResult_NonePeerHandleErrorZ_get_ok(uint64_t owner) {
6536 LDKCResult_NonePeerHandleErrorZ* owner_conv = (LDKCResult_NonePeerHandleErrorZ*)untag_ptr(owner);
6537 CResult_NonePeerHandleErrorZ_get_ok(owner_conv);
6540 static inline struct LDKPeerHandleError CResult_NonePeerHandleErrorZ_get_err(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner){
6541 LDKPeerHandleError ret = *owner->contents.err;
6542 ret.is_owned = false;
6545 uint64_t __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_get_err"))) TS_CResult_NonePeerHandleErrorZ_get_err(uint64_t owner) {
6546 LDKCResult_NonePeerHandleErrorZ* owner_conv = (LDKCResult_NonePeerHandleErrorZ*)untag_ptr(owner);
6547 LDKPeerHandleError ret_var = CResult_NonePeerHandleErrorZ_get_err(owner_conv);
6548 uint64_t ret_ref = 0;
6549 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6550 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6554 static inline bool CResult_boolPeerHandleErrorZ_get_ok(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner){
6555 CHECK(owner->result_ok);
6556 return *owner->contents.result;
6558 jboolean __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_get_ok"))) TS_CResult_boolPeerHandleErrorZ_get_ok(uint64_t owner) {
6559 LDKCResult_boolPeerHandleErrorZ* owner_conv = (LDKCResult_boolPeerHandleErrorZ*)untag_ptr(owner);
6560 jboolean ret_conv = CResult_boolPeerHandleErrorZ_get_ok(owner_conv);
6564 static inline struct LDKPeerHandleError CResult_boolPeerHandleErrorZ_get_err(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner){
6565 LDKPeerHandleError ret = *owner->contents.err;
6566 ret.is_owned = false;
6569 uint64_t __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_get_err"))) TS_CResult_boolPeerHandleErrorZ_get_err(uint64_t owner) {
6570 LDKCResult_boolPeerHandleErrorZ* owner_conv = (LDKCResult_boolPeerHandleErrorZ*)untag_ptr(owner);
6571 LDKPeerHandleError ret_var = CResult_boolPeerHandleErrorZ_get_err(owner_conv);
6572 uint64_t ret_ref = 0;
6573 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6574 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6578 uint32_t __attribute__((export_name("TS_LDKSendError_ty_from_ptr"))) TS_LDKSendError_ty_from_ptr(uint64_t ptr) {
6579 LDKSendError *obj = (LDKSendError*)untag_ptr(ptr);
6581 case LDKSendError_Secp256k1: return 0;
6582 case LDKSendError_TooBigPacket: return 1;
6583 case LDKSendError_TooFewBlindedHops: return 2;
6584 case LDKSendError_InvalidFirstHop: return 3;
6585 case LDKSendError_InvalidMessage: return 4;
6586 case LDKSendError_BufferFull: return 5;
6587 case LDKSendError_GetNodeIdFailed: return 6;
6588 case LDKSendError_BlindedPathAdvanceFailed: return 7;
6592 uint32_t __attribute__((export_name("TS_LDKSendError_Secp256k1_get_secp256k1"))) TS_LDKSendError_Secp256k1_get_secp256k1(uint64_t ptr) {
6593 LDKSendError *obj = (LDKSendError*)untag_ptr(ptr);
6594 assert(obj->tag == LDKSendError_Secp256k1);
6595 uint32_t secp256k1_conv = LDKSecp256k1Error_to_js(obj->secp256k1);
6596 return secp256k1_conv;
6598 static inline void CResult_NoneSendErrorZ_get_ok(LDKCResult_NoneSendErrorZ *NONNULL_PTR owner){
6599 CHECK(owner->result_ok);
6600 return *owner->contents.result;
6602 void __attribute__((export_name("TS_CResult_NoneSendErrorZ_get_ok"))) TS_CResult_NoneSendErrorZ_get_ok(uint64_t owner) {
6603 LDKCResult_NoneSendErrorZ* owner_conv = (LDKCResult_NoneSendErrorZ*)untag_ptr(owner);
6604 CResult_NoneSendErrorZ_get_ok(owner_conv);
6607 static inline struct LDKSendError CResult_NoneSendErrorZ_get_err(LDKCResult_NoneSendErrorZ *NONNULL_PTR owner){
6608 CHECK(!owner->result_ok);
6609 return SendError_clone(&*owner->contents.err);
6611 uint64_t __attribute__((export_name("TS_CResult_NoneSendErrorZ_get_err"))) TS_CResult_NoneSendErrorZ_get_err(uint64_t owner) {
6612 LDKCResult_NoneSendErrorZ* owner_conv = (LDKCResult_NoneSendErrorZ*)untag_ptr(owner);
6613 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
6614 *ret_copy = CResult_NoneSendErrorZ_get_err(owner_conv);
6615 uint64_t ret_ref = tag_ptr(ret_copy, true);
6619 uint32_t __attribute__((export_name("TS_LDKGraphSyncError_ty_from_ptr"))) TS_LDKGraphSyncError_ty_from_ptr(uint64_t ptr) {
6620 LDKGraphSyncError *obj = (LDKGraphSyncError*)untag_ptr(ptr);
6622 case LDKGraphSyncError_DecodeError: return 0;
6623 case LDKGraphSyncError_LightningError: return 1;
6627 uint64_t __attribute__((export_name("TS_LDKGraphSyncError_DecodeError_get_decode_error"))) TS_LDKGraphSyncError_DecodeError_get_decode_error(uint64_t ptr) {
6628 LDKGraphSyncError *obj = (LDKGraphSyncError*)untag_ptr(ptr);
6629 assert(obj->tag == LDKGraphSyncError_DecodeError);
6630 uint64_t decode_error_ref = tag_ptr(&obj->decode_error, false);
6631 return decode_error_ref;
6633 uint64_t __attribute__((export_name("TS_LDKGraphSyncError_LightningError_get_lightning_error"))) TS_LDKGraphSyncError_LightningError_get_lightning_error(uint64_t ptr) {
6634 LDKGraphSyncError *obj = (LDKGraphSyncError*)untag_ptr(ptr);
6635 assert(obj->tag == LDKGraphSyncError_LightningError);
6636 LDKLightningError lightning_error_var = obj->lightning_error;
6637 uint64_t lightning_error_ref = 0;
6638 CHECK_INNER_FIELD_ACCESS_OR_NULL(lightning_error_var);
6639 lightning_error_ref = tag_ptr(lightning_error_var.inner, false);
6640 return lightning_error_ref;
6642 static inline uint32_t CResult_u32GraphSyncErrorZ_get_ok(LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR owner){
6643 CHECK(owner->result_ok);
6644 return *owner->contents.result;
6646 int32_t __attribute__((export_name("TS_CResult_u32GraphSyncErrorZ_get_ok"))) TS_CResult_u32GraphSyncErrorZ_get_ok(uint64_t owner) {
6647 LDKCResult_u32GraphSyncErrorZ* owner_conv = (LDKCResult_u32GraphSyncErrorZ*)untag_ptr(owner);
6648 int32_t ret_conv = CResult_u32GraphSyncErrorZ_get_ok(owner_conv);
6652 static inline struct LDKGraphSyncError CResult_u32GraphSyncErrorZ_get_err(LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR owner){
6653 CHECK(!owner->result_ok);
6654 return GraphSyncError_clone(&*owner->contents.err);
6656 uint64_t __attribute__((export_name("TS_CResult_u32GraphSyncErrorZ_get_err"))) TS_CResult_u32GraphSyncErrorZ_get_err(uint64_t owner) {
6657 LDKCResult_u32GraphSyncErrorZ* owner_conv = (LDKCResult_u32GraphSyncErrorZ*)untag_ptr(owner);
6658 LDKGraphSyncError *ret_copy = MALLOC(sizeof(LDKGraphSyncError), "LDKGraphSyncError");
6659 *ret_copy = CResult_u32GraphSyncErrorZ_get_err(owner_conv);
6660 uint64_t ret_ref = tag_ptr(ret_copy, true);
6664 uint32_t __attribute__((export_name("TS_LDKParseError_ty_from_ptr"))) TS_LDKParseError_ty_from_ptr(uint64_t ptr) {
6665 LDKParseError *obj = (LDKParseError*)untag_ptr(ptr);
6667 case LDKParseError_Bech32Error: return 0;
6668 case LDKParseError_ParseAmountError: return 1;
6669 case LDKParseError_MalformedSignature: return 2;
6670 case LDKParseError_BadPrefix: return 3;
6671 case LDKParseError_UnknownCurrency: return 4;
6672 case LDKParseError_UnknownSiPrefix: return 5;
6673 case LDKParseError_MalformedHRP: return 6;
6674 case LDKParseError_TooShortDataPart: return 7;
6675 case LDKParseError_UnexpectedEndOfTaggedFields: return 8;
6676 case LDKParseError_DescriptionDecodeError: return 9;
6677 case LDKParseError_PaddingError: return 10;
6678 case LDKParseError_IntegerOverflowError: return 11;
6679 case LDKParseError_InvalidSegWitProgramLength: return 12;
6680 case LDKParseError_InvalidPubKeyHashLength: return 13;
6681 case LDKParseError_InvalidScriptHashLength: return 14;
6682 case LDKParseError_InvalidRecoveryId: return 15;
6683 case LDKParseError_InvalidSliceLength: return 16;
6684 case LDKParseError_Skip: return 17;
6688 uint64_t __attribute__((export_name("TS_LDKParseError_Bech32Error_get_bech32_error"))) TS_LDKParseError_Bech32Error_get_bech32_error(uint64_t ptr) {
6689 LDKParseError *obj = (LDKParseError*)untag_ptr(ptr);
6690 assert(obj->tag == LDKParseError_Bech32Error);
6691 uint64_t bech32_error_ref = tag_ptr(&obj->bech32_error, false);
6692 return bech32_error_ref;
6694 int32_t __attribute__((export_name("TS_LDKParseError_ParseAmountError_get_parse_amount_error"))) TS_LDKParseError_ParseAmountError_get_parse_amount_error(uint64_t ptr) {
6695 LDKParseError *obj = (LDKParseError*)untag_ptr(ptr);
6696 assert(obj->tag == LDKParseError_ParseAmountError);
6697 /*obj->parse_amount_error*/
6700 uint32_t __attribute__((export_name("TS_LDKParseError_MalformedSignature_get_malformed_signature"))) TS_LDKParseError_MalformedSignature_get_malformed_signature(uint64_t ptr) {
6701 LDKParseError *obj = (LDKParseError*)untag_ptr(ptr);
6702 assert(obj->tag == LDKParseError_MalformedSignature);
6703 uint32_t malformed_signature_conv = LDKSecp256k1Error_to_js(obj->malformed_signature);
6704 return malformed_signature_conv;
6706 int32_t __attribute__((export_name("TS_LDKParseError_DescriptionDecodeError_get_description_decode_error"))) TS_LDKParseError_DescriptionDecodeError_get_description_decode_error(uint64_t ptr) {
6707 LDKParseError *obj = (LDKParseError*)untag_ptr(ptr);
6708 assert(obj->tag == LDKParseError_DescriptionDecodeError);
6709 /*obj->description_decode_error*/
6712 jstring __attribute__((export_name("TS_LDKParseError_InvalidSliceLength_get_invalid_slice_length"))) TS_LDKParseError_InvalidSliceLength_get_invalid_slice_length(uint64_t ptr) {
6713 LDKParseError *obj = (LDKParseError*)untag_ptr(ptr);
6714 assert(obj->tag == LDKParseError_InvalidSliceLength);
6715 LDKStr invalid_slice_length_str = obj->invalid_slice_length;
6716 jstring invalid_slice_length_conv = str_ref_to_ts(invalid_slice_length_str.chars, invalid_slice_length_str.len);
6717 return invalid_slice_length_conv;
6719 static inline enum LDKSiPrefix CResult_SiPrefixParseErrorZ_get_ok(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner){
6720 CHECK(owner->result_ok);
6721 return SiPrefix_clone(&*owner->contents.result);
6723 uint32_t __attribute__((export_name("TS_CResult_SiPrefixParseErrorZ_get_ok"))) TS_CResult_SiPrefixParseErrorZ_get_ok(uint64_t owner) {
6724 LDKCResult_SiPrefixParseErrorZ* owner_conv = (LDKCResult_SiPrefixParseErrorZ*)untag_ptr(owner);
6725 uint32_t ret_conv = LDKSiPrefix_to_js(CResult_SiPrefixParseErrorZ_get_ok(owner_conv));
6729 static inline struct LDKParseError CResult_SiPrefixParseErrorZ_get_err(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner){
6730 CHECK(!owner->result_ok);
6731 return ParseError_clone(&*owner->contents.err);
6733 uint64_t __attribute__((export_name("TS_CResult_SiPrefixParseErrorZ_get_err"))) TS_CResult_SiPrefixParseErrorZ_get_err(uint64_t owner) {
6734 LDKCResult_SiPrefixParseErrorZ* owner_conv = (LDKCResult_SiPrefixParseErrorZ*)untag_ptr(owner);
6735 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
6736 *ret_copy = CResult_SiPrefixParseErrorZ_get_err(owner_conv);
6737 uint64_t ret_ref = tag_ptr(ret_copy, true);
6741 uint32_t __attribute__((export_name("TS_LDKParseOrSemanticError_ty_from_ptr"))) TS_LDKParseOrSemanticError_ty_from_ptr(uint64_t ptr) {
6742 LDKParseOrSemanticError *obj = (LDKParseOrSemanticError*)untag_ptr(ptr);
6744 case LDKParseOrSemanticError_ParseError: return 0;
6745 case LDKParseOrSemanticError_SemanticError: return 1;
6749 uint64_t __attribute__((export_name("TS_LDKParseOrSemanticError_ParseError_get_parse_error"))) TS_LDKParseOrSemanticError_ParseError_get_parse_error(uint64_t ptr) {
6750 LDKParseOrSemanticError *obj = (LDKParseOrSemanticError*)untag_ptr(ptr);
6751 assert(obj->tag == LDKParseOrSemanticError_ParseError);
6752 uint64_t parse_error_ref = tag_ptr(&obj->parse_error, false);
6753 return parse_error_ref;
6755 uint32_t __attribute__((export_name("TS_LDKParseOrSemanticError_SemanticError_get_semantic_error"))) TS_LDKParseOrSemanticError_SemanticError_get_semantic_error(uint64_t ptr) {
6756 LDKParseOrSemanticError *obj = (LDKParseOrSemanticError*)untag_ptr(ptr);
6757 assert(obj->tag == LDKParseOrSemanticError_SemanticError);
6758 uint32_t semantic_error_conv = LDKSemanticError_to_js(obj->semantic_error);
6759 return semantic_error_conv;
6761 static inline struct LDKInvoice CResult_InvoiceParseOrSemanticErrorZ_get_ok(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner){
6762 LDKInvoice ret = *owner->contents.result;
6763 ret.is_owned = false;
6766 uint64_t __attribute__((export_name("TS_CResult_InvoiceParseOrSemanticErrorZ_get_ok"))) TS_CResult_InvoiceParseOrSemanticErrorZ_get_ok(uint64_t owner) {
6767 LDKCResult_InvoiceParseOrSemanticErrorZ* owner_conv = (LDKCResult_InvoiceParseOrSemanticErrorZ*)untag_ptr(owner);
6768 LDKInvoice ret_var = CResult_InvoiceParseOrSemanticErrorZ_get_ok(owner_conv);
6769 uint64_t ret_ref = 0;
6770 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6771 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6775 static inline struct LDKParseOrSemanticError CResult_InvoiceParseOrSemanticErrorZ_get_err(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner){
6776 CHECK(!owner->result_ok);
6777 return ParseOrSemanticError_clone(&*owner->contents.err);
6779 uint64_t __attribute__((export_name("TS_CResult_InvoiceParseOrSemanticErrorZ_get_err"))) TS_CResult_InvoiceParseOrSemanticErrorZ_get_err(uint64_t owner) {
6780 LDKCResult_InvoiceParseOrSemanticErrorZ* owner_conv = (LDKCResult_InvoiceParseOrSemanticErrorZ*)untag_ptr(owner);
6781 LDKParseOrSemanticError *ret_copy = MALLOC(sizeof(LDKParseOrSemanticError), "LDKParseOrSemanticError");
6782 *ret_copy = CResult_InvoiceParseOrSemanticErrorZ_get_err(owner_conv);
6783 uint64_t ret_ref = tag_ptr(ret_copy, true);
6787 static inline struct LDKSignedRawInvoice CResult_SignedRawInvoiceParseErrorZ_get_ok(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner){
6788 LDKSignedRawInvoice ret = *owner->contents.result;
6789 ret.is_owned = false;
6792 uint64_t __attribute__((export_name("TS_CResult_SignedRawInvoiceParseErrorZ_get_ok"))) TS_CResult_SignedRawInvoiceParseErrorZ_get_ok(uint64_t owner) {
6793 LDKCResult_SignedRawInvoiceParseErrorZ* owner_conv = (LDKCResult_SignedRawInvoiceParseErrorZ*)untag_ptr(owner);
6794 LDKSignedRawInvoice ret_var = CResult_SignedRawInvoiceParseErrorZ_get_ok(owner_conv);
6795 uint64_t ret_ref = 0;
6796 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6797 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6801 static inline struct LDKParseError CResult_SignedRawInvoiceParseErrorZ_get_err(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner){
6802 CHECK(!owner->result_ok);
6803 return ParseError_clone(&*owner->contents.err);
6805 uint64_t __attribute__((export_name("TS_CResult_SignedRawInvoiceParseErrorZ_get_err"))) TS_CResult_SignedRawInvoiceParseErrorZ_get_err(uint64_t owner) {
6806 LDKCResult_SignedRawInvoiceParseErrorZ* owner_conv = (LDKCResult_SignedRawInvoiceParseErrorZ*)untag_ptr(owner);
6807 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
6808 *ret_copy = CResult_SignedRawInvoiceParseErrorZ_get_err(owner_conv);
6809 uint64_t ret_ref = tag_ptr(ret_copy, true);
6813 static inline struct LDKRawInvoice C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner){
6814 LDKRawInvoice ret = owner->a;
6815 ret.is_owned = false;
6818 uint64_t __attribute__((export_name("TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(uint64_t owner) {
6819 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* owner_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)untag_ptr(owner);
6820 LDKRawInvoice ret_var = C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner_conv);
6821 uint64_t ret_ref = 0;
6822 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6823 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6827 static inline struct LDKThirtyTwoBytes C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner){
6828 return ThirtyTwoBytes_clone(&owner->b);
6830 int8_tArray __attribute__((export_name("TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(uint64_t owner) {
6831 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* owner_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)untag_ptr(owner);
6832 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
6833 memcpy(ret_arr->elems, C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner_conv).data, 32);
6837 static inline struct LDKInvoiceSignature C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner){
6838 LDKInvoiceSignature ret = owner->c;
6839 ret.is_owned = false;
6842 uint64_t __attribute__((export_name("TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(uint64_t owner) {
6843 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* owner_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)untag_ptr(owner);
6844 LDKInvoiceSignature ret_var = C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner_conv);
6845 uint64_t ret_ref = 0;
6846 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6847 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6851 static inline struct LDKPayeePubKey CResult_PayeePubKeyErrorZ_get_ok(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner){
6852 LDKPayeePubKey ret = *owner->contents.result;
6853 ret.is_owned = false;
6856 uint64_t __attribute__((export_name("TS_CResult_PayeePubKeyErrorZ_get_ok"))) TS_CResult_PayeePubKeyErrorZ_get_ok(uint64_t owner) {
6857 LDKCResult_PayeePubKeyErrorZ* owner_conv = (LDKCResult_PayeePubKeyErrorZ*)untag_ptr(owner);
6858 LDKPayeePubKey ret_var = CResult_PayeePubKeyErrorZ_get_ok(owner_conv);
6859 uint64_t ret_ref = 0;
6860 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6861 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6865 static inline enum LDKSecp256k1Error CResult_PayeePubKeyErrorZ_get_err(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner){
6866 CHECK(!owner->result_ok);
6867 return *owner->contents.err;
6869 uint32_t __attribute__((export_name("TS_CResult_PayeePubKeyErrorZ_get_err"))) TS_CResult_PayeePubKeyErrorZ_get_err(uint64_t owner) {
6870 LDKCResult_PayeePubKeyErrorZ* owner_conv = (LDKCResult_PayeePubKeyErrorZ*)untag_ptr(owner);
6871 uint32_t ret_conv = LDKSecp256k1Error_to_js(CResult_PayeePubKeyErrorZ_get_err(owner_conv));
6875 static inline LDKCVec_PrivateRouteZ CVec_PrivateRouteZ_clone(const LDKCVec_PrivateRouteZ *orig) {
6876 LDKCVec_PrivateRouteZ ret = { .data = MALLOC(sizeof(LDKPrivateRoute) * orig->datalen, "LDKCVec_PrivateRouteZ clone bytes"), .datalen = orig->datalen };
6877 for (size_t i = 0; i < ret.datalen; i++) {
6878 ret.data[i] = PrivateRoute_clone(&orig->data[i]);
6882 static inline struct LDKPositiveTimestamp CResult_PositiveTimestampCreationErrorZ_get_ok(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner){
6883 LDKPositiveTimestamp ret = *owner->contents.result;
6884 ret.is_owned = false;
6887 uint64_t __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_get_ok"))) TS_CResult_PositiveTimestampCreationErrorZ_get_ok(uint64_t owner) {
6888 LDKCResult_PositiveTimestampCreationErrorZ* owner_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)untag_ptr(owner);
6889 LDKPositiveTimestamp ret_var = CResult_PositiveTimestampCreationErrorZ_get_ok(owner_conv);
6890 uint64_t ret_ref = 0;
6891 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6892 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6896 static inline enum LDKCreationError CResult_PositiveTimestampCreationErrorZ_get_err(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner){
6897 CHECK(!owner->result_ok);
6898 return CreationError_clone(&*owner->contents.err);
6900 uint32_t __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_get_err"))) TS_CResult_PositiveTimestampCreationErrorZ_get_err(uint64_t owner) {
6901 LDKCResult_PositiveTimestampCreationErrorZ* owner_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)untag_ptr(owner);
6902 uint32_t ret_conv = LDKCreationError_to_js(CResult_PositiveTimestampCreationErrorZ_get_err(owner_conv));
6906 static inline void CResult_NoneSemanticErrorZ_get_ok(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner){
6907 CHECK(owner->result_ok);
6908 return *owner->contents.result;
6910 void __attribute__((export_name("TS_CResult_NoneSemanticErrorZ_get_ok"))) TS_CResult_NoneSemanticErrorZ_get_ok(uint64_t owner) {
6911 LDKCResult_NoneSemanticErrorZ* owner_conv = (LDKCResult_NoneSemanticErrorZ*)untag_ptr(owner);
6912 CResult_NoneSemanticErrorZ_get_ok(owner_conv);
6915 static inline enum LDKSemanticError CResult_NoneSemanticErrorZ_get_err(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner){
6916 CHECK(!owner->result_ok);
6917 return SemanticError_clone(&*owner->contents.err);
6919 uint32_t __attribute__((export_name("TS_CResult_NoneSemanticErrorZ_get_err"))) TS_CResult_NoneSemanticErrorZ_get_err(uint64_t owner) {
6920 LDKCResult_NoneSemanticErrorZ* owner_conv = (LDKCResult_NoneSemanticErrorZ*)untag_ptr(owner);
6921 uint32_t ret_conv = LDKSemanticError_to_js(CResult_NoneSemanticErrorZ_get_err(owner_conv));
6925 static inline struct LDKInvoice CResult_InvoiceSemanticErrorZ_get_ok(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner){
6926 LDKInvoice ret = *owner->contents.result;
6927 ret.is_owned = false;
6930 uint64_t __attribute__((export_name("TS_CResult_InvoiceSemanticErrorZ_get_ok"))) TS_CResult_InvoiceSemanticErrorZ_get_ok(uint64_t owner) {
6931 LDKCResult_InvoiceSemanticErrorZ* owner_conv = (LDKCResult_InvoiceSemanticErrorZ*)untag_ptr(owner);
6932 LDKInvoice ret_var = CResult_InvoiceSemanticErrorZ_get_ok(owner_conv);
6933 uint64_t ret_ref = 0;
6934 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6935 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6939 static inline enum LDKSemanticError CResult_InvoiceSemanticErrorZ_get_err(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner){
6940 CHECK(!owner->result_ok);
6941 return SemanticError_clone(&*owner->contents.err);
6943 uint32_t __attribute__((export_name("TS_CResult_InvoiceSemanticErrorZ_get_err"))) TS_CResult_InvoiceSemanticErrorZ_get_err(uint64_t owner) {
6944 LDKCResult_InvoiceSemanticErrorZ* owner_conv = (LDKCResult_InvoiceSemanticErrorZ*)untag_ptr(owner);
6945 uint32_t ret_conv = LDKSemanticError_to_js(CResult_InvoiceSemanticErrorZ_get_err(owner_conv));
6949 static inline struct LDKDescription CResult_DescriptionCreationErrorZ_get_ok(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner){
6950 LDKDescription ret = *owner->contents.result;
6951 ret.is_owned = false;
6954 uint64_t __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_get_ok"))) TS_CResult_DescriptionCreationErrorZ_get_ok(uint64_t owner) {
6955 LDKCResult_DescriptionCreationErrorZ* owner_conv = (LDKCResult_DescriptionCreationErrorZ*)untag_ptr(owner);
6956 LDKDescription ret_var = CResult_DescriptionCreationErrorZ_get_ok(owner_conv);
6957 uint64_t ret_ref = 0;
6958 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6959 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6963 static inline enum LDKCreationError CResult_DescriptionCreationErrorZ_get_err(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner){
6964 CHECK(!owner->result_ok);
6965 return CreationError_clone(&*owner->contents.err);
6967 uint32_t __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_get_err"))) TS_CResult_DescriptionCreationErrorZ_get_err(uint64_t owner) {
6968 LDKCResult_DescriptionCreationErrorZ* owner_conv = (LDKCResult_DescriptionCreationErrorZ*)untag_ptr(owner);
6969 uint32_t ret_conv = LDKCreationError_to_js(CResult_DescriptionCreationErrorZ_get_err(owner_conv));
6973 static inline struct LDKPrivateRoute CResult_PrivateRouteCreationErrorZ_get_ok(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner){
6974 LDKPrivateRoute ret = *owner->contents.result;
6975 ret.is_owned = false;
6978 uint64_t __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_get_ok"))) TS_CResult_PrivateRouteCreationErrorZ_get_ok(uint64_t owner) {
6979 LDKCResult_PrivateRouteCreationErrorZ* owner_conv = (LDKCResult_PrivateRouteCreationErrorZ*)untag_ptr(owner);
6980 LDKPrivateRoute ret_var = CResult_PrivateRouteCreationErrorZ_get_ok(owner_conv);
6981 uint64_t ret_ref = 0;
6982 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6983 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6987 static inline enum LDKCreationError CResult_PrivateRouteCreationErrorZ_get_err(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner){
6988 CHECK(!owner->result_ok);
6989 return CreationError_clone(&*owner->contents.err);
6991 uint32_t __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_get_err"))) TS_CResult_PrivateRouteCreationErrorZ_get_err(uint64_t owner) {
6992 LDKCResult_PrivateRouteCreationErrorZ* owner_conv = (LDKCResult_PrivateRouteCreationErrorZ*)untag_ptr(owner);
6993 uint32_t ret_conv = LDKCreationError_to_js(CResult_PrivateRouteCreationErrorZ_get_err(owner_conv));
6997 static inline void CResult_NoneErrorZ_get_ok(LDKCResult_NoneErrorZ *NONNULL_PTR owner){
6998 CHECK(owner->result_ok);
6999 return *owner->contents.result;
7001 void __attribute__((export_name("TS_CResult_NoneErrorZ_get_ok"))) TS_CResult_NoneErrorZ_get_ok(uint64_t owner) {
7002 LDKCResult_NoneErrorZ* owner_conv = (LDKCResult_NoneErrorZ*)untag_ptr(owner);
7003 CResult_NoneErrorZ_get_ok(owner_conv);
7006 static inline enum LDKIOError CResult_NoneErrorZ_get_err(LDKCResult_NoneErrorZ *NONNULL_PTR owner){
7007 CHECK(!owner->result_ok);
7008 return *owner->contents.err;
7010 uint32_t __attribute__((export_name("TS_CResult_NoneErrorZ_get_err"))) TS_CResult_NoneErrorZ_get_err(uint64_t owner) {
7011 LDKCResult_NoneErrorZ* owner_conv = (LDKCResult_NoneErrorZ*)untag_ptr(owner);
7012 uint32_t ret_conv = LDKIOError_to_js(CResult_NoneErrorZ_get_err(owner_conv));
7016 static inline struct LDKNetAddress CResult_NetAddressDecodeErrorZ_get_ok(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner){
7017 CHECK(owner->result_ok);
7018 return NetAddress_clone(&*owner->contents.result);
7020 uint64_t __attribute__((export_name("TS_CResult_NetAddressDecodeErrorZ_get_ok"))) TS_CResult_NetAddressDecodeErrorZ_get_ok(uint64_t owner) {
7021 LDKCResult_NetAddressDecodeErrorZ* owner_conv = (LDKCResult_NetAddressDecodeErrorZ*)untag_ptr(owner);
7022 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
7023 *ret_copy = CResult_NetAddressDecodeErrorZ_get_ok(owner_conv);
7024 uint64_t ret_ref = tag_ptr(ret_copy, true);
7028 static inline struct LDKDecodeError CResult_NetAddressDecodeErrorZ_get_err(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner){
7029 CHECK(!owner->result_ok);
7030 return DecodeError_clone(&*owner->contents.err);
7032 uint64_t __attribute__((export_name("TS_CResult_NetAddressDecodeErrorZ_get_err"))) TS_CResult_NetAddressDecodeErrorZ_get_err(uint64_t owner) {
7033 LDKCResult_NetAddressDecodeErrorZ* owner_conv = (LDKCResult_NetAddressDecodeErrorZ*)untag_ptr(owner);
7034 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7035 *ret_copy = CResult_NetAddressDecodeErrorZ_get_err(owner_conv);
7036 uint64_t ret_ref = tag_ptr(ret_copy, true);
7040 static inline LDKCVec_UpdateAddHTLCZ CVec_UpdateAddHTLCZ_clone(const LDKCVec_UpdateAddHTLCZ *orig) {
7041 LDKCVec_UpdateAddHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateAddHTLC) * orig->datalen, "LDKCVec_UpdateAddHTLCZ clone bytes"), .datalen = orig->datalen };
7042 for (size_t i = 0; i < ret.datalen; i++) {
7043 ret.data[i] = UpdateAddHTLC_clone(&orig->data[i]);
7047 static inline LDKCVec_UpdateFulfillHTLCZ CVec_UpdateFulfillHTLCZ_clone(const LDKCVec_UpdateFulfillHTLCZ *orig) {
7048 LDKCVec_UpdateFulfillHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFulfillHTLC) * orig->datalen, "LDKCVec_UpdateFulfillHTLCZ clone bytes"), .datalen = orig->datalen };
7049 for (size_t i = 0; i < ret.datalen; i++) {
7050 ret.data[i] = UpdateFulfillHTLC_clone(&orig->data[i]);
7054 static inline LDKCVec_UpdateFailHTLCZ CVec_UpdateFailHTLCZ_clone(const LDKCVec_UpdateFailHTLCZ *orig) {
7055 LDKCVec_UpdateFailHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFailHTLC) * orig->datalen, "LDKCVec_UpdateFailHTLCZ clone bytes"), .datalen = orig->datalen };
7056 for (size_t i = 0; i < ret.datalen; i++) {
7057 ret.data[i] = UpdateFailHTLC_clone(&orig->data[i]);
7061 static inline LDKCVec_UpdateFailMalformedHTLCZ CVec_UpdateFailMalformedHTLCZ_clone(const LDKCVec_UpdateFailMalformedHTLCZ *orig) {
7062 LDKCVec_UpdateFailMalformedHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFailMalformedHTLC) * orig->datalen, "LDKCVec_UpdateFailMalformedHTLCZ clone bytes"), .datalen = orig->datalen };
7063 for (size_t i = 0; i < ret.datalen; i++) {
7064 ret.data[i] = UpdateFailMalformedHTLC_clone(&orig->data[i]);
7068 static inline struct LDKAcceptChannel CResult_AcceptChannelDecodeErrorZ_get_ok(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner){
7069 LDKAcceptChannel ret = *owner->contents.result;
7070 ret.is_owned = false;
7073 uint64_t __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_get_ok"))) TS_CResult_AcceptChannelDecodeErrorZ_get_ok(uint64_t owner) {
7074 LDKCResult_AcceptChannelDecodeErrorZ* owner_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)untag_ptr(owner);
7075 LDKAcceptChannel ret_var = CResult_AcceptChannelDecodeErrorZ_get_ok(owner_conv);
7076 uint64_t ret_ref = 0;
7077 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7078 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7082 static inline struct LDKDecodeError CResult_AcceptChannelDecodeErrorZ_get_err(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner){
7083 CHECK(!owner->result_ok);
7084 return DecodeError_clone(&*owner->contents.err);
7086 uint64_t __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_get_err"))) TS_CResult_AcceptChannelDecodeErrorZ_get_err(uint64_t owner) {
7087 LDKCResult_AcceptChannelDecodeErrorZ* owner_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)untag_ptr(owner);
7088 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7089 *ret_copy = CResult_AcceptChannelDecodeErrorZ_get_err(owner_conv);
7090 uint64_t ret_ref = tag_ptr(ret_copy, true);
7094 static inline struct LDKAnnouncementSignatures CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner){
7095 LDKAnnouncementSignatures ret = *owner->contents.result;
7096 ret.is_owned = false;
7099 uint64_t __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_ok"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(uint64_t owner) {
7100 LDKCResult_AnnouncementSignaturesDecodeErrorZ* owner_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)untag_ptr(owner);
7101 LDKAnnouncementSignatures ret_var = CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner_conv);
7102 uint64_t ret_ref = 0;
7103 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7104 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7108 static inline struct LDKDecodeError CResult_AnnouncementSignaturesDecodeErrorZ_get_err(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner){
7109 CHECK(!owner->result_ok);
7110 return DecodeError_clone(&*owner->contents.err);
7112 uint64_t __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_err"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_err(uint64_t owner) {
7113 LDKCResult_AnnouncementSignaturesDecodeErrorZ* owner_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)untag_ptr(owner);
7114 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7115 *ret_copy = CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner_conv);
7116 uint64_t ret_ref = tag_ptr(ret_copy, true);
7120 static inline struct LDKChannelReestablish CResult_ChannelReestablishDecodeErrorZ_get_ok(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner){
7121 LDKChannelReestablish ret = *owner->contents.result;
7122 ret.is_owned = false;
7125 uint64_t __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_get_ok"))) TS_CResult_ChannelReestablishDecodeErrorZ_get_ok(uint64_t owner) {
7126 LDKCResult_ChannelReestablishDecodeErrorZ* owner_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)untag_ptr(owner);
7127 LDKChannelReestablish ret_var = CResult_ChannelReestablishDecodeErrorZ_get_ok(owner_conv);
7128 uint64_t ret_ref = 0;
7129 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7130 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7134 static inline struct LDKDecodeError CResult_ChannelReestablishDecodeErrorZ_get_err(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner){
7135 CHECK(!owner->result_ok);
7136 return DecodeError_clone(&*owner->contents.err);
7138 uint64_t __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_get_err"))) TS_CResult_ChannelReestablishDecodeErrorZ_get_err(uint64_t owner) {
7139 LDKCResult_ChannelReestablishDecodeErrorZ* owner_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)untag_ptr(owner);
7140 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7141 *ret_copy = CResult_ChannelReestablishDecodeErrorZ_get_err(owner_conv);
7142 uint64_t ret_ref = tag_ptr(ret_copy, true);
7146 static inline struct LDKClosingSigned CResult_ClosingSignedDecodeErrorZ_get_ok(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner){
7147 LDKClosingSigned ret = *owner->contents.result;
7148 ret.is_owned = false;
7151 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_get_ok"))) TS_CResult_ClosingSignedDecodeErrorZ_get_ok(uint64_t owner) {
7152 LDKCResult_ClosingSignedDecodeErrorZ* owner_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)untag_ptr(owner);
7153 LDKClosingSigned ret_var = CResult_ClosingSignedDecodeErrorZ_get_ok(owner_conv);
7154 uint64_t ret_ref = 0;
7155 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7156 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7160 static inline struct LDKDecodeError CResult_ClosingSignedDecodeErrorZ_get_err(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner){
7161 CHECK(!owner->result_ok);
7162 return DecodeError_clone(&*owner->contents.err);
7164 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_get_err"))) TS_CResult_ClosingSignedDecodeErrorZ_get_err(uint64_t owner) {
7165 LDKCResult_ClosingSignedDecodeErrorZ* owner_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)untag_ptr(owner);
7166 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7167 *ret_copy = CResult_ClosingSignedDecodeErrorZ_get_err(owner_conv);
7168 uint64_t ret_ref = tag_ptr(ret_copy, true);
7172 static inline struct LDKClosingSignedFeeRange CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner){
7173 LDKClosingSignedFeeRange ret = *owner->contents.result;
7174 ret.is_owned = false;
7177 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(uint64_t owner) {
7178 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* owner_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)untag_ptr(owner);
7179 LDKClosingSignedFeeRange ret_var = CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner_conv);
7180 uint64_t ret_ref = 0;
7181 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7182 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7186 static inline struct LDKDecodeError CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner){
7187 CHECK(!owner->result_ok);
7188 return DecodeError_clone(&*owner->contents.err);
7190 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(uint64_t owner) {
7191 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* owner_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)untag_ptr(owner);
7192 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7193 *ret_copy = CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner_conv);
7194 uint64_t ret_ref = tag_ptr(ret_copy, true);
7198 static inline struct LDKCommitmentSigned CResult_CommitmentSignedDecodeErrorZ_get_ok(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner){
7199 LDKCommitmentSigned ret = *owner->contents.result;
7200 ret.is_owned = false;
7203 uint64_t __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_get_ok"))) TS_CResult_CommitmentSignedDecodeErrorZ_get_ok(uint64_t owner) {
7204 LDKCResult_CommitmentSignedDecodeErrorZ* owner_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)untag_ptr(owner);
7205 LDKCommitmentSigned ret_var = CResult_CommitmentSignedDecodeErrorZ_get_ok(owner_conv);
7206 uint64_t ret_ref = 0;
7207 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7208 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7212 static inline struct LDKDecodeError CResult_CommitmentSignedDecodeErrorZ_get_err(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner){
7213 CHECK(!owner->result_ok);
7214 return DecodeError_clone(&*owner->contents.err);
7216 uint64_t __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_get_err"))) TS_CResult_CommitmentSignedDecodeErrorZ_get_err(uint64_t owner) {
7217 LDKCResult_CommitmentSignedDecodeErrorZ* owner_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)untag_ptr(owner);
7218 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7219 *ret_copy = CResult_CommitmentSignedDecodeErrorZ_get_err(owner_conv);
7220 uint64_t ret_ref = tag_ptr(ret_copy, true);
7224 static inline struct LDKFundingCreated CResult_FundingCreatedDecodeErrorZ_get_ok(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner){
7225 LDKFundingCreated ret = *owner->contents.result;
7226 ret.is_owned = false;
7229 uint64_t __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_get_ok"))) TS_CResult_FundingCreatedDecodeErrorZ_get_ok(uint64_t owner) {
7230 LDKCResult_FundingCreatedDecodeErrorZ* owner_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)untag_ptr(owner);
7231 LDKFundingCreated ret_var = CResult_FundingCreatedDecodeErrorZ_get_ok(owner_conv);
7232 uint64_t ret_ref = 0;
7233 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7234 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7238 static inline struct LDKDecodeError CResult_FundingCreatedDecodeErrorZ_get_err(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner){
7239 CHECK(!owner->result_ok);
7240 return DecodeError_clone(&*owner->contents.err);
7242 uint64_t __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_get_err"))) TS_CResult_FundingCreatedDecodeErrorZ_get_err(uint64_t owner) {
7243 LDKCResult_FundingCreatedDecodeErrorZ* owner_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)untag_ptr(owner);
7244 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7245 *ret_copy = CResult_FundingCreatedDecodeErrorZ_get_err(owner_conv);
7246 uint64_t ret_ref = tag_ptr(ret_copy, true);
7250 static inline struct LDKFundingSigned CResult_FundingSignedDecodeErrorZ_get_ok(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner){
7251 LDKFundingSigned ret = *owner->contents.result;
7252 ret.is_owned = false;
7255 uint64_t __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_get_ok"))) TS_CResult_FundingSignedDecodeErrorZ_get_ok(uint64_t owner) {
7256 LDKCResult_FundingSignedDecodeErrorZ* owner_conv = (LDKCResult_FundingSignedDecodeErrorZ*)untag_ptr(owner);
7257 LDKFundingSigned ret_var = CResult_FundingSignedDecodeErrorZ_get_ok(owner_conv);
7258 uint64_t ret_ref = 0;
7259 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7260 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7264 static inline struct LDKDecodeError CResult_FundingSignedDecodeErrorZ_get_err(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner){
7265 CHECK(!owner->result_ok);
7266 return DecodeError_clone(&*owner->contents.err);
7268 uint64_t __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_get_err"))) TS_CResult_FundingSignedDecodeErrorZ_get_err(uint64_t owner) {
7269 LDKCResult_FundingSignedDecodeErrorZ* owner_conv = (LDKCResult_FundingSignedDecodeErrorZ*)untag_ptr(owner);
7270 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7271 *ret_copy = CResult_FundingSignedDecodeErrorZ_get_err(owner_conv);
7272 uint64_t ret_ref = tag_ptr(ret_copy, true);
7276 static inline struct LDKChannelReady CResult_ChannelReadyDecodeErrorZ_get_ok(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner){
7277 LDKChannelReady ret = *owner->contents.result;
7278 ret.is_owned = false;
7281 uint64_t __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_get_ok"))) TS_CResult_ChannelReadyDecodeErrorZ_get_ok(uint64_t owner) {
7282 LDKCResult_ChannelReadyDecodeErrorZ* owner_conv = (LDKCResult_ChannelReadyDecodeErrorZ*)untag_ptr(owner);
7283 LDKChannelReady ret_var = CResult_ChannelReadyDecodeErrorZ_get_ok(owner_conv);
7284 uint64_t ret_ref = 0;
7285 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7286 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7290 static inline struct LDKDecodeError CResult_ChannelReadyDecodeErrorZ_get_err(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner){
7291 CHECK(!owner->result_ok);
7292 return DecodeError_clone(&*owner->contents.err);
7294 uint64_t __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_get_err"))) TS_CResult_ChannelReadyDecodeErrorZ_get_err(uint64_t owner) {
7295 LDKCResult_ChannelReadyDecodeErrorZ* owner_conv = (LDKCResult_ChannelReadyDecodeErrorZ*)untag_ptr(owner);
7296 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7297 *ret_copy = CResult_ChannelReadyDecodeErrorZ_get_err(owner_conv);
7298 uint64_t ret_ref = tag_ptr(ret_copy, true);
7302 static inline struct LDKInit CResult_InitDecodeErrorZ_get_ok(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner){
7303 LDKInit ret = *owner->contents.result;
7304 ret.is_owned = false;
7307 uint64_t __attribute__((export_name("TS_CResult_InitDecodeErrorZ_get_ok"))) TS_CResult_InitDecodeErrorZ_get_ok(uint64_t owner) {
7308 LDKCResult_InitDecodeErrorZ* owner_conv = (LDKCResult_InitDecodeErrorZ*)untag_ptr(owner);
7309 LDKInit ret_var = CResult_InitDecodeErrorZ_get_ok(owner_conv);
7310 uint64_t ret_ref = 0;
7311 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7312 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7316 static inline struct LDKDecodeError CResult_InitDecodeErrorZ_get_err(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner){
7317 CHECK(!owner->result_ok);
7318 return DecodeError_clone(&*owner->contents.err);
7320 uint64_t __attribute__((export_name("TS_CResult_InitDecodeErrorZ_get_err"))) TS_CResult_InitDecodeErrorZ_get_err(uint64_t owner) {
7321 LDKCResult_InitDecodeErrorZ* owner_conv = (LDKCResult_InitDecodeErrorZ*)untag_ptr(owner);
7322 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7323 *ret_copy = CResult_InitDecodeErrorZ_get_err(owner_conv);
7324 uint64_t ret_ref = tag_ptr(ret_copy, true);
7328 static inline struct LDKOpenChannel CResult_OpenChannelDecodeErrorZ_get_ok(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner){
7329 LDKOpenChannel ret = *owner->contents.result;
7330 ret.is_owned = false;
7333 uint64_t __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_get_ok"))) TS_CResult_OpenChannelDecodeErrorZ_get_ok(uint64_t owner) {
7334 LDKCResult_OpenChannelDecodeErrorZ* owner_conv = (LDKCResult_OpenChannelDecodeErrorZ*)untag_ptr(owner);
7335 LDKOpenChannel ret_var = CResult_OpenChannelDecodeErrorZ_get_ok(owner_conv);
7336 uint64_t ret_ref = 0;
7337 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7338 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7342 static inline struct LDKDecodeError CResult_OpenChannelDecodeErrorZ_get_err(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner){
7343 CHECK(!owner->result_ok);
7344 return DecodeError_clone(&*owner->contents.err);
7346 uint64_t __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_get_err"))) TS_CResult_OpenChannelDecodeErrorZ_get_err(uint64_t owner) {
7347 LDKCResult_OpenChannelDecodeErrorZ* owner_conv = (LDKCResult_OpenChannelDecodeErrorZ*)untag_ptr(owner);
7348 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7349 *ret_copy = CResult_OpenChannelDecodeErrorZ_get_err(owner_conv);
7350 uint64_t ret_ref = tag_ptr(ret_copy, true);
7354 static inline struct LDKRevokeAndACK CResult_RevokeAndACKDecodeErrorZ_get_ok(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner){
7355 LDKRevokeAndACK ret = *owner->contents.result;
7356 ret.is_owned = false;
7359 uint64_t __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_get_ok"))) TS_CResult_RevokeAndACKDecodeErrorZ_get_ok(uint64_t owner) {
7360 LDKCResult_RevokeAndACKDecodeErrorZ* owner_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)untag_ptr(owner);
7361 LDKRevokeAndACK ret_var = CResult_RevokeAndACKDecodeErrorZ_get_ok(owner_conv);
7362 uint64_t ret_ref = 0;
7363 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7364 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7368 static inline struct LDKDecodeError CResult_RevokeAndACKDecodeErrorZ_get_err(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner){
7369 CHECK(!owner->result_ok);
7370 return DecodeError_clone(&*owner->contents.err);
7372 uint64_t __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_get_err"))) TS_CResult_RevokeAndACKDecodeErrorZ_get_err(uint64_t owner) {
7373 LDKCResult_RevokeAndACKDecodeErrorZ* owner_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)untag_ptr(owner);
7374 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7375 *ret_copy = CResult_RevokeAndACKDecodeErrorZ_get_err(owner_conv);
7376 uint64_t ret_ref = tag_ptr(ret_copy, true);
7380 static inline struct LDKShutdown CResult_ShutdownDecodeErrorZ_get_ok(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner){
7381 LDKShutdown ret = *owner->contents.result;
7382 ret.is_owned = false;
7385 uint64_t __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_get_ok"))) TS_CResult_ShutdownDecodeErrorZ_get_ok(uint64_t owner) {
7386 LDKCResult_ShutdownDecodeErrorZ* owner_conv = (LDKCResult_ShutdownDecodeErrorZ*)untag_ptr(owner);
7387 LDKShutdown ret_var = CResult_ShutdownDecodeErrorZ_get_ok(owner_conv);
7388 uint64_t ret_ref = 0;
7389 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7390 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7394 static inline struct LDKDecodeError CResult_ShutdownDecodeErrorZ_get_err(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner){
7395 CHECK(!owner->result_ok);
7396 return DecodeError_clone(&*owner->contents.err);
7398 uint64_t __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_get_err"))) TS_CResult_ShutdownDecodeErrorZ_get_err(uint64_t owner) {
7399 LDKCResult_ShutdownDecodeErrorZ* owner_conv = (LDKCResult_ShutdownDecodeErrorZ*)untag_ptr(owner);
7400 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7401 *ret_copy = CResult_ShutdownDecodeErrorZ_get_err(owner_conv);
7402 uint64_t ret_ref = tag_ptr(ret_copy, true);
7406 static inline struct LDKUpdateFailHTLC CResult_UpdateFailHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner){
7407 LDKUpdateFailHTLC ret = *owner->contents.result;
7408 ret.is_owned = false;
7411 uint64_t __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_get_ok"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_get_ok(uint64_t owner) {
7412 LDKCResult_UpdateFailHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)untag_ptr(owner);
7413 LDKUpdateFailHTLC ret_var = CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner_conv);
7414 uint64_t ret_ref = 0;
7415 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7416 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7420 static inline struct LDKDecodeError CResult_UpdateFailHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner){
7421 CHECK(!owner->result_ok);
7422 return DecodeError_clone(&*owner->contents.err);
7424 uint64_t __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_get_err"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_get_err(uint64_t owner) {
7425 LDKCResult_UpdateFailHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)untag_ptr(owner);
7426 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7427 *ret_copy = CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner_conv);
7428 uint64_t ret_ref = tag_ptr(ret_copy, true);
7432 static inline struct LDKUpdateFailMalformedHTLC CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner){
7433 LDKUpdateFailMalformedHTLC ret = *owner->contents.result;
7434 ret.is_owned = false;
7437 uint64_t __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(uint64_t owner) {
7438 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)untag_ptr(owner);
7439 LDKUpdateFailMalformedHTLC ret_var = CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner_conv);
7440 uint64_t ret_ref = 0;
7441 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7442 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7446 static inline struct LDKDecodeError CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner){
7447 CHECK(!owner->result_ok);
7448 return DecodeError_clone(&*owner->contents.err);
7450 uint64_t __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(uint64_t owner) {
7451 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)untag_ptr(owner);
7452 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7453 *ret_copy = CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner_conv);
7454 uint64_t ret_ref = tag_ptr(ret_copy, true);
7458 static inline struct LDKUpdateFee CResult_UpdateFeeDecodeErrorZ_get_ok(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner){
7459 LDKUpdateFee ret = *owner->contents.result;
7460 ret.is_owned = false;
7463 uint64_t __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_get_ok"))) TS_CResult_UpdateFeeDecodeErrorZ_get_ok(uint64_t owner) {
7464 LDKCResult_UpdateFeeDecodeErrorZ* owner_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)untag_ptr(owner);
7465 LDKUpdateFee ret_var = CResult_UpdateFeeDecodeErrorZ_get_ok(owner_conv);
7466 uint64_t ret_ref = 0;
7467 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7468 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7472 static inline struct LDKDecodeError CResult_UpdateFeeDecodeErrorZ_get_err(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner){
7473 CHECK(!owner->result_ok);
7474 return DecodeError_clone(&*owner->contents.err);
7476 uint64_t __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_get_err"))) TS_CResult_UpdateFeeDecodeErrorZ_get_err(uint64_t owner) {
7477 LDKCResult_UpdateFeeDecodeErrorZ* owner_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)untag_ptr(owner);
7478 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7479 *ret_copy = CResult_UpdateFeeDecodeErrorZ_get_err(owner_conv);
7480 uint64_t ret_ref = tag_ptr(ret_copy, true);
7484 static inline struct LDKUpdateFulfillHTLC CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner){
7485 LDKUpdateFulfillHTLC ret = *owner->contents.result;
7486 ret.is_owned = false;
7489 uint64_t __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(uint64_t owner) {
7490 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)untag_ptr(owner);
7491 LDKUpdateFulfillHTLC ret_var = CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner_conv);
7492 uint64_t ret_ref = 0;
7493 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7494 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7498 static inline struct LDKDecodeError CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner){
7499 CHECK(!owner->result_ok);
7500 return DecodeError_clone(&*owner->contents.err);
7502 uint64_t __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_err"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(uint64_t owner) {
7503 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)untag_ptr(owner);
7504 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7505 *ret_copy = CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner_conv);
7506 uint64_t ret_ref = tag_ptr(ret_copy, true);
7510 static inline struct LDKUpdateAddHTLC CResult_UpdateAddHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner){
7511 LDKUpdateAddHTLC ret = *owner->contents.result;
7512 ret.is_owned = false;
7515 uint64_t __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_get_ok"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_get_ok(uint64_t owner) {
7516 LDKCResult_UpdateAddHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)untag_ptr(owner);
7517 LDKUpdateAddHTLC ret_var = CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner_conv);
7518 uint64_t ret_ref = 0;
7519 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7520 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7524 static inline struct LDKDecodeError CResult_UpdateAddHTLCDecodeErrorZ_get_err(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner){
7525 CHECK(!owner->result_ok);
7526 return DecodeError_clone(&*owner->contents.err);
7528 uint64_t __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_get_err"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_get_err(uint64_t owner) {
7529 LDKCResult_UpdateAddHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)untag_ptr(owner);
7530 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7531 *ret_copy = CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner_conv);
7532 uint64_t ret_ref = tag_ptr(ret_copy, true);
7536 static inline struct LDKOnionMessage CResult_OnionMessageDecodeErrorZ_get_ok(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR owner){
7537 LDKOnionMessage ret = *owner->contents.result;
7538 ret.is_owned = false;
7541 uint64_t __attribute__((export_name("TS_CResult_OnionMessageDecodeErrorZ_get_ok"))) TS_CResult_OnionMessageDecodeErrorZ_get_ok(uint64_t owner) {
7542 LDKCResult_OnionMessageDecodeErrorZ* owner_conv = (LDKCResult_OnionMessageDecodeErrorZ*)untag_ptr(owner);
7543 LDKOnionMessage ret_var = CResult_OnionMessageDecodeErrorZ_get_ok(owner_conv);
7544 uint64_t ret_ref = 0;
7545 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7546 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7550 static inline struct LDKDecodeError CResult_OnionMessageDecodeErrorZ_get_err(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR owner){
7551 CHECK(!owner->result_ok);
7552 return DecodeError_clone(&*owner->contents.err);
7554 uint64_t __attribute__((export_name("TS_CResult_OnionMessageDecodeErrorZ_get_err"))) TS_CResult_OnionMessageDecodeErrorZ_get_err(uint64_t owner) {
7555 LDKCResult_OnionMessageDecodeErrorZ* owner_conv = (LDKCResult_OnionMessageDecodeErrorZ*)untag_ptr(owner);
7556 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7557 *ret_copy = CResult_OnionMessageDecodeErrorZ_get_err(owner_conv);
7558 uint64_t ret_ref = tag_ptr(ret_copy, true);
7562 static inline struct LDKPing CResult_PingDecodeErrorZ_get_ok(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner){
7563 LDKPing ret = *owner->contents.result;
7564 ret.is_owned = false;
7567 uint64_t __attribute__((export_name("TS_CResult_PingDecodeErrorZ_get_ok"))) TS_CResult_PingDecodeErrorZ_get_ok(uint64_t owner) {
7568 LDKCResult_PingDecodeErrorZ* owner_conv = (LDKCResult_PingDecodeErrorZ*)untag_ptr(owner);
7569 LDKPing ret_var = CResult_PingDecodeErrorZ_get_ok(owner_conv);
7570 uint64_t ret_ref = 0;
7571 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7572 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7576 static inline struct LDKDecodeError CResult_PingDecodeErrorZ_get_err(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner){
7577 CHECK(!owner->result_ok);
7578 return DecodeError_clone(&*owner->contents.err);
7580 uint64_t __attribute__((export_name("TS_CResult_PingDecodeErrorZ_get_err"))) TS_CResult_PingDecodeErrorZ_get_err(uint64_t owner) {
7581 LDKCResult_PingDecodeErrorZ* owner_conv = (LDKCResult_PingDecodeErrorZ*)untag_ptr(owner);
7582 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7583 *ret_copy = CResult_PingDecodeErrorZ_get_err(owner_conv);
7584 uint64_t ret_ref = tag_ptr(ret_copy, true);
7588 static inline struct LDKPong CResult_PongDecodeErrorZ_get_ok(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner){
7589 LDKPong ret = *owner->contents.result;
7590 ret.is_owned = false;
7593 uint64_t __attribute__((export_name("TS_CResult_PongDecodeErrorZ_get_ok"))) TS_CResult_PongDecodeErrorZ_get_ok(uint64_t owner) {
7594 LDKCResult_PongDecodeErrorZ* owner_conv = (LDKCResult_PongDecodeErrorZ*)untag_ptr(owner);
7595 LDKPong ret_var = CResult_PongDecodeErrorZ_get_ok(owner_conv);
7596 uint64_t ret_ref = 0;
7597 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7598 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7602 static inline struct LDKDecodeError CResult_PongDecodeErrorZ_get_err(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner){
7603 CHECK(!owner->result_ok);
7604 return DecodeError_clone(&*owner->contents.err);
7606 uint64_t __attribute__((export_name("TS_CResult_PongDecodeErrorZ_get_err"))) TS_CResult_PongDecodeErrorZ_get_err(uint64_t owner) {
7607 LDKCResult_PongDecodeErrorZ* owner_conv = (LDKCResult_PongDecodeErrorZ*)untag_ptr(owner);
7608 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7609 *ret_copy = CResult_PongDecodeErrorZ_get_err(owner_conv);
7610 uint64_t ret_ref = tag_ptr(ret_copy, true);
7614 static inline struct LDKUnsignedChannelAnnouncement CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner){
7615 LDKUnsignedChannelAnnouncement ret = *owner->contents.result;
7616 ret.is_owned = false;
7619 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(uint64_t owner) {
7620 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)untag_ptr(owner);
7621 LDKUnsignedChannelAnnouncement ret_var = CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner_conv);
7622 uint64_t ret_ref = 0;
7623 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7624 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7628 static inline struct LDKDecodeError CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner){
7629 CHECK(!owner->result_ok);
7630 return DecodeError_clone(&*owner->contents.err);
7632 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(uint64_t owner) {
7633 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)untag_ptr(owner);
7634 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7635 *ret_copy = CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner_conv);
7636 uint64_t ret_ref = tag_ptr(ret_copy, true);
7640 static inline struct LDKChannelAnnouncement CResult_ChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner){
7641 LDKChannelAnnouncement ret = *owner->contents.result;
7642 ret.is_owned = false;
7645 uint64_t __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_get_ok"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_get_ok(uint64_t owner) {
7646 LDKCResult_ChannelAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)untag_ptr(owner);
7647 LDKChannelAnnouncement ret_var = CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner_conv);
7648 uint64_t ret_ref = 0;
7649 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7650 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7654 static inline struct LDKDecodeError CResult_ChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner){
7655 CHECK(!owner->result_ok);
7656 return DecodeError_clone(&*owner->contents.err);
7658 uint64_t __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_get_err"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_get_err(uint64_t owner) {
7659 LDKCResult_ChannelAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)untag_ptr(owner);
7660 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7661 *ret_copy = CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner_conv);
7662 uint64_t ret_ref = tag_ptr(ret_copy, true);
7666 static inline struct LDKUnsignedChannelUpdate CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner){
7667 LDKUnsignedChannelUpdate ret = *owner->contents.result;
7668 ret.is_owned = false;
7671 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(uint64_t owner) {
7672 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* owner_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)untag_ptr(owner);
7673 LDKUnsignedChannelUpdate ret_var = CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner_conv);
7674 uint64_t ret_ref = 0;
7675 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7676 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7680 static inline struct LDKDecodeError CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner){
7681 CHECK(!owner->result_ok);
7682 return DecodeError_clone(&*owner->contents.err);
7684 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_err"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(uint64_t owner) {
7685 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* owner_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)untag_ptr(owner);
7686 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7687 *ret_copy = CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner_conv);
7688 uint64_t ret_ref = tag_ptr(ret_copy, true);
7692 static inline struct LDKChannelUpdate CResult_ChannelUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner){
7693 LDKChannelUpdate ret = *owner->contents.result;
7694 ret.is_owned = false;
7697 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_get_ok"))) TS_CResult_ChannelUpdateDecodeErrorZ_get_ok(uint64_t owner) {
7698 LDKCResult_ChannelUpdateDecodeErrorZ* owner_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)untag_ptr(owner);
7699 LDKChannelUpdate ret_var = CResult_ChannelUpdateDecodeErrorZ_get_ok(owner_conv);
7700 uint64_t ret_ref = 0;
7701 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7702 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7706 static inline struct LDKDecodeError CResult_ChannelUpdateDecodeErrorZ_get_err(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner){
7707 CHECK(!owner->result_ok);
7708 return DecodeError_clone(&*owner->contents.err);
7710 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_get_err"))) TS_CResult_ChannelUpdateDecodeErrorZ_get_err(uint64_t owner) {
7711 LDKCResult_ChannelUpdateDecodeErrorZ* owner_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)untag_ptr(owner);
7712 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7713 *ret_copy = CResult_ChannelUpdateDecodeErrorZ_get_err(owner_conv);
7714 uint64_t ret_ref = tag_ptr(ret_copy, true);
7718 static inline struct LDKErrorMessage CResult_ErrorMessageDecodeErrorZ_get_ok(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner){
7719 LDKErrorMessage ret = *owner->contents.result;
7720 ret.is_owned = false;
7723 uint64_t __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_get_ok"))) TS_CResult_ErrorMessageDecodeErrorZ_get_ok(uint64_t owner) {
7724 LDKCResult_ErrorMessageDecodeErrorZ* owner_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)untag_ptr(owner);
7725 LDKErrorMessage ret_var = CResult_ErrorMessageDecodeErrorZ_get_ok(owner_conv);
7726 uint64_t ret_ref = 0;
7727 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7728 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7732 static inline struct LDKDecodeError CResult_ErrorMessageDecodeErrorZ_get_err(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner){
7733 CHECK(!owner->result_ok);
7734 return DecodeError_clone(&*owner->contents.err);
7736 uint64_t __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_get_err"))) TS_CResult_ErrorMessageDecodeErrorZ_get_err(uint64_t owner) {
7737 LDKCResult_ErrorMessageDecodeErrorZ* owner_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)untag_ptr(owner);
7738 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7739 *ret_copy = CResult_ErrorMessageDecodeErrorZ_get_err(owner_conv);
7740 uint64_t ret_ref = tag_ptr(ret_copy, true);
7744 static inline struct LDKWarningMessage CResult_WarningMessageDecodeErrorZ_get_ok(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner){
7745 LDKWarningMessage ret = *owner->contents.result;
7746 ret.is_owned = false;
7749 uint64_t __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_get_ok"))) TS_CResult_WarningMessageDecodeErrorZ_get_ok(uint64_t owner) {
7750 LDKCResult_WarningMessageDecodeErrorZ* owner_conv = (LDKCResult_WarningMessageDecodeErrorZ*)untag_ptr(owner);
7751 LDKWarningMessage ret_var = CResult_WarningMessageDecodeErrorZ_get_ok(owner_conv);
7752 uint64_t ret_ref = 0;
7753 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7754 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7758 static inline struct LDKDecodeError CResult_WarningMessageDecodeErrorZ_get_err(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner){
7759 CHECK(!owner->result_ok);
7760 return DecodeError_clone(&*owner->contents.err);
7762 uint64_t __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_get_err"))) TS_CResult_WarningMessageDecodeErrorZ_get_err(uint64_t owner) {
7763 LDKCResult_WarningMessageDecodeErrorZ* owner_conv = (LDKCResult_WarningMessageDecodeErrorZ*)untag_ptr(owner);
7764 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7765 *ret_copy = CResult_WarningMessageDecodeErrorZ_get_err(owner_conv);
7766 uint64_t ret_ref = tag_ptr(ret_copy, true);
7770 static inline struct LDKUnsignedNodeAnnouncement CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner){
7771 LDKUnsignedNodeAnnouncement ret = *owner->contents.result;
7772 ret.is_owned = false;
7775 uint64_t __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(uint64_t owner) {
7776 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)untag_ptr(owner);
7777 LDKUnsignedNodeAnnouncement ret_var = CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner_conv);
7778 uint64_t ret_ref = 0;
7779 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7780 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7784 static inline struct LDKDecodeError CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner){
7785 CHECK(!owner->result_ok);
7786 return DecodeError_clone(&*owner->contents.err);
7788 uint64_t __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(uint64_t owner) {
7789 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)untag_ptr(owner);
7790 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7791 *ret_copy = CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner_conv);
7792 uint64_t ret_ref = tag_ptr(ret_copy, true);
7796 static inline struct LDKNodeAnnouncement CResult_NodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner){
7797 LDKNodeAnnouncement ret = *owner->contents.result;
7798 ret.is_owned = false;
7801 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_get_ok"))) TS_CResult_NodeAnnouncementDecodeErrorZ_get_ok(uint64_t owner) {
7802 LDKCResult_NodeAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)untag_ptr(owner);
7803 LDKNodeAnnouncement ret_var = CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner_conv);
7804 uint64_t ret_ref = 0;
7805 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7806 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7810 static inline struct LDKDecodeError CResult_NodeAnnouncementDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner){
7811 CHECK(!owner->result_ok);
7812 return DecodeError_clone(&*owner->contents.err);
7814 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_get_err"))) TS_CResult_NodeAnnouncementDecodeErrorZ_get_err(uint64_t owner) {
7815 LDKCResult_NodeAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)untag_ptr(owner);
7816 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7817 *ret_copy = CResult_NodeAnnouncementDecodeErrorZ_get_err(owner_conv);
7818 uint64_t ret_ref = tag_ptr(ret_copy, true);
7822 static inline struct LDKQueryShortChannelIds CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner){
7823 LDKQueryShortChannelIds ret = *owner->contents.result;
7824 ret.is_owned = false;
7827 uint64_t __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_ok"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(uint64_t owner) {
7828 LDKCResult_QueryShortChannelIdsDecodeErrorZ* owner_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)untag_ptr(owner);
7829 LDKQueryShortChannelIds ret_var = CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner_conv);
7830 uint64_t ret_ref = 0;
7831 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7832 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7836 static inline struct LDKDecodeError CResult_QueryShortChannelIdsDecodeErrorZ_get_err(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner){
7837 CHECK(!owner->result_ok);
7838 return DecodeError_clone(&*owner->contents.err);
7840 uint64_t __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_err"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_err(uint64_t owner) {
7841 LDKCResult_QueryShortChannelIdsDecodeErrorZ* owner_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)untag_ptr(owner);
7842 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7843 *ret_copy = CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner_conv);
7844 uint64_t ret_ref = tag_ptr(ret_copy, true);
7848 static inline struct LDKReplyShortChannelIdsEnd CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner){
7849 LDKReplyShortChannelIdsEnd ret = *owner->contents.result;
7850 ret.is_owned = false;
7853 uint64_t __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(uint64_t owner) {
7854 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* owner_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)untag_ptr(owner);
7855 LDKReplyShortChannelIdsEnd ret_var = CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner_conv);
7856 uint64_t ret_ref = 0;
7857 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7858 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7862 static inline struct LDKDecodeError CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner){
7863 CHECK(!owner->result_ok);
7864 return DecodeError_clone(&*owner->contents.err);
7866 uint64_t __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(uint64_t owner) {
7867 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* owner_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)untag_ptr(owner);
7868 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7869 *ret_copy = CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner_conv);
7870 uint64_t ret_ref = tag_ptr(ret_copy, true);
7874 static inline struct LDKQueryChannelRange CResult_QueryChannelRangeDecodeErrorZ_get_ok(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner){
7875 LDKQueryChannelRange ret = *owner->contents.result;
7876 ret.is_owned = false;
7879 uint64_t __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_get_ok"))) TS_CResult_QueryChannelRangeDecodeErrorZ_get_ok(uint64_t owner) {
7880 LDKCResult_QueryChannelRangeDecodeErrorZ* owner_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)untag_ptr(owner);
7881 LDKQueryChannelRange ret_var = CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner_conv);
7882 uint64_t ret_ref = 0;
7883 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7884 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7888 static inline struct LDKDecodeError CResult_QueryChannelRangeDecodeErrorZ_get_err(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner){
7889 CHECK(!owner->result_ok);
7890 return DecodeError_clone(&*owner->contents.err);
7892 uint64_t __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_get_err"))) TS_CResult_QueryChannelRangeDecodeErrorZ_get_err(uint64_t owner) {
7893 LDKCResult_QueryChannelRangeDecodeErrorZ* owner_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)untag_ptr(owner);
7894 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7895 *ret_copy = CResult_QueryChannelRangeDecodeErrorZ_get_err(owner_conv);
7896 uint64_t ret_ref = tag_ptr(ret_copy, true);
7900 static inline struct LDKReplyChannelRange CResult_ReplyChannelRangeDecodeErrorZ_get_ok(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner){
7901 LDKReplyChannelRange ret = *owner->contents.result;
7902 ret.is_owned = false;
7905 uint64_t __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_get_ok"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_get_ok(uint64_t owner) {
7906 LDKCResult_ReplyChannelRangeDecodeErrorZ* owner_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)untag_ptr(owner);
7907 LDKReplyChannelRange ret_var = CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner_conv);
7908 uint64_t ret_ref = 0;
7909 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7910 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7914 static inline struct LDKDecodeError CResult_ReplyChannelRangeDecodeErrorZ_get_err(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner){
7915 CHECK(!owner->result_ok);
7916 return DecodeError_clone(&*owner->contents.err);
7918 uint64_t __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_get_err"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_get_err(uint64_t owner) {
7919 LDKCResult_ReplyChannelRangeDecodeErrorZ* owner_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)untag_ptr(owner);
7920 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7921 *ret_copy = CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner_conv);
7922 uint64_t ret_ref = tag_ptr(ret_copy, true);
7926 static inline struct LDKGossipTimestampFilter CResult_GossipTimestampFilterDecodeErrorZ_get_ok(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner){
7927 LDKGossipTimestampFilter ret = *owner->contents.result;
7928 ret.is_owned = false;
7931 uint64_t __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_get_ok"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_get_ok(uint64_t owner) {
7932 LDKCResult_GossipTimestampFilterDecodeErrorZ* owner_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)untag_ptr(owner);
7933 LDKGossipTimestampFilter ret_var = CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner_conv);
7934 uint64_t ret_ref = 0;
7935 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7936 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7940 static inline struct LDKDecodeError CResult_GossipTimestampFilterDecodeErrorZ_get_err(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner){
7941 CHECK(!owner->result_ok);
7942 return DecodeError_clone(&*owner->contents.err);
7944 uint64_t __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_get_err"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_get_err(uint64_t owner) {
7945 LDKCResult_GossipTimestampFilterDecodeErrorZ* owner_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)untag_ptr(owner);
7946 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7947 *ret_copy = CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner_conv);
7948 uint64_t ret_ref = tag_ptr(ret_copy, true);
7952 uint32_t __attribute__((export_name("TS_LDKSignOrCreationError_ty_from_ptr"))) TS_LDKSignOrCreationError_ty_from_ptr(uint64_t ptr) {
7953 LDKSignOrCreationError *obj = (LDKSignOrCreationError*)untag_ptr(ptr);
7955 case LDKSignOrCreationError_SignError: return 0;
7956 case LDKSignOrCreationError_CreationError: return 1;
7960 uint32_t __attribute__((export_name("TS_LDKSignOrCreationError_CreationError_get_creation_error"))) TS_LDKSignOrCreationError_CreationError_get_creation_error(uint64_t ptr) {
7961 LDKSignOrCreationError *obj = (LDKSignOrCreationError*)untag_ptr(ptr);
7962 assert(obj->tag == LDKSignOrCreationError_CreationError);
7963 uint32_t creation_error_conv = LDKCreationError_to_js(obj->creation_error);
7964 return creation_error_conv;
7966 static inline struct LDKInvoice CResult_InvoiceSignOrCreationErrorZ_get_ok(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner){
7967 LDKInvoice ret = *owner->contents.result;
7968 ret.is_owned = false;
7971 uint64_t __attribute__((export_name("TS_CResult_InvoiceSignOrCreationErrorZ_get_ok"))) TS_CResult_InvoiceSignOrCreationErrorZ_get_ok(uint64_t owner) {
7972 LDKCResult_InvoiceSignOrCreationErrorZ* owner_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)untag_ptr(owner);
7973 LDKInvoice ret_var = CResult_InvoiceSignOrCreationErrorZ_get_ok(owner_conv);
7974 uint64_t ret_ref = 0;
7975 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7976 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7980 static inline struct LDKSignOrCreationError CResult_InvoiceSignOrCreationErrorZ_get_err(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner){
7981 CHECK(!owner->result_ok);
7982 return SignOrCreationError_clone(&*owner->contents.err);
7984 uint64_t __attribute__((export_name("TS_CResult_InvoiceSignOrCreationErrorZ_get_err"))) TS_CResult_InvoiceSignOrCreationErrorZ_get_err(uint64_t owner) {
7985 LDKCResult_InvoiceSignOrCreationErrorZ* owner_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)untag_ptr(owner);
7986 LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
7987 *ret_copy = CResult_InvoiceSignOrCreationErrorZ_get_err(owner_conv);
7988 uint64_t ret_ref = tag_ptr(ret_copy, true);
7992 typedef struct LDKFilter_JCalls {
7993 atomic_size_t refcnt;
7994 uint32_t instance_ptr;
7996 static void LDKFilter_JCalls_free(void* this_arg) {
7997 LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg;
7998 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
8002 void register_tx_LDKFilter_jcall(const void* this_arg, const uint8_t (* txid)[32], LDKu8slice script_pubkey) {
8003 LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg;
8004 int8_tArray txid_arr = init_int8_tArray(32, __LINE__);
8005 memcpy(txid_arr->elems, *txid, 32);
8006 LDKu8slice script_pubkey_var = script_pubkey;
8007 int8_tArray script_pubkey_arr = init_int8_tArray(script_pubkey_var.datalen, __LINE__);
8008 memcpy(script_pubkey_arr->elems, script_pubkey_var.data, script_pubkey_var.datalen);
8009 js_invoke_function_uuuuuu(j_calls->instance_ptr, 38, (uint32_t)txid_arr, (uint32_t)script_pubkey_arr, 0, 0, 0, 0);
8011 void register_output_LDKFilter_jcall(const void* this_arg, LDKWatchedOutput output) {
8012 LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg;
8013 LDKWatchedOutput output_var = output;
8014 uint64_t output_ref = 0;
8015 CHECK_INNER_FIELD_ACCESS_OR_NULL(output_var);
8016 output_ref = tag_ptr(output_var.inner, output_var.is_owned);
8017 js_invoke_function_buuuuu(j_calls->instance_ptr, 39, output_ref, 0, 0, 0, 0, 0);
8019 static void LDKFilter_JCalls_cloned(LDKFilter* new_obj) {
8020 LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) new_obj->this_arg;
8021 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
8023 static inline LDKFilter LDKFilter_init (JSValue o) {
8024 LDKFilter_JCalls *calls = MALLOC(sizeof(LDKFilter_JCalls), "LDKFilter_JCalls");
8025 atomic_init(&calls->refcnt, 1);
8026 calls->instance_ptr = o;
8029 .this_arg = (void*) calls,
8030 .register_tx = register_tx_LDKFilter_jcall,
8031 .register_output = register_output_LDKFilter_jcall,
8032 .free = LDKFilter_JCalls_free,
8036 uint64_t __attribute__((export_name("TS_LDKFilter_new"))) TS_LDKFilter_new(JSValue o) {
8037 LDKFilter *res_ptr = MALLOC(sizeof(LDKFilter), "LDKFilter");
8038 *res_ptr = LDKFilter_init(o);
8039 return tag_ptr(res_ptr, true);
8041 void __attribute__((export_name("TS_Filter_register_tx"))) TS_Filter_register_tx(uint64_t this_arg, int8_tArray txid, int8_tArray script_pubkey) {
8042 void* this_arg_ptr = untag_ptr(this_arg);
8043 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
8044 LDKFilter* this_arg_conv = (LDKFilter*)this_arg_ptr;
8045 unsigned char txid_arr[32];
8046 CHECK(txid->arr_len == 32);
8047 memcpy(txid_arr, txid->elems, 32); FREE(txid);
8048 unsigned char (*txid_ref)[32] = &txid_arr;
8049 LDKu8slice script_pubkey_ref;
8050 script_pubkey_ref.datalen = script_pubkey->arr_len;
8051 script_pubkey_ref.data = script_pubkey->elems;
8052 (this_arg_conv->register_tx)(this_arg_conv->this_arg, txid_ref, script_pubkey_ref);
8053 FREE(script_pubkey);
8056 void __attribute__((export_name("TS_Filter_register_output"))) TS_Filter_register_output(uint64_t this_arg, uint64_t output) {
8057 void* this_arg_ptr = untag_ptr(this_arg);
8058 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
8059 LDKFilter* this_arg_conv = (LDKFilter*)this_arg_ptr;
8060 LDKWatchedOutput output_conv;
8061 output_conv.inner = untag_ptr(output);
8062 output_conv.is_owned = ptr_is_owned(output);
8063 CHECK_INNER_FIELD_ACCESS_OR_NULL(output_conv);
8064 output_conv = WatchedOutput_clone(&output_conv);
8065 (this_arg_conv->register_output)(this_arg_conv->this_arg, output_conv);
8068 uint32_t __attribute__((export_name("TS_LDKCOption_FilterZ_ty_from_ptr"))) TS_LDKCOption_FilterZ_ty_from_ptr(uint64_t ptr) {
8069 LDKCOption_FilterZ *obj = (LDKCOption_FilterZ*)untag_ptr(ptr);
8071 case LDKCOption_FilterZ_Some: return 0;
8072 case LDKCOption_FilterZ_None: return 1;
8076 uint64_t __attribute__((export_name("TS_LDKCOption_FilterZ_Some_get_some"))) TS_LDKCOption_FilterZ_Some_get_some(uint64_t ptr) {
8077 LDKCOption_FilterZ *obj = (LDKCOption_FilterZ*)untag_ptr(ptr);
8078 assert(obj->tag == LDKCOption_FilterZ_Some);
8079 LDKFilter* some_ret = MALLOC(sizeof(LDKFilter), "LDKFilter");
8080 *some_ret = obj->some;
8081 // WARNING: We likely need to clone here, but no clone is available, so we just do it for Java instances
8082 if ((*some_ret).free == LDKFilter_JCalls_free) {
8083 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
8084 LDKFilter_JCalls_cloned(&(*some_ret));
8086 return tag_ptr(some_ret, true);
8088 static inline struct LDKLockedChannelMonitor CResult_LockedChannelMonitorNoneZ_get_ok(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner){
8089 LDKLockedChannelMonitor ret = *owner->contents.result;
8090 ret.is_owned = false;
8093 uint64_t __attribute__((export_name("TS_CResult_LockedChannelMonitorNoneZ_get_ok"))) TS_CResult_LockedChannelMonitorNoneZ_get_ok(uint64_t owner) {
8094 LDKCResult_LockedChannelMonitorNoneZ* owner_conv = (LDKCResult_LockedChannelMonitorNoneZ*)untag_ptr(owner);
8095 LDKLockedChannelMonitor ret_var = CResult_LockedChannelMonitorNoneZ_get_ok(owner_conv);
8096 uint64_t ret_ref = 0;
8097 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8098 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8102 static inline void CResult_LockedChannelMonitorNoneZ_get_err(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner){
8103 CHECK(!owner->result_ok);
8104 return *owner->contents.err;
8106 void __attribute__((export_name("TS_CResult_LockedChannelMonitorNoneZ_get_err"))) TS_CResult_LockedChannelMonitorNoneZ_get_err(uint64_t owner) {
8107 LDKCResult_LockedChannelMonitorNoneZ* owner_conv = (LDKCResult_LockedChannelMonitorNoneZ*)untag_ptr(owner);
8108 CResult_LockedChannelMonitorNoneZ_get_err(owner_conv);
8111 static inline LDKCVec_OutPointZ CVec_OutPointZ_clone(const LDKCVec_OutPointZ *orig) {
8112 LDKCVec_OutPointZ ret = { .data = MALLOC(sizeof(LDKOutPoint) * orig->datalen, "LDKCVec_OutPointZ clone bytes"), .datalen = orig->datalen };
8113 for (size_t i = 0; i < ret.datalen; i++) {
8114 ret.data[i] = OutPoint_clone(&orig->data[i]);
8118 static inline LDKCVec_MonitorUpdateIdZ CVec_MonitorUpdateIdZ_clone(const LDKCVec_MonitorUpdateIdZ *orig) {
8119 LDKCVec_MonitorUpdateIdZ ret = { .data = MALLOC(sizeof(LDKMonitorUpdateId) * orig->datalen, "LDKCVec_MonitorUpdateIdZ clone bytes"), .datalen = orig->datalen };
8120 for (size_t i = 0; i < ret.datalen; i++) {
8121 ret.data[i] = MonitorUpdateId_clone(&orig->data[i]);
8125 static inline struct LDKOutPoint C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR owner){
8126 LDKOutPoint ret = owner->a;
8127 ret.is_owned = false;
8130 uint64_t __attribute__((export_name("TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a"))) TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(uint64_t owner) {
8131 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* owner_conv = (LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ*)untag_ptr(owner);
8132 LDKOutPoint ret_var = C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(owner_conv);
8133 uint64_t ret_ref = 0;
8134 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8135 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8139 static inline struct LDKCVec_MonitorUpdateIdZ C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR owner){
8140 return CVec_MonitorUpdateIdZ_clone(&owner->b);
8142 uint64_tArray __attribute__((export_name("TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b"))) TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(uint64_t owner) {
8143 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* owner_conv = (LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ*)untag_ptr(owner);
8144 LDKCVec_MonitorUpdateIdZ ret_var = C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(owner_conv);
8145 uint64_tArray ret_arr = NULL;
8146 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
8147 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
8148 for (size_t r = 0; r < ret_var.datalen; r++) {
8149 LDKMonitorUpdateId ret_conv_17_var = ret_var.data[r];
8150 uint64_t ret_conv_17_ref = 0;
8151 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_17_var);
8152 ret_conv_17_ref = tag_ptr(ret_conv_17_var.inner, ret_conv_17_var.is_owned);
8153 ret_arr_ptr[r] = ret_conv_17_ref;
8160 static inline LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_clone(const LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ *orig) {
8161 LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ) * orig->datalen, "LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ clone bytes"), .datalen = orig->datalen };
8162 for (size_t i = 0; i < ret.datalen; i++) {
8163 ret.data[i] = C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(&orig->data[i]);
8167 typedef struct LDKMessageSendEventsProvider_JCalls {
8168 atomic_size_t refcnt;
8169 uint32_t instance_ptr;
8170 } LDKMessageSendEventsProvider_JCalls;
8171 static void LDKMessageSendEventsProvider_JCalls_free(void* this_arg) {
8172 LDKMessageSendEventsProvider_JCalls *j_calls = (LDKMessageSendEventsProvider_JCalls*) this_arg;
8173 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
8177 LDKCVec_MessageSendEventZ get_and_clear_pending_msg_events_LDKMessageSendEventsProvider_jcall(const void* this_arg) {
8178 LDKMessageSendEventsProvider_JCalls *j_calls = (LDKMessageSendEventsProvider_JCalls*) this_arg;
8179 uint64_tArray ret = (uint64_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 40, 0, 0, 0, 0, 0, 0);
8180 LDKCVec_MessageSendEventZ ret_constr;
8181 ret_constr.datalen = ret->arr_len;
8182 if (ret_constr.datalen > 0)
8183 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKMessageSendEvent), "LDKCVec_MessageSendEventZ Elements");
8185 ret_constr.data = NULL;
8186 uint64_t* ret_vals = ret->elems;
8187 for (size_t s = 0; s < ret_constr.datalen; s++) {
8188 uint64_t ret_conv_18 = ret_vals[s];
8189 void* ret_conv_18_ptr = untag_ptr(ret_conv_18);
8190 CHECK_ACCESS(ret_conv_18_ptr);
8191 LDKMessageSendEvent ret_conv_18_conv = *(LDKMessageSendEvent*)(ret_conv_18_ptr);
8192 FREE(untag_ptr(ret_conv_18));
8193 ret_constr.data[s] = ret_conv_18_conv;
8198 static void LDKMessageSendEventsProvider_JCalls_cloned(LDKMessageSendEventsProvider* new_obj) {
8199 LDKMessageSendEventsProvider_JCalls *j_calls = (LDKMessageSendEventsProvider_JCalls*) new_obj->this_arg;
8200 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
8202 static inline LDKMessageSendEventsProvider LDKMessageSendEventsProvider_init (JSValue o) {
8203 LDKMessageSendEventsProvider_JCalls *calls = MALLOC(sizeof(LDKMessageSendEventsProvider_JCalls), "LDKMessageSendEventsProvider_JCalls");
8204 atomic_init(&calls->refcnt, 1);
8205 calls->instance_ptr = o;
8207 LDKMessageSendEventsProvider ret = {
8208 .this_arg = (void*) calls,
8209 .get_and_clear_pending_msg_events = get_and_clear_pending_msg_events_LDKMessageSendEventsProvider_jcall,
8210 .free = LDKMessageSendEventsProvider_JCalls_free,
8214 uint64_t __attribute__((export_name("TS_LDKMessageSendEventsProvider_new"))) TS_LDKMessageSendEventsProvider_new(JSValue o) {
8215 LDKMessageSendEventsProvider *res_ptr = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
8216 *res_ptr = LDKMessageSendEventsProvider_init(o);
8217 return tag_ptr(res_ptr, true);
8219 uint64_tArray __attribute__((export_name("TS_MessageSendEventsProvider_get_and_clear_pending_msg_events"))) TS_MessageSendEventsProvider_get_and_clear_pending_msg_events(uint64_t this_arg) {
8220 void* this_arg_ptr = untag_ptr(this_arg);
8221 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
8222 LDKMessageSendEventsProvider* this_arg_conv = (LDKMessageSendEventsProvider*)this_arg_ptr;
8223 LDKCVec_MessageSendEventZ ret_var = (this_arg_conv->get_and_clear_pending_msg_events)(this_arg_conv->this_arg);
8224 uint64_tArray ret_arr = NULL;
8225 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
8226 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
8227 for (size_t s = 0; s < ret_var.datalen; s++) {
8228 LDKMessageSendEvent *ret_conv_18_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
8229 *ret_conv_18_copy = ret_var.data[s];
8230 uint64_t ret_conv_18_ref = tag_ptr(ret_conv_18_copy, true);
8231 ret_arr_ptr[s] = ret_conv_18_ref;
8238 typedef struct LDKOnionMessageProvider_JCalls {
8239 atomic_size_t refcnt;
8240 uint32_t instance_ptr;
8241 } LDKOnionMessageProvider_JCalls;
8242 static void LDKOnionMessageProvider_JCalls_free(void* this_arg) {
8243 LDKOnionMessageProvider_JCalls *j_calls = (LDKOnionMessageProvider_JCalls*) this_arg;
8244 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
8248 LDKOnionMessage next_onion_message_for_peer_LDKOnionMessageProvider_jcall(const void* this_arg, LDKPublicKey peer_node_id) {
8249 LDKOnionMessageProvider_JCalls *j_calls = (LDKOnionMessageProvider_JCalls*) this_arg;
8250 int8_tArray peer_node_id_arr = init_int8_tArray(33, __LINE__);
8251 memcpy(peer_node_id_arr->elems, peer_node_id.compressed_form, 33);
8252 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 41, (uint32_t)peer_node_id_arr, 0, 0, 0, 0, 0);
8253 LDKOnionMessage ret_conv;
8254 ret_conv.inner = untag_ptr(ret);
8255 ret_conv.is_owned = ptr_is_owned(ret);
8256 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
8259 static void LDKOnionMessageProvider_JCalls_cloned(LDKOnionMessageProvider* new_obj) {
8260 LDKOnionMessageProvider_JCalls *j_calls = (LDKOnionMessageProvider_JCalls*) new_obj->this_arg;
8261 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
8263 static inline LDKOnionMessageProvider LDKOnionMessageProvider_init (JSValue o) {
8264 LDKOnionMessageProvider_JCalls *calls = MALLOC(sizeof(LDKOnionMessageProvider_JCalls), "LDKOnionMessageProvider_JCalls");
8265 atomic_init(&calls->refcnt, 1);
8266 calls->instance_ptr = o;
8268 LDKOnionMessageProvider ret = {
8269 .this_arg = (void*) calls,
8270 .next_onion_message_for_peer = next_onion_message_for_peer_LDKOnionMessageProvider_jcall,
8271 .free = LDKOnionMessageProvider_JCalls_free,
8275 uint64_t __attribute__((export_name("TS_LDKOnionMessageProvider_new"))) TS_LDKOnionMessageProvider_new(JSValue o) {
8276 LDKOnionMessageProvider *res_ptr = MALLOC(sizeof(LDKOnionMessageProvider), "LDKOnionMessageProvider");
8277 *res_ptr = LDKOnionMessageProvider_init(o);
8278 return tag_ptr(res_ptr, true);
8280 uint64_t __attribute__((export_name("TS_OnionMessageProvider_next_onion_message_for_peer"))) TS_OnionMessageProvider_next_onion_message_for_peer(uint64_t this_arg, int8_tArray peer_node_id) {
8281 void* this_arg_ptr = untag_ptr(this_arg);
8282 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
8283 LDKOnionMessageProvider* this_arg_conv = (LDKOnionMessageProvider*)this_arg_ptr;
8284 LDKPublicKey peer_node_id_ref;
8285 CHECK(peer_node_id->arr_len == 33);
8286 memcpy(peer_node_id_ref.compressed_form, peer_node_id->elems, 33); FREE(peer_node_id);
8287 LDKOnionMessage ret_var = (this_arg_conv->next_onion_message_for_peer)(this_arg_conv->this_arg, peer_node_id_ref);
8288 uint64_t ret_ref = 0;
8289 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8290 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8294 typedef struct LDKEventHandler_JCalls {
8295 atomic_size_t refcnt;
8296 uint32_t instance_ptr;
8297 } LDKEventHandler_JCalls;
8298 static void LDKEventHandler_JCalls_free(void* this_arg) {
8299 LDKEventHandler_JCalls *j_calls = (LDKEventHandler_JCalls*) this_arg;
8300 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
8304 void handle_event_LDKEventHandler_jcall(const void* this_arg, LDKEvent event) {
8305 LDKEventHandler_JCalls *j_calls = (LDKEventHandler_JCalls*) this_arg;
8306 LDKEvent *event_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
8307 *event_copy = event;
8308 uint64_t event_ref = tag_ptr(event_copy, true);
8309 js_invoke_function_buuuuu(j_calls->instance_ptr, 42, event_ref, 0, 0, 0, 0, 0);
8311 static void LDKEventHandler_JCalls_cloned(LDKEventHandler* new_obj) {
8312 LDKEventHandler_JCalls *j_calls = (LDKEventHandler_JCalls*) new_obj->this_arg;
8313 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
8315 static inline LDKEventHandler LDKEventHandler_init (JSValue o) {
8316 LDKEventHandler_JCalls *calls = MALLOC(sizeof(LDKEventHandler_JCalls), "LDKEventHandler_JCalls");
8317 atomic_init(&calls->refcnt, 1);
8318 calls->instance_ptr = o;
8320 LDKEventHandler ret = {
8321 .this_arg = (void*) calls,
8322 .handle_event = handle_event_LDKEventHandler_jcall,
8323 .free = LDKEventHandler_JCalls_free,
8327 uint64_t __attribute__((export_name("TS_LDKEventHandler_new"))) TS_LDKEventHandler_new(JSValue o) {
8328 LDKEventHandler *res_ptr = MALLOC(sizeof(LDKEventHandler), "LDKEventHandler");
8329 *res_ptr = LDKEventHandler_init(o);
8330 return tag_ptr(res_ptr, true);
8332 void __attribute__((export_name("TS_EventHandler_handle_event"))) TS_EventHandler_handle_event(uint64_t this_arg, uint64_t event) {
8333 void* this_arg_ptr = untag_ptr(this_arg);
8334 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
8335 LDKEventHandler* this_arg_conv = (LDKEventHandler*)this_arg_ptr;
8336 void* event_ptr = untag_ptr(event);
8337 CHECK_ACCESS(event_ptr);
8338 LDKEvent event_conv = *(LDKEvent*)(event_ptr);
8339 event_conv = Event_clone((LDKEvent*)untag_ptr(event));
8340 (this_arg_conv->handle_event)(this_arg_conv->this_arg, event_conv);
8343 typedef struct LDKEventsProvider_JCalls {
8344 atomic_size_t refcnt;
8345 uint32_t instance_ptr;
8346 } LDKEventsProvider_JCalls;
8347 static void LDKEventsProvider_JCalls_free(void* this_arg) {
8348 LDKEventsProvider_JCalls *j_calls = (LDKEventsProvider_JCalls*) this_arg;
8349 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
8353 void process_pending_events_LDKEventsProvider_jcall(const void* this_arg, LDKEventHandler handler) {
8354 LDKEventsProvider_JCalls *j_calls = (LDKEventsProvider_JCalls*) this_arg;
8355 LDKEventHandler* handler_ret = MALLOC(sizeof(LDKEventHandler), "LDKEventHandler");
8356 *handler_ret = handler;
8357 js_invoke_function_buuuuu(j_calls->instance_ptr, 43, tag_ptr(handler_ret, true), 0, 0, 0, 0, 0);
8359 static void LDKEventsProvider_JCalls_cloned(LDKEventsProvider* new_obj) {
8360 LDKEventsProvider_JCalls *j_calls = (LDKEventsProvider_JCalls*) new_obj->this_arg;
8361 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
8363 static inline LDKEventsProvider LDKEventsProvider_init (JSValue o) {
8364 LDKEventsProvider_JCalls *calls = MALLOC(sizeof(LDKEventsProvider_JCalls), "LDKEventsProvider_JCalls");
8365 atomic_init(&calls->refcnt, 1);
8366 calls->instance_ptr = o;
8368 LDKEventsProvider ret = {
8369 .this_arg = (void*) calls,
8370 .process_pending_events = process_pending_events_LDKEventsProvider_jcall,
8371 .free = LDKEventsProvider_JCalls_free,
8375 uint64_t __attribute__((export_name("TS_LDKEventsProvider_new"))) TS_LDKEventsProvider_new(JSValue o) {
8376 LDKEventsProvider *res_ptr = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider");
8377 *res_ptr = LDKEventsProvider_init(o);
8378 return tag_ptr(res_ptr, true);
8380 void __attribute__((export_name("TS_EventsProvider_process_pending_events"))) TS_EventsProvider_process_pending_events(uint64_t this_arg, uint64_t handler) {
8381 void* this_arg_ptr = untag_ptr(this_arg);
8382 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
8383 LDKEventsProvider* this_arg_conv = (LDKEventsProvider*)this_arg_ptr;
8384 void* handler_ptr = untag_ptr(handler);
8385 CHECK_ACCESS(handler_ptr);
8386 LDKEventHandler handler_conv = *(LDKEventHandler*)(handler_ptr);
8387 if (handler_conv.free == LDKEventHandler_JCalls_free) {
8388 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
8389 LDKEventHandler_JCalls_cloned(&handler_conv);
8391 (this_arg_conv->process_pending_events)(this_arg_conv->this_arg, handler_conv);
8394 typedef struct LDKScore_JCalls {
8395 atomic_size_t refcnt;
8396 uint32_t instance_ptr;
8398 static void LDKScore_JCalls_free(void* this_arg) {
8399 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
8400 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
8404 uint64_t channel_penalty_msat_LDKScore_jcall(const void* this_arg, uint64_t short_channel_id, const LDKNodeId * source, const LDKNodeId * target, LDKChannelUsage usage) {
8405 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
8406 int64_t short_channel_id_conv = short_channel_id;
8407 LDKNodeId source_var = *source;
8408 uint64_t source_ref = 0;
8409 source_var = NodeId_clone(&source_var);
8410 CHECK_INNER_FIELD_ACCESS_OR_NULL(source_var);
8411 source_ref = tag_ptr(source_var.inner, source_var.is_owned);
8412 LDKNodeId target_var = *target;
8413 uint64_t target_ref = 0;
8414 target_var = NodeId_clone(&target_var);
8415 CHECK_INNER_FIELD_ACCESS_OR_NULL(target_var);
8416 target_ref = tag_ptr(target_var.inner, target_var.is_owned);
8417 LDKChannelUsage usage_var = usage;
8418 uint64_t usage_ref = 0;
8419 CHECK_INNER_FIELD_ACCESS_OR_NULL(usage_var);
8420 usage_ref = tag_ptr(usage_var.inner, usage_var.is_owned);
8421 return js_invoke_function_bbbbuu(j_calls->instance_ptr, 44, short_channel_id_conv, source_ref, target_ref, usage_ref, 0, 0);
8423 void payment_path_failed_LDKScore_jcall(void* this_arg, LDKCVec_RouteHopZ path, uint64_t short_channel_id) {
8424 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
8425 LDKCVec_RouteHopZ path_var = path;
8426 uint64_tArray path_arr = NULL;
8427 path_arr = init_uint64_tArray(path_var.datalen, __LINE__);
8428 uint64_t *path_arr_ptr = (uint64_t*)(((uint8_t*)path_arr) + 8);
8429 for (size_t k = 0; k < path_var.datalen; k++) {
8430 LDKRouteHop path_conv_10_var = path_var.data[k];
8431 uint64_t path_conv_10_ref = 0;
8432 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
8433 path_conv_10_ref = tag_ptr(path_conv_10_var.inner, path_conv_10_var.is_owned);
8434 path_arr_ptr[k] = path_conv_10_ref;
8437 FREE(path_var.data);
8438 int64_t short_channel_id_conv = short_channel_id;
8439 js_invoke_function_ubuuuu(j_calls->instance_ptr, 45, (uint32_t)path_arr, short_channel_id_conv, 0, 0, 0, 0);
8441 void payment_path_successful_LDKScore_jcall(void* this_arg, LDKCVec_RouteHopZ path) {
8442 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
8443 LDKCVec_RouteHopZ path_var = path;
8444 uint64_tArray path_arr = NULL;
8445 path_arr = init_uint64_tArray(path_var.datalen, __LINE__);
8446 uint64_t *path_arr_ptr = (uint64_t*)(((uint8_t*)path_arr) + 8);
8447 for (size_t k = 0; k < path_var.datalen; k++) {
8448 LDKRouteHop path_conv_10_var = path_var.data[k];
8449 uint64_t path_conv_10_ref = 0;
8450 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
8451 path_conv_10_ref = tag_ptr(path_conv_10_var.inner, path_conv_10_var.is_owned);
8452 path_arr_ptr[k] = path_conv_10_ref;
8455 FREE(path_var.data);
8456 js_invoke_function_uuuuuu(j_calls->instance_ptr, 46, (uint32_t)path_arr, 0, 0, 0, 0, 0);
8458 void probe_failed_LDKScore_jcall(void* this_arg, LDKCVec_RouteHopZ path, uint64_t short_channel_id) {
8459 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
8460 LDKCVec_RouteHopZ path_var = path;
8461 uint64_tArray path_arr = NULL;
8462 path_arr = init_uint64_tArray(path_var.datalen, __LINE__);
8463 uint64_t *path_arr_ptr = (uint64_t*)(((uint8_t*)path_arr) + 8);
8464 for (size_t k = 0; k < path_var.datalen; k++) {
8465 LDKRouteHop path_conv_10_var = path_var.data[k];
8466 uint64_t path_conv_10_ref = 0;
8467 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
8468 path_conv_10_ref = tag_ptr(path_conv_10_var.inner, path_conv_10_var.is_owned);
8469 path_arr_ptr[k] = path_conv_10_ref;
8472 FREE(path_var.data);
8473 int64_t short_channel_id_conv = short_channel_id;
8474 js_invoke_function_ubuuuu(j_calls->instance_ptr, 47, (uint32_t)path_arr, short_channel_id_conv, 0, 0, 0, 0);
8476 void probe_successful_LDKScore_jcall(void* this_arg, LDKCVec_RouteHopZ path) {
8477 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
8478 LDKCVec_RouteHopZ path_var = path;
8479 uint64_tArray path_arr = NULL;
8480 path_arr = init_uint64_tArray(path_var.datalen, __LINE__);
8481 uint64_t *path_arr_ptr = (uint64_t*)(((uint8_t*)path_arr) + 8);
8482 for (size_t k = 0; k < path_var.datalen; k++) {
8483 LDKRouteHop path_conv_10_var = path_var.data[k];
8484 uint64_t path_conv_10_ref = 0;
8485 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
8486 path_conv_10_ref = tag_ptr(path_conv_10_var.inner, path_conv_10_var.is_owned);
8487 path_arr_ptr[k] = path_conv_10_ref;
8490 FREE(path_var.data);
8491 js_invoke_function_uuuuuu(j_calls->instance_ptr, 48, (uint32_t)path_arr, 0, 0, 0, 0, 0);
8493 LDKCVec_u8Z write_LDKScore_jcall(const void* this_arg) {
8494 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
8495 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 49, 0, 0, 0, 0, 0, 0);
8496 LDKCVec_u8Z ret_ref;
8497 ret_ref.datalen = ret->arr_len;
8498 ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
8499 memcpy(ret_ref.data, ret->elems, ret_ref.datalen); FREE(ret);
8502 static void LDKScore_JCalls_cloned(LDKScore* new_obj) {
8503 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) new_obj->this_arg;
8504 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
8506 static inline LDKScore LDKScore_init (JSValue o) {
8507 LDKScore_JCalls *calls = MALLOC(sizeof(LDKScore_JCalls), "LDKScore_JCalls");
8508 atomic_init(&calls->refcnt, 1);
8509 calls->instance_ptr = o;
8512 .this_arg = (void*) calls,
8513 .channel_penalty_msat = channel_penalty_msat_LDKScore_jcall,
8514 .payment_path_failed = payment_path_failed_LDKScore_jcall,
8515 .payment_path_successful = payment_path_successful_LDKScore_jcall,
8516 .probe_failed = probe_failed_LDKScore_jcall,
8517 .probe_successful = probe_successful_LDKScore_jcall,
8518 .write = write_LDKScore_jcall,
8519 .free = LDKScore_JCalls_free,
8523 uint64_t __attribute__((export_name("TS_LDKScore_new"))) TS_LDKScore_new(JSValue o) {
8524 LDKScore *res_ptr = MALLOC(sizeof(LDKScore), "LDKScore");
8525 *res_ptr = LDKScore_init(o);
8526 return tag_ptr(res_ptr, true);
8528 int64_t __attribute__((export_name("TS_Score_channel_penalty_msat"))) TS_Score_channel_penalty_msat(uint64_t this_arg, int64_t short_channel_id, uint64_t source, uint64_t target, uint64_t usage) {
8529 void* this_arg_ptr = untag_ptr(this_arg);
8530 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
8531 LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
8532 LDKNodeId source_conv;
8533 source_conv.inner = untag_ptr(source);
8534 source_conv.is_owned = ptr_is_owned(source);
8535 CHECK_INNER_FIELD_ACCESS_OR_NULL(source_conv);
8536 source_conv.is_owned = false;
8537 LDKNodeId target_conv;
8538 target_conv.inner = untag_ptr(target);
8539 target_conv.is_owned = ptr_is_owned(target);
8540 CHECK_INNER_FIELD_ACCESS_OR_NULL(target_conv);
8541 target_conv.is_owned = false;
8542 LDKChannelUsage usage_conv;
8543 usage_conv.inner = untag_ptr(usage);
8544 usage_conv.is_owned = ptr_is_owned(usage);
8545 CHECK_INNER_FIELD_ACCESS_OR_NULL(usage_conv);
8546 usage_conv = ChannelUsage_clone(&usage_conv);
8547 int64_t ret_conv = (this_arg_conv->channel_penalty_msat)(this_arg_conv->this_arg, short_channel_id, &source_conv, &target_conv, usage_conv);
8551 void __attribute__((export_name("TS_Score_payment_path_failed"))) TS_Score_payment_path_failed(uint64_t this_arg, uint64_tArray path, int64_t short_channel_id) {
8552 void* this_arg_ptr = untag_ptr(this_arg);
8553 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
8554 LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
8555 LDKCVec_RouteHopZ path_constr;
8556 path_constr.datalen = path->arr_len;
8557 if (path_constr.datalen > 0)
8558 path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
8560 path_constr.data = NULL;
8561 uint64_t* path_vals = path->elems;
8562 for (size_t k = 0; k < path_constr.datalen; k++) {
8563 uint64_t path_conv_10 = path_vals[k];
8564 LDKRouteHop path_conv_10_conv;
8565 path_conv_10_conv.inner = untag_ptr(path_conv_10);
8566 path_conv_10_conv.is_owned = ptr_is_owned(path_conv_10);
8567 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
8568 path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
8569 path_constr.data[k] = path_conv_10_conv;
8572 (this_arg_conv->payment_path_failed)(this_arg_conv->this_arg, path_constr, short_channel_id);
8575 void __attribute__((export_name("TS_Score_payment_path_successful"))) TS_Score_payment_path_successful(uint64_t this_arg, uint64_tArray path) {
8576 void* this_arg_ptr = untag_ptr(this_arg);
8577 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
8578 LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
8579 LDKCVec_RouteHopZ path_constr;
8580 path_constr.datalen = path->arr_len;
8581 if (path_constr.datalen > 0)
8582 path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
8584 path_constr.data = NULL;
8585 uint64_t* path_vals = path->elems;
8586 for (size_t k = 0; k < path_constr.datalen; k++) {
8587 uint64_t path_conv_10 = path_vals[k];
8588 LDKRouteHop path_conv_10_conv;
8589 path_conv_10_conv.inner = untag_ptr(path_conv_10);
8590 path_conv_10_conv.is_owned = ptr_is_owned(path_conv_10);
8591 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
8592 path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
8593 path_constr.data[k] = path_conv_10_conv;
8596 (this_arg_conv->payment_path_successful)(this_arg_conv->this_arg, path_constr);
8599 void __attribute__((export_name("TS_Score_probe_failed"))) TS_Score_probe_failed(uint64_t this_arg, uint64_tArray path, int64_t short_channel_id) {
8600 void* this_arg_ptr = untag_ptr(this_arg);
8601 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
8602 LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
8603 LDKCVec_RouteHopZ path_constr;
8604 path_constr.datalen = path->arr_len;
8605 if (path_constr.datalen > 0)
8606 path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
8608 path_constr.data = NULL;
8609 uint64_t* path_vals = path->elems;
8610 for (size_t k = 0; k < path_constr.datalen; k++) {
8611 uint64_t path_conv_10 = path_vals[k];
8612 LDKRouteHop path_conv_10_conv;
8613 path_conv_10_conv.inner = untag_ptr(path_conv_10);
8614 path_conv_10_conv.is_owned = ptr_is_owned(path_conv_10);
8615 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
8616 path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
8617 path_constr.data[k] = path_conv_10_conv;
8620 (this_arg_conv->probe_failed)(this_arg_conv->this_arg, path_constr, short_channel_id);
8623 void __attribute__((export_name("TS_Score_probe_successful"))) TS_Score_probe_successful(uint64_t this_arg, uint64_tArray path) {
8624 void* this_arg_ptr = untag_ptr(this_arg);
8625 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
8626 LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
8627 LDKCVec_RouteHopZ path_constr;
8628 path_constr.datalen = path->arr_len;
8629 if (path_constr.datalen > 0)
8630 path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
8632 path_constr.data = NULL;
8633 uint64_t* path_vals = path->elems;
8634 for (size_t k = 0; k < path_constr.datalen; k++) {
8635 uint64_t path_conv_10 = path_vals[k];
8636 LDKRouteHop path_conv_10_conv;
8637 path_conv_10_conv.inner = untag_ptr(path_conv_10);
8638 path_conv_10_conv.is_owned = ptr_is_owned(path_conv_10);
8639 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
8640 path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
8641 path_constr.data[k] = path_conv_10_conv;
8644 (this_arg_conv->probe_successful)(this_arg_conv->this_arg, path_constr);
8647 int8_tArray __attribute__((export_name("TS_Score_write"))) TS_Score_write(uint64_t this_arg) {
8648 void* this_arg_ptr = untag_ptr(this_arg);
8649 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
8650 LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
8651 LDKCVec_u8Z ret_var = (this_arg_conv->write)(this_arg_conv->this_arg);
8652 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
8653 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
8654 CVec_u8Z_free(ret_var);
8658 typedef struct LDKLockableScore_JCalls {
8659 atomic_size_t refcnt;
8660 uint32_t instance_ptr;
8661 } LDKLockableScore_JCalls;
8662 static void LDKLockableScore_JCalls_free(void* this_arg) {
8663 LDKLockableScore_JCalls *j_calls = (LDKLockableScore_JCalls*) this_arg;
8664 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
8668 LDKScore lock_LDKLockableScore_jcall(const void* this_arg) {
8669 LDKLockableScore_JCalls *j_calls = (LDKLockableScore_JCalls*) this_arg;
8670 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 50, 0, 0, 0, 0, 0, 0);
8671 void* ret_ptr = untag_ptr(ret);
8672 CHECK_ACCESS(ret_ptr);
8673 LDKScore ret_conv = *(LDKScore*)(ret_ptr);
8674 if (ret_conv.free == LDKScore_JCalls_free) {
8675 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
8676 LDKScore_JCalls_cloned(&ret_conv);
8677 }// WARNING: we may need a move here but no clone is available for LDKScore
8681 static void LDKLockableScore_JCalls_cloned(LDKLockableScore* new_obj) {
8682 LDKLockableScore_JCalls *j_calls = (LDKLockableScore_JCalls*) new_obj->this_arg;
8683 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
8685 static inline LDKLockableScore LDKLockableScore_init (JSValue o) {
8686 LDKLockableScore_JCalls *calls = MALLOC(sizeof(LDKLockableScore_JCalls), "LDKLockableScore_JCalls");
8687 atomic_init(&calls->refcnt, 1);
8688 calls->instance_ptr = o;
8690 LDKLockableScore ret = {
8691 .this_arg = (void*) calls,
8692 .lock = lock_LDKLockableScore_jcall,
8693 .free = LDKLockableScore_JCalls_free,
8697 uint64_t __attribute__((export_name("TS_LDKLockableScore_new"))) TS_LDKLockableScore_new(JSValue o) {
8698 LDKLockableScore *res_ptr = MALLOC(sizeof(LDKLockableScore), "LDKLockableScore");
8699 *res_ptr = LDKLockableScore_init(o);
8700 return tag_ptr(res_ptr, true);
8702 uint64_t __attribute__((export_name("TS_LockableScore_lock"))) TS_LockableScore_lock(uint64_t this_arg) {
8703 void* this_arg_ptr = untag_ptr(this_arg);
8704 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
8705 LDKLockableScore* this_arg_conv = (LDKLockableScore*)this_arg_ptr;
8706 LDKScore* ret_ret = MALLOC(sizeof(LDKScore), "LDKScore");
8707 *ret_ret = (this_arg_conv->lock)(this_arg_conv->this_arg);
8708 return tag_ptr(ret_ret, true);
8711 typedef struct LDKWriteableScore_JCalls {
8712 atomic_size_t refcnt;
8713 uint32_t instance_ptr;
8714 LDKLockableScore_JCalls* LockableScore;
8715 } LDKWriteableScore_JCalls;
8716 static void LDKWriteableScore_JCalls_free(void* this_arg) {
8717 LDKWriteableScore_JCalls *j_calls = (LDKWriteableScore_JCalls*) this_arg;
8718 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
8722 LDKCVec_u8Z write_LDKWriteableScore_jcall(const void* this_arg) {
8723 LDKWriteableScore_JCalls *j_calls = (LDKWriteableScore_JCalls*) this_arg;
8724 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 51, 0, 0, 0, 0, 0, 0);
8725 LDKCVec_u8Z ret_ref;
8726 ret_ref.datalen = ret->arr_len;
8727 ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
8728 memcpy(ret_ref.data, ret->elems, ret_ref.datalen); FREE(ret);
8731 static void LDKWriteableScore_JCalls_cloned(LDKWriteableScore* new_obj) {
8732 LDKWriteableScore_JCalls *j_calls = (LDKWriteableScore_JCalls*) new_obj->this_arg;
8733 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
8734 atomic_fetch_add_explicit(&j_calls->LockableScore->refcnt, 1, memory_order_release);
8736 static inline LDKWriteableScore LDKWriteableScore_init (JSValue o, JSValue LockableScore) {
8737 LDKWriteableScore_JCalls *calls = MALLOC(sizeof(LDKWriteableScore_JCalls), "LDKWriteableScore_JCalls");
8738 atomic_init(&calls->refcnt, 1);
8739 calls->instance_ptr = o;
8741 LDKWriteableScore ret = {
8742 .this_arg = (void*) calls,
8743 .write = write_LDKWriteableScore_jcall,
8744 .free = LDKWriteableScore_JCalls_free,
8745 .LockableScore = LDKLockableScore_init(LockableScore),
8747 calls->LockableScore = ret.LockableScore.this_arg;
8750 uint64_t __attribute__((export_name("TS_LDKWriteableScore_new"))) TS_LDKWriteableScore_new(JSValue o, JSValue LockableScore) {
8751 LDKWriteableScore *res_ptr = MALLOC(sizeof(LDKWriteableScore), "LDKWriteableScore");
8752 *res_ptr = LDKWriteableScore_init(o, LockableScore);
8753 return tag_ptr(res_ptr, true);
8755 int8_tArray __attribute__((export_name("TS_WriteableScore_write"))) TS_WriteableScore_write(uint64_t this_arg) {
8756 void* this_arg_ptr = untag_ptr(this_arg);
8757 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
8758 LDKWriteableScore* this_arg_conv = (LDKWriteableScore*)this_arg_ptr;
8759 LDKCVec_u8Z ret_var = (this_arg_conv->write)(this_arg_conv->this_arg);
8760 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
8761 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
8762 CVec_u8Z_free(ret_var);
8766 typedef struct LDKPersister_JCalls {
8767 atomic_size_t refcnt;
8768 uint32_t instance_ptr;
8769 } LDKPersister_JCalls;
8770 static void LDKPersister_JCalls_free(void* this_arg) {
8771 LDKPersister_JCalls *j_calls = (LDKPersister_JCalls*) this_arg;
8772 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
8776 LDKCResult_NoneErrorZ persist_manager_LDKPersister_jcall(const void* this_arg, const LDKChannelManager * channel_manager) {
8777 LDKPersister_JCalls *j_calls = (LDKPersister_JCalls*) this_arg;
8778 LDKChannelManager channel_manager_var = *channel_manager;
8779 uint64_t channel_manager_ref = 0;
8780 // WARNING: we may need a move here but no clone is available for LDKChannelManager
8781 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_manager_var);
8782 channel_manager_ref = tag_ptr(channel_manager_var.inner, channel_manager_var.is_owned);
8783 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 52, channel_manager_ref, 0, 0, 0, 0, 0);
8784 void* ret_ptr = untag_ptr(ret);
8785 CHECK_ACCESS(ret_ptr);
8786 LDKCResult_NoneErrorZ ret_conv = *(LDKCResult_NoneErrorZ*)(ret_ptr);
8787 FREE(untag_ptr(ret));
8790 LDKCResult_NoneErrorZ persist_graph_LDKPersister_jcall(const void* this_arg, const LDKNetworkGraph * network_graph) {
8791 LDKPersister_JCalls *j_calls = (LDKPersister_JCalls*) this_arg;
8792 LDKNetworkGraph network_graph_var = *network_graph;
8793 uint64_t network_graph_ref = 0;
8794 // WARNING: we may need a move here but no clone is available for LDKNetworkGraph
8795 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_var);
8796 network_graph_ref = tag_ptr(network_graph_var.inner, network_graph_var.is_owned);
8797 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 53, network_graph_ref, 0, 0, 0, 0, 0);
8798 void* ret_ptr = untag_ptr(ret);
8799 CHECK_ACCESS(ret_ptr);
8800 LDKCResult_NoneErrorZ ret_conv = *(LDKCResult_NoneErrorZ*)(ret_ptr);
8801 FREE(untag_ptr(ret));
8804 LDKCResult_NoneErrorZ persist_scorer_LDKPersister_jcall(const void* this_arg, const LDKWriteableScore * scorer) {
8805 LDKPersister_JCalls *j_calls = (LDKPersister_JCalls*) this_arg;
8806 // WARNING: This object doesn't live past this scope, needs clone!
8807 uint64_t ret_scorer = tag_ptr(scorer, false);
8808 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 54, ret_scorer, 0, 0, 0, 0, 0);
8809 void* ret_ptr = untag_ptr(ret);
8810 CHECK_ACCESS(ret_ptr);
8811 LDKCResult_NoneErrorZ ret_conv = *(LDKCResult_NoneErrorZ*)(ret_ptr);
8812 FREE(untag_ptr(ret));
8815 static void LDKPersister_JCalls_cloned(LDKPersister* new_obj) {
8816 LDKPersister_JCalls *j_calls = (LDKPersister_JCalls*) new_obj->this_arg;
8817 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
8819 static inline LDKPersister LDKPersister_init (JSValue o) {
8820 LDKPersister_JCalls *calls = MALLOC(sizeof(LDKPersister_JCalls), "LDKPersister_JCalls");
8821 atomic_init(&calls->refcnt, 1);
8822 calls->instance_ptr = o;
8824 LDKPersister ret = {
8825 .this_arg = (void*) calls,
8826 .persist_manager = persist_manager_LDKPersister_jcall,
8827 .persist_graph = persist_graph_LDKPersister_jcall,
8828 .persist_scorer = persist_scorer_LDKPersister_jcall,
8829 .free = LDKPersister_JCalls_free,
8833 uint64_t __attribute__((export_name("TS_LDKPersister_new"))) TS_LDKPersister_new(JSValue o) {
8834 LDKPersister *res_ptr = MALLOC(sizeof(LDKPersister), "LDKPersister");
8835 *res_ptr = LDKPersister_init(o);
8836 return tag_ptr(res_ptr, true);
8838 uint64_t __attribute__((export_name("TS_Persister_persist_manager"))) TS_Persister_persist_manager(uint64_t this_arg, uint64_t channel_manager) {
8839 void* this_arg_ptr = untag_ptr(this_arg);
8840 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
8841 LDKPersister* this_arg_conv = (LDKPersister*)this_arg_ptr;
8842 LDKChannelManager channel_manager_conv;
8843 channel_manager_conv.inner = untag_ptr(channel_manager);
8844 channel_manager_conv.is_owned = ptr_is_owned(channel_manager);
8845 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_manager_conv);
8846 channel_manager_conv.is_owned = false;
8847 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
8848 *ret_conv = (this_arg_conv->persist_manager)(this_arg_conv->this_arg, &channel_manager_conv);
8849 return tag_ptr(ret_conv, true);
8852 uint64_t __attribute__((export_name("TS_Persister_persist_graph"))) TS_Persister_persist_graph(uint64_t this_arg, uint64_t network_graph) {
8853 void* this_arg_ptr = untag_ptr(this_arg);
8854 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
8855 LDKPersister* this_arg_conv = (LDKPersister*)this_arg_ptr;
8856 LDKNetworkGraph network_graph_conv;
8857 network_graph_conv.inner = untag_ptr(network_graph);
8858 network_graph_conv.is_owned = ptr_is_owned(network_graph);
8859 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
8860 network_graph_conv.is_owned = false;
8861 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
8862 *ret_conv = (this_arg_conv->persist_graph)(this_arg_conv->this_arg, &network_graph_conv);
8863 return tag_ptr(ret_conv, true);
8866 uint64_t __attribute__((export_name("TS_Persister_persist_scorer"))) TS_Persister_persist_scorer(uint64_t this_arg, uint64_t scorer) {
8867 void* this_arg_ptr = untag_ptr(this_arg);
8868 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
8869 LDKPersister* this_arg_conv = (LDKPersister*)this_arg_ptr;
8870 void* scorer_ptr = untag_ptr(scorer);
8871 if (ptr_is_owned(scorer)) { CHECK_ACCESS(scorer_ptr); }
8872 LDKWriteableScore* scorer_conv = (LDKWriteableScore*)scorer_ptr;
8873 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
8874 *ret_conv = (this_arg_conv->persist_scorer)(this_arg_conv->this_arg, scorer_conv);
8875 return tag_ptr(ret_conv, true);
8878 typedef struct LDKFutureCallback_JCalls {
8879 atomic_size_t refcnt;
8880 uint32_t instance_ptr;
8881 } LDKFutureCallback_JCalls;
8882 static void LDKFutureCallback_JCalls_free(void* this_arg) {
8883 LDKFutureCallback_JCalls *j_calls = (LDKFutureCallback_JCalls*) this_arg;
8884 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
8888 void call_LDKFutureCallback_jcall(const void* this_arg) {
8889 LDKFutureCallback_JCalls *j_calls = (LDKFutureCallback_JCalls*) this_arg;
8890 js_invoke_function_uuuuuu(j_calls->instance_ptr, 55, 0, 0, 0, 0, 0, 0);
8892 static void LDKFutureCallback_JCalls_cloned(LDKFutureCallback* new_obj) {
8893 LDKFutureCallback_JCalls *j_calls = (LDKFutureCallback_JCalls*) new_obj->this_arg;
8894 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
8896 static inline LDKFutureCallback LDKFutureCallback_init (JSValue o) {
8897 LDKFutureCallback_JCalls *calls = MALLOC(sizeof(LDKFutureCallback_JCalls), "LDKFutureCallback_JCalls");
8898 atomic_init(&calls->refcnt, 1);
8899 calls->instance_ptr = o;
8901 LDKFutureCallback ret = {
8902 .this_arg = (void*) calls,
8903 .call = call_LDKFutureCallback_jcall,
8904 .free = LDKFutureCallback_JCalls_free,
8908 uint64_t __attribute__((export_name("TS_LDKFutureCallback_new"))) TS_LDKFutureCallback_new(JSValue o) {
8909 LDKFutureCallback *res_ptr = MALLOC(sizeof(LDKFutureCallback), "LDKFutureCallback");
8910 *res_ptr = LDKFutureCallback_init(o);
8911 return tag_ptr(res_ptr, true);
8913 void __attribute__((export_name("TS_FutureCallback_call"))) TS_FutureCallback_call(uint64_t this_arg) {
8914 void* this_arg_ptr = untag_ptr(this_arg);
8915 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
8916 LDKFutureCallback* this_arg_conv = (LDKFutureCallback*)this_arg_ptr;
8917 (this_arg_conv->call)(this_arg_conv->this_arg);
8920 typedef struct LDKListen_JCalls {
8921 atomic_size_t refcnt;
8922 uint32_t instance_ptr;
8924 static void LDKListen_JCalls_free(void* this_arg) {
8925 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
8926 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
8930 void filtered_block_connected_LDKListen_jcall(const void* this_arg, const uint8_t (* header)[80], LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height) {
8931 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
8932 int8_tArray header_arr = init_int8_tArray(80, __LINE__);
8933 memcpy(header_arr->elems, *header, 80);
8934 LDKCVec_C2Tuple_usizeTransactionZZ txdata_var = txdata;
8935 uint64_tArray txdata_arr = NULL;
8936 txdata_arr = init_uint64_tArray(txdata_var.datalen, __LINE__);
8937 uint64_t *txdata_arr_ptr = (uint64_t*)(((uint8_t*)txdata_arr) + 8);
8938 for (size_t c = 0; c < txdata_var.datalen; c++) {
8939 LDKC2Tuple_usizeTransactionZ* txdata_conv_28_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
8940 *txdata_conv_28_conv = txdata_var.data[c];
8941 txdata_arr_ptr[c] = tag_ptr(txdata_conv_28_conv, true);
8944 FREE(txdata_var.data);
8945 int32_t height_conv = height;
8946 js_invoke_function_uuuuuu(j_calls->instance_ptr, 56, (uint32_t)header_arr, (uint32_t)txdata_arr, height_conv, 0, 0, 0);
8948 void block_connected_LDKListen_jcall(const void* this_arg, LDKu8slice block, uint32_t height) {
8949 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
8950 LDKu8slice block_var = block;
8951 int8_tArray block_arr = init_int8_tArray(block_var.datalen, __LINE__);
8952 memcpy(block_arr->elems, block_var.data, block_var.datalen);
8953 int32_t height_conv = height;
8954 js_invoke_function_uuuuuu(j_calls->instance_ptr, 57, (uint32_t)block_arr, height_conv, 0, 0, 0, 0);
8956 void block_disconnected_LDKListen_jcall(const void* this_arg, const uint8_t (* header)[80], uint32_t height) {
8957 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
8958 int8_tArray header_arr = init_int8_tArray(80, __LINE__);
8959 memcpy(header_arr->elems, *header, 80);
8960 int32_t height_conv = height;
8961 js_invoke_function_uuuuuu(j_calls->instance_ptr, 58, (uint32_t)header_arr, height_conv, 0, 0, 0, 0);
8963 static void LDKListen_JCalls_cloned(LDKListen* new_obj) {
8964 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) new_obj->this_arg;
8965 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
8967 static inline LDKListen LDKListen_init (JSValue o) {
8968 LDKListen_JCalls *calls = MALLOC(sizeof(LDKListen_JCalls), "LDKListen_JCalls");
8969 atomic_init(&calls->refcnt, 1);
8970 calls->instance_ptr = o;
8973 .this_arg = (void*) calls,
8974 .filtered_block_connected = filtered_block_connected_LDKListen_jcall,
8975 .block_connected = block_connected_LDKListen_jcall,
8976 .block_disconnected = block_disconnected_LDKListen_jcall,
8977 .free = LDKListen_JCalls_free,
8981 uint64_t __attribute__((export_name("TS_LDKListen_new"))) TS_LDKListen_new(JSValue o) {
8982 LDKListen *res_ptr = MALLOC(sizeof(LDKListen), "LDKListen");
8983 *res_ptr = LDKListen_init(o);
8984 return tag_ptr(res_ptr, true);
8986 void __attribute__((export_name("TS_Listen_filtered_block_connected"))) TS_Listen_filtered_block_connected(uint64_t this_arg, int8_tArray header, uint64_tArray txdata, int32_t height) {
8987 void* this_arg_ptr = untag_ptr(this_arg);
8988 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
8989 LDKListen* this_arg_conv = (LDKListen*)this_arg_ptr;
8990 unsigned char header_arr[80];
8991 CHECK(header->arr_len == 80);
8992 memcpy(header_arr, header->elems, 80); FREE(header);
8993 unsigned char (*header_ref)[80] = &header_arr;
8994 LDKCVec_C2Tuple_usizeTransactionZZ txdata_constr;
8995 txdata_constr.datalen = txdata->arr_len;
8996 if (txdata_constr.datalen > 0)
8997 txdata_constr.data = MALLOC(txdata_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
8999 txdata_constr.data = NULL;
9000 uint64_t* txdata_vals = txdata->elems;
9001 for (size_t c = 0; c < txdata_constr.datalen; c++) {
9002 uint64_t txdata_conv_28 = txdata_vals[c];
9003 void* txdata_conv_28_ptr = untag_ptr(txdata_conv_28);
9004 CHECK_ACCESS(txdata_conv_28_ptr);
9005 LDKC2Tuple_usizeTransactionZ txdata_conv_28_conv = *(LDKC2Tuple_usizeTransactionZ*)(txdata_conv_28_ptr);
9006 txdata_conv_28_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)untag_ptr(txdata_conv_28));
9007 txdata_constr.data[c] = txdata_conv_28_conv;
9010 (this_arg_conv->filtered_block_connected)(this_arg_conv->this_arg, header_ref, txdata_constr, height);
9013 void __attribute__((export_name("TS_Listen_block_connected"))) TS_Listen_block_connected(uint64_t this_arg, int8_tArray block, int32_t height) {
9014 void* this_arg_ptr = untag_ptr(this_arg);
9015 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9016 LDKListen* this_arg_conv = (LDKListen*)this_arg_ptr;
9017 LDKu8slice block_ref;
9018 block_ref.datalen = block->arr_len;
9019 block_ref.data = block->elems;
9020 (this_arg_conv->block_connected)(this_arg_conv->this_arg, block_ref, height);
9024 void __attribute__((export_name("TS_Listen_block_disconnected"))) TS_Listen_block_disconnected(uint64_t this_arg, int8_tArray header, int32_t height) {
9025 void* this_arg_ptr = untag_ptr(this_arg);
9026 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9027 LDKListen* this_arg_conv = (LDKListen*)this_arg_ptr;
9028 unsigned char header_arr[80];
9029 CHECK(header->arr_len == 80);
9030 memcpy(header_arr, header->elems, 80); FREE(header);
9031 unsigned char (*header_ref)[80] = &header_arr;
9032 (this_arg_conv->block_disconnected)(this_arg_conv->this_arg, header_ref, height);
9035 typedef struct LDKConfirm_JCalls {
9036 atomic_size_t refcnt;
9037 uint32_t instance_ptr;
9038 } LDKConfirm_JCalls;
9039 static void LDKConfirm_JCalls_free(void* this_arg) {
9040 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
9041 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
9045 void transactions_confirmed_LDKConfirm_jcall(const void* this_arg, const uint8_t (* header)[80], LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height) {
9046 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
9047 int8_tArray header_arr = init_int8_tArray(80, __LINE__);
9048 memcpy(header_arr->elems, *header, 80);
9049 LDKCVec_C2Tuple_usizeTransactionZZ txdata_var = txdata;
9050 uint64_tArray txdata_arr = NULL;
9051 txdata_arr = init_uint64_tArray(txdata_var.datalen, __LINE__);
9052 uint64_t *txdata_arr_ptr = (uint64_t*)(((uint8_t*)txdata_arr) + 8);
9053 for (size_t c = 0; c < txdata_var.datalen; c++) {
9054 LDKC2Tuple_usizeTransactionZ* txdata_conv_28_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
9055 *txdata_conv_28_conv = txdata_var.data[c];
9056 txdata_arr_ptr[c] = tag_ptr(txdata_conv_28_conv, true);
9059 FREE(txdata_var.data);
9060 int32_t height_conv = height;
9061 js_invoke_function_uuuuuu(j_calls->instance_ptr, 59, (uint32_t)header_arr, (uint32_t)txdata_arr, height_conv, 0, 0, 0);
9063 void transaction_unconfirmed_LDKConfirm_jcall(const void* this_arg, const uint8_t (* txid)[32]) {
9064 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
9065 int8_tArray txid_arr = init_int8_tArray(32, __LINE__);
9066 memcpy(txid_arr->elems, *txid, 32);
9067 js_invoke_function_uuuuuu(j_calls->instance_ptr, 60, (uint32_t)txid_arr, 0, 0, 0, 0, 0);
9069 void best_block_updated_LDKConfirm_jcall(const void* this_arg, const uint8_t (* header)[80], uint32_t height) {
9070 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
9071 int8_tArray header_arr = init_int8_tArray(80, __LINE__);
9072 memcpy(header_arr->elems, *header, 80);
9073 int32_t height_conv = height;
9074 js_invoke_function_uuuuuu(j_calls->instance_ptr, 61, (uint32_t)header_arr, height_conv, 0, 0, 0, 0);
9076 LDKCVec_C2Tuple_TxidBlockHashZZ get_relevant_txids_LDKConfirm_jcall(const void* this_arg) {
9077 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
9078 uint64_tArray ret = (uint64_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 62, 0, 0, 0, 0, 0, 0);
9079 LDKCVec_C2Tuple_TxidBlockHashZZ ret_constr;
9080 ret_constr.datalen = ret->arr_len;
9081 if (ret_constr.datalen > 0)
9082 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKC2Tuple_TxidBlockHashZ), "LDKCVec_C2Tuple_TxidBlockHashZZ Elements");
9084 ret_constr.data = NULL;
9085 uint64_t* ret_vals = ret->elems;
9086 for (size_t z = 0; z < ret_constr.datalen; z++) {
9087 uint64_t ret_conv_25 = ret_vals[z];
9088 void* ret_conv_25_ptr = untag_ptr(ret_conv_25);
9089 CHECK_ACCESS(ret_conv_25_ptr);
9090 LDKC2Tuple_TxidBlockHashZ ret_conv_25_conv = *(LDKC2Tuple_TxidBlockHashZ*)(ret_conv_25_ptr);
9091 FREE(untag_ptr(ret_conv_25));
9092 ret_constr.data[z] = ret_conv_25_conv;
9097 static void LDKConfirm_JCalls_cloned(LDKConfirm* new_obj) {
9098 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) new_obj->this_arg;
9099 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
9101 static inline LDKConfirm LDKConfirm_init (JSValue o) {
9102 LDKConfirm_JCalls *calls = MALLOC(sizeof(LDKConfirm_JCalls), "LDKConfirm_JCalls");
9103 atomic_init(&calls->refcnt, 1);
9104 calls->instance_ptr = o;
9107 .this_arg = (void*) calls,
9108 .transactions_confirmed = transactions_confirmed_LDKConfirm_jcall,
9109 .transaction_unconfirmed = transaction_unconfirmed_LDKConfirm_jcall,
9110 .best_block_updated = best_block_updated_LDKConfirm_jcall,
9111 .get_relevant_txids = get_relevant_txids_LDKConfirm_jcall,
9112 .free = LDKConfirm_JCalls_free,
9116 uint64_t __attribute__((export_name("TS_LDKConfirm_new"))) TS_LDKConfirm_new(JSValue o) {
9117 LDKConfirm *res_ptr = MALLOC(sizeof(LDKConfirm), "LDKConfirm");
9118 *res_ptr = LDKConfirm_init(o);
9119 return tag_ptr(res_ptr, true);
9121 void __attribute__((export_name("TS_Confirm_transactions_confirmed"))) TS_Confirm_transactions_confirmed(uint64_t this_arg, int8_tArray header, uint64_tArray txdata, int32_t height) {
9122 void* this_arg_ptr = untag_ptr(this_arg);
9123 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9124 LDKConfirm* this_arg_conv = (LDKConfirm*)this_arg_ptr;
9125 unsigned char header_arr[80];
9126 CHECK(header->arr_len == 80);
9127 memcpy(header_arr, header->elems, 80); FREE(header);
9128 unsigned char (*header_ref)[80] = &header_arr;
9129 LDKCVec_C2Tuple_usizeTransactionZZ txdata_constr;
9130 txdata_constr.datalen = txdata->arr_len;
9131 if (txdata_constr.datalen > 0)
9132 txdata_constr.data = MALLOC(txdata_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
9134 txdata_constr.data = NULL;
9135 uint64_t* txdata_vals = txdata->elems;
9136 for (size_t c = 0; c < txdata_constr.datalen; c++) {
9137 uint64_t txdata_conv_28 = txdata_vals[c];
9138 void* txdata_conv_28_ptr = untag_ptr(txdata_conv_28);
9139 CHECK_ACCESS(txdata_conv_28_ptr);
9140 LDKC2Tuple_usizeTransactionZ txdata_conv_28_conv = *(LDKC2Tuple_usizeTransactionZ*)(txdata_conv_28_ptr);
9141 txdata_conv_28_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)untag_ptr(txdata_conv_28));
9142 txdata_constr.data[c] = txdata_conv_28_conv;
9145 (this_arg_conv->transactions_confirmed)(this_arg_conv->this_arg, header_ref, txdata_constr, height);
9148 void __attribute__((export_name("TS_Confirm_transaction_unconfirmed"))) TS_Confirm_transaction_unconfirmed(uint64_t this_arg, int8_tArray txid) {
9149 void* this_arg_ptr = untag_ptr(this_arg);
9150 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9151 LDKConfirm* this_arg_conv = (LDKConfirm*)this_arg_ptr;
9152 unsigned char txid_arr[32];
9153 CHECK(txid->arr_len == 32);
9154 memcpy(txid_arr, txid->elems, 32); FREE(txid);
9155 unsigned char (*txid_ref)[32] = &txid_arr;
9156 (this_arg_conv->transaction_unconfirmed)(this_arg_conv->this_arg, txid_ref);
9159 void __attribute__((export_name("TS_Confirm_best_block_updated"))) TS_Confirm_best_block_updated(uint64_t this_arg, int8_tArray header, int32_t height) {
9160 void* this_arg_ptr = untag_ptr(this_arg);
9161 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9162 LDKConfirm* this_arg_conv = (LDKConfirm*)this_arg_ptr;
9163 unsigned char header_arr[80];
9164 CHECK(header->arr_len == 80);
9165 memcpy(header_arr, header->elems, 80); FREE(header);
9166 unsigned char (*header_ref)[80] = &header_arr;
9167 (this_arg_conv->best_block_updated)(this_arg_conv->this_arg, header_ref, height);
9170 uint64_tArray __attribute__((export_name("TS_Confirm_get_relevant_txids"))) TS_Confirm_get_relevant_txids(uint64_t this_arg) {
9171 void* this_arg_ptr = untag_ptr(this_arg);
9172 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9173 LDKConfirm* this_arg_conv = (LDKConfirm*)this_arg_ptr;
9174 LDKCVec_C2Tuple_TxidBlockHashZZ ret_var = (this_arg_conv->get_relevant_txids)(this_arg_conv->this_arg);
9175 uint64_tArray ret_arr = NULL;
9176 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
9177 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
9178 for (size_t z = 0; z < ret_var.datalen; z++) {
9179 LDKC2Tuple_TxidBlockHashZ* ret_conv_25_conv = MALLOC(sizeof(LDKC2Tuple_TxidBlockHashZ), "LDKC2Tuple_TxidBlockHashZ");
9180 *ret_conv_25_conv = ret_var.data[z];
9181 ret_arr_ptr[z] = tag_ptr(ret_conv_25_conv, true);
9188 typedef struct LDKPersist_JCalls {
9189 atomic_size_t refcnt;
9190 uint32_t instance_ptr;
9191 } LDKPersist_JCalls;
9192 static void LDKPersist_JCalls_free(void* this_arg) {
9193 LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) this_arg;
9194 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
9198 LDKChannelMonitorUpdateStatus persist_new_channel_LDKPersist_jcall(const void* this_arg, LDKOutPoint channel_id, const LDKChannelMonitor * data, LDKMonitorUpdateId update_id) {
9199 LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) this_arg;
9200 LDKOutPoint channel_id_var = channel_id;
9201 uint64_t channel_id_ref = 0;
9202 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_var);
9203 channel_id_ref = tag_ptr(channel_id_var.inner, channel_id_var.is_owned);
9204 LDKChannelMonitor data_var = *data;
9205 uint64_t data_ref = 0;
9206 data_var = ChannelMonitor_clone(&data_var);
9207 CHECK_INNER_FIELD_ACCESS_OR_NULL(data_var);
9208 data_ref = tag_ptr(data_var.inner, data_var.is_owned);
9209 LDKMonitorUpdateId update_id_var = update_id;
9210 uint64_t update_id_ref = 0;
9211 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_var);
9212 update_id_ref = tag_ptr(update_id_var.inner, update_id_var.is_owned);
9213 uint64_t ret = js_invoke_function_bbbuuu(j_calls->instance_ptr, 63, channel_id_ref, data_ref, update_id_ref, 0, 0, 0);
9214 LDKChannelMonitorUpdateStatus ret_conv = LDKChannelMonitorUpdateStatus_from_js(ret);
9217 LDKChannelMonitorUpdateStatus update_persisted_channel_LDKPersist_jcall(const void* this_arg, LDKOutPoint channel_id, const LDKChannelMonitorUpdate * update, const LDKChannelMonitor * data, LDKMonitorUpdateId update_id) {
9218 LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) this_arg;
9219 LDKOutPoint channel_id_var = channel_id;
9220 uint64_t channel_id_ref = 0;
9221 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_var);
9222 channel_id_ref = tag_ptr(channel_id_var.inner, channel_id_var.is_owned);
9223 LDKChannelMonitorUpdate update_var = *update;
9224 uint64_t update_ref = 0;
9225 update_var = ChannelMonitorUpdate_clone(&update_var);
9226 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_var);
9227 update_ref = tag_ptr(update_var.inner, update_var.is_owned);
9228 LDKChannelMonitor data_var = *data;
9229 uint64_t data_ref = 0;
9230 data_var = ChannelMonitor_clone(&data_var);
9231 CHECK_INNER_FIELD_ACCESS_OR_NULL(data_var);
9232 data_ref = tag_ptr(data_var.inner, data_var.is_owned);
9233 LDKMonitorUpdateId update_id_var = update_id;
9234 uint64_t update_id_ref = 0;
9235 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_var);
9236 update_id_ref = tag_ptr(update_id_var.inner, update_id_var.is_owned);
9237 uint64_t ret = js_invoke_function_bbbbuu(j_calls->instance_ptr, 64, channel_id_ref, update_ref, data_ref, update_id_ref, 0, 0);
9238 LDKChannelMonitorUpdateStatus ret_conv = LDKChannelMonitorUpdateStatus_from_js(ret);
9241 static void LDKPersist_JCalls_cloned(LDKPersist* new_obj) {
9242 LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) new_obj->this_arg;
9243 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
9245 static inline LDKPersist LDKPersist_init (JSValue o) {
9246 LDKPersist_JCalls *calls = MALLOC(sizeof(LDKPersist_JCalls), "LDKPersist_JCalls");
9247 atomic_init(&calls->refcnt, 1);
9248 calls->instance_ptr = o;
9251 .this_arg = (void*) calls,
9252 .persist_new_channel = persist_new_channel_LDKPersist_jcall,
9253 .update_persisted_channel = update_persisted_channel_LDKPersist_jcall,
9254 .free = LDKPersist_JCalls_free,
9258 uint64_t __attribute__((export_name("TS_LDKPersist_new"))) TS_LDKPersist_new(JSValue o) {
9259 LDKPersist *res_ptr = MALLOC(sizeof(LDKPersist), "LDKPersist");
9260 *res_ptr = LDKPersist_init(o);
9261 return tag_ptr(res_ptr, true);
9263 uint32_t __attribute__((export_name("TS_Persist_persist_new_channel"))) TS_Persist_persist_new_channel(uint64_t this_arg, uint64_t channel_id, uint64_t data, uint64_t update_id) {
9264 void* this_arg_ptr = untag_ptr(this_arg);
9265 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9266 LDKPersist* this_arg_conv = (LDKPersist*)this_arg_ptr;
9267 LDKOutPoint channel_id_conv;
9268 channel_id_conv.inner = untag_ptr(channel_id);
9269 channel_id_conv.is_owned = ptr_is_owned(channel_id);
9270 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_conv);
9271 channel_id_conv = OutPoint_clone(&channel_id_conv);
9272 LDKChannelMonitor data_conv;
9273 data_conv.inner = untag_ptr(data);
9274 data_conv.is_owned = ptr_is_owned(data);
9275 CHECK_INNER_FIELD_ACCESS_OR_NULL(data_conv);
9276 data_conv.is_owned = false;
9277 LDKMonitorUpdateId update_id_conv;
9278 update_id_conv.inner = untag_ptr(update_id);
9279 update_id_conv.is_owned = ptr_is_owned(update_id);
9280 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_conv);
9281 update_id_conv = MonitorUpdateId_clone(&update_id_conv);
9282 uint32_t ret_conv = LDKChannelMonitorUpdateStatus_to_js((this_arg_conv->persist_new_channel)(this_arg_conv->this_arg, channel_id_conv, &data_conv, update_id_conv));
9286 uint32_t __attribute__((export_name("TS_Persist_update_persisted_channel"))) TS_Persist_update_persisted_channel(uint64_t this_arg, uint64_t channel_id, uint64_t update, uint64_t data, uint64_t update_id) {
9287 void* this_arg_ptr = untag_ptr(this_arg);
9288 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9289 LDKPersist* this_arg_conv = (LDKPersist*)this_arg_ptr;
9290 LDKOutPoint channel_id_conv;
9291 channel_id_conv.inner = untag_ptr(channel_id);
9292 channel_id_conv.is_owned = ptr_is_owned(channel_id);
9293 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_conv);
9294 channel_id_conv = OutPoint_clone(&channel_id_conv);
9295 LDKChannelMonitorUpdate update_conv;
9296 update_conv.inner = untag_ptr(update);
9297 update_conv.is_owned = ptr_is_owned(update);
9298 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_conv);
9299 update_conv.is_owned = false;
9300 LDKChannelMonitor data_conv;
9301 data_conv.inner = untag_ptr(data);
9302 data_conv.is_owned = ptr_is_owned(data);
9303 CHECK_INNER_FIELD_ACCESS_OR_NULL(data_conv);
9304 data_conv.is_owned = false;
9305 LDKMonitorUpdateId update_id_conv;
9306 update_id_conv.inner = untag_ptr(update_id);
9307 update_id_conv.is_owned = ptr_is_owned(update_id);
9308 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_conv);
9309 update_id_conv = MonitorUpdateId_clone(&update_id_conv);
9310 uint32_t ret_conv = LDKChannelMonitorUpdateStatus_to_js((this_arg_conv->update_persisted_channel)(this_arg_conv->this_arg, channel_id_conv, &update_conv, &data_conv, update_id_conv));
9314 typedef struct LDKChannelMessageHandler_JCalls {
9315 atomic_size_t refcnt;
9316 uint32_t instance_ptr;
9317 LDKMessageSendEventsProvider_JCalls* MessageSendEventsProvider;
9318 } LDKChannelMessageHandler_JCalls;
9319 static void LDKChannelMessageHandler_JCalls_free(void* this_arg) {
9320 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9321 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
9325 void handle_open_channel_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKInitFeatures their_features, const LDKOpenChannel * msg) {
9326 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9327 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9328 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9329 LDKInitFeatures their_features_var = their_features;
9330 uint64_t their_features_ref = 0;
9331 CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_var);
9332 their_features_ref = tag_ptr(their_features_var.inner, their_features_var.is_owned);
9333 LDKOpenChannel msg_var = *msg;
9334 uint64_t msg_ref = 0;
9335 msg_var = OpenChannel_clone(&msg_var);
9336 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9337 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
9338 js_invoke_function_ubbuuu(j_calls->instance_ptr, 65, (uint32_t)their_node_id_arr, their_features_ref, msg_ref, 0, 0, 0);
9340 void handle_accept_channel_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKInitFeatures their_features, const LDKAcceptChannel * msg) {
9341 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9342 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9343 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9344 LDKInitFeatures their_features_var = their_features;
9345 uint64_t their_features_ref = 0;
9346 CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_var);
9347 their_features_ref = tag_ptr(their_features_var.inner, their_features_var.is_owned);
9348 LDKAcceptChannel msg_var = *msg;
9349 uint64_t msg_ref = 0;
9350 msg_var = AcceptChannel_clone(&msg_var);
9351 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9352 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
9353 js_invoke_function_ubbuuu(j_calls->instance_ptr, 66, (uint32_t)their_node_id_arr, their_features_ref, msg_ref, 0, 0, 0);
9355 void handle_funding_created_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKFundingCreated * msg) {
9356 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9357 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9358 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9359 LDKFundingCreated msg_var = *msg;
9360 uint64_t msg_ref = 0;
9361 msg_var = FundingCreated_clone(&msg_var);
9362 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9363 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
9364 js_invoke_function_ubuuuu(j_calls->instance_ptr, 67, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
9366 void handle_funding_signed_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKFundingSigned * msg) {
9367 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9368 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9369 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9370 LDKFundingSigned msg_var = *msg;
9371 uint64_t msg_ref = 0;
9372 msg_var = FundingSigned_clone(&msg_var);
9373 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9374 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
9375 js_invoke_function_ubuuuu(j_calls->instance_ptr, 68, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
9377 void handle_channel_ready_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKChannelReady * msg) {
9378 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9379 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9380 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9381 LDKChannelReady msg_var = *msg;
9382 uint64_t msg_ref = 0;
9383 msg_var = ChannelReady_clone(&msg_var);
9384 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9385 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
9386 js_invoke_function_ubuuuu(j_calls->instance_ptr, 69, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
9388 void handle_shutdown_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInitFeatures * their_features, const LDKShutdown * msg) {
9389 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9390 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9391 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9392 LDKInitFeatures their_features_var = *their_features;
9393 uint64_t their_features_ref = 0;
9394 their_features_var = InitFeatures_clone(&their_features_var);
9395 CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_var);
9396 their_features_ref = tag_ptr(their_features_var.inner, their_features_var.is_owned);
9397 LDKShutdown msg_var = *msg;
9398 uint64_t msg_ref = 0;
9399 msg_var = Shutdown_clone(&msg_var);
9400 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9401 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
9402 js_invoke_function_ubbuuu(j_calls->instance_ptr, 70, (uint32_t)their_node_id_arr, their_features_ref, msg_ref, 0, 0, 0);
9404 void handle_closing_signed_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKClosingSigned * msg) {
9405 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9406 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9407 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9408 LDKClosingSigned msg_var = *msg;
9409 uint64_t msg_ref = 0;
9410 msg_var = ClosingSigned_clone(&msg_var);
9411 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9412 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
9413 js_invoke_function_ubuuuu(j_calls->instance_ptr, 71, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
9415 void handle_update_add_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateAddHTLC * msg) {
9416 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9417 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9418 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9419 LDKUpdateAddHTLC msg_var = *msg;
9420 uint64_t msg_ref = 0;
9421 msg_var = UpdateAddHTLC_clone(&msg_var);
9422 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9423 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
9424 js_invoke_function_ubuuuu(j_calls->instance_ptr, 72, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
9426 void handle_update_fulfill_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFulfillHTLC * msg) {
9427 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9428 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9429 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9430 LDKUpdateFulfillHTLC msg_var = *msg;
9431 uint64_t msg_ref = 0;
9432 msg_var = UpdateFulfillHTLC_clone(&msg_var);
9433 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9434 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
9435 js_invoke_function_ubuuuu(j_calls->instance_ptr, 73, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
9437 void handle_update_fail_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFailHTLC * msg) {
9438 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9439 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9440 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9441 LDKUpdateFailHTLC msg_var = *msg;
9442 uint64_t msg_ref = 0;
9443 msg_var = UpdateFailHTLC_clone(&msg_var);
9444 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9445 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
9446 js_invoke_function_ubuuuu(j_calls->instance_ptr, 74, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
9448 void handle_update_fail_malformed_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFailMalformedHTLC * msg) {
9449 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9450 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9451 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9452 LDKUpdateFailMalformedHTLC msg_var = *msg;
9453 uint64_t msg_ref = 0;
9454 msg_var = UpdateFailMalformedHTLC_clone(&msg_var);
9455 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9456 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
9457 js_invoke_function_ubuuuu(j_calls->instance_ptr, 75, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
9459 void handle_commitment_signed_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKCommitmentSigned * msg) {
9460 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9461 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9462 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9463 LDKCommitmentSigned msg_var = *msg;
9464 uint64_t msg_ref = 0;
9465 msg_var = CommitmentSigned_clone(&msg_var);
9466 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9467 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
9468 js_invoke_function_ubuuuu(j_calls->instance_ptr, 76, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
9470 void handle_revoke_and_ack_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKRevokeAndACK * msg) {
9471 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9472 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9473 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9474 LDKRevokeAndACK msg_var = *msg;
9475 uint64_t msg_ref = 0;
9476 msg_var = RevokeAndACK_clone(&msg_var);
9477 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9478 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
9479 js_invoke_function_ubuuuu(j_calls->instance_ptr, 77, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
9481 void handle_update_fee_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFee * msg) {
9482 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9483 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9484 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9485 LDKUpdateFee msg_var = *msg;
9486 uint64_t msg_ref = 0;
9487 msg_var = UpdateFee_clone(&msg_var);
9488 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9489 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
9490 js_invoke_function_ubuuuu(j_calls->instance_ptr, 78, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
9492 void handle_announcement_signatures_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKAnnouncementSignatures * msg) {
9493 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9494 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9495 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9496 LDKAnnouncementSignatures msg_var = *msg;
9497 uint64_t msg_ref = 0;
9498 msg_var = AnnouncementSignatures_clone(&msg_var);
9499 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9500 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
9501 js_invoke_function_ubuuuu(j_calls->instance_ptr, 79, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
9503 void peer_disconnected_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, bool no_connection_possible) {
9504 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9505 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9506 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9507 jboolean no_connection_possible_conv = no_connection_possible;
9508 js_invoke_function_uuuuuu(j_calls->instance_ptr, 80, (uint32_t)their_node_id_arr, no_connection_possible_conv, 0, 0, 0, 0);
9510 LDKCResult_NoneNoneZ peer_connected_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInit * msg) {
9511 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9512 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9513 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9514 LDKInit msg_var = *msg;
9515 uint64_t msg_ref = 0;
9516 msg_var = Init_clone(&msg_var);
9517 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9518 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
9519 uint64_t ret = js_invoke_function_ubuuuu(j_calls->instance_ptr, 81, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
9520 void* ret_ptr = untag_ptr(ret);
9521 CHECK_ACCESS(ret_ptr);
9522 LDKCResult_NoneNoneZ ret_conv = *(LDKCResult_NoneNoneZ*)(ret_ptr);
9523 FREE(untag_ptr(ret));
9526 void handle_channel_reestablish_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKChannelReestablish * msg) {
9527 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9528 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9529 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9530 LDKChannelReestablish msg_var = *msg;
9531 uint64_t msg_ref = 0;
9532 msg_var = ChannelReestablish_clone(&msg_var);
9533 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9534 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
9535 js_invoke_function_ubuuuu(j_calls->instance_ptr, 82, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
9537 void handle_channel_update_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKChannelUpdate * msg) {
9538 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9539 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9540 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9541 LDKChannelUpdate msg_var = *msg;
9542 uint64_t msg_ref = 0;
9543 msg_var = ChannelUpdate_clone(&msg_var);
9544 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9545 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
9546 js_invoke_function_ubuuuu(j_calls->instance_ptr, 83, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
9548 void handle_error_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKErrorMessage * msg) {
9549 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9550 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9551 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9552 LDKErrorMessage msg_var = *msg;
9553 uint64_t msg_ref = 0;
9554 msg_var = ErrorMessage_clone(&msg_var);
9555 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9556 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
9557 js_invoke_function_ubuuuu(j_calls->instance_ptr, 84, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
9559 LDKNodeFeatures provided_node_features_LDKChannelMessageHandler_jcall(const void* this_arg) {
9560 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9561 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 85, 0, 0, 0, 0, 0, 0);
9562 LDKNodeFeatures ret_conv;
9563 ret_conv.inner = untag_ptr(ret);
9564 ret_conv.is_owned = ptr_is_owned(ret);
9565 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
9568 LDKInitFeatures provided_init_features_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id) {
9569 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9570 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9571 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9572 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 86, (uint32_t)their_node_id_arr, 0, 0, 0, 0, 0);
9573 LDKInitFeatures ret_conv;
9574 ret_conv.inner = untag_ptr(ret);
9575 ret_conv.is_owned = ptr_is_owned(ret);
9576 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
9579 static void LDKChannelMessageHandler_JCalls_cloned(LDKChannelMessageHandler* new_obj) {
9580 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) new_obj->this_arg;
9581 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
9582 atomic_fetch_add_explicit(&j_calls->MessageSendEventsProvider->refcnt, 1, memory_order_release);
9584 static inline LDKChannelMessageHandler LDKChannelMessageHandler_init (JSValue o, JSValue MessageSendEventsProvider) {
9585 LDKChannelMessageHandler_JCalls *calls = MALLOC(sizeof(LDKChannelMessageHandler_JCalls), "LDKChannelMessageHandler_JCalls");
9586 atomic_init(&calls->refcnt, 1);
9587 calls->instance_ptr = o;
9589 LDKChannelMessageHandler ret = {
9590 .this_arg = (void*) calls,
9591 .handle_open_channel = handle_open_channel_LDKChannelMessageHandler_jcall,
9592 .handle_accept_channel = handle_accept_channel_LDKChannelMessageHandler_jcall,
9593 .handle_funding_created = handle_funding_created_LDKChannelMessageHandler_jcall,
9594 .handle_funding_signed = handle_funding_signed_LDKChannelMessageHandler_jcall,
9595 .handle_channel_ready = handle_channel_ready_LDKChannelMessageHandler_jcall,
9596 .handle_shutdown = handle_shutdown_LDKChannelMessageHandler_jcall,
9597 .handle_closing_signed = handle_closing_signed_LDKChannelMessageHandler_jcall,
9598 .handle_update_add_htlc = handle_update_add_htlc_LDKChannelMessageHandler_jcall,
9599 .handle_update_fulfill_htlc = handle_update_fulfill_htlc_LDKChannelMessageHandler_jcall,
9600 .handle_update_fail_htlc = handle_update_fail_htlc_LDKChannelMessageHandler_jcall,
9601 .handle_update_fail_malformed_htlc = handle_update_fail_malformed_htlc_LDKChannelMessageHandler_jcall,
9602 .handle_commitment_signed = handle_commitment_signed_LDKChannelMessageHandler_jcall,
9603 .handle_revoke_and_ack = handle_revoke_and_ack_LDKChannelMessageHandler_jcall,
9604 .handle_update_fee = handle_update_fee_LDKChannelMessageHandler_jcall,
9605 .handle_announcement_signatures = handle_announcement_signatures_LDKChannelMessageHandler_jcall,
9606 .peer_disconnected = peer_disconnected_LDKChannelMessageHandler_jcall,
9607 .peer_connected = peer_connected_LDKChannelMessageHandler_jcall,
9608 .handle_channel_reestablish = handle_channel_reestablish_LDKChannelMessageHandler_jcall,
9609 .handle_channel_update = handle_channel_update_LDKChannelMessageHandler_jcall,
9610 .handle_error = handle_error_LDKChannelMessageHandler_jcall,
9611 .provided_node_features = provided_node_features_LDKChannelMessageHandler_jcall,
9612 .provided_init_features = provided_init_features_LDKChannelMessageHandler_jcall,
9613 .free = LDKChannelMessageHandler_JCalls_free,
9614 .MessageSendEventsProvider = LDKMessageSendEventsProvider_init(MessageSendEventsProvider),
9616 calls->MessageSendEventsProvider = ret.MessageSendEventsProvider.this_arg;
9619 uint64_t __attribute__((export_name("TS_LDKChannelMessageHandler_new"))) TS_LDKChannelMessageHandler_new(JSValue o, JSValue MessageSendEventsProvider) {
9620 LDKChannelMessageHandler *res_ptr = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
9621 *res_ptr = LDKChannelMessageHandler_init(o, MessageSendEventsProvider);
9622 return tag_ptr(res_ptr, true);
9624 void __attribute__((export_name("TS_ChannelMessageHandler_handle_open_channel"))) TS_ChannelMessageHandler_handle_open_channel(uint64_t this_arg, int8_tArray their_node_id, uint64_t their_features, uint64_t msg) {
9625 void* this_arg_ptr = untag_ptr(this_arg);
9626 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9627 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
9628 LDKPublicKey their_node_id_ref;
9629 CHECK(their_node_id->arr_len == 33);
9630 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
9631 LDKInitFeatures their_features_conv;
9632 their_features_conv.inner = untag_ptr(their_features);
9633 their_features_conv.is_owned = ptr_is_owned(their_features);
9634 CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_conv);
9635 their_features_conv = InitFeatures_clone(&their_features_conv);
9636 LDKOpenChannel msg_conv;
9637 msg_conv.inner = untag_ptr(msg);
9638 msg_conv.is_owned = ptr_is_owned(msg);
9639 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
9640 msg_conv.is_owned = false;
9641 (this_arg_conv->handle_open_channel)(this_arg_conv->this_arg, their_node_id_ref, their_features_conv, &msg_conv);
9644 void __attribute__((export_name("TS_ChannelMessageHandler_handle_accept_channel"))) TS_ChannelMessageHandler_handle_accept_channel(uint64_t this_arg, int8_tArray their_node_id, uint64_t their_features, uint64_t msg) {
9645 void* this_arg_ptr = untag_ptr(this_arg);
9646 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9647 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
9648 LDKPublicKey their_node_id_ref;
9649 CHECK(their_node_id->arr_len == 33);
9650 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
9651 LDKInitFeatures their_features_conv;
9652 their_features_conv.inner = untag_ptr(their_features);
9653 their_features_conv.is_owned = ptr_is_owned(their_features);
9654 CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_conv);
9655 their_features_conv = InitFeatures_clone(&their_features_conv);
9656 LDKAcceptChannel msg_conv;
9657 msg_conv.inner = untag_ptr(msg);
9658 msg_conv.is_owned = ptr_is_owned(msg);
9659 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
9660 msg_conv.is_owned = false;
9661 (this_arg_conv->handle_accept_channel)(this_arg_conv->this_arg, their_node_id_ref, their_features_conv, &msg_conv);
9664 void __attribute__((export_name("TS_ChannelMessageHandler_handle_funding_created"))) TS_ChannelMessageHandler_handle_funding_created(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
9665 void* this_arg_ptr = untag_ptr(this_arg);
9666 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9667 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
9668 LDKPublicKey their_node_id_ref;
9669 CHECK(their_node_id->arr_len == 33);
9670 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
9671 LDKFundingCreated msg_conv;
9672 msg_conv.inner = untag_ptr(msg);
9673 msg_conv.is_owned = ptr_is_owned(msg);
9674 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
9675 msg_conv.is_owned = false;
9676 (this_arg_conv->handle_funding_created)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
9679 void __attribute__((export_name("TS_ChannelMessageHandler_handle_funding_signed"))) TS_ChannelMessageHandler_handle_funding_signed(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
9680 void* this_arg_ptr = untag_ptr(this_arg);
9681 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9682 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
9683 LDKPublicKey their_node_id_ref;
9684 CHECK(their_node_id->arr_len == 33);
9685 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
9686 LDKFundingSigned msg_conv;
9687 msg_conv.inner = untag_ptr(msg);
9688 msg_conv.is_owned = ptr_is_owned(msg);
9689 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
9690 msg_conv.is_owned = false;
9691 (this_arg_conv->handle_funding_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
9694 void __attribute__((export_name("TS_ChannelMessageHandler_handle_channel_ready"))) TS_ChannelMessageHandler_handle_channel_ready(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
9695 void* this_arg_ptr = untag_ptr(this_arg);
9696 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9697 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
9698 LDKPublicKey their_node_id_ref;
9699 CHECK(their_node_id->arr_len == 33);
9700 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
9701 LDKChannelReady msg_conv;
9702 msg_conv.inner = untag_ptr(msg);
9703 msg_conv.is_owned = ptr_is_owned(msg);
9704 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
9705 msg_conv.is_owned = false;
9706 (this_arg_conv->handle_channel_ready)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
9709 void __attribute__((export_name("TS_ChannelMessageHandler_handle_shutdown"))) TS_ChannelMessageHandler_handle_shutdown(uint64_t this_arg, int8_tArray their_node_id, uint64_t their_features, uint64_t msg) {
9710 void* this_arg_ptr = untag_ptr(this_arg);
9711 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9712 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
9713 LDKPublicKey their_node_id_ref;
9714 CHECK(their_node_id->arr_len == 33);
9715 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
9716 LDKInitFeatures their_features_conv;
9717 their_features_conv.inner = untag_ptr(their_features);
9718 their_features_conv.is_owned = ptr_is_owned(their_features);
9719 CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_conv);
9720 their_features_conv.is_owned = false;
9721 LDKShutdown msg_conv;
9722 msg_conv.inner = untag_ptr(msg);
9723 msg_conv.is_owned = ptr_is_owned(msg);
9724 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
9725 msg_conv.is_owned = false;
9726 (this_arg_conv->handle_shutdown)(this_arg_conv->this_arg, their_node_id_ref, &their_features_conv, &msg_conv);
9729 void __attribute__((export_name("TS_ChannelMessageHandler_handle_closing_signed"))) TS_ChannelMessageHandler_handle_closing_signed(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
9730 void* this_arg_ptr = untag_ptr(this_arg);
9731 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9732 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
9733 LDKPublicKey their_node_id_ref;
9734 CHECK(their_node_id->arr_len == 33);
9735 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
9736 LDKClosingSigned msg_conv;
9737 msg_conv.inner = untag_ptr(msg);
9738 msg_conv.is_owned = ptr_is_owned(msg);
9739 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
9740 msg_conv.is_owned = false;
9741 (this_arg_conv->handle_closing_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
9744 void __attribute__((export_name("TS_ChannelMessageHandler_handle_update_add_htlc"))) TS_ChannelMessageHandler_handle_update_add_htlc(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
9745 void* this_arg_ptr = untag_ptr(this_arg);
9746 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9747 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
9748 LDKPublicKey their_node_id_ref;
9749 CHECK(their_node_id->arr_len == 33);
9750 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
9751 LDKUpdateAddHTLC msg_conv;
9752 msg_conv.inner = untag_ptr(msg);
9753 msg_conv.is_owned = ptr_is_owned(msg);
9754 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
9755 msg_conv.is_owned = false;
9756 (this_arg_conv->handle_update_add_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
9759 void __attribute__((export_name("TS_ChannelMessageHandler_handle_update_fulfill_htlc"))) TS_ChannelMessageHandler_handle_update_fulfill_htlc(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
9760 void* this_arg_ptr = untag_ptr(this_arg);
9761 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9762 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
9763 LDKPublicKey their_node_id_ref;
9764 CHECK(their_node_id->arr_len == 33);
9765 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
9766 LDKUpdateFulfillHTLC msg_conv;
9767 msg_conv.inner = untag_ptr(msg);
9768 msg_conv.is_owned = ptr_is_owned(msg);
9769 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
9770 msg_conv.is_owned = false;
9771 (this_arg_conv->handle_update_fulfill_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
9774 void __attribute__((export_name("TS_ChannelMessageHandler_handle_update_fail_htlc"))) TS_ChannelMessageHandler_handle_update_fail_htlc(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
9775 void* this_arg_ptr = untag_ptr(this_arg);
9776 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9777 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
9778 LDKPublicKey their_node_id_ref;
9779 CHECK(their_node_id->arr_len == 33);
9780 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
9781 LDKUpdateFailHTLC msg_conv;
9782 msg_conv.inner = untag_ptr(msg);
9783 msg_conv.is_owned = ptr_is_owned(msg);
9784 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
9785 msg_conv.is_owned = false;
9786 (this_arg_conv->handle_update_fail_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
9789 void __attribute__((export_name("TS_ChannelMessageHandler_handle_update_fail_malformed_htlc"))) TS_ChannelMessageHandler_handle_update_fail_malformed_htlc(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
9790 void* this_arg_ptr = untag_ptr(this_arg);
9791 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9792 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
9793 LDKPublicKey their_node_id_ref;
9794 CHECK(their_node_id->arr_len == 33);
9795 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
9796 LDKUpdateFailMalformedHTLC msg_conv;
9797 msg_conv.inner = untag_ptr(msg);
9798 msg_conv.is_owned = ptr_is_owned(msg);
9799 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
9800 msg_conv.is_owned = false;
9801 (this_arg_conv->handle_update_fail_malformed_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
9804 void __attribute__((export_name("TS_ChannelMessageHandler_handle_commitment_signed"))) TS_ChannelMessageHandler_handle_commitment_signed(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
9805 void* this_arg_ptr = untag_ptr(this_arg);
9806 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9807 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
9808 LDKPublicKey their_node_id_ref;
9809 CHECK(their_node_id->arr_len == 33);
9810 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
9811 LDKCommitmentSigned msg_conv;
9812 msg_conv.inner = untag_ptr(msg);
9813 msg_conv.is_owned = ptr_is_owned(msg);
9814 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
9815 msg_conv.is_owned = false;
9816 (this_arg_conv->handle_commitment_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
9819 void __attribute__((export_name("TS_ChannelMessageHandler_handle_revoke_and_ack"))) TS_ChannelMessageHandler_handle_revoke_and_ack(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
9820 void* this_arg_ptr = untag_ptr(this_arg);
9821 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9822 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
9823 LDKPublicKey their_node_id_ref;
9824 CHECK(their_node_id->arr_len == 33);
9825 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
9826 LDKRevokeAndACK msg_conv;
9827 msg_conv.inner = untag_ptr(msg);
9828 msg_conv.is_owned = ptr_is_owned(msg);
9829 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
9830 msg_conv.is_owned = false;
9831 (this_arg_conv->handle_revoke_and_ack)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
9834 void __attribute__((export_name("TS_ChannelMessageHandler_handle_update_fee"))) TS_ChannelMessageHandler_handle_update_fee(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
9835 void* this_arg_ptr = untag_ptr(this_arg);
9836 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9837 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
9838 LDKPublicKey their_node_id_ref;
9839 CHECK(their_node_id->arr_len == 33);
9840 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
9841 LDKUpdateFee msg_conv;
9842 msg_conv.inner = untag_ptr(msg);
9843 msg_conv.is_owned = ptr_is_owned(msg);
9844 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
9845 msg_conv.is_owned = false;
9846 (this_arg_conv->handle_update_fee)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
9849 void __attribute__((export_name("TS_ChannelMessageHandler_handle_announcement_signatures"))) TS_ChannelMessageHandler_handle_announcement_signatures(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
9850 void* this_arg_ptr = untag_ptr(this_arg);
9851 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9852 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
9853 LDKPublicKey their_node_id_ref;
9854 CHECK(their_node_id->arr_len == 33);
9855 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
9856 LDKAnnouncementSignatures msg_conv;
9857 msg_conv.inner = untag_ptr(msg);
9858 msg_conv.is_owned = ptr_is_owned(msg);
9859 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
9860 msg_conv.is_owned = false;
9861 (this_arg_conv->handle_announcement_signatures)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
9864 void __attribute__((export_name("TS_ChannelMessageHandler_peer_disconnected"))) TS_ChannelMessageHandler_peer_disconnected(uint64_t this_arg, int8_tArray their_node_id, jboolean no_connection_possible) {
9865 void* this_arg_ptr = untag_ptr(this_arg);
9866 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9867 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
9868 LDKPublicKey their_node_id_ref;
9869 CHECK(their_node_id->arr_len == 33);
9870 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
9871 (this_arg_conv->peer_disconnected)(this_arg_conv->this_arg, their_node_id_ref, no_connection_possible);
9874 uint64_t __attribute__((export_name("TS_ChannelMessageHandler_peer_connected"))) TS_ChannelMessageHandler_peer_connected(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
9875 void* this_arg_ptr = untag_ptr(this_arg);
9876 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9877 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
9878 LDKPublicKey their_node_id_ref;
9879 CHECK(their_node_id->arr_len == 33);
9880 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
9882 msg_conv.inner = untag_ptr(msg);
9883 msg_conv.is_owned = ptr_is_owned(msg);
9884 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
9885 msg_conv.is_owned = false;
9886 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
9887 *ret_conv = (this_arg_conv->peer_connected)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
9888 return tag_ptr(ret_conv, true);
9891 void __attribute__((export_name("TS_ChannelMessageHandler_handle_channel_reestablish"))) TS_ChannelMessageHandler_handle_channel_reestablish(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
9892 void* this_arg_ptr = untag_ptr(this_arg);
9893 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9894 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
9895 LDKPublicKey their_node_id_ref;
9896 CHECK(their_node_id->arr_len == 33);
9897 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
9898 LDKChannelReestablish msg_conv;
9899 msg_conv.inner = untag_ptr(msg);
9900 msg_conv.is_owned = ptr_is_owned(msg);
9901 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
9902 msg_conv.is_owned = false;
9903 (this_arg_conv->handle_channel_reestablish)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
9906 void __attribute__((export_name("TS_ChannelMessageHandler_handle_channel_update"))) TS_ChannelMessageHandler_handle_channel_update(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
9907 void* this_arg_ptr = untag_ptr(this_arg);
9908 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9909 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
9910 LDKPublicKey their_node_id_ref;
9911 CHECK(their_node_id->arr_len == 33);
9912 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
9913 LDKChannelUpdate msg_conv;
9914 msg_conv.inner = untag_ptr(msg);
9915 msg_conv.is_owned = ptr_is_owned(msg);
9916 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
9917 msg_conv.is_owned = false;
9918 (this_arg_conv->handle_channel_update)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
9921 void __attribute__((export_name("TS_ChannelMessageHandler_handle_error"))) TS_ChannelMessageHandler_handle_error(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
9922 void* this_arg_ptr = untag_ptr(this_arg);
9923 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9924 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
9925 LDKPublicKey their_node_id_ref;
9926 CHECK(their_node_id->arr_len == 33);
9927 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
9928 LDKErrorMessage msg_conv;
9929 msg_conv.inner = untag_ptr(msg);
9930 msg_conv.is_owned = ptr_is_owned(msg);
9931 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
9932 msg_conv.is_owned = false;
9933 (this_arg_conv->handle_error)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
9936 uint64_t __attribute__((export_name("TS_ChannelMessageHandler_provided_node_features"))) TS_ChannelMessageHandler_provided_node_features(uint64_t this_arg) {
9937 void* this_arg_ptr = untag_ptr(this_arg);
9938 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9939 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
9940 LDKNodeFeatures ret_var = (this_arg_conv->provided_node_features)(this_arg_conv->this_arg);
9941 uint64_t ret_ref = 0;
9942 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
9943 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
9947 uint64_t __attribute__((export_name("TS_ChannelMessageHandler_provided_init_features"))) TS_ChannelMessageHandler_provided_init_features(uint64_t this_arg, int8_tArray their_node_id) {
9948 void* this_arg_ptr = untag_ptr(this_arg);
9949 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9950 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
9951 LDKPublicKey their_node_id_ref;
9952 CHECK(their_node_id->arr_len == 33);
9953 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
9954 LDKInitFeatures ret_var = (this_arg_conv->provided_init_features)(this_arg_conv->this_arg, their_node_id_ref);
9955 uint64_t ret_ref = 0;
9956 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
9957 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
9961 typedef struct LDKRoutingMessageHandler_JCalls {
9962 atomic_size_t refcnt;
9963 uint32_t instance_ptr;
9964 LDKMessageSendEventsProvider_JCalls* MessageSendEventsProvider;
9965 } LDKRoutingMessageHandler_JCalls;
9966 static void LDKRoutingMessageHandler_JCalls_free(void* this_arg) {
9967 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
9968 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
9972 LDKCResult_boolLightningErrorZ handle_node_announcement_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKNodeAnnouncement * msg) {
9973 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
9974 LDKNodeAnnouncement msg_var = *msg;
9975 uint64_t msg_ref = 0;
9976 msg_var = NodeAnnouncement_clone(&msg_var);
9977 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9978 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
9979 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 87, msg_ref, 0, 0, 0, 0, 0);
9980 void* ret_ptr = untag_ptr(ret);
9981 CHECK_ACCESS(ret_ptr);
9982 LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(ret_ptr);
9983 FREE(untag_ptr(ret));
9986 LDKCResult_boolLightningErrorZ handle_channel_announcement_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKChannelAnnouncement * msg) {
9987 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
9988 LDKChannelAnnouncement msg_var = *msg;
9989 uint64_t msg_ref = 0;
9990 msg_var = ChannelAnnouncement_clone(&msg_var);
9991 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9992 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
9993 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 88, msg_ref, 0, 0, 0, 0, 0);
9994 void* ret_ptr = untag_ptr(ret);
9995 CHECK_ACCESS(ret_ptr);
9996 LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(ret_ptr);
9997 FREE(untag_ptr(ret));
10000 LDKCResult_boolLightningErrorZ handle_channel_update_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKChannelUpdate * msg) {
10001 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10002 LDKChannelUpdate msg_var = *msg;
10003 uint64_t msg_ref = 0;
10004 msg_var = ChannelUpdate_clone(&msg_var);
10005 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10006 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10007 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 89, msg_ref, 0, 0, 0, 0, 0);
10008 void* ret_ptr = untag_ptr(ret);
10009 CHECK_ACCESS(ret_ptr);
10010 LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(ret_ptr);
10011 FREE(untag_ptr(ret));
10014 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ get_next_channel_announcement_LDKRoutingMessageHandler_jcall(const void* this_arg, uint64_t starting_point) {
10015 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10016 int64_t starting_point_conv = starting_point;
10017 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 90, starting_point_conv, 0, 0, 0, 0, 0);
10018 void* ret_ptr = untag_ptr(ret);
10019 CHECK_ACCESS(ret_ptr);
10020 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret_conv = *(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ*)(ret_ptr);
10021 FREE(untag_ptr(ret));
10024 LDKNodeAnnouncement get_next_node_announcement_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey starting_point) {
10025 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10026 int8_tArray starting_point_arr = init_int8_tArray(33, __LINE__);
10027 memcpy(starting_point_arr->elems, starting_point.compressed_form, 33);
10028 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 91, (uint32_t)starting_point_arr, 0, 0, 0, 0, 0);
10029 LDKNodeAnnouncement ret_conv;
10030 ret_conv.inner = untag_ptr(ret);
10031 ret_conv.is_owned = ptr_is_owned(ret);
10032 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
10035 LDKCResult_NoneNoneZ peer_connected_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInit * init) {
10036 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10037 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10038 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10039 LDKInit init_var = *init;
10040 uint64_t init_ref = 0;
10041 init_var = Init_clone(&init_var);
10042 CHECK_INNER_FIELD_ACCESS_OR_NULL(init_var);
10043 init_ref = tag_ptr(init_var.inner, init_var.is_owned);
10044 uint64_t ret = js_invoke_function_ubuuuu(j_calls->instance_ptr, 92, (uint32_t)their_node_id_arr, init_ref, 0, 0, 0, 0);
10045 void* ret_ptr = untag_ptr(ret);
10046 CHECK_ACCESS(ret_ptr);
10047 LDKCResult_NoneNoneZ ret_conv = *(LDKCResult_NoneNoneZ*)(ret_ptr);
10048 FREE(untag_ptr(ret));
10051 LDKCResult_NoneLightningErrorZ handle_reply_channel_range_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKReplyChannelRange msg) {
10052 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10053 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10054 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10055 LDKReplyChannelRange msg_var = msg;
10056 uint64_t msg_ref = 0;
10057 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10058 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10059 uint64_t ret = js_invoke_function_ubuuuu(j_calls->instance_ptr, 93, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10060 void* ret_ptr = untag_ptr(ret);
10061 CHECK_ACCESS(ret_ptr);
10062 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
10063 FREE(untag_ptr(ret));
10066 LDKCResult_NoneLightningErrorZ handle_reply_short_channel_ids_end_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKReplyShortChannelIdsEnd msg) {
10067 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10068 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10069 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10070 LDKReplyShortChannelIdsEnd msg_var = msg;
10071 uint64_t msg_ref = 0;
10072 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10073 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10074 uint64_t ret = js_invoke_function_ubuuuu(j_calls->instance_ptr, 94, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10075 void* ret_ptr = untag_ptr(ret);
10076 CHECK_ACCESS(ret_ptr);
10077 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
10078 FREE(untag_ptr(ret));
10081 LDKCResult_NoneLightningErrorZ handle_query_channel_range_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKQueryChannelRange msg) {
10082 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10083 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10084 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10085 LDKQueryChannelRange msg_var = msg;
10086 uint64_t msg_ref = 0;
10087 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10088 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10089 uint64_t ret = js_invoke_function_ubuuuu(j_calls->instance_ptr, 95, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10090 void* ret_ptr = untag_ptr(ret);
10091 CHECK_ACCESS(ret_ptr);
10092 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
10093 FREE(untag_ptr(ret));
10096 LDKCResult_NoneLightningErrorZ handle_query_short_channel_ids_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKQueryShortChannelIds msg) {
10097 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10098 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10099 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10100 LDKQueryShortChannelIds msg_var = msg;
10101 uint64_t msg_ref = 0;
10102 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10103 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10104 uint64_t ret = js_invoke_function_ubuuuu(j_calls->instance_ptr, 96, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10105 void* ret_ptr = untag_ptr(ret);
10106 CHECK_ACCESS(ret_ptr);
10107 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
10108 FREE(untag_ptr(ret));
10111 LDKNodeFeatures provided_node_features_LDKRoutingMessageHandler_jcall(const void* this_arg) {
10112 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10113 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 97, 0, 0, 0, 0, 0, 0);
10114 LDKNodeFeatures ret_conv;
10115 ret_conv.inner = untag_ptr(ret);
10116 ret_conv.is_owned = ptr_is_owned(ret);
10117 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
10120 LDKInitFeatures provided_init_features_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id) {
10121 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10122 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10123 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10124 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 98, (uint32_t)their_node_id_arr, 0, 0, 0, 0, 0);
10125 LDKInitFeatures ret_conv;
10126 ret_conv.inner = untag_ptr(ret);
10127 ret_conv.is_owned = ptr_is_owned(ret);
10128 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
10131 static void LDKRoutingMessageHandler_JCalls_cloned(LDKRoutingMessageHandler* new_obj) {
10132 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) new_obj->this_arg;
10133 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
10134 atomic_fetch_add_explicit(&j_calls->MessageSendEventsProvider->refcnt, 1, memory_order_release);
10136 static inline LDKRoutingMessageHandler LDKRoutingMessageHandler_init (JSValue o, JSValue MessageSendEventsProvider) {
10137 LDKRoutingMessageHandler_JCalls *calls = MALLOC(sizeof(LDKRoutingMessageHandler_JCalls), "LDKRoutingMessageHandler_JCalls");
10138 atomic_init(&calls->refcnt, 1);
10139 calls->instance_ptr = o;
10141 LDKRoutingMessageHandler ret = {
10142 .this_arg = (void*) calls,
10143 .handle_node_announcement = handle_node_announcement_LDKRoutingMessageHandler_jcall,
10144 .handle_channel_announcement = handle_channel_announcement_LDKRoutingMessageHandler_jcall,
10145 .handle_channel_update = handle_channel_update_LDKRoutingMessageHandler_jcall,
10146 .get_next_channel_announcement = get_next_channel_announcement_LDKRoutingMessageHandler_jcall,
10147 .get_next_node_announcement = get_next_node_announcement_LDKRoutingMessageHandler_jcall,
10148 .peer_connected = peer_connected_LDKRoutingMessageHandler_jcall,
10149 .handle_reply_channel_range = handle_reply_channel_range_LDKRoutingMessageHandler_jcall,
10150 .handle_reply_short_channel_ids_end = handle_reply_short_channel_ids_end_LDKRoutingMessageHandler_jcall,
10151 .handle_query_channel_range = handle_query_channel_range_LDKRoutingMessageHandler_jcall,
10152 .handle_query_short_channel_ids = handle_query_short_channel_ids_LDKRoutingMessageHandler_jcall,
10153 .provided_node_features = provided_node_features_LDKRoutingMessageHandler_jcall,
10154 .provided_init_features = provided_init_features_LDKRoutingMessageHandler_jcall,
10155 .free = LDKRoutingMessageHandler_JCalls_free,
10156 .MessageSendEventsProvider = LDKMessageSendEventsProvider_init(MessageSendEventsProvider),
10158 calls->MessageSendEventsProvider = ret.MessageSendEventsProvider.this_arg;
10161 uint64_t __attribute__((export_name("TS_LDKRoutingMessageHandler_new"))) TS_LDKRoutingMessageHandler_new(JSValue o, JSValue MessageSendEventsProvider) {
10162 LDKRoutingMessageHandler *res_ptr = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
10163 *res_ptr = LDKRoutingMessageHandler_init(o, MessageSendEventsProvider);
10164 return tag_ptr(res_ptr, true);
10166 uint64_t __attribute__((export_name("TS_RoutingMessageHandler_handle_node_announcement"))) TS_RoutingMessageHandler_handle_node_announcement(uint64_t this_arg, uint64_t msg) {
10167 void* this_arg_ptr = untag_ptr(this_arg);
10168 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10169 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10170 LDKNodeAnnouncement msg_conv;
10171 msg_conv.inner = untag_ptr(msg);
10172 msg_conv.is_owned = ptr_is_owned(msg);
10173 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10174 msg_conv.is_owned = false;
10175 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
10176 *ret_conv = (this_arg_conv->handle_node_announcement)(this_arg_conv->this_arg, &msg_conv);
10177 return tag_ptr(ret_conv, true);
10180 uint64_t __attribute__((export_name("TS_RoutingMessageHandler_handle_channel_announcement"))) TS_RoutingMessageHandler_handle_channel_announcement(uint64_t this_arg, uint64_t msg) {
10181 void* this_arg_ptr = untag_ptr(this_arg);
10182 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10183 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10184 LDKChannelAnnouncement msg_conv;
10185 msg_conv.inner = untag_ptr(msg);
10186 msg_conv.is_owned = ptr_is_owned(msg);
10187 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10188 msg_conv.is_owned = false;
10189 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
10190 *ret_conv = (this_arg_conv->handle_channel_announcement)(this_arg_conv->this_arg, &msg_conv);
10191 return tag_ptr(ret_conv, true);
10194 uint64_t __attribute__((export_name("TS_RoutingMessageHandler_handle_channel_update"))) TS_RoutingMessageHandler_handle_channel_update(uint64_t this_arg, uint64_t msg) {
10195 void* this_arg_ptr = untag_ptr(this_arg);
10196 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10197 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10198 LDKChannelUpdate msg_conv;
10199 msg_conv.inner = untag_ptr(msg);
10200 msg_conv.is_owned = ptr_is_owned(msg);
10201 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10202 msg_conv.is_owned = false;
10203 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
10204 *ret_conv = (this_arg_conv->handle_channel_update)(this_arg_conv->this_arg, &msg_conv);
10205 return tag_ptr(ret_conv, true);
10208 uint64_t __attribute__((export_name("TS_RoutingMessageHandler_get_next_channel_announcement"))) TS_RoutingMessageHandler_get_next_channel_announcement(uint64_t this_arg, int64_t starting_point) {
10209 void* this_arg_ptr = untag_ptr(this_arg);
10210 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10211 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10212 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret_copy = MALLOC(sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
10213 *ret_copy = (this_arg_conv->get_next_channel_announcement)(this_arg_conv->this_arg, starting_point);
10214 uint64_t ret_ref = tag_ptr(ret_copy, true);
10218 uint64_t __attribute__((export_name("TS_RoutingMessageHandler_get_next_node_announcement"))) TS_RoutingMessageHandler_get_next_node_announcement(uint64_t this_arg, int8_tArray starting_point) {
10219 void* this_arg_ptr = untag_ptr(this_arg);
10220 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10221 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10222 LDKPublicKey starting_point_ref;
10223 CHECK(starting_point->arr_len == 33);
10224 memcpy(starting_point_ref.compressed_form, starting_point->elems, 33); FREE(starting_point);
10225 LDKNodeAnnouncement ret_var = (this_arg_conv->get_next_node_announcement)(this_arg_conv->this_arg, starting_point_ref);
10226 uint64_t ret_ref = 0;
10227 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10228 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10232 uint64_t __attribute__((export_name("TS_RoutingMessageHandler_peer_connected"))) TS_RoutingMessageHandler_peer_connected(uint64_t this_arg, int8_tArray their_node_id, uint64_t init) {
10233 void* this_arg_ptr = untag_ptr(this_arg);
10234 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10235 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10236 LDKPublicKey their_node_id_ref;
10237 CHECK(their_node_id->arr_len == 33);
10238 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10240 init_conv.inner = untag_ptr(init);
10241 init_conv.is_owned = ptr_is_owned(init);
10242 CHECK_INNER_FIELD_ACCESS_OR_NULL(init_conv);
10243 init_conv.is_owned = false;
10244 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
10245 *ret_conv = (this_arg_conv->peer_connected)(this_arg_conv->this_arg, their_node_id_ref, &init_conv);
10246 return tag_ptr(ret_conv, true);
10249 uint64_t __attribute__((export_name("TS_RoutingMessageHandler_handle_reply_channel_range"))) TS_RoutingMessageHandler_handle_reply_channel_range(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
10250 void* this_arg_ptr = untag_ptr(this_arg);
10251 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10252 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10253 LDKPublicKey their_node_id_ref;
10254 CHECK(their_node_id->arr_len == 33);
10255 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10256 LDKReplyChannelRange msg_conv;
10257 msg_conv.inner = untag_ptr(msg);
10258 msg_conv.is_owned = ptr_is_owned(msg);
10259 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10260 msg_conv = ReplyChannelRange_clone(&msg_conv);
10261 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
10262 *ret_conv = (this_arg_conv->handle_reply_channel_range)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
10263 return tag_ptr(ret_conv, true);
10266 uint64_t __attribute__((export_name("TS_RoutingMessageHandler_handle_reply_short_channel_ids_end"))) TS_RoutingMessageHandler_handle_reply_short_channel_ids_end(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
10267 void* this_arg_ptr = untag_ptr(this_arg);
10268 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10269 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10270 LDKPublicKey their_node_id_ref;
10271 CHECK(their_node_id->arr_len == 33);
10272 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10273 LDKReplyShortChannelIdsEnd msg_conv;
10274 msg_conv.inner = untag_ptr(msg);
10275 msg_conv.is_owned = ptr_is_owned(msg);
10276 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10277 msg_conv = ReplyShortChannelIdsEnd_clone(&msg_conv);
10278 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
10279 *ret_conv = (this_arg_conv->handle_reply_short_channel_ids_end)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
10280 return tag_ptr(ret_conv, true);
10283 uint64_t __attribute__((export_name("TS_RoutingMessageHandler_handle_query_channel_range"))) TS_RoutingMessageHandler_handle_query_channel_range(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
10284 void* this_arg_ptr = untag_ptr(this_arg);
10285 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10286 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10287 LDKPublicKey their_node_id_ref;
10288 CHECK(their_node_id->arr_len == 33);
10289 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10290 LDKQueryChannelRange msg_conv;
10291 msg_conv.inner = untag_ptr(msg);
10292 msg_conv.is_owned = ptr_is_owned(msg);
10293 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10294 msg_conv = QueryChannelRange_clone(&msg_conv);
10295 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
10296 *ret_conv = (this_arg_conv->handle_query_channel_range)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
10297 return tag_ptr(ret_conv, true);
10300 uint64_t __attribute__((export_name("TS_RoutingMessageHandler_handle_query_short_channel_ids"))) TS_RoutingMessageHandler_handle_query_short_channel_ids(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
10301 void* this_arg_ptr = untag_ptr(this_arg);
10302 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10303 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10304 LDKPublicKey their_node_id_ref;
10305 CHECK(their_node_id->arr_len == 33);
10306 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10307 LDKQueryShortChannelIds msg_conv;
10308 msg_conv.inner = untag_ptr(msg);
10309 msg_conv.is_owned = ptr_is_owned(msg);
10310 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10311 msg_conv = QueryShortChannelIds_clone(&msg_conv);
10312 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
10313 *ret_conv = (this_arg_conv->handle_query_short_channel_ids)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
10314 return tag_ptr(ret_conv, true);
10317 uint64_t __attribute__((export_name("TS_RoutingMessageHandler_provided_node_features"))) TS_RoutingMessageHandler_provided_node_features(uint64_t this_arg) {
10318 void* this_arg_ptr = untag_ptr(this_arg);
10319 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10320 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10321 LDKNodeFeatures ret_var = (this_arg_conv->provided_node_features)(this_arg_conv->this_arg);
10322 uint64_t ret_ref = 0;
10323 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10324 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10328 uint64_t __attribute__((export_name("TS_RoutingMessageHandler_provided_init_features"))) TS_RoutingMessageHandler_provided_init_features(uint64_t this_arg, int8_tArray their_node_id) {
10329 void* this_arg_ptr = untag_ptr(this_arg);
10330 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10331 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10332 LDKPublicKey their_node_id_ref;
10333 CHECK(their_node_id->arr_len == 33);
10334 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10335 LDKInitFeatures ret_var = (this_arg_conv->provided_init_features)(this_arg_conv->this_arg, their_node_id_ref);
10336 uint64_t ret_ref = 0;
10337 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10338 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10342 typedef struct LDKOnionMessageHandler_JCalls {
10343 atomic_size_t refcnt;
10344 uint32_t instance_ptr;
10345 LDKOnionMessageProvider_JCalls* OnionMessageProvider;
10346 } LDKOnionMessageHandler_JCalls;
10347 static void LDKOnionMessageHandler_JCalls_free(void* this_arg) {
10348 LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) this_arg;
10349 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
10353 void handle_onion_message_LDKOnionMessageHandler_jcall(const void* this_arg, LDKPublicKey peer_node_id, const LDKOnionMessage * msg) {
10354 LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) this_arg;
10355 int8_tArray peer_node_id_arr = init_int8_tArray(33, __LINE__);
10356 memcpy(peer_node_id_arr->elems, peer_node_id.compressed_form, 33);
10357 LDKOnionMessage msg_var = *msg;
10358 uint64_t msg_ref = 0;
10359 msg_var = OnionMessage_clone(&msg_var);
10360 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10361 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10362 js_invoke_function_ubuuuu(j_calls->instance_ptr, 99, (uint32_t)peer_node_id_arr, msg_ref, 0, 0, 0, 0);
10364 LDKCResult_NoneNoneZ peer_connected_LDKOnionMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInit * init) {
10365 LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) this_arg;
10366 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10367 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10368 LDKInit init_var = *init;
10369 uint64_t init_ref = 0;
10370 init_var = Init_clone(&init_var);
10371 CHECK_INNER_FIELD_ACCESS_OR_NULL(init_var);
10372 init_ref = tag_ptr(init_var.inner, init_var.is_owned);
10373 uint64_t ret = js_invoke_function_ubuuuu(j_calls->instance_ptr, 100, (uint32_t)their_node_id_arr, init_ref, 0, 0, 0, 0);
10374 void* ret_ptr = untag_ptr(ret);
10375 CHECK_ACCESS(ret_ptr);
10376 LDKCResult_NoneNoneZ ret_conv = *(LDKCResult_NoneNoneZ*)(ret_ptr);
10377 FREE(untag_ptr(ret));
10380 void peer_disconnected_LDKOnionMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, bool no_connection_possible) {
10381 LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) this_arg;
10382 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10383 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10384 jboolean no_connection_possible_conv = no_connection_possible;
10385 js_invoke_function_uuuuuu(j_calls->instance_ptr, 101, (uint32_t)their_node_id_arr, no_connection_possible_conv, 0, 0, 0, 0);
10387 LDKNodeFeatures provided_node_features_LDKOnionMessageHandler_jcall(const void* this_arg) {
10388 LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) this_arg;
10389 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 102, 0, 0, 0, 0, 0, 0);
10390 LDKNodeFeatures ret_conv;
10391 ret_conv.inner = untag_ptr(ret);
10392 ret_conv.is_owned = ptr_is_owned(ret);
10393 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
10396 LDKInitFeatures provided_init_features_LDKOnionMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id) {
10397 LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) this_arg;
10398 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10399 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10400 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 103, (uint32_t)their_node_id_arr, 0, 0, 0, 0, 0);
10401 LDKInitFeatures ret_conv;
10402 ret_conv.inner = untag_ptr(ret);
10403 ret_conv.is_owned = ptr_is_owned(ret);
10404 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
10407 static void LDKOnionMessageHandler_JCalls_cloned(LDKOnionMessageHandler* new_obj) {
10408 LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) new_obj->this_arg;
10409 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
10410 atomic_fetch_add_explicit(&j_calls->OnionMessageProvider->refcnt, 1, memory_order_release);
10412 static inline LDKOnionMessageHandler LDKOnionMessageHandler_init (JSValue o, JSValue OnionMessageProvider) {
10413 LDKOnionMessageHandler_JCalls *calls = MALLOC(sizeof(LDKOnionMessageHandler_JCalls), "LDKOnionMessageHandler_JCalls");
10414 atomic_init(&calls->refcnt, 1);
10415 calls->instance_ptr = o;
10417 LDKOnionMessageHandler ret = {
10418 .this_arg = (void*) calls,
10419 .handle_onion_message = handle_onion_message_LDKOnionMessageHandler_jcall,
10420 .peer_connected = peer_connected_LDKOnionMessageHandler_jcall,
10421 .peer_disconnected = peer_disconnected_LDKOnionMessageHandler_jcall,
10422 .provided_node_features = provided_node_features_LDKOnionMessageHandler_jcall,
10423 .provided_init_features = provided_init_features_LDKOnionMessageHandler_jcall,
10424 .free = LDKOnionMessageHandler_JCalls_free,
10425 .OnionMessageProvider = LDKOnionMessageProvider_init(OnionMessageProvider),
10427 calls->OnionMessageProvider = ret.OnionMessageProvider.this_arg;
10430 uint64_t __attribute__((export_name("TS_LDKOnionMessageHandler_new"))) TS_LDKOnionMessageHandler_new(JSValue o, JSValue OnionMessageProvider) {
10431 LDKOnionMessageHandler *res_ptr = MALLOC(sizeof(LDKOnionMessageHandler), "LDKOnionMessageHandler");
10432 *res_ptr = LDKOnionMessageHandler_init(o, OnionMessageProvider);
10433 return tag_ptr(res_ptr, true);
10435 void __attribute__((export_name("TS_OnionMessageHandler_handle_onion_message"))) TS_OnionMessageHandler_handle_onion_message(uint64_t this_arg, int8_tArray peer_node_id, uint64_t msg) {
10436 void* this_arg_ptr = untag_ptr(this_arg);
10437 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10438 LDKOnionMessageHandler* this_arg_conv = (LDKOnionMessageHandler*)this_arg_ptr;
10439 LDKPublicKey peer_node_id_ref;
10440 CHECK(peer_node_id->arr_len == 33);
10441 memcpy(peer_node_id_ref.compressed_form, peer_node_id->elems, 33); FREE(peer_node_id);
10442 LDKOnionMessage msg_conv;
10443 msg_conv.inner = untag_ptr(msg);
10444 msg_conv.is_owned = ptr_is_owned(msg);
10445 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10446 msg_conv.is_owned = false;
10447 (this_arg_conv->handle_onion_message)(this_arg_conv->this_arg, peer_node_id_ref, &msg_conv);
10450 uint64_t __attribute__((export_name("TS_OnionMessageHandler_peer_connected"))) TS_OnionMessageHandler_peer_connected(uint64_t this_arg, int8_tArray their_node_id, uint64_t init) {
10451 void* this_arg_ptr = untag_ptr(this_arg);
10452 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10453 LDKOnionMessageHandler* this_arg_conv = (LDKOnionMessageHandler*)this_arg_ptr;
10454 LDKPublicKey their_node_id_ref;
10455 CHECK(their_node_id->arr_len == 33);
10456 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10458 init_conv.inner = untag_ptr(init);
10459 init_conv.is_owned = ptr_is_owned(init);
10460 CHECK_INNER_FIELD_ACCESS_OR_NULL(init_conv);
10461 init_conv.is_owned = false;
10462 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
10463 *ret_conv = (this_arg_conv->peer_connected)(this_arg_conv->this_arg, their_node_id_ref, &init_conv);
10464 return tag_ptr(ret_conv, true);
10467 void __attribute__((export_name("TS_OnionMessageHandler_peer_disconnected"))) TS_OnionMessageHandler_peer_disconnected(uint64_t this_arg, int8_tArray their_node_id, jboolean no_connection_possible) {
10468 void* this_arg_ptr = untag_ptr(this_arg);
10469 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10470 LDKOnionMessageHandler* this_arg_conv = (LDKOnionMessageHandler*)this_arg_ptr;
10471 LDKPublicKey their_node_id_ref;
10472 CHECK(their_node_id->arr_len == 33);
10473 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10474 (this_arg_conv->peer_disconnected)(this_arg_conv->this_arg, their_node_id_ref, no_connection_possible);
10477 uint64_t __attribute__((export_name("TS_OnionMessageHandler_provided_node_features"))) TS_OnionMessageHandler_provided_node_features(uint64_t this_arg) {
10478 void* this_arg_ptr = untag_ptr(this_arg);
10479 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10480 LDKOnionMessageHandler* this_arg_conv = (LDKOnionMessageHandler*)this_arg_ptr;
10481 LDKNodeFeatures ret_var = (this_arg_conv->provided_node_features)(this_arg_conv->this_arg);
10482 uint64_t ret_ref = 0;
10483 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10484 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10488 uint64_t __attribute__((export_name("TS_OnionMessageHandler_provided_init_features"))) TS_OnionMessageHandler_provided_init_features(uint64_t this_arg, int8_tArray their_node_id) {
10489 void* this_arg_ptr = untag_ptr(this_arg);
10490 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10491 LDKOnionMessageHandler* this_arg_conv = (LDKOnionMessageHandler*)this_arg_ptr;
10492 LDKPublicKey their_node_id_ref;
10493 CHECK(their_node_id->arr_len == 33);
10494 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10495 LDKInitFeatures ret_var = (this_arg_conv->provided_init_features)(this_arg_conv->this_arg, their_node_id_ref);
10496 uint64_t ret_ref = 0;
10497 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10498 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10502 typedef struct LDKCustomMessageReader_JCalls {
10503 atomic_size_t refcnt;
10504 uint32_t instance_ptr;
10505 } LDKCustomMessageReader_JCalls;
10506 static void LDKCustomMessageReader_JCalls_free(void* this_arg) {
10507 LDKCustomMessageReader_JCalls *j_calls = (LDKCustomMessageReader_JCalls*) this_arg;
10508 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
10512 LDKCResult_COption_TypeZDecodeErrorZ read_LDKCustomMessageReader_jcall(const void* this_arg, uint16_t message_type, LDKu8slice buffer) {
10513 LDKCustomMessageReader_JCalls *j_calls = (LDKCustomMessageReader_JCalls*) this_arg;
10514 int16_t message_type_conv = message_type;
10515 LDKu8slice buffer_var = buffer;
10516 int8_tArray buffer_arr = init_int8_tArray(buffer_var.datalen, __LINE__);
10517 memcpy(buffer_arr->elems, buffer_var.data, buffer_var.datalen);
10518 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 104, message_type_conv, (uint32_t)buffer_arr, 0, 0, 0, 0);
10519 void* ret_ptr = untag_ptr(ret);
10520 CHECK_ACCESS(ret_ptr);
10521 LDKCResult_COption_TypeZDecodeErrorZ ret_conv = *(LDKCResult_COption_TypeZDecodeErrorZ*)(ret_ptr);
10522 FREE(untag_ptr(ret));
10525 static void LDKCustomMessageReader_JCalls_cloned(LDKCustomMessageReader* new_obj) {
10526 LDKCustomMessageReader_JCalls *j_calls = (LDKCustomMessageReader_JCalls*) new_obj->this_arg;
10527 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
10529 static inline LDKCustomMessageReader LDKCustomMessageReader_init (JSValue o) {
10530 LDKCustomMessageReader_JCalls *calls = MALLOC(sizeof(LDKCustomMessageReader_JCalls), "LDKCustomMessageReader_JCalls");
10531 atomic_init(&calls->refcnt, 1);
10532 calls->instance_ptr = o;
10534 LDKCustomMessageReader ret = {
10535 .this_arg = (void*) calls,
10536 .read = read_LDKCustomMessageReader_jcall,
10537 .free = LDKCustomMessageReader_JCalls_free,
10541 uint64_t __attribute__((export_name("TS_LDKCustomMessageReader_new"))) TS_LDKCustomMessageReader_new(JSValue o) {
10542 LDKCustomMessageReader *res_ptr = MALLOC(sizeof(LDKCustomMessageReader), "LDKCustomMessageReader");
10543 *res_ptr = LDKCustomMessageReader_init(o);
10544 return tag_ptr(res_ptr, true);
10546 uint64_t __attribute__((export_name("TS_CustomMessageReader_read"))) TS_CustomMessageReader_read(uint64_t this_arg, int16_t message_type, int8_tArray buffer) {
10547 void* this_arg_ptr = untag_ptr(this_arg);
10548 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10549 LDKCustomMessageReader* this_arg_conv = (LDKCustomMessageReader*)this_arg_ptr;
10550 LDKu8slice buffer_ref;
10551 buffer_ref.datalen = buffer->arr_len;
10552 buffer_ref.data = buffer->elems;
10553 LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
10554 *ret_conv = (this_arg_conv->read)(this_arg_conv->this_arg, message_type, buffer_ref);
10556 return tag_ptr(ret_conv, true);
10559 typedef struct LDKCustomMessageHandler_JCalls {
10560 atomic_size_t refcnt;
10561 uint32_t instance_ptr;
10562 LDKCustomMessageReader_JCalls* CustomMessageReader;
10563 } LDKCustomMessageHandler_JCalls;
10564 static void LDKCustomMessageHandler_JCalls_free(void* this_arg) {
10565 LDKCustomMessageHandler_JCalls *j_calls = (LDKCustomMessageHandler_JCalls*) this_arg;
10566 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
10570 LDKCResult_NoneLightningErrorZ handle_custom_message_LDKCustomMessageHandler_jcall(const void* this_arg, LDKType msg, LDKPublicKey sender_node_id) {
10571 LDKCustomMessageHandler_JCalls *j_calls = (LDKCustomMessageHandler_JCalls*) this_arg;
10572 LDKType* msg_ret = MALLOC(sizeof(LDKType), "LDKType");
10574 int8_tArray sender_node_id_arr = init_int8_tArray(33, __LINE__);
10575 memcpy(sender_node_id_arr->elems, sender_node_id.compressed_form, 33);
10576 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 105, tag_ptr(msg_ret, true), (uint32_t)sender_node_id_arr, 0, 0, 0, 0);
10577 void* ret_ptr = untag_ptr(ret);
10578 CHECK_ACCESS(ret_ptr);
10579 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
10580 FREE(untag_ptr(ret));
10583 LDKCVec_C2Tuple_PublicKeyTypeZZ get_and_clear_pending_msg_LDKCustomMessageHandler_jcall(const void* this_arg) {
10584 LDKCustomMessageHandler_JCalls *j_calls = (LDKCustomMessageHandler_JCalls*) this_arg;
10585 uint64_tArray ret = (uint64_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 106, 0, 0, 0, 0, 0, 0);
10586 LDKCVec_C2Tuple_PublicKeyTypeZZ ret_constr;
10587 ret_constr.datalen = ret->arr_len;
10588 if (ret_constr.datalen > 0)
10589 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKCVec_C2Tuple_PublicKeyTypeZZ Elements");
10591 ret_constr.data = NULL;
10592 uint64_t* ret_vals = ret->elems;
10593 for (size_t z = 0; z < ret_constr.datalen; z++) {
10594 uint64_t ret_conv_25 = ret_vals[z];
10595 void* ret_conv_25_ptr = untag_ptr(ret_conv_25);
10596 CHECK_ACCESS(ret_conv_25_ptr);
10597 LDKC2Tuple_PublicKeyTypeZ ret_conv_25_conv = *(LDKC2Tuple_PublicKeyTypeZ*)(ret_conv_25_ptr);
10598 FREE(untag_ptr(ret_conv_25));
10599 ret_constr.data[z] = ret_conv_25_conv;
10604 static void LDKCustomMessageHandler_JCalls_cloned(LDKCustomMessageHandler* new_obj) {
10605 LDKCustomMessageHandler_JCalls *j_calls = (LDKCustomMessageHandler_JCalls*) new_obj->this_arg;
10606 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
10607 atomic_fetch_add_explicit(&j_calls->CustomMessageReader->refcnt, 1, memory_order_release);
10609 static inline LDKCustomMessageHandler LDKCustomMessageHandler_init (JSValue o, JSValue CustomMessageReader) {
10610 LDKCustomMessageHandler_JCalls *calls = MALLOC(sizeof(LDKCustomMessageHandler_JCalls), "LDKCustomMessageHandler_JCalls");
10611 atomic_init(&calls->refcnt, 1);
10612 calls->instance_ptr = o;
10614 LDKCustomMessageHandler ret = {
10615 .this_arg = (void*) calls,
10616 .handle_custom_message = handle_custom_message_LDKCustomMessageHandler_jcall,
10617 .get_and_clear_pending_msg = get_and_clear_pending_msg_LDKCustomMessageHandler_jcall,
10618 .free = LDKCustomMessageHandler_JCalls_free,
10619 .CustomMessageReader = LDKCustomMessageReader_init(CustomMessageReader),
10621 calls->CustomMessageReader = ret.CustomMessageReader.this_arg;
10624 uint64_t __attribute__((export_name("TS_LDKCustomMessageHandler_new"))) TS_LDKCustomMessageHandler_new(JSValue o, JSValue CustomMessageReader) {
10625 LDKCustomMessageHandler *res_ptr = MALLOC(sizeof(LDKCustomMessageHandler), "LDKCustomMessageHandler");
10626 *res_ptr = LDKCustomMessageHandler_init(o, CustomMessageReader);
10627 return tag_ptr(res_ptr, true);
10629 uint64_t __attribute__((export_name("TS_CustomMessageHandler_handle_custom_message"))) TS_CustomMessageHandler_handle_custom_message(uint64_t this_arg, uint64_t msg, int8_tArray sender_node_id) {
10630 void* this_arg_ptr = untag_ptr(this_arg);
10631 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10632 LDKCustomMessageHandler* this_arg_conv = (LDKCustomMessageHandler*)this_arg_ptr;
10633 void* msg_ptr = untag_ptr(msg);
10634 CHECK_ACCESS(msg_ptr);
10635 LDKType msg_conv = *(LDKType*)(msg_ptr);
10636 if (msg_conv.free == LDKType_JCalls_free) {
10637 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
10638 LDKType_JCalls_cloned(&msg_conv);
10640 LDKPublicKey sender_node_id_ref;
10641 CHECK(sender_node_id->arr_len == 33);
10642 memcpy(sender_node_id_ref.compressed_form, sender_node_id->elems, 33); FREE(sender_node_id);
10643 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
10644 *ret_conv = (this_arg_conv->handle_custom_message)(this_arg_conv->this_arg, msg_conv, sender_node_id_ref);
10645 return tag_ptr(ret_conv, true);
10648 uint64_tArray __attribute__((export_name("TS_CustomMessageHandler_get_and_clear_pending_msg"))) TS_CustomMessageHandler_get_and_clear_pending_msg(uint64_t this_arg) {
10649 void* this_arg_ptr = untag_ptr(this_arg);
10650 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10651 LDKCustomMessageHandler* this_arg_conv = (LDKCustomMessageHandler*)this_arg_ptr;
10652 LDKCVec_C2Tuple_PublicKeyTypeZZ ret_var = (this_arg_conv->get_and_clear_pending_msg)(this_arg_conv->this_arg);
10653 uint64_tArray ret_arr = NULL;
10654 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
10655 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
10656 for (size_t z = 0; z < ret_var.datalen; z++) {
10657 LDKC2Tuple_PublicKeyTypeZ* ret_conv_25_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ");
10658 *ret_conv_25_conv = ret_var.data[z];
10659 ret_arr_ptr[z] = tag_ptr(ret_conv_25_conv, true);
10662 FREE(ret_var.data);
10666 typedef struct LDKCustomOnionMessageHandler_JCalls {
10667 atomic_size_t refcnt;
10668 uint32_t instance_ptr;
10669 } LDKCustomOnionMessageHandler_JCalls;
10670 static void LDKCustomOnionMessageHandler_JCalls_free(void* this_arg) {
10671 LDKCustomOnionMessageHandler_JCalls *j_calls = (LDKCustomOnionMessageHandler_JCalls*) this_arg;
10672 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
10676 void handle_custom_message_LDKCustomOnionMessageHandler_jcall(const void* this_arg, LDKCustomOnionMessageContents msg) {
10677 LDKCustomOnionMessageHandler_JCalls *j_calls = (LDKCustomOnionMessageHandler_JCalls*) this_arg;
10678 LDKCustomOnionMessageContents* msg_ret = MALLOC(sizeof(LDKCustomOnionMessageContents), "LDKCustomOnionMessageContents");
10680 js_invoke_function_buuuuu(j_calls->instance_ptr, 107, tag_ptr(msg_ret, true), 0, 0, 0, 0, 0);
10682 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ read_custom_message_LDKCustomOnionMessageHandler_jcall(const void* this_arg, uint64_t message_type, LDKu8slice buffer) {
10683 LDKCustomOnionMessageHandler_JCalls *j_calls = (LDKCustomOnionMessageHandler_JCalls*) this_arg;
10684 int64_t message_type_conv = message_type;
10685 LDKu8slice buffer_var = buffer;
10686 int8_tArray buffer_arr = init_int8_tArray(buffer_var.datalen, __LINE__);
10687 memcpy(buffer_arr->elems, buffer_var.data, buffer_var.datalen);
10688 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 108, message_type_conv, (uint32_t)buffer_arr, 0, 0, 0, 0);
10689 void* ret_ptr = untag_ptr(ret);
10690 CHECK_ACCESS(ret_ptr);
10691 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ ret_conv = *(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ*)(ret_ptr);
10692 FREE(untag_ptr(ret));
10695 static void LDKCustomOnionMessageHandler_JCalls_cloned(LDKCustomOnionMessageHandler* new_obj) {
10696 LDKCustomOnionMessageHandler_JCalls *j_calls = (LDKCustomOnionMessageHandler_JCalls*) new_obj->this_arg;
10697 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
10699 static inline LDKCustomOnionMessageHandler LDKCustomOnionMessageHandler_init (JSValue o) {
10700 LDKCustomOnionMessageHandler_JCalls *calls = MALLOC(sizeof(LDKCustomOnionMessageHandler_JCalls), "LDKCustomOnionMessageHandler_JCalls");
10701 atomic_init(&calls->refcnt, 1);
10702 calls->instance_ptr = o;
10704 LDKCustomOnionMessageHandler ret = {
10705 .this_arg = (void*) calls,
10706 .handle_custom_message = handle_custom_message_LDKCustomOnionMessageHandler_jcall,
10707 .read_custom_message = read_custom_message_LDKCustomOnionMessageHandler_jcall,
10708 .free = LDKCustomOnionMessageHandler_JCalls_free,
10712 uint64_t __attribute__((export_name("TS_LDKCustomOnionMessageHandler_new"))) TS_LDKCustomOnionMessageHandler_new(JSValue o) {
10713 LDKCustomOnionMessageHandler *res_ptr = MALLOC(sizeof(LDKCustomOnionMessageHandler), "LDKCustomOnionMessageHandler");
10714 *res_ptr = LDKCustomOnionMessageHandler_init(o);
10715 return tag_ptr(res_ptr, true);
10717 void __attribute__((export_name("TS_CustomOnionMessageHandler_handle_custom_message"))) TS_CustomOnionMessageHandler_handle_custom_message(uint64_t this_arg, uint64_t msg) {
10718 void* this_arg_ptr = untag_ptr(this_arg);
10719 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10720 LDKCustomOnionMessageHandler* this_arg_conv = (LDKCustomOnionMessageHandler*)this_arg_ptr;
10721 void* msg_ptr = untag_ptr(msg);
10722 CHECK_ACCESS(msg_ptr);
10723 LDKCustomOnionMessageContents msg_conv = *(LDKCustomOnionMessageContents*)(msg_ptr);
10724 if (msg_conv.free == LDKCustomOnionMessageContents_JCalls_free) {
10725 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
10726 LDKCustomOnionMessageContents_JCalls_cloned(&msg_conv);
10728 (this_arg_conv->handle_custom_message)(this_arg_conv->this_arg, msg_conv);
10731 uint64_t __attribute__((export_name("TS_CustomOnionMessageHandler_read_custom_message"))) TS_CustomOnionMessageHandler_read_custom_message(uint64_t this_arg, int64_t message_type, int8_tArray buffer) {
10732 void* this_arg_ptr = untag_ptr(this_arg);
10733 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10734 LDKCustomOnionMessageHandler* this_arg_conv = (LDKCustomOnionMessageHandler*)this_arg_ptr;
10735 LDKu8slice buffer_ref;
10736 buffer_ref.datalen = buffer->arr_len;
10737 buffer_ref.data = buffer->elems;
10738 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ), "LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ");
10739 *ret_conv = (this_arg_conv->read_custom_message)(this_arg_conv->this_arg, message_type, buffer_ref);
10741 return tag_ptr(ret_conv, true);
10744 typedef struct LDKSocketDescriptor_JCalls {
10745 atomic_size_t refcnt;
10746 uint32_t instance_ptr;
10747 } LDKSocketDescriptor_JCalls;
10748 static void LDKSocketDescriptor_JCalls_free(void* this_arg) {
10749 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
10750 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
10754 uintptr_t send_data_LDKSocketDescriptor_jcall(void* this_arg, LDKu8slice data, bool resume_read) {
10755 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
10756 LDKu8slice data_var = data;
10757 int8_tArray data_arr = init_int8_tArray(data_var.datalen, __LINE__);
10758 memcpy(data_arr->elems, data_var.data, data_var.datalen);
10759 jboolean resume_read_conv = resume_read;
10760 return js_invoke_function_uuuuuu(j_calls->instance_ptr, 109, (uint32_t)data_arr, resume_read_conv, 0, 0, 0, 0);
10762 void disconnect_socket_LDKSocketDescriptor_jcall(void* this_arg) {
10763 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
10764 js_invoke_function_uuuuuu(j_calls->instance_ptr, 110, 0, 0, 0, 0, 0, 0);
10766 bool eq_LDKSocketDescriptor_jcall(const void* this_arg, const LDKSocketDescriptor * other_arg) {
10767 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
10768 LDKSocketDescriptor *other_arg_clone = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
10769 *other_arg_clone = SocketDescriptor_clone(other_arg);
10770 return js_invoke_function_buuuuu(j_calls->instance_ptr, 111, tag_ptr(other_arg_clone, true), 0, 0, 0, 0, 0);
10772 uint64_t hash_LDKSocketDescriptor_jcall(const void* this_arg) {
10773 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
10774 return js_invoke_function_uuuuuu(j_calls->instance_ptr, 112, 0, 0, 0, 0, 0, 0);
10776 static void LDKSocketDescriptor_JCalls_cloned(LDKSocketDescriptor* new_obj) {
10777 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) new_obj->this_arg;
10778 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
10780 static inline LDKSocketDescriptor LDKSocketDescriptor_init (JSValue o) {
10781 LDKSocketDescriptor_JCalls *calls = MALLOC(sizeof(LDKSocketDescriptor_JCalls), "LDKSocketDescriptor_JCalls");
10782 atomic_init(&calls->refcnt, 1);
10783 calls->instance_ptr = o;
10785 LDKSocketDescriptor ret = {
10786 .this_arg = (void*) calls,
10787 .send_data = send_data_LDKSocketDescriptor_jcall,
10788 .disconnect_socket = disconnect_socket_LDKSocketDescriptor_jcall,
10789 .eq = eq_LDKSocketDescriptor_jcall,
10790 .hash = hash_LDKSocketDescriptor_jcall,
10791 .cloned = LDKSocketDescriptor_JCalls_cloned,
10792 .free = LDKSocketDescriptor_JCalls_free,
10796 uint64_t __attribute__((export_name("TS_LDKSocketDescriptor_new"))) TS_LDKSocketDescriptor_new(JSValue o) {
10797 LDKSocketDescriptor *res_ptr = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
10798 *res_ptr = LDKSocketDescriptor_init(o);
10799 return tag_ptr(res_ptr, true);
10801 uint32_t __attribute__((export_name("TS_SocketDescriptor_send_data"))) TS_SocketDescriptor_send_data(uint64_t this_arg, int8_tArray data, jboolean resume_read) {
10802 void* this_arg_ptr = untag_ptr(this_arg);
10803 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10804 LDKSocketDescriptor* this_arg_conv = (LDKSocketDescriptor*)this_arg_ptr;
10805 LDKu8slice data_ref;
10806 data_ref.datalen = data->arr_len;
10807 data_ref.data = data->elems;
10808 uint32_t ret_conv = (this_arg_conv->send_data)(this_arg_conv->this_arg, data_ref, resume_read);
10813 void __attribute__((export_name("TS_SocketDescriptor_disconnect_socket"))) TS_SocketDescriptor_disconnect_socket(uint64_t this_arg) {
10814 void* this_arg_ptr = untag_ptr(this_arg);
10815 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10816 LDKSocketDescriptor* this_arg_conv = (LDKSocketDescriptor*)this_arg_ptr;
10817 (this_arg_conv->disconnect_socket)(this_arg_conv->this_arg);
10820 int64_t __attribute__((export_name("TS_SocketDescriptor_hash"))) TS_SocketDescriptor_hash(uint64_t this_arg) {
10821 void* this_arg_ptr = untag_ptr(this_arg);
10822 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10823 LDKSocketDescriptor* this_arg_conv = (LDKSocketDescriptor*)this_arg_ptr;
10824 int64_t ret_conv = (this_arg_conv->hash)(this_arg_conv->this_arg);
10828 uint32_t __attribute__((export_name("TS_LDKEffectiveCapacity_ty_from_ptr"))) TS_LDKEffectiveCapacity_ty_from_ptr(uint64_t ptr) {
10829 LDKEffectiveCapacity *obj = (LDKEffectiveCapacity*)untag_ptr(ptr);
10831 case LDKEffectiveCapacity_ExactLiquidity: return 0;
10832 case LDKEffectiveCapacity_MaximumHTLC: return 1;
10833 case LDKEffectiveCapacity_Total: return 2;
10834 case LDKEffectiveCapacity_Infinite: return 3;
10835 case LDKEffectiveCapacity_Unknown: return 4;
10839 int64_t __attribute__((export_name("TS_LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat"))) TS_LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(uint64_t ptr) {
10840 LDKEffectiveCapacity *obj = (LDKEffectiveCapacity*)untag_ptr(ptr);
10841 assert(obj->tag == LDKEffectiveCapacity_ExactLiquidity);
10842 int64_t liquidity_msat_conv = obj->exact_liquidity.liquidity_msat;
10843 return liquidity_msat_conv;
10845 int64_t __attribute__((export_name("TS_LDKEffectiveCapacity_MaximumHTLC_get_amount_msat"))) TS_LDKEffectiveCapacity_MaximumHTLC_get_amount_msat(uint64_t ptr) {
10846 LDKEffectiveCapacity *obj = (LDKEffectiveCapacity*)untag_ptr(ptr);
10847 assert(obj->tag == LDKEffectiveCapacity_MaximumHTLC);
10848 int64_t amount_msat_conv = obj->maximum_htlc.amount_msat;
10849 return amount_msat_conv;
10851 int64_t __attribute__((export_name("TS_LDKEffectiveCapacity_Total_get_capacity_msat"))) TS_LDKEffectiveCapacity_Total_get_capacity_msat(uint64_t ptr) {
10852 LDKEffectiveCapacity *obj = (LDKEffectiveCapacity*)untag_ptr(ptr);
10853 assert(obj->tag == LDKEffectiveCapacity_Total);
10854 int64_t capacity_msat_conv = obj->total.capacity_msat;
10855 return capacity_msat_conv;
10857 int64_t __attribute__((export_name("TS_LDKEffectiveCapacity_Total_get_htlc_maximum_msat"))) TS_LDKEffectiveCapacity_Total_get_htlc_maximum_msat(uint64_t ptr) {
10858 LDKEffectiveCapacity *obj = (LDKEffectiveCapacity*)untag_ptr(ptr);
10859 assert(obj->tag == LDKEffectiveCapacity_Total);
10860 int64_t htlc_maximum_msat_conv = obj->total.htlc_maximum_msat;
10861 return htlc_maximum_msat_conv;
10863 typedef struct LDKRouter_JCalls {
10864 atomic_size_t refcnt;
10865 uint32_t instance_ptr;
10866 } LDKRouter_JCalls;
10867 static void LDKRouter_JCalls_free(void* this_arg) {
10868 LDKRouter_JCalls *j_calls = (LDKRouter_JCalls*) this_arg;
10869 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
10873 LDKCResult_RouteLightningErrorZ find_route_LDKRouter_jcall(const void* this_arg, LDKPublicKey payer, const LDKRouteParameters * route_params, LDKCVec_ChannelDetailsZ * first_hops, LDKInFlightHtlcs inflight_htlcs) {
10874 LDKRouter_JCalls *j_calls = (LDKRouter_JCalls*) this_arg;
10875 int8_tArray payer_arr = init_int8_tArray(33, __LINE__);
10876 memcpy(payer_arr->elems, payer.compressed_form, 33);
10877 LDKRouteParameters route_params_var = *route_params;
10878 uint64_t route_params_ref = 0;
10879 route_params_var = RouteParameters_clone(&route_params_var);
10880 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_var);
10881 route_params_ref = tag_ptr(route_params_var.inner, route_params_var.is_owned);
10882 LDKCVec_ChannelDetailsZ *first_hops_var_ptr = first_hops;
10883 uint64_tArray first_hops_arr = NULL;
10884 if (first_hops != NULL) {
10885 LDKCVec_ChannelDetailsZ first_hops_var = *first_hops_var_ptr;
10886 first_hops_arr = init_uint64_tArray(first_hops_var.datalen, __LINE__);
10887 uint64_t *first_hops_arr_ptr = (uint64_t*)(((uint8_t*)first_hops_arr) + 8);
10888 for (size_t q = 0; q < first_hops_var.datalen; q++) {
10889 LDKChannelDetails first_hops_conv_16_var = first_hops_var.data[q];
10890 uint64_t first_hops_conv_16_ref = 0;
10891 CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_var);
10892 first_hops_conv_16_ref = tag_ptr(first_hops_conv_16_var.inner, first_hops_conv_16_var.is_owned);
10893 first_hops_arr_ptr[q] = first_hops_conv_16_ref;
10897 LDKInFlightHtlcs inflight_htlcs_var = inflight_htlcs;
10898 uint64_t inflight_htlcs_ref = 0;
10899 CHECK_INNER_FIELD_ACCESS_OR_NULL(inflight_htlcs_var);
10900 inflight_htlcs_ref = tag_ptr(inflight_htlcs_var.inner, inflight_htlcs_var.is_owned);
10901 uint64_t ret = js_invoke_function_ububuu(j_calls->instance_ptr, 113, (uint32_t)payer_arr, route_params_ref, (uint32_t)first_hops_arr, inflight_htlcs_ref, 0, 0);
10902 void* ret_ptr = untag_ptr(ret);
10903 CHECK_ACCESS(ret_ptr);
10904 LDKCResult_RouteLightningErrorZ ret_conv = *(LDKCResult_RouteLightningErrorZ*)(ret_ptr);
10905 FREE(untag_ptr(ret));
10908 LDKCResult_RouteLightningErrorZ find_route_with_id_LDKRouter_jcall(const void* this_arg, LDKPublicKey payer, const LDKRouteParameters * route_params, LDKCVec_ChannelDetailsZ * first_hops, LDKInFlightHtlcs inflight_htlcs, LDKThirtyTwoBytes _payment_hash, LDKThirtyTwoBytes _payment_id) {
10909 LDKRouter_JCalls *j_calls = (LDKRouter_JCalls*) this_arg;
10910 int8_tArray payer_arr = init_int8_tArray(33, __LINE__);
10911 memcpy(payer_arr->elems, payer.compressed_form, 33);
10912 LDKRouteParameters route_params_var = *route_params;
10913 uint64_t route_params_ref = 0;
10914 route_params_var = RouteParameters_clone(&route_params_var);
10915 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_var);
10916 route_params_ref = tag_ptr(route_params_var.inner, route_params_var.is_owned);
10917 LDKCVec_ChannelDetailsZ *first_hops_var_ptr = first_hops;
10918 uint64_tArray first_hops_arr = NULL;
10919 if (first_hops != NULL) {
10920 LDKCVec_ChannelDetailsZ first_hops_var = *first_hops_var_ptr;
10921 first_hops_arr = init_uint64_tArray(first_hops_var.datalen, __LINE__);
10922 uint64_t *first_hops_arr_ptr = (uint64_t*)(((uint8_t*)first_hops_arr) + 8);
10923 for (size_t q = 0; q < first_hops_var.datalen; q++) {
10924 LDKChannelDetails first_hops_conv_16_var = first_hops_var.data[q];
10925 uint64_t first_hops_conv_16_ref = 0;
10926 CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_var);
10927 first_hops_conv_16_ref = tag_ptr(first_hops_conv_16_var.inner, first_hops_conv_16_var.is_owned);
10928 first_hops_arr_ptr[q] = first_hops_conv_16_ref;
10932 LDKInFlightHtlcs inflight_htlcs_var = inflight_htlcs;
10933 uint64_t inflight_htlcs_ref = 0;
10934 CHECK_INNER_FIELD_ACCESS_OR_NULL(inflight_htlcs_var);
10935 inflight_htlcs_ref = tag_ptr(inflight_htlcs_var.inner, inflight_htlcs_var.is_owned);
10936 int8_tArray _payment_hash_arr = init_int8_tArray(32, __LINE__);
10937 memcpy(_payment_hash_arr->elems, _payment_hash.data, 32);
10938 int8_tArray _payment_id_arr = init_int8_tArray(32, __LINE__);
10939 memcpy(_payment_id_arr->elems, _payment_id.data, 32);
10940 uint64_t ret = js_invoke_function_ububuu(j_calls->instance_ptr, 114, (uint32_t)payer_arr, route_params_ref, (uint32_t)first_hops_arr, inflight_htlcs_ref, (uint32_t)_payment_hash_arr, (uint32_t)_payment_id_arr);
10941 void* ret_ptr = untag_ptr(ret);
10942 CHECK_ACCESS(ret_ptr);
10943 LDKCResult_RouteLightningErrorZ ret_conv = *(LDKCResult_RouteLightningErrorZ*)(ret_ptr);
10944 FREE(untag_ptr(ret));
10947 void notify_payment_path_failed_LDKRouter_jcall(const void* this_arg, LDKCVec_RouteHopZ path, uint64_t short_channel_id) {
10948 LDKRouter_JCalls *j_calls = (LDKRouter_JCalls*) this_arg;
10949 LDKCVec_RouteHopZ path_var = path;
10950 uint64_tArray path_arr = NULL;
10951 path_arr = init_uint64_tArray(path_var.datalen, __LINE__);
10952 uint64_t *path_arr_ptr = (uint64_t*)(((uint8_t*)path_arr) + 8);
10953 for (size_t k = 0; k < path_var.datalen; k++) {
10954 LDKRouteHop path_conv_10_var = path_var.data[k];
10955 uint64_t path_conv_10_ref = 0;
10956 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
10957 path_conv_10_ref = tag_ptr(path_conv_10_var.inner, path_conv_10_var.is_owned);
10958 path_arr_ptr[k] = path_conv_10_ref;
10961 FREE(path_var.data);
10962 int64_t short_channel_id_conv = short_channel_id;
10963 js_invoke_function_ubuuuu(j_calls->instance_ptr, 115, (uint32_t)path_arr, short_channel_id_conv, 0, 0, 0, 0);
10965 void notify_payment_path_successful_LDKRouter_jcall(const void* this_arg, LDKCVec_RouteHopZ path) {
10966 LDKRouter_JCalls *j_calls = (LDKRouter_JCalls*) this_arg;
10967 LDKCVec_RouteHopZ path_var = path;
10968 uint64_tArray path_arr = NULL;
10969 path_arr = init_uint64_tArray(path_var.datalen, __LINE__);
10970 uint64_t *path_arr_ptr = (uint64_t*)(((uint8_t*)path_arr) + 8);
10971 for (size_t k = 0; k < path_var.datalen; k++) {
10972 LDKRouteHop path_conv_10_var = path_var.data[k];
10973 uint64_t path_conv_10_ref = 0;
10974 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
10975 path_conv_10_ref = tag_ptr(path_conv_10_var.inner, path_conv_10_var.is_owned);
10976 path_arr_ptr[k] = path_conv_10_ref;
10979 FREE(path_var.data);
10980 js_invoke_function_uuuuuu(j_calls->instance_ptr, 116, (uint32_t)path_arr, 0, 0, 0, 0, 0);
10982 void notify_payment_probe_successful_LDKRouter_jcall(const void* this_arg, LDKCVec_RouteHopZ path) {
10983 LDKRouter_JCalls *j_calls = (LDKRouter_JCalls*) this_arg;
10984 LDKCVec_RouteHopZ path_var = path;
10985 uint64_tArray path_arr = NULL;
10986 path_arr = init_uint64_tArray(path_var.datalen, __LINE__);
10987 uint64_t *path_arr_ptr = (uint64_t*)(((uint8_t*)path_arr) + 8);
10988 for (size_t k = 0; k < path_var.datalen; k++) {
10989 LDKRouteHop path_conv_10_var = path_var.data[k];
10990 uint64_t path_conv_10_ref = 0;
10991 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
10992 path_conv_10_ref = tag_ptr(path_conv_10_var.inner, path_conv_10_var.is_owned);
10993 path_arr_ptr[k] = path_conv_10_ref;
10996 FREE(path_var.data);
10997 js_invoke_function_uuuuuu(j_calls->instance_ptr, 117, (uint32_t)path_arr, 0, 0, 0, 0, 0);
10999 void notify_payment_probe_failed_LDKRouter_jcall(const void* this_arg, LDKCVec_RouteHopZ path, uint64_t short_channel_id) {
11000 LDKRouter_JCalls *j_calls = (LDKRouter_JCalls*) this_arg;
11001 LDKCVec_RouteHopZ path_var = path;
11002 uint64_tArray path_arr = NULL;
11003 path_arr = init_uint64_tArray(path_var.datalen, __LINE__);
11004 uint64_t *path_arr_ptr = (uint64_t*)(((uint8_t*)path_arr) + 8);
11005 for (size_t k = 0; k < path_var.datalen; k++) {
11006 LDKRouteHop path_conv_10_var = path_var.data[k];
11007 uint64_t path_conv_10_ref = 0;
11008 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
11009 path_conv_10_ref = tag_ptr(path_conv_10_var.inner, path_conv_10_var.is_owned);
11010 path_arr_ptr[k] = path_conv_10_ref;
11013 FREE(path_var.data);
11014 int64_t short_channel_id_conv = short_channel_id;
11015 js_invoke_function_ubuuuu(j_calls->instance_ptr, 118, (uint32_t)path_arr, short_channel_id_conv, 0, 0, 0, 0);
11017 static void LDKRouter_JCalls_cloned(LDKRouter* new_obj) {
11018 LDKRouter_JCalls *j_calls = (LDKRouter_JCalls*) new_obj->this_arg;
11019 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
11021 static inline LDKRouter LDKRouter_init (JSValue o) {
11022 LDKRouter_JCalls *calls = MALLOC(sizeof(LDKRouter_JCalls), "LDKRouter_JCalls");
11023 atomic_init(&calls->refcnt, 1);
11024 calls->instance_ptr = o;
11027 .this_arg = (void*) calls,
11028 .find_route = find_route_LDKRouter_jcall,
11029 .find_route_with_id = find_route_with_id_LDKRouter_jcall,
11030 .notify_payment_path_failed = notify_payment_path_failed_LDKRouter_jcall,
11031 .notify_payment_path_successful = notify_payment_path_successful_LDKRouter_jcall,
11032 .notify_payment_probe_successful = notify_payment_probe_successful_LDKRouter_jcall,
11033 .notify_payment_probe_failed = notify_payment_probe_failed_LDKRouter_jcall,
11034 .free = LDKRouter_JCalls_free,
11038 uint64_t __attribute__((export_name("TS_LDKRouter_new"))) TS_LDKRouter_new(JSValue o) {
11039 LDKRouter *res_ptr = MALLOC(sizeof(LDKRouter), "LDKRouter");
11040 *res_ptr = LDKRouter_init(o);
11041 return tag_ptr(res_ptr, true);
11043 uint64_t __attribute__((export_name("TS_Router_find_route"))) TS_Router_find_route(uint64_t this_arg, int8_tArray payer, uint64_t route_params, uint64_tArray first_hops, uint64_t inflight_htlcs) {
11044 void* this_arg_ptr = untag_ptr(this_arg);
11045 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11046 LDKRouter* this_arg_conv = (LDKRouter*)this_arg_ptr;
11047 LDKPublicKey payer_ref;
11048 CHECK(payer->arr_len == 33);
11049 memcpy(payer_ref.compressed_form, payer->elems, 33); FREE(payer);
11050 LDKRouteParameters route_params_conv;
11051 route_params_conv.inner = untag_ptr(route_params);
11052 route_params_conv.is_owned = ptr_is_owned(route_params);
11053 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_conv);
11054 route_params_conv.is_owned = false;
11055 LDKCVec_ChannelDetailsZ first_hops_constr;
11056 LDKCVec_ChannelDetailsZ *first_hops_ptr = NULL;
11057 if (first_hops != 0) {
11058 first_hops_constr.datalen = first_hops->arr_len;
11059 if (first_hops_constr.datalen > 0)
11060 first_hops_constr.data = MALLOC(first_hops_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
11062 first_hops_constr.data = NULL;
11063 uint64_t* first_hops_vals = first_hops->elems;
11064 for (size_t q = 0; q < first_hops_constr.datalen; q++) {
11065 uint64_t first_hops_conv_16 = first_hops_vals[q];
11066 LDKChannelDetails first_hops_conv_16_conv;
11067 first_hops_conv_16_conv.inner = untag_ptr(first_hops_conv_16);
11068 first_hops_conv_16_conv.is_owned = ptr_is_owned(first_hops_conv_16);
11069 CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_conv);
11070 first_hops_conv_16_conv.is_owned = false;
11071 first_hops_constr.data[q] = first_hops_conv_16_conv;
11074 first_hops_ptr = &first_hops_constr;
11076 LDKInFlightHtlcs inflight_htlcs_conv;
11077 inflight_htlcs_conv.inner = untag_ptr(inflight_htlcs);
11078 inflight_htlcs_conv.is_owned = ptr_is_owned(inflight_htlcs);
11079 CHECK_INNER_FIELD_ACCESS_OR_NULL(inflight_htlcs_conv);
11080 inflight_htlcs_conv = InFlightHtlcs_clone(&inflight_htlcs_conv);
11081 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
11082 *ret_conv = (this_arg_conv->find_route)(this_arg_conv->this_arg, payer_ref, &route_params_conv, first_hops_ptr, inflight_htlcs_conv);
11083 if (first_hops_ptr != NULL) { FREE(first_hops_constr.data); }
11084 return tag_ptr(ret_conv, true);
11087 uint64_t __attribute__((export_name("TS_Router_find_route_with_id"))) TS_Router_find_route_with_id(uint64_t this_arg, int8_tArray payer, uint64_t route_params, uint64_tArray first_hops, uint64_t inflight_htlcs, int8_tArray _payment_hash, int8_tArray _payment_id) {
11088 void* this_arg_ptr = untag_ptr(this_arg);
11089 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11090 LDKRouter* this_arg_conv = (LDKRouter*)this_arg_ptr;
11091 LDKPublicKey payer_ref;
11092 CHECK(payer->arr_len == 33);
11093 memcpy(payer_ref.compressed_form, payer->elems, 33); FREE(payer);
11094 LDKRouteParameters route_params_conv;
11095 route_params_conv.inner = untag_ptr(route_params);
11096 route_params_conv.is_owned = ptr_is_owned(route_params);
11097 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_conv);
11098 route_params_conv.is_owned = false;
11099 LDKCVec_ChannelDetailsZ first_hops_constr;
11100 LDKCVec_ChannelDetailsZ *first_hops_ptr = NULL;
11101 if (first_hops != 0) {
11102 first_hops_constr.datalen = first_hops->arr_len;
11103 if (first_hops_constr.datalen > 0)
11104 first_hops_constr.data = MALLOC(first_hops_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
11106 first_hops_constr.data = NULL;
11107 uint64_t* first_hops_vals = first_hops->elems;
11108 for (size_t q = 0; q < first_hops_constr.datalen; q++) {
11109 uint64_t first_hops_conv_16 = first_hops_vals[q];
11110 LDKChannelDetails first_hops_conv_16_conv;
11111 first_hops_conv_16_conv.inner = untag_ptr(first_hops_conv_16);
11112 first_hops_conv_16_conv.is_owned = ptr_is_owned(first_hops_conv_16);
11113 CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_conv);
11114 first_hops_conv_16_conv.is_owned = false;
11115 first_hops_constr.data[q] = first_hops_conv_16_conv;
11118 first_hops_ptr = &first_hops_constr;
11120 LDKInFlightHtlcs inflight_htlcs_conv;
11121 inflight_htlcs_conv.inner = untag_ptr(inflight_htlcs);
11122 inflight_htlcs_conv.is_owned = ptr_is_owned(inflight_htlcs);
11123 CHECK_INNER_FIELD_ACCESS_OR_NULL(inflight_htlcs_conv);
11124 inflight_htlcs_conv = InFlightHtlcs_clone(&inflight_htlcs_conv);
11125 LDKThirtyTwoBytes _payment_hash_ref;
11126 CHECK(_payment_hash->arr_len == 32);
11127 memcpy(_payment_hash_ref.data, _payment_hash->elems, 32); FREE(_payment_hash);
11128 LDKThirtyTwoBytes _payment_id_ref;
11129 CHECK(_payment_id->arr_len == 32);
11130 memcpy(_payment_id_ref.data, _payment_id->elems, 32); FREE(_payment_id);
11131 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
11132 *ret_conv = (this_arg_conv->find_route_with_id)(this_arg_conv->this_arg, payer_ref, &route_params_conv, first_hops_ptr, inflight_htlcs_conv, _payment_hash_ref, _payment_id_ref);
11133 if (first_hops_ptr != NULL) { FREE(first_hops_constr.data); }
11134 return tag_ptr(ret_conv, true);
11137 void __attribute__((export_name("TS_Router_notify_payment_path_failed"))) TS_Router_notify_payment_path_failed(uint64_t this_arg, uint64_tArray path, int64_t short_channel_id) {
11138 void* this_arg_ptr = untag_ptr(this_arg);
11139 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11140 LDKRouter* this_arg_conv = (LDKRouter*)this_arg_ptr;
11141 LDKCVec_RouteHopZ path_constr;
11142 path_constr.datalen = path->arr_len;
11143 if (path_constr.datalen > 0)
11144 path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
11146 path_constr.data = NULL;
11147 uint64_t* path_vals = path->elems;
11148 for (size_t k = 0; k < path_constr.datalen; k++) {
11149 uint64_t path_conv_10 = path_vals[k];
11150 LDKRouteHop path_conv_10_conv;
11151 path_conv_10_conv.inner = untag_ptr(path_conv_10);
11152 path_conv_10_conv.is_owned = ptr_is_owned(path_conv_10);
11153 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
11154 path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
11155 path_constr.data[k] = path_conv_10_conv;
11158 (this_arg_conv->notify_payment_path_failed)(this_arg_conv->this_arg, path_constr, short_channel_id);
11161 void __attribute__((export_name("TS_Router_notify_payment_path_successful"))) TS_Router_notify_payment_path_successful(uint64_t this_arg, uint64_tArray path) {
11162 void* this_arg_ptr = untag_ptr(this_arg);
11163 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11164 LDKRouter* this_arg_conv = (LDKRouter*)this_arg_ptr;
11165 LDKCVec_RouteHopZ path_constr;
11166 path_constr.datalen = path->arr_len;
11167 if (path_constr.datalen > 0)
11168 path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
11170 path_constr.data = NULL;
11171 uint64_t* path_vals = path->elems;
11172 for (size_t k = 0; k < path_constr.datalen; k++) {
11173 uint64_t path_conv_10 = path_vals[k];
11174 LDKRouteHop path_conv_10_conv;
11175 path_conv_10_conv.inner = untag_ptr(path_conv_10);
11176 path_conv_10_conv.is_owned = ptr_is_owned(path_conv_10);
11177 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
11178 path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
11179 path_constr.data[k] = path_conv_10_conv;
11182 (this_arg_conv->notify_payment_path_successful)(this_arg_conv->this_arg, path_constr);
11185 void __attribute__((export_name("TS_Router_notify_payment_probe_successful"))) TS_Router_notify_payment_probe_successful(uint64_t this_arg, uint64_tArray path) {
11186 void* this_arg_ptr = untag_ptr(this_arg);
11187 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11188 LDKRouter* this_arg_conv = (LDKRouter*)this_arg_ptr;
11189 LDKCVec_RouteHopZ path_constr;
11190 path_constr.datalen = path->arr_len;
11191 if (path_constr.datalen > 0)
11192 path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
11194 path_constr.data = NULL;
11195 uint64_t* path_vals = path->elems;
11196 for (size_t k = 0; k < path_constr.datalen; k++) {
11197 uint64_t path_conv_10 = path_vals[k];
11198 LDKRouteHop path_conv_10_conv;
11199 path_conv_10_conv.inner = untag_ptr(path_conv_10);
11200 path_conv_10_conv.is_owned = ptr_is_owned(path_conv_10);
11201 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
11202 path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
11203 path_constr.data[k] = path_conv_10_conv;
11206 (this_arg_conv->notify_payment_probe_successful)(this_arg_conv->this_arg, path_constr);
11209 void __attribute__((export_name("TS_Router_notify_payment_probe_failed"))) TS_Router_notify_payment_probe_failed(uint64_t this_arg, uint64_tArray path, int64_t short_channel_id) {
11210 void* this_arg_ptr = untag_ptr(this_arg);
11211 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11212 LDKRouter* this_arg_conv = (LDKRouter*)this_arg_ptr;
11213 LDKCVec_RouteHopZ path_constr;
11214 path_constr.datalen = path->arr_len;
11215 if (path_constr.datalen > 0)
11216 path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
11218 path_constr.data = NULL;
11219 uint64_t* path_vals = path->elems;
11220 for (size_t k = 0; k < path_constr.datalen; k++) {
11221 uint64_t path_conv_10 = path_vals[k];
11222 LDKRouteHop path_conv_10_conv;
11223 path_conv_10_conv.inner = untag_ptr(path_conv_10);
11224 path_conv_10_conv.is_owned = ptr_is_owned(path_conv_10);
11225 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
11226 path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
11227 path_constr.data[k] = path_conv_10_conv;
11230 (this_arg_conv->notify_payment_probe_failed)(this_arg_conv->this_arg, path_constr, short_channel_id);
11233 uint32_t __attribute__((export_name("TS_LDKDestination_ty_from_ptr"))) TS_LDKDestination_ty_from_ptr(uint64_t ptr) {
11234 LDKDestination *obj = (LDKDestination*)untag_ptr(ptr);
11236 case LDKDestination_Node: return 0;
11237 case LDKDestination_BlindedPath: return 1;
11241 int8_tArray __attribute__((export_name("TS_LDKDestination_Node_get_node"))) TS_LDKDestination_Node_get_node(uint64_t ptr) {
11242 LDKDestination *obj = (LDKDestination*)untag_ptr(ptr);
11243 assert(obj->tag == LDKDestination_Node);
11244 int8_tArray node_arr = init_int8_tArray(33, __LINE__);
11245 memcpy(node_arr->elems, obj->node.compressed_form, 33);
11248 uint64_t __attribute__((export_name("TS_LDKDestination_BlindedPath_get_blinded_path"))) TS_LDKDestination_BlindedPath_get_blinded_path(uint64_t ptr) {
11249 LDKDestination *obj = (LDKDestination*)untag_ptr(ptr);
11250 assert(obj->tag == LDKDestination_BlindedPath);
11251 LDKBlindedPath blinded_path_var = obj->blinded_path;
11252 uint64_t blinded_path_ref = 0;
11253 CHECK_INNER_FIELD_ACCESS_OR_NULL(blinded_path_var);
11254 blinded_path_ref = tag_ptr(blinded_path_var.inner, false);
11255 return blinded_path_ref;
11257 uint32_t __attribute__((export_name("TS_LDKOnionMessageContents_ty_from_ptr"))) TS_LDKOnionMessageContents_ty_from_ptr(uint64_t ptr) {
11258 LDKOnionMessageContents *obj = (LDKOnionMessageContents*)untag_ptr(ptr);
11260 case LDKOnionMessageContents_Custom: return 0;
11264 uint64_t __attribute__((export_name("TS_LDKOnionMessageContents_Custom_get_custom"))) TS_LDKOnionMessageContents_Custom_get_custom(uint64_t ptr) {
11265 LDKOnionMessageContents *obj = (LDKOnionMessageContents*)untag_ptr(ptr);
11266 assert(obj->tag == LDKOnionMessageContents_Custom);
11267 LDKCustomOnionMessageContents* custom_ret = MALLOC(sizeof(LDKCustomOnionMessageContents), "LDKCustomOnionMessageContents");
11268 *custom_ret = CustomOnionMessageContents_clone(&obj->custom);
11269 return tag_ptr(custom_ret, true);
11271 uint32_t __attribute__((export_name("TS_LDKFallback_ty_from_ptr"))) TS_LDKFallback_ty_from_ptr(uint64_t ptr) {
11272 LDKFallback *obj = (LDKFallback*)untag_ptr(ptr);
11274 case LDKFallback_SegWitProgram: return 0;
11275 case LDKFallback_PubKeyHash: return 1;
11276 case LDKFallback_ScriptHash: return 2;
11280 int8_t __attribute__((export_name("TS_LDKFallback_SegWitProgram_get_version"))) TS_LDKFallback_SegWitProgram_get_version(uint64_t ptr) {
11281 LDKFallback *obj = (LDKFallback*)untag_ptr(ptr);
11282 assert(obj->tag == LDKFallback_SegWitProgram);
11283 uint8_t version_val = obj->seg_wit_program.version._0;
11284 return version_val;
11286 int8_tArray __attribute__((export_name("TS_LDKFallback_SegWitProgram_get_program"))) TS_LDKFallback_SegWitProgram_get_program(uint64_t ptr) {
11287 LDKFallback *obj = (LDKFallback*)untag_ptr(ptr);
11288 assert(obj->tag == LDKFallback_SegWitProgram);
11289 LDKCVec_u8Z program_var = obj->seg_wit_program.program;
11290 int8_tArray program_arr = init_int8_tArray(program_var.datalen, __LINE__);
11291 memcpy(program_arr->elems, program_var.data, program_var.datalen);
11292 return program_arr;
11294 int8_tArray __attribute__((export_name("TS_LDKFallback_PubKeyHash_get_pub_key_hash"))) TS_LDKFallback_PubKeyHash_get_pub_key_hash(uint64_t ptr) {
11295 LDKFallback *obj = (LDKFallback*)untag_ptr(ptr);
11296 assert(obj->tag == LDKFallback_PubKeyHash);
11297 int8_tArray pub_key_hash_arr = init_int8_tArray(20, __LINE__);
11298 memcpy(pub_key_hash_arr->elems, obj->pub_key_hash.data, 20);
11299 return pub_key_hash_arr;
11301 int8_tArray __attribute__((export_name("TS_LDKFallback_ScriptHash_get_script_hash"))) TS_LDKFallback_ScriptHash_get_script_hash(uint64_t ptr) {
11302 LDKFallback *obj = (LDKFallback*)untag_ptr(ptr);
11303 assert(obj->tag == LDKFallback_ScriptHash);
11304 int8_tArray script_hash_arr = init_int8_tArray(20, __LINE__);
11305 memcpy(script_hash_arr->elems, obj->script_hash.data, 20);
11306 return script_hash_arr;
11308 typedef struct LDKPayer_JCalls {
11309 atomic_size_t refcnt;
11310 uint32_t instance_ptr;
11312 static void LDKPayer_JCalls_free(void* this_arg) {
11313 LDKPayer_JCalls *j_calls = (LDKPayer_JCalls*) this_arg;
11314 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
11318 LDKPublicKey node_id_LDKPayer_jcall(const void* this_arg) {
11319 LDKPayer_JCalls *j_calls = (LDKPayer_JCalls*) this_arg;
11320 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 119, 0, 0, 0, 0, 0, 0);
11321 LDKPublicKey ret_ref;
11322 CHECK(ret->arr_len == 33);
11323 memcpy(ret_ref.compressed_form, ret->elems, 33); FREE(ret);
11326 LDKCVec_ChannelDetailsZ first_hops_LDKPayer_jcall(const void* this_arg) {
11327 LDKPayer_JCalls *j_calls = (LDKPayer_JCalls*) this_arg;
11328 uint64_tArray ret = (uint64_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 120, 0, 0, 0, 0, 0, 0);
11329 LDKCVec_ChannelDetailsZ ret_constr;
11330 ret_constr.datalen = ret->arr_len;
11331 if (ret_constr.datalen > 0)
11332 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
11334 ret_constr.data = NULL;
11335 uint64_t* ret_vals = ret->elems;
11336 for (size_t q = 0; q < ret_constr.datalen; q++) {
11337 uint64_t ret_conv_16 = ret_vals[q];
11338 LDKChannelDetails ret_conv_16_conv;
11339 ret_conv_16_conv.inner = untag_ptr(ret_conv_16);
11340 ret_conv_16_conv.is_owned = ptr_is_owned(ret_conv_16);
11341 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_conv);
11342 ret_constr.data[q] = ret_conv_16_conv;
11347 LDKCResult_NonePaymentSendFailureZ send_payment_LDKPayer_jcall(const void* this_arg, const LDKRoute * route, LDKThirtyTwoBytes payment_hash, LDKThirtyTwoBytes payment_secret, LDKThirtyTwoBytes payment_id) {
11348 LDKPayer_JCalls *j_calls = (LDKPayer_JCalls*) this_arg;
11349 LDKRoute route_var = *route;
11350 uint64_t route_ref = 0;
11351 route_var = Route_clone(&route_var);
11352 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_var);
11353 route_ref = tag_ptr(route_var.inner, route_var.is_owned);
11354 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
11355 memcpy(payment_hash_arr->elems, payment_hash.data, 32);
11356 int8_tArray payment_secret_arr = init_int8_tArray(32, __LINE__);
11357 memcpy(payment_secret_arr->elems, payment_secret.data, 32);
11358 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
11359 memcpy(payment_id_arr->elems, payment_id.data, 32);
11360 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 121, route_ref, (uint32_t)payment_hash_arr, (uint32_t)payment_secret_arr, (uint32_t)payment_id_arr, 0, 0);
11361 void* ret_ptr = untag_ptr(ret);
11362 CHECK_ACCESS(ret_ptr);
11363 LDKCResult_NonePaymentSendFailureZ ret_conv = *(LDKCResult_NonePaymentSendFailureZ*)(ret_ptr);
11364 FREE(untag_ptr(ret));
11367 LDKCResult_NonePaymentSendFailureZ send_spontaneous_payment_LDKPayer_jcall(const void* this_arg, const LDKRoute * route, LDKThirtyTwoBytes payment_preimage, LDKThirtyTwoBytes payment_id) {
11368 LDKPayer_JCalls *j_calls = (LDKPayer_JCalls*) this_arg;
11369 LDKRoute route_var = *route;
11370 uint64_t route_ref = 0;
11371 route_var = Route_clone(&route_var);
11372 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_var);
11373 route_ref = tag_ptr(route_var.inner, route_var.is_owned);
11374 int8_tArray payment_preimage_arr = init_int8_tArray(32, __LINE__);
11375 memcpy(payment_preimage_arr->elems, payment_preimage.data, 32);
11376 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
11377 memcpy(payment_id_arr->elems, payment_id.data, 32);
11378 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 122, route_ref, (uint32_t)payment_preimage_arr, (uint32_t)payment_id_arr, 0, 0, 0);
11379 void* ret_ptr = untag_ptr(ret);
11380 CHECK_ACCESS(ret_ptr);
11381 LDKCResult_NonePaymentSendFailureZ ret_conv = *(LDKCResult_NonePaymentSendFailureZ*)(ret_ptr);
11382 FREE(untag_ptr(ret));
11385 LDKCResult_NonePaymentSendFailureZ retry_payment_LDKPayer_jcall(const void* this_arg, const LDKRoute * route, LDKThirtyTwoBytes payment_id) {
11386 LDKPayer_JCalls *j_calls = (LDKPayer_JCalls*) this_arg;
11387 LDKRoute route_var = *route;
11388 uint64_t route_ref = 0;
11389 route_var = Route_clone(&route_var);
11390 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_var);
11391 route_ref = tag_ptr(route_var.inner, route_var.is_owned);
11392 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
11393 memcpy(payment_id_arr->elems, payment_id.data, 32);
11394 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 123, route_ref, (uint32_t)payment_id_arr, 0, 0, 0, 0);
11395 void* ret_ptr = untag_ptr(ret);
11396 CHECK_ACCESS(ret_ptr);
11397 LDKCResult_NonePaymentSendFailureZ ret_conv = *(LDKCResult_NonePaymentSendFailureZ*)(ret_ptr);
11398 FREE(untag_ptr(ret));
11401 void abandon_payment_LDKPayer_jcall(const void* this_arg, LDKThirtyTwoBytes payment_id) {
11402 LDKPayer_JCalls *j_calls = (LDKPayer_JCalls*) this_arg;
11403 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
11404 memcpy(payment_id_arr->elems, payment_id.data, 32);
11405 js_invoke_function_uuuuuu(j_calls->instance_ptr, 124, (uint32_t)payment_id_arr, 0, 0, 0, 0, 0);
11407 LDKInFlightHtlcs inflight_htlcs_LDKPayer_jcall(const void* this_arg) {
11408 LDKPayer_JCalls *j_calls = (LDKPayer_JCalls*) this_arg;
11409 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 125, 0, 0, 0, 0, 0, 0);
11410 LDKInFlightHtlcs ret_conv;
11411 ret_conv.inner = untag_ptr(ret);
11412 ret_conv.is_owned = ptr_is_owned(ret);
11413 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
11416 static void LDKPayer_JCalls_cloned(LDKPayer* new_obj) {
11417 LDKPayer_JCalls *j_calls = (LDKPayer_JCalls*) new_obj->this_arg;
11418 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
11420 static inline LDKPayer LDKPayer_init (JSValue o) {
11421 LDKPayer_JCalls *calls = MALLOC(sizeof(LDKPayer_JCalls), "LDKPayer_JCalls");
11422 atomic_init(&calls->refcnt, 1);
11423 calls->instance_ptr = o;
11426 .this_arg = (void*) calls,
11427 .node_id = node_id_LDKPayer_jcall,
11428 .first_hops = first_hops_LDKPayer_jcall,
11429 .send_payment = send_payment_LDKPayer_jcall,
11430 .send_spontaneous_payment = send_spontaneous_payment_LDKPayer_jcall,
11431 .retry_payment = retry_payment_LDKPayer_jcall,
11432 .abandon_payment = abandon_payment_LDKPayer_jcall,
11433 .inflight_htlcs = inflight_htlcs_LDKPayer_jcall,
11434 .free = LDKPayer_JCalls_free,
11438 uint64_t __attribute__((export_name("TS_LDKPayer_new"))) TS_LDKPayer_new(JSValue o) {
11439 LDKPayer *res_ptr = MALLOC(sizeof(LDKPayer), "LDKPayer");
11440 *res_ptr = LDKPayer_init(o);
11441 return tag_ptr(res_ptr, true);
11443 int8_tArray __attribute__((export_name("TS_Payer_node_id"))) TS_Payer_node_id(uint64_t this_arg) {
11444 void* this_arg_ptr = untag_ptr(this_arg);
11445 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11446 LDKPayer* this_arg_conv = (LDKPayer*)this_arg_ptr;
11447 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
11448 memcpy(ret_arr->elems, (this_arg_conv->node_id)(this_arg_conv->this_arg).compressed_form, 33);
11452 uint64_tArray __attribute__((export_name("TS_Payer_first_hops"))) TS_Payer_first_hops(uint64_t this_arg) {
11453 void* this_arg_ptr = untag_ptr(this_arg);
11454 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11455 LDKPayer* this_arg_conv = (LDKPayer*)this_arg_ptr;
11456 LDKCVec_ChannelDetailsZ ret_var = (this_arg_conv->first_hops)(this_arg_conv->this_arg);
11457 uint64_tArray ret_arr = NULL;
11458 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
11459 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
11460 for (size_t q = 0; q < ret_var.datalen; q++) {
11461 LDKChannelDetails ret_conv_16_var = ret_var.data[q];
11462 uint64_t ret_conv_16_ref = 0;
11463 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
11464 ret_conv_16_ref = tag_ptr(ret_conv_16_var.inner, ret_conv_16_var.is_owned);
11465 ret_arr_ptr[q] = ret_conv_16_ref;
11468 FREE(ret_var.data);
11472 uint64_t __attribute__((export_name("TS_Payer_send_payment"))) TS_Payer_send_payment(uint64_t this_arg, uint64_t route, int8_tArray payment_hash, int8_tArray payment_secret, int8_tArray payment_id) {
11473 void* this_arg_ptr = untag_ptr(this_arg);
11474 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11475 LDKPayer* this_arg_conv = (LDKPayer*)this_arg_ptr;
11476 LDKRoute route_conv;
11477 route_conv.inner = untag_ptr(route);
11478 route_conv.is_owned = ptr_is_owned(route);
11479 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
11480 route_conv.is_owned = false;
11481 LDKThirtyTwoBytes payment_hash_ref;
11482 CHECK(payment_hash->arr_len == 32);
11483 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
11484 LDKThirtyTwoBytes payment_secret_ref;
11485 CHECK(payment_secret->arr_len == 32);
11486 memcpy(payment_secret_ref.data, payment_secret->elems, 32); FREE(payment_secret);
11487 LDKThirtyTwoBytes payment_id_ref;
11488 CHECK(payment_id->arr_len == 32);
11489 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
11490 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
11491 *ret_conv = (this_arg_conv->send_payment)(this_arg_conv->this_arg, &route_conv, payment_hash_ref, payment_secret_ref, payment_id_ref);
11492 return tag_ptr(ret_conv, true);
11495 uint64_t __attribute__((export_name("TS_Payer_send_spontaneous_payment"))) TS_Payer_send_spontaneous_payment(uint64_t this_arg, uint64_t route, int8_tArray payment_preimage, int8_tArray payment_id) {
11496 void* this_arg_ptr = untag_ptr(this_arg);
11497 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11498 LDKPayer* this_arg_conv = (LDKPayer*)this_arg_ptr;
11499 LDKRoute route_conv;
11500 route_conv.inner = untag_ptr(route);
11501 route_conv.is_owned = ptr_is_owned(route);
11502 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
11503 route_conv.is_owned = false;
11504 LDKThirtyTwoBytes payment_preimage_ref;
11505 CHECK(payment_preimage->arr_len == 32);
11506 memcpy(payment_preimage_ref.data, payment_preimage->elems, 32); FREE(payment_preimage);
11507 LDKThirtyTwoBytes payment_id_ref;
11508 CHECK(payment_id->arr_len == 32);
11509 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
11510 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
11511 *ret_conv = (this_arg_conv->send_spontaneous_payment)(this_arg_conv->this_arg, &route_conv, payment_preimage_ref, payment_id_ref);
11512 return tag_ptr(ret_conv, true);
11515 uint64_t __attribute__((export_name("TS_Payer_retry_payment"))) TS_Payer_retry_payment(uint64_t this_arg, uint64_t route, int8_tArray payment_id) {
11516 void* this_arg_ptr = untag_ptr(this_arg);
11517 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11518 LDKPayer* this_arg_conv = (LDKPayer*)this_arg_ptr;
11519 LDKRoute route_conv;
11520 route_conv.inner = untag_ptr(route);
11521 route_conv.is_owned = ptr_is_owned(route);
11522 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
11523 route_conv.is_owned = false;
11524 LDKThirtyTwoBytes payment_id_ref;
11525 CHECK(payment_id->arr_len == 32);
11526 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
11527 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
11528 *ret_conv = (this_arg_conv->retry_payment)(this_arg_conv->this_arg, &route_conv, payment_id_ref);
11529 return tag_ptr(ret_conv, true);
11532 void __attribute__((export_name("TS_Payer_abandon_payment"))) TS_Payer_abandon_payment(uint64_t this_arg, int8_tArray payment_id) {
11533 void* this_arg_ptr = untag_ptr(this_arg);
11534 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11535 LDKPayer* this_arg_conv = (LDKPayer*)this_arg_ptr;
11536 LDKThirtyTwoBytes payment_id_ref;
11537 CHECK(payment_id->arr_len == 32);
11538 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
11539 (this_arg_conv->abandon_payment)(this_arg_conv->this_arg, payment_id_ref);
11542 uint64_t __attribute__((export_name("TS_Payer_inflight_htlcs"))) TS_Payer_inflight_htlcs(uint64_t this_arg) {
11543 void* this_arg_ptr = untag_ptr(this_arg);
11544 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11545 LDKPayer* this_arg_conv = (LDKPayer*)this_arg_ptr;
11546 LDKInFlightHtlcs ret_var = (this_arg_conv->inflight_htlcs)(this_arg_conv->this_arg);
11547 uint64_t ret_ref = 0;
11548 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
11549 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
11553 uint32_t __attribute__((export_name("TS_LDKRetry_ty_from_ptr"))) TS_LDKRetry_ty_from_ptr(uint64_t ptr) {
11554 LDKRetry *obj = (LDKRetry*)untag_ptr(ptr);
11556 case LDKRetry_Attempts: return 0;
11560 uint32_t __attribute__((export_name("TS_LDKRetry_Attempts_get_attempts"))) TS_LDKRetry_Attempts_get_attempts(uint64_t ptr) {
11561 LDKRetry *obj = (LDKRetry*)untag_ptr(ptr);
11562 assert(obj->tag == LDKRetry_Attempts);
11563 uint32_t attempts_conv = obj->attempts;
11564 return attempts_conv;
11566 jstring __attribute__((export_name("TS__ldk_get_compiled_version"))) TS__ldk_get_compiled_version() {
11567 LDKStr ret_str = _ldk_get_compiled_version();
11568 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
11573 jstring __attribute__((export_name("TS__ldk_c_bindings_get_compiled_version"))) TS__ldk_c_bindings_get_compiled_version() {
11574 LDKStr ret_str = _ldk_c_bindings_get_compiled_version();
11575 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
11580 int8_tArray __attribute__((export_name("TS_U128_le_bytes"))) TS_U128_le_bytes(int8_tArray val) {
11582 CHECK(val->arr_len == 16);
11583 memcpy(val_ref.le_bytes, val->elems, 16); FREE(val);
11584 int8_tArray ret_arr = init_int8_tArray(16, __LINE__);
11585 memcpy(ret_arr->elems, U128_le_bytes(val_ref).data, 16);
11589 int8_tArray __attribute__((export_name("TS_U128_new"))) TS_U128_new(int8_tArray le_bytes) {
11590 LDKSixteenBytes le_bytes_ref;
11591 CHECK(le_bytes->arr_len == 16);
11592 memcpy(le_bytes_ref.data, le_bytes->elems, 16); FREE(le_bytes);
11593 int8_tArray ret_arr = init_int8_tArray(16, __LINE__);
11594 memcpy(ret_arr->elems, U128_new(le_bytes_ref).le_bytes, 16);
11598 uint64_t __attribute__((export_name("TS_BigEndianScalar_new"))) TS_BigEndianScalar_new(int8_tArray big_endian_bytes) {
11599 LDKThirtyTwoBytes big_endian_bytes_ref;
11600 CHECK(big_endian_bytes->arr_len == 32);
11601 memcpy(big_endian_bytes_ref.data, big_endian_bytes->elems, 32); FREE(big_endian_bytes);
11602 LDKBigEndianScalar* ret_ref = MALLOC(sizeof(LDKBigEndianScalar), "LDKBigEndianScalar");
11603 *ret_ref = BigEndianScalar_new(big_endian_bytes_ref);
11604 return tag_ptr(ret_ref, true);
11607 static inline uint64_t Bech32Error_clone_ptr(LDKBech32Error *NONNULL_PTR arg) {
11608 LDKBech32Error *ret_copy = MALLOC(sizeof(LDKBech32Error), "LDKBech32Error");
11609 *ret_copy = Bech32Error_clone(arg);
11610 uint64_t ret_ref = tag_ptr(ret_copy, true);
11613 int64_t __attribute__((export_name("TS_Bech32Error_clone_ptr"))) TS_Bech32Error_clone_ptr(uint64_t arg) {
11614 LDKBech32Error* arg_conv = (LDKBech32Error*)untag_ptr(arg);
11615 int64_t ret_conv = Bech32Error_clone_ptr(arg_conv);
11619 uint64_t __attribute__((export_name("TS_Bech32Error_clone"))) TS_Bech32Error_clone(uint64_t orig) {
11620 LDKBech32Error* orig_conv = (LDKBech32Error*)untag_ptr(orig);
11621 LDKBech32Error *ret_copy = MALLOC(sizeof(LDKBech32Error), "LDKBech32Error");
11622 *ret_copy = Bech32Error_clone(orig_conv);
11623 uint64_t ret_ref = tag_ptr(ret_copy, true);
11627 void __attribute__((export_name("TS_Bech32Error_free"))) TS_Bech32Error_free(uint64_t o) {
11628 if (!ptr_is_owned(o)) return;
11629 void* o_ptr = untag_ptr(o);
11630 CHECK_ACCESS(o_ptr);
11631 LDKBech32Error o_conv = *(LDKBech32Error*)(o_ptr);
11632 FREE(untag_ptr(o));
11633 Bech32Error_free(o_conv);
11636 void __attribute__((export_name("TS_Transaction_free"))) TS_Transaction_free(int8_tArray _res) {
11637 LDKTransaction _res_ref;
11638 _res_ref.datalen = _res->arr_len;
11639 _res_ref.data = MALLOC(_res_ref.datalen, "LDKTransaction Bytes");
11640 memcpy(_res_ref.data, _res->elems, _res_ref.datalen); FREE(_res);
11641 _res_ref.data_is_owned = true;
11642 Transaction_free(_res_ref);
11645 void __attribute__((export_name("TS_Witness_free"))) TS_Witness_free(int8_tArray _res) {
11646 LDKWitness _res_ref;
11647 _res_ref.datalen = _res->arr_len;
11648 _res_ref.data = MALLOC(_res_ref.datalen, "LDKWitness Bytes");
11649 memcpy(_res_ref.data, _res->elems, _res_ref.datalen); FREE(_res);
11650 _res_ref.data_is_owned = true;
11651 Witness_free(_res_ref);
11654 uint64_t __attribute__((export_name("TS_TxOut_new"))) TS_TxOut_new(int8_tArray script_pubkey, int64_t value) {
11655 LDKCVec_u8Z script_pubkey_ref;
11656 script_pubkey_ref.datalen = script_pubkey->arr_len;
11657 script_pubkey_ref.data = MALLOC(script_pubkey_ref.datalen, "LDKCVec_u8Z Bytes");
11658 memcpy(script_pubkey_ref.data, script_pubkey->elems, script_pubkey_ref.datalen); FREE(script_pubkey);
11659 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
11660 *ret_ref = TxOut_new(script_pubkey_ref, value);
11661 return tag_ptr(ret_ref, true);
11664 void __attribute__((export_name("TS_TxOut_free"))) TS_TxOut_free(uint64_t _res) {
11665 if (!ptr_is_owned(_res)) return;
11666 void* _res_ptr = untag_ptr(_res);
11667 CHECK_ACCESS(_res_ptr);
11668 LDKTxOut _res_conv = *(LDKTxOut*)(_res_ptr);
11669 FREE(untag_ptr(_res));
11670 TxOut_free(_res_conv);
11673 static inline uint64_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg) {
11674 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
11675 *ret_ref = TxOut_clone(arg);
11676 return tag_ptr(ret_ref, true);
11678 int64_t __attribute__((export_name("TS_TxOut_clone_ptr"))) TS_TxOut_clone_ptr(uint64_t arg) {
11679 LDKTxOut* arg_conv = (LDKTxOut*)untag_ptr(arg);
11680 int64_t ret_conv = TxOut_clone_ptr(arg_conv);
11684 uint64_t __attribute__((export_name("TS_TxOut_clone"))) TS_TxOut_clone(uint64_t orig) {
11685 LDKTxOut* orig_conv = (LDKTxOut*)untag_ptr(orig);
11686 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
11687 *ret_ref = TxOut_clone(orig_conv);
11688 return tag_ptr(ret_ref, true);
11691 void __attribute__((export_name("TS_Str_free"))) TS_Str_free(jstring _res) {
11692 LDKStr dummy = { .chars = NULL, .len = 0, .chars_is_owned = false };
11696 uint64_t __attribute__((export_name("TS_COption_HTLCClaimZ_some"))) TS_COption_HTLCClaimZ_some(uint32_t o) {
11697 LDKHTLCClaim o_conv = LDKHTLCClaim_from_js(o);
11698 LDKCOption_HTLCClaimZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCClaimZ), "LDKCOption_HTLCClaimZ");
11699 *ret_copy = COption_HTLCClaimZ_some(o_conv);
11700 uint64_t ret_ref = tag_ptr(ret_copy, true);
11704 uint64_t __attribute__((export_name("TS_COption_HTLCClaimZ_none"))) TS_COption_HTLCClaimZ_none() {
11705 LDKCOption_HTLCClaimZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCClaimZ), "LDKCOption_HTLCClaimZ");
11706 *ret_copy = COption_HTLCClaimZ_none();
11707 uint64_t ret_ref = tag_ptr(ret_copy, true);
11711 void __attribute__((export_name("TS_COption_HTLCClaimZ_free"))) TS_COption_HTLCClaimZ_free(uint64_t _res) {
11712 if (!ptr_is_owned(_res)) return;
11713 void* _res_ptr = untag_ptr(_res);
11714 CHECK_ACCESS(_res_ptr);
11715 LDKCOption_HTLCClaimZ _res_conv = *(LDKCOption_HTLCClaimZ*)(_res_ptr);
11716 FREE(untag_ptr(_res));
11717 COption_HTLCClaimZ_free(_res_conv);
11720 uint64_t __attribute__((export_name("TS_CResult_NoneNoneZ_ok"))) TS_CResult_NoneNoneZ_ok() {
11721 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
11722 *ret_conv = CResult_NoneNoneZ_ok();
11723 return tag_ptr(ret_conv, true);
11726 uint64_t __attribute__((export_name("TS_CResult_NoneNoneZ_err"))) TS_CResult_NoneNoneZ_err() {
11727 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
11728 *ret_conv = CResult_NoneNoneZ_err();
11729 return tag_ptr(ret_conv, true);
11732 jboolean __attribute__((export_name("TS_CResult_NoneNoneZ_is_ok"))) TS_CResult_NoneNoneZ_is_ok(uint64_t o) {
11733 LDKCResult_NoneNoneZ* o_conv = (LDKCResult_NoneNoneZ*)untag_ptr(o);
11734 jboolean ret_conv = CResult_NoneNoneZ_is_ok(o_conv);
11738 void __attribute__((export_name("TS_CResult_NoneNoneZ_free"))) TS_CResult_NoneNoneZ_free(uint64_t _res) {
11739 if (!ptr_is_owned(_res)) return;
11740 void* _res_ptr = untag_ptr(_res);
11741 CHECK_ACCESS(_res_ptr);
11742 LDKCResult_NoneNoneZ _res_conv = *(LDKCResult_NoneNoneZ*)(_res_ptr);
11743 FREE(untag_ptr(_res));
11744 CResult_NoneNoneZ_free(_res_conv);
11747 static inline uint64_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg) {
11748 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
11749 *ret_conv = CResult_NoneNoneZ_clone(arg);
11750 return tag_ptr(ret_conv, true);
11752 int64_t __attribute__((export_name("TS_CResult_NoneNoneZ_clone_ptr"))) TS_CResult_NoneNoneZ_clone_ptr(uint64_t arg) {
11753 LDKCResult_NoneNoneZ* arg_conv = (LDKCResult_NoneNoneZ*)untag_ptr(arg);
11754 int64_t ret_conv = CResult_NoneNoneZ_clone_ptr(arg_conv);
11758 uint64_t __attribute__((export_name("TS_CResult_NoneNoneZ_clone"))) TS_CResult_NoneNoneZ_clone(uint64_t orig) {
11759 LDKCResult_NoneNoneZ* orig_conv = (LDKCResult_NoneNoneZ*)untag_ptr(orig);
11760 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
11761 *ret_conv = CResult_NoneNoneZ_clone(orig_conv);
11762 return tag_ptr(ret_conv, true);
11765 uint64_t __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(uint64_t o) {
11766 LDKCounterpartyCommitmentSecrets o_conv;
11767 o_conv.inner = untag_ptr(o);
11768 o_conv.is_owned = ptr_is_owned(o);
11769 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
11770 o_conv = CounterpartyCommitmentSecrets_clone(&o_conv);
11771 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ), "LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ");
11772 *ret_conv = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o_conv);
11773 return tag_ptr(ret_conv, true);
11776 uint64_t __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(uint64_t e) {
11777 void* e_ptr = untag_ptr(e);
11778 CHECK_ACCESS(e_ptr);
11779 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
11780 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
11781 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ), "LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ");
11782 *ret_conv = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e_conv);
11783 return tag_ptr(ret_conv, true);
11786 jboolean __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(uint64_t o) {
11787 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* o_conv = (LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ*)untag_ptr(o);
11788 jboolean ret_conv = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o_conv);
11792 void __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(uint64_t _res) {
11793 if (!ptr_is_owned(_res)) return;
11794 void* _res_ptr = untag_ptr(_res);
11795 CHECK_ACCESS(_res_ptr);
11796 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ _res_conv = *(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ*)(_res_ptr);
11797 FREE(untag_ptr(_res));
11798 CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res_conv);
11801 static inline uint64_t CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR arg) {
11802 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ), "LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ");
11803 *ret_conv = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(arg);
11804 return tag_ptr(ret_conv, true);
11806 int64_t __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(uint64_t arg) {
11807 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* arg_conv = (LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ*)untag_ptr(arg);
11808 int64_t ret_conv = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg_conv);
11812 uint64_t __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(uint64_t orig) {
11813 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* orig_conv = (LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ*)untag_ptr(orig);
11814 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ), "LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ");
11815 *ret_conv = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig_conv);
11816 return tag_ptr(ret_conv, true);
11819 uint64_t __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_ok"))) TS_CResult_TxCreationKeysDecodeErrorZ_ok(uint64_t o) {
11820 LDKTxCreationKeys o_conv;
11821 o_conv.inner = untag_ptr(o);
11822 o_conv.is_owned = ptr_is_owned(o);
11823 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
11824 o_conv = TxCreationKeys_clone(&o_conv);
11825 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
11826 *ret_conv = CResult_TxCreationKeysDecodeErrorZ_ok(o_conv);
11827 return tag_ptr(ret_conv, true);
11830 uint64_t __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_err"))) TS_CResult_TxCreationKeysDecodeErrorZ_err(uint64_t e) {
11831 void* e_ptr = untag_ptr(e);
11832 CHECK_ACCESS(e_ptr);
11833 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
11834 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
11835 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
11836 *ret_conv = CResult_TxCreationKeysDecodeErrorZ_err(e_conv);
11837 return tag_ptr(ret_conv, true);
11840 jboolean __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_is_ok"))) TS_CResult_TxCreationKeysDecodeErrorZ_is_ok(uint64_t o) {
11841 LDKCResult_TxCreationKeysDecodeErrorZ* o_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)untag_ptr(o);
11842 jboolean ret_conv = CResult_TxCreationKeysDecodeErrorZ_is_ok(o_conv);
11846 void __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_free"))) TS_CResult_TxCreationKeysDecodeErrorZ_free(uint64_t _res) {
11847 if (!ptr_is_owned(_res)) return;
11848 void* _res_ptr = untag_ptr(_res);
11849 CHECK_ACCESS(_res_ptr);
11850 LDKCResult_TxCreationKeysDecodeErrorZ _res_conv = *(LDKCResult_TxCreationKeysDecodeErrorZ*)(_res_ptr);
11851 FREE(untag_ptr(_res));
11852 CResult_TxCreationKeysDecodeErrorZ_free(_res_conv);
11855 static inline uint64_t CResult_TxCreationKeysDecodeErrorZ_clone_ptr(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR arg) {
11856 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
11857 *ret_conv = CResult_TxCreationKeysDecodeErrorZ_clone(arg);
11858 return tag_ptr(ret_conv, true);
11860 int64_t __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_clone_ptr"))) TS_CResult_TxCreationKeysDecodeErrorZ_clone_ptr(uint64_t arg) {
11861 LDKCResult_TxCreationKeysDecodeErrorZ* arg_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)untag_ptr(arg);
11862 int64_t ret_conv = CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg_conv);
11866 uint64_t __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_clone"))) TS_CResult_TxCreationKeysDecodeErrorZ_clone(uint64_t orig) {
11867 LDKCResult_TxCreationKeysDecodeErrorZ* orig_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)untag_ptr(orig);
11868 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
11869 *ret_conv = CResult_TxCreationKeysDecodeErrorZ_clone(orig_conv);
11870 return tag_ptr(ret_conv, true);
11873 uint64_t __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_ok"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_ok(uint64_t o) {
11874 LDKChannelPublicKeys o_conv;
11875 o_conv.inner = untag_ptr(o);
11876 o_conv.is_owned = ptr_is_owned(o);
11877 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
11878 o_conv = ChannelPublicKeys_clone(&o_conv);
11879 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
11880 *ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_ok(o_conv);
11881 return tag_ptr(ret_conv, true);
11884 uint64_t __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_err"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_err(uint64_t e) {
11885 void* e_ptr = untag_ptr(e);
11886 CHECK_ACCESS(e_ptr);
11887 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
11888 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
11889 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
11890 *ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_err(e_conv);
11891 return tag_ptr(ret_conv, true);
11894 jboolean __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_is_ok"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_is_ok(uint64_t o) {
11895 LDKCResult_ChannelPublicKeysDecodeErrorZ* o_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)untag_ptr(o);
11896 jboolean ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o_conv);
11900 void __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_free"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_free(uint64_t _res) {
11901 if (!ptr_is_owned(_res)) return;
11902 void* _res_ptr = untag_ptr(_res);
11903 CHECK_ACCESS(_res_ptr);
11904 LDKCResult_ChannelPublicKeysDecodeErrorZ _res_conv = *(LDKCResult_ChannelPublicKeysDecodeErrorZ*)(_res_ptr);
11905 FREE(untag_ptr(_res));
11906 CResult_ChannelPublicKeysDecodeErrorZ_free(_res_conv);
11909 static inline uint64_t CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR arg) {
11910 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
11911 *ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_clone(arg);
11912 return tag_ptr(ret_conv, true);
11914 int64_t __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(uint64_t arg) {
11915 LDKCResult_ChannelPublicKeysDecodeErrorZ* arg_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)untag_ptr(arg);
11916 int64_t ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg_conv);
11920 uint64_t __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_clone"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_clone(uint64_t orig) {
11921 LDKCResult_ChannelPublicKeysDecodeErrorZ* orig_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)untag_ptr(orig);
11922 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
11923 *ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_clone(orig_conv);
11924 return tag_ptr(ret_conv, true);
11927 uint64_t __attribute__((export_name("TS_COption_u32Z_some"))) TS_COption_u32Z_some(int32_t o) {
11928 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
11929 *ret_copy = COption_u32Z_some(o);
11930 uint64_t ret_ref = tag_ptr(ret_copy, true);
11934 uint64_t __attribute__((export_name("TS_COption_u32Z_none"))) TS_COption_u32Z_none() {
11935 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
11936 *ret_copy = COption_u32Z_none();
11937 uint64_t ret_ref = tag_ptr(ret_copy, true);
11941 void __attribute__((export_name("TS_COption_u32Z_free"))) TS_COption_u32Z_free(uint64_t _res) {
11942 if (!ptr_is_owned(_res)) return;
11943 void* _res_ptr = untag_ptr(_res);
11944 CHECK_ACCESS(_res_ptr);
11945 LDKCOption_u32Z _res_conv = *(LDKCOption_u32Z*)(_res_ptr);
11946 FREE(untag_ptr(_res));
11947 COption_u32Z_free(_res_conv);
11950 static inline uint64_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg) {
11951 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
11952 *ret_copy = COption_u32Z_clone(arg);
11953 uint64_t ret_ref = tag_ptr(ret_copy, true);
11956 int64_t __attribute__((export_name("TS_COption_u32Z_clone_ptr"))) TS_COption_u32Z_clone_ptr(uint64_t arg) {
11957 LDKCOption_u32Z* arg_conv = (LDKCOption_u32Z*)untag_ptr(arg);
11958 int64_t ret_conv = COption_u32Z_clone_ptr(arg_conv);
11962 uint64_t __attribute__((export_name("TS_COption_u32Z_clone"))) TS_COption_u32Z_clone(uint64_t orig) {
11963 LDKCOption_u32Z* orig_conv = (LDKCOption_u32Z*)untag_ptr(orig);
11964 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
11965 *ret_copy = COption_u32Z_clone(orig_conv);
11966 uint64_t ret_ref = tag_ptr(ret_copy, true);
11970 uint64_t __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_ok"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(uint64_t o) {
11971 LDKHTLCOutputInCommitment o_conv;
11972 o_conv.inner = untag_ptr(o);
11973 o_conv.is_owned = ptr_is_owned(o);
11974 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
11975 o_conv = HTLCOutputInCommitment_clone(&o_conv);
11976 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
11977 *ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o_conv);
11978 return tag_ptr(ret_conv, true);
11981 uint64_t __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_err"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_err(uint64_t e) {
11982 void* e_ptr = untag_ptr(e);
11983 CHECK_ACCESS(e_ptr);
11984 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
11985 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
11986 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
11987 *ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e_conv);
11988 return tag_ptr(ret_conv, true);
11991 jboolean __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(uint64_t o) {
11992 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* o_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)untag_ptr(o);
11993 jboolean ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o_conv);
11997 void __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free(uint64_t _res) {
11998 if (!ptr_is_owned(_res)) return;
11999 void* _res_ptr = untag_ptr(_res);
12000 CHECK_ACCESS(_res_ptr);
12001 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ _res_conv = *(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(_res_ptr);
12002 FREE(untag_ptr(_res));
12003 CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res_conv);
12006 static inline uint64_t CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR arg) {
12007 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
12008 *ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(arg);
12009 return tag_ptr(ret_conv, true);
12011 int64_t __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(uint64_t arg) {
12012 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* arg_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)untag_ptr(arg);
12013 int64_t ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg_conv);
12017 uint64_t __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(uint64_t orig) {
12018 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* orig_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)untag_ptr(orig);
12019 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
12020 *ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig_conv);
12021 return tag_ptr(ret_conv, true);
12024 uint32_t __attribute__((export_name("TS_COption_NoneZ_some"))) TS_COption_NoneZ_some() {
12025 uint32_t ret_conv = LDKCOption_NoneZ_to_js(COption_NoneZ_some());
12029 uint32_t __attribute__((export_name("TS_COption_NoneZ_none"))) TS_COption_NoneZ_none() {
12030 uint32_t ret_conv = LDKCOption_NoneZ_to_js(COption_NoneZ_none());
12034 void __attribute__((export_name("TS_COption_NoneZ_free"))) TS_COption_NoneZ_free(uint32_t _res) {
12035 LDKCOption_NoneZ _res_conv = LDKCOption_NoneZ_from_js(_res);
12036 COption_NoneZ_free(_res_conv);
12039 uint64_t __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(uint64_t o) {
12040 LDKCounterpartyChannelTransactionParameters o_conv;
12041 o_conv.inner = untag_ptr(o);
12042 o_conv.is_owned = ptr_is_owned(o);
12043 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12044 o_conv = CounterpartyChannelTransactionParameters_clone(&o_conv);
12045 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
12046 *ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o_conv);
12047 return tag_ptr(ret_conv, true);
12050 uint64_t __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(uint64_t e) {
12051 void* e_ptr = untag_ptr(e);
12052 CHECK_ACCESS(e_ptr);
12053 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
12054 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
12055 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
12056 *ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e_conv);
12057 return tag_ptr(ret_conv, true);
12060 jboolean __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(uint64_t o) {
12061 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* o_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)untag_ptr(o);
12062 jboolean ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o_conv);
12066 void __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(uint64_t _res) {
12067 if (!ptr_is_owned(_res)) return;
12068 void* _res_ptr = untag_ptr(_res);
12069 CHECK_ACCESS(_res_ptr);
12070 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ _res_conv = *(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(_res_ptr);
12071 FREE(untag_ptr(_res));
12072 CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res_conv);
12075 static inline uint64_t CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg) {
12076 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
12077 *ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(arg);
12078 return tag_ptr(ret_conv, true);
12080 int64_t __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(uint64_t arg) {
12081 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* arg_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)untag_ptr(arg);
12082 int64_t ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg_conv);
12086 uint64_t __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(uint64_t orig) {
12087 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* orig_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)untag_ptr(orig);
12088 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
12089 *ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig_conv);
12090 return tag_ptr(ret_conv, true);
12093 uint64_t __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_ok"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_ok(uint64_t o) {
12094 LDKChannelTransactionParameters o_conv;
12095 o_conv.inner = untag_ptr(o);
12096 o_conv.is_owned = ptr_is_owned(o);
12097 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12098 o_conv = ChannelTransactionParameters_clone(&o_conv);
12099 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
12100 *ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_ok(o_conv);
12101 return tag_ptr(ret_conv, true);
12104 uint64_t __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_err"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_err(uint64_t e) {
12105 void* e_ptr = untag_ptr(e);
12106 CHECK_ACCESS(e_ptr);
12107 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
12108 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
12109 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
12110 *ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_err(e_conv);
12111 return tag_ptr(ret_conv, true);
12114 jboolean __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_is_ok"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(uint64_t o) {
12115 LDKCResult_ChannelTransactionParametersDecodeErrorZ* o_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)untag_ptr(o);
12116 jboolean ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o_conv);
12120 void __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_free"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_free(uint64_t _res) {
12121 if (!ptr_is_owned(_res)) return;
12122 void* _res_ptr = untag_ptr(_res);
12123 CHECK_ACCESS(_res_ptr);
12124 LDKCResult_ChannelTransactionParametersDecodeErrorZ _res_conv = *(LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(_res_ptr);
12125 FREE(untag_ptr(_res));
12126 CResult_ChannelTransactionParametersDecodeErrorZ_free(_res_conv);
12129 static inline uint64_t CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg) {
12130 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
12131 *ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_clone(arg);
12132 return tag_ptr(ret_conv, true);
12134 int64_t __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(uint64_t arg) {
12135 LDKCResult_ChannelTransactionParametersDecodeErrorZ* arg_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)untag_ptr(arg);
12136 int64_t ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg_conv);
12140 uint64_t __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone(uint64_t orig) {
12141 LDKCResult_ChannelTransactionParametersDecodeErrorZ* orig_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)untag_ptr(orig);
12142 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
12143 *ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig_conv);
12144 return tag_ptr(ret_conv, true);
12147 void __attribute__((export_name("TS_CVec_SignatureZ_free"))) TS_CVec_SignatureZ_free(ptrArray _res) {
12148 LDKCVec_SignatureZ _res_constr;
12149 _res_constr.datalen = _res->arr_len;
12150 if (_res_constr.datalen > 0)
12151 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
12153 _res_constr.data = NULL;
12154 int8_tArray* _res_vals = (void*) _res->elems;
12155 for (size_t m = 0; m < _res_constr.datalen; m++) {
12156 int8_tArray _res_conv_12 = _res_vals[m];
12157 LDKSignature _res_conv_12_ref;
12158 CHECK(_res_conv_12->arr_len == 64);
12159 memcpy(_res_conv_12_ref.compact_form, _res_conv_12->elems, 64); FREE(_res_conv_12);
12160 _res_constr.data[m] = _res_conv_12_ref;
12163 CVec_SignatureZ_free(_res_constr);
12166 uint64_t __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_ok"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_ok(uint64_t o) {
12167 LDKHolderCommitmentTransaction o_conv;
12168 o_conv.inner = untag_ptr(o);
12169 o_conv.is_owned = ptr_is_owned(o);
12170 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12171 o_conv = HolderCommitmentTransaction_clone(&o_conv);
12172 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
12173 *ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o_conv);
12174 return tag_ptr(ret_conv, true);
12177 uint64_t __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_err"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_err(uint64_t e) {
12178 void* e_ptr = untag_ptr(e);
12179 CHECK_ACCESS(e_ptr);
12180 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
12181 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
12182 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
12183 *ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_err(e_conv);
12184 return tag_ptr(ret_conv, true);
12187 jboolean __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(uint64_t o) {
12188 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* o_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)untag_ptr(o);
12189 jboolean ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o_conv);
12193 void __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free(uint64_t _res) {
12194 if (!ptr_is_owned(_res)) return;
12195 void* _res_ptr = untag_ptr(_res);
12196 CHECK_ACCESS(_res_ptr);
12197 LDKCResult_HolderCommitmentTransactionDecodeErrorZ _res_conv = *(LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(_res_ptr);
12198 FREE(untag_ptr(_res));
12199 CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res_conv);
12202 static inline uint64_t CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg) {
12203 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
12204 *ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_clone(arg);
12205 return tag_ptr(ret_conv, true);
12207 int64_t __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(uint64_t arg) {
12208 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* arg_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)untag_ptr(arg);
12209 int64_t ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg_conv);
12213 uint64_t __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone(uint64_t orig) {
12214 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)untag_ptr(orig);
12215 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
12216 *ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig_conv);
12217 return tag_ptr(ret_conv, true);
12220 uint64_t __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_ok"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(uint64_t o) {
12221 LDKBuiltCommitmentTransaction o_conv;
12222 o_conv.inner = untag_ptr(o);
12223 o_conv.is_owned = ptr_is_owned(o);
12224 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12225 o_conv = BuiltCommitmentTransaction_clone(&o_conv);
12226 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
12227 *ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o_conv);
12228 return tag_ptr(ret_conv, true);
12231 uint64_t __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_err"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_err(uint64_t e) {
12232 void* e_ptr = untag_ptr(e);
12233 CHECK_ACCESS(e_ptr);
12234 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
12235 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
12236 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
12237 *ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e_conv);
12238 return tag_ptr(ret_conv, true);
12241 jboolean __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(uint64_t o) {
12242 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* o_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)untag_ptr(o);
12243 jboolean ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o_conv);
12247 void __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free(uint64_t _res) {
12248 if (!ptr_is_owned(_res)) return;
12249 void* _res_ptr = untag_ptr(_res);
12250 CHECK_ACCESS(_res_ptr);
12251 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ _res_conv = *(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(_res_ptr);
12252 FREE(untag_ptr(_res));
12253 CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res_conv);
12256 static inline uint64_t CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg) {
12257 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
12258 *ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(arg);
12259 return tag_ptr(ret_conv, true);
12261 int64_t __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(uint64_t arg) {
12262 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* arg_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)untag_ptr(arg);
12263 int64_t ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg_conv);
12267 uint64_t __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(uint64_t orig) {
12268 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)untag_ptr(orig);
12269 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
12270 *ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig_conv);
12271 return tag_ptr(ret_conv, true);
12274 uint64_t __attribute__((export_name("TS_CResult_TrustedClosingTransactionNoneZ_ok"))) TS_CResult_TrustedClosingTransactionNoneZ_ok(uint64_t o) {
12275 LDKTrustedClosingTransaction o_conv;
12276 o_conv.inner = untag_ptr(o);
12277 o_conv.is_owned = ptr_is_owned(o);
12278 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12279 // WARNING: we need a move here but no clone is available for LDKTrustedClosingTransaction
12281 LDKCResult_TrustedClosingTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedClosingTransactionNoneZ), "LDKCResult_TrustedClosingTransactionNoneZ");
12282 *ret_conv = CResult_TrustedClosingTransactionNoneZ_ok(o_conv);
12283 return tag_ptr(ret_conv, true);
12286 uint64_t __attribute__((export_name("TS_CResult_TrustedClosingTransactionNoneZ_err"))) TS_CResult_TrustedClosingTransactionNoneZ_err() {
12287 LDKCResult_TrustedClosingTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedClosingTransactionNoneZ), "LDKCResult_TrustedClosingTransactionNoneZ");
12288 *ret_conv = CResult_TrustedClosingTransactionNoneZ_err();
12289 return tag_ptr(ret_conv, true);
12292 jboolean __attribute__((export_name("TS_CResult_TrustedClosingTransactionNoneZ_is_ok"))) TS_CResult_TrustedClosingTransactionNoneZ_is_ok(uint64_t o) {
12293 LDKCResult_TrustedClosingTransactionNoneZ* o_conv = (LDKCResult_TrustedClosingTransactionNoneZ*)untag_ptr(o);
12294 jboolean ret_conv = CResult_TrustedClosingTransactionNoneZ_is_ok(o_conv);
12298 void __attribute__((export_name("TS_CResult_TrustedClosingTransactionNoneZ_free"))) TS_CResult_TrustedClosingTransactionNoneZ_free(uint64_t _res) {
12299 if (!ptr_is_owned(_res)) return;
12300 void* _res_ptr = untag_ptr(_res);
12301 CHECK_ACCESS(_res_ptr);
12302 LDKCResult_TrustedClosingTransactionNoneZ _res_conv = *(LDKCResult_TrustedClosingTransactionNoneZ*)(_res_ptr);
12303 FREE(untag_ptr(_res));
12304 CResult_TrustedClosingTransactionNoneZ_free(_res_conv);
12307 uint64_t __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_ok"))) TS_CResult_CommitmentTransactionDecodeErrorZ_ok(uint64_t o) {
12308 LDKCommitmentTransaction o_conv;
12309 o_conv.inner = untag_ptr(o);
12310 o_conv.is_owned = ptr_is_owned(o);
12311 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12312 o_conv = CommitmentTransaction_clone(&o_conv);
12313 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
12314 *ret_conv = CResult_CommitmentTransactionDecodeErrorZ_ok(o_conv);
12315 return tag_ptr(ret_conv, true);
12318 uint64_t __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_err"))) TS_CResult_CommitmentTransactionDecodeErrorZ_err(uint64_t e) {
12319 void* e_ptr = untag_ptr(e);
12320 CHECK_ACCESS(e_ptr);
12321 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
12322 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
12323 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
12324 *ret_conv = CResult_CommitmentTransactionDecodeErrorZ_err(e_conv);
12325 return tag_ptr(ret_conv, true);
12328 jboolean __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_is_ok"))) TS_CResult_CommitmentTransactionDecodeErrorZ_is_ok(uint64_t o) {
12329 LDKCResult_CommitmentTransactionDecodeErrorZ* o_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)untag_ptr(o);
12330 jboolean ret_conv = CResult_CommitmentTransactionDecodeErrorZ_is_ok(o_conv);
12334 void __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_free"))) TS_CResult_CommitmentTransactionDecodeErrorZ_free(uint64_t _res) {
12335 if (!ptr_is_owned(_res)) return;
12336 void* _res_ptr = untag_ptr(_res);
12337 CHECK_ACCESS(_res_ptr);
12338 LDKCResult_CommitmentTransactionDecodeErrorZ _res_conv = *(LDKCResult_CommitmentTransactionDecodeErrorZ*)(_res_ptr);
12339 FREE(untag_ptr(_res));
12340 CResult_CommitmentTransactionDecodeErrorZ_free(_res_conv);
12343 static inline uint64_t CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR arg) {
12344 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
12345 *ret_conv = CResult_CommitmentTransactionDecodeErrorZ_clone(arg);
12346 return tag_ptr(ret_conv, true);
12348 int64_t __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_clone_ptr"))) TS_CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(uint64_t arg) {
12349 LDKCResult_CommitmentTransactionDecodeErrorZ* arg_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)untag_ptr(arg);
12350 int64_t ret_conv = CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg_conv);
12354 uint64_t __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_clone"))) TS_CResult_CommitmentTransactionDecodeErrorZ_clone(uint64_t orig) {
12355 LDKCResult_CommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)untag_ptr(orig);
12356 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
12357 *ret_conv = CResult_CommitmentTransactionDecodeErrorZ_clone(orig_conv);
12358 return tag_ptr(ret_conv, true);
12361 uint64_t __attribute__((export_name("TS_CResult_TrustedCommitmentTransactionNoneZ_ok"))) TS_CResult_TrustedCommitmentTransactionNoneZ_ok(uint64_t o) {
12362 LDKTrustedCommitmentTransaction o_conv;
12363 o_conv.inner = untag_ptr(o);
12364 o_conv.is_owned = ptr_is_owned(o);
12365 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12366 // WARNING: we need a move here but no clone is available for LDKTrustedCommitmentTransaction
12368 LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
12369 *ret_conv = CResult_TrustedCommitmentTransactionNoneZ_ok(o_conv);
12370 return tag_ptr(ret_conv, true);
12373 uint64_t __attribute__((export_name("TS_CResult_TrustedCommitmentTransactionNoneZ_err"))) TS_CResult_TrustedCommitmentTransactionNoneZ_err() {
12374 LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
12375 *ret_conv = CResult_TrustedCommitmentTransactionNoneZ_err();
12376 return tag_ptr(ret_conv, true);
12379 jboolean __attribute__((export_name("TS_CResult_TrustedCommitmentTransactionNoneZ_is_ok"))) TS_CResult_TrustedCommitmentTransactionNoneZ_is_ok(uint64_t o) {
12380 LDKCResult_TrustedCommitmentTransactionNoneZ* o_conv = (LDKCResult_TrustedCommitmentTransactionNoneZ*)untag_ptr(o);
12381 jboolean ret_conv = CResult_TrustedCommitmentTransactionNoneZ_is_ok(o_conv);
12385 void __attribute__((export_name("TS_CResult_TrustedCommitmentTransactionNoneZ_free"))) TS_CResult_TrustedCommitmentTransactionNoneZ_free(uint64_t _res) {
12386 if (!ptr_is_owned(_res)) return;
12387 void* _res_ptr = untag_ptr(_res);
12388 CHECK_ACCESS(_res_ptr);
12389 LDKCResult_TrustedCommitmentTransactionNoneZ _res_conv = *(LDKCResult_TrustedCommitmentTransactionNoneZ*)(_res_ptr);
12390 FREE(untag_ptr(_res));
12391 CResult_TrustedCommitmentTransactionNoneZ_free(_res_conv);
12394 uint64_t __attribute__((export_name("TS_CResult_CVec_SignatureZNoneZ_ok"))) TS_CResult_CVec_SignatureZNoneZ_ok(ptrArray o) {
12395 LDKCVec_SignatureZ o_constr;
12396 o_constr.datalen = o->arr_len;
12397 if (o_constr.datalen > 0)
12398 o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
12400 o_constr.data = NULL;
12401 int8_tArray* o_vals = (void*) o->elems;
12402 for (size_t m = 0; m < o_constr.datalen; m++) {
12403 int8_tArray o_conv_12 = o_vals[m];
12404 LDKSignature o_conv_12_ref;
12405 CHECK(o_conv_12->arr_len == 64);
12406 memcpy(o_conv_12_ref.compact_form, o_conv_12->elems, 64); FREE(o_conv_12);
12407 o_constr.data[m] = o_conv_12_ref;
12410 LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
12411 *ret_conv = CResult_CVec_SignatureZNoneZ_ok(o_constr);
12412 return tag_ptr(ret_conv, true);
12415 uint64_t __attribute__((export_name("TS_CResult_CVec_SignatureZNoneZ_err"))) TS_CResult_CVec_SignatureZNoneZ_err() {
12416 LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
12417 *ret_conv = CResult_CVec_SignatureZNoneZ_err();
12418 return tag_ptr(ret_conv, true);
12421 jboolean __attribute__((export_name("TS_CResult_CVec_SignatureZNoneZ_is_ok"))) TS_CResult_CVec_SignatureZNoneZ_is_ok(uint64_t o) {
12422 LDKCResult_CVec_SignatureZNoneZ* o_conv = (LDKCResult_CVec_SignatureZNoneZ*)untag_ptr(o);
12423 jboolean ret_conv = CResult_CVec_SignatureZNoneZ_is_ok(o_conv);
12427 void __attribute__((export_name("TS_CResult_CVec_SignatureZNoneZ_free"))) TS_CResult_CVec_SignatureZNoneZ_free(uint64_t _res) {
12428 if (!ptr_is_owned(_res)) return;
12429 void* _res_ptr = untag_ptr(_res);
12430 CHECK_ACCESS(_res_ptr);
12431 LDKCResult_CVec_SignatureZNoneZ _res_conv = *(LDKCResult_CVec_SignatureZNoneZ*)(_res_ptr);
12432 FREE(untag_ptr(_res));
12433 CResult_CVec_SignatureZNoneZ_free(_res_conv);
12436 static inline uint64_t CResult_CVec_SignatureZNoneZ_clone_ptr(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR arg) {
12437 LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
12438 *ret_conv = CResult_CVec_SignatureZNoneZ_clone(arg);
12439 return tag_ptr(ret_conv, true);
12441 int64_t __attribute__((export_name("TS_CResult_CVec_SignatureZNoneZ_clone_ptr"))) TS_CResult_CVec_SignatureZNoneZ_clone_ptr(uint64_t arg) {
12442 LDKCResult_CVec_SignatureZNoneZ* arg_conv = (LDKCResult_CVec_SignatureZNoneZ*)untag_ptr(arg);
12443 int64_t ret_conv = CResult_CVec_SignatureZNoneZ_clone_ptr(arg_conv);
12447 uint64_t __attribute__((export_name("TS_CResult_CVec_SignatureZNoneZ_clone"))) TS_CResult_CVec_SignatureZNoneZ_clone(uint64_t orig) {
12448 LDKCResult_CVec_SignatureZNoneZ* orig_conv = (LDKCResult_CVec_SignatureZNoneZ*)untag_ptr(orig);
12449 LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
12450 *ret_conv = CResult_CVec_SignatureZNoneZ_clone(orig_conv);
12451 return tag_ptr(ret_conv, true);
12454 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_ok"))) TS_CResult_ShutdownScriptDecodeErrorZ_ok(uint64_t o) {
12455 LDKShutdownScript o_conv;
12456 o_conv.inner = untag_ptr(o);
12457 o_conv.is_owned = ptr_is_owned(o);
12458 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12459 o_conv = ShutdownScript_clone(&o_conv);
12460 LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
12461 *ret_conv = CResult_ShutdownScriptDecodeErrorZ_ok(o_conv);
12462 return tag_ptr(ret_conv, true);
12465 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_err"))) TS_CResult_ShutdownScriptDecodeErrorZ_err(uint64_t e) {
12466 void* e_ptr = untag_ptr(e);
12467 CHECK_ACCESS(e_ptr);
12468 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
12469 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
12470 LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
12471 *ret_conv = CResult_ShutdownScriptDecodeErrorZ_err(e_conv);
12472 return tag_ptr(ret_conv, true);
12475 jboolean __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_is_ok"))) TS_CResult_ShutdownScriptDecodeErrorZ_is_ok(uint64_t o) {
12476 LDKCResult_ShutdownScriptDecodeErrorZ* o_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)untag_ptr(o);
12477 jboolean ret_conv = CResult_ShutdownScriptDecodeErrorZ_is_ok(o_conv);
12481 void __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_free"))) TS_CResult_ShutdownScriptDecodeErrorZ_free(uint64_t _res) {
12482 if (!ptr_is_owned(_res)) return;
12483 void* _res_ptr = untag_ptr(_res);
12484 CHECK_ACCESS(_res_ptr);
12485 LDKCResult_ShutdownScriptDecodeErrorZ _res_conv = *(LDKCResult_ShutdownScriptDecodeErrorZ*)(_res_ptr);
12486 FREE(untag_ptr(_res));
12487 CResult_ShutdownScriptDecodeErrorZ_free(_res_conv);
12490 static inline uint64_t CResult_ShutdownScriptDecodeErrorZ_clone_ptr(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR arg) {
12491 LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
12492 *ret_conv = CResult_ShutdownScriptDecodeErrorZ_clone(arg);
12493 return tag_ptr(ret_conv, true);
12495 int64_t __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_clone_ptr"))) TS_CResult_ShutdownScriptDecodeErrorZ_clone_ptr(uint64_t arg) {
12496 LDKCResult_ShutdownScriptDecodeErrorZ* arg_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)untag_ptr(arg);
12497 int64_t ret_conv = CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg_conv);
12501 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_clone"))) TS_CResult_ShutdownScriptDecodeErrorZ_clone(uint64_t orig) {
12502 LDKCResult_ShutdownScriptDecodeErrorZ* orig_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)untag_ptr(orig);
12503 LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
12504 *ret_conv = CResult_ShutdownScriptDecodeErrorZ_clone(orig_conv);
12505 return tag_ptr(ret_conv, true);
12508 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_ok"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_ok(uint64_t o) {
12509 LDKShutdownScript o_conv;
12510 o_conv.inner = untag_ptr(o);
12511 o_conv.is_owned = ptr_is_owned(o);
12512 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12513 o_conv = ShutdownScript_clone(&o_conv);
12514 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
12515 *ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o_conv);
12516 return tag_ptr(ret_conv, true);
12519 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_err"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_err(uint64_t e) {
12520 LDKInvalidShutdownScript e_conv;
12521 e_conv.inner = untag_ptr(e);
12522 e_conv.is_owned = ptr_is_owned(e);
12523 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
12524 e_conv = InvalidShutdownScript_clone(&e_conv);
12525 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
12526 *ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_err(e_conv);
12527 return tag_ptr(ret_conv, true);
12530 jboolean __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(uint64_t o) {
12531 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* o_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)untag_ptr(o);
12532 jboolean ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o_conv);
12536 void __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_free"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_free(uint64_t _res) {
12537 if (!ptr_is_owned(_res)) return;
12538 void* _res_ptr = untag_ptr(_res);
12539 CHECK_ACCESS(_res_ptr);
12540 LDKCResult_ShutdownScriptInvalidShutdownScriptZ _res_conv = *(LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)(_res_ptr);
12541 FREE(untag_ptr(_res));
12542 CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res_conv);
12545 static inline uint64_t CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR arg) {
12546 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
12547 *ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_clone(arg);
12548 return tag_ptr(ret_conv, true);
12550 int64_t __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(uint64_t arg) {
12551 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* arg_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)untag_ptr(arg);
12552 int64_t ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg_conv);
12556 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone(uint64_t orig) {
12557 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* orig_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)untag_ptr(orig);
12558 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
12559 *ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig_conv);
12560 return tag_ptr(ret_conv, true);
12563 void __attribute__((export_name("TS_CVec_PublicKeyZ_free"))) TS_CVec_PublicKeyZ_free(ptrArray _res) {
12564 LDKCVec_PublicKeyZ _res_constr;
12565 _res_constr.datalen = _res->arr_len;
12566 if (_res_constr.datalen > 0)
12567 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKPublicKey), "LDKCVec_PublicKeyZ Elements");
12569 _res_constr.data = NULL;
12570 int8_tArray* _res_vals = (void*) _res->elems;
12571 for (size_t m = 0; m < _res_constr.datalen; m++) {
12572 int8_tArray _res_conv_12 = _res_vals[m];
12573 LDKPublicKey _res_conv_12_ref;
12574 CHECK(_res_conv_12->arr_len == 33);
12575 memcpy(_res_conv_12_ref.compressed_form, _res_conv_12->elems, 33); FREE(_res_conv_12);
12576 _res_constr.data[m] = _res_conv_12_ref;
12579 CVec_PublicKeyZ_free(_res_constr);
12582 uint64_t __attribute__((export_name("TS_CResult_BlindedPathNoneZ_ok"))) TS_CResult_BlindedPathNoneZ_ok(uint64_t o) {
12583 LDKBlindedPath o_conv;
12584 o_conv.inner = untag_ptr(o);
12585 o_conv.is_owned = ptr_is_owned(o);
12586 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12587 o_conv = BlindedPath_clone(&o_conv);
12588 LDKCResult_BlindedPathNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathNoneZ), "LDKCResult_BlindedPathNoneZ");
12589 *ret_conv = CResult_BlindedPathNoneZ_ok(o_conv);
12590 return tag_ptr(ret_conv, true);
12593 uint64_t __attribute__((export_name("TS_CResult_BlindedPathNoneZ_err"))) TS_CResult_BlindedPathNoneZ_err() {
12594 LDKCResult_BlindedPathNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathNoneZ), "LDKCResult_BlindedPathNoneZ");
12595 *ret_conv = CResult_BlindedPathNoneZ_err();
12596 return tag_ptr(ret_conv, true);
12599 jboolean __attribute__((export_name("TS_CResult_BlindedPathNoneZ_is_ok"))) TS_CResult_BlindedPathNoneZ_is_ok(uint64_t o) {
12600 LDKCResult_BlindedPathNoneZ* o_conv = (LDKCResult_BlindedPathNoneZ*)untag_ptr(o);
12601 jboolean ret_conv = CResult_BlindedPathNoneZ_is_ok(o_conv);
12605 void __attribute__((export_name("TS_CResult_BlindedPathNoneZ_free"))) TS_CResult_BlindedPathNoneZ_free(uint64_t _res) {
12606 if (!ptr_is_owned(_res)) return;
12607 void* _res_ptr = untag_ptr(_res);
12608 CHECK_ACCESS(_res_ptr);
12609 LDKCResult_BlindedPathNoneZ _res_conv = *(LDKCResult_BlindedPathNoneZ*)(_res_ptr);
12610 FREE(untag_ptr(_res));
12611 CResult_BlindedPathNoneZ_free(_res_conv);
12614 static inline uint64_t CResult_BlindedPathNoneZ_clone_ptr(LDKCResult_BlindedPathNoneZ *NONNULL_PTR arg) {
12615 LDKCResult_BlindedPathNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathNoneZ), "LDKCResult_BlindedPathNoneZ");
12616 *ret_conv = CResult_BlindedPathNoneZ_clone(arg);
12617 return tag_ptr(ret_conv, true);
12619 int64_t __attribute__((export_name("TS_CResult_BlindedPathNoneZ_clone_ptr"))) TS_CResult_BlindedPathNoneZ_clone_ptr(uint64_t arg) {
12620 LDKCResult_BlindedPathNoneZ* arg_conv = (LDKCResult_BlindedPathNoneZ*)untag_ptr(arg);
12621 int64_t ret_conv = CResult_BlindedPathNoneZ_clone_ptr(arg_conv);
12625 uint64_t __attribute__((export_name("TS_CResult_BlindedPathNoneZ_clone"))) TS_CResult_BlindedPathNoneZ_clone(uint64_t orig) {
12626 LDKCResult_BlindedPathNoneZ* orig_conv = (LDKCResult_BlindedPathNoneZ*)untag_ptr(orig);
12627 LDKCResult_BlindedPathNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathNoneZ), "LDKCResult_BlindedPathNoneZ");
12628 *ret_conv = CResult_BlindedPathNoneZ_clone(orig_conv);
12629 return tag_ptr(ret_conv, true);
12632 uint64_t __attribute__((export_name("TS_CResult_BlindedPathDecodeErrorZ_ok"))) TS_CResult_BlindedPathDecodeErrorZ_ok(uint64_t o) {
12633 LDKBlindedPath o_conv;
12634 o_conv.inner = untag_ptr(o);
12635 o_conv.is_owned = ptr_is_owned(o);
12636 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12637 o_conv = BlindedPath_clone(&o_conv);
12638 LDKCResult_BlindedPathDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathDecodeErrorZ), "LDKCResult_BlindedPathDecodeErrorZ");
12639 *ret_conv = CResult_BlindedPathDecodeErrorZ_ok(o_conv);
12640 return tag_ptr(ret_conv, true);
12643 uint64_t __attribute__((export_name("TS_CResult_BlindedPathDecodeErrorZ_err"))) TS_CResult_BlindedPathDecodeErrorZ_err(uint64_t e) {
12644 void* e_ptr = untag_ptr(e);
12645 CHECK_ACCESS(e_ptr);
12646 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
12647 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
12648 LDKCResult_BlindedPathDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathDecodeErrorZ), "LDKCResult_BlindedPathDecodeErrorZ");
12649 *ret_conv = CResult_BlindedPathDecodeErrorZ_err(e_conv);
12650 return tag_ptr(ret_conv, true);
12653 jboolean __attribute__((export_name("TS_CResult_BlindedPathDecodeErrorZ_is_ok"))) TS_CResult_BlindedPathDecodeErrorZ_is_ok(uint64_t o) {
12654 LDKCResult_BlindedPathDecodeErrorZ* o_conv = (LDKCResult_BlindedPathDecodeErrorZ*)untag_ptr(o);
12655 jboolean ret_conv = CResult_BlindedPathDecodeErrorZ_is_ok(o_conv);
12659 void __attribute__((export_name("TS_CResult_BlindedPathDecodeErrorZ_free"))) TS_CResult_BlindedPathDecodeErrorZ_free(uint64_t _res) {
12660 if (!ptr_is_owned(_res)) return;
12661 void* _res_ptr = untag_ptr(_res);
12662 CHECK_ACCESS(_res_ptr);
12663 LDKCResult_BlindedPathDecodeErrorZ _res_conv = *(LDKCResult_BlindedPathDecodeErrorZ*)(_res_ptr);
12664 FREE(untag_ptr(_res));
12665 CResult_BlindedPathDecodeErrorZ_free(_res_conv);
12668 static inline uint64_t CResult_BlindedPathDecodeErrorZ_clone_ptr(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR arg) {
12669 LDKCResult_BlindedPathDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathDecodeErrorZ), "LDKCResult_BlindedPathDecodeErrorZ");
12670 *ret_conv = CResult_BlindedPathDecodeErrorZ_clone(arg);
12671 return tag_ptr(ret_conv, true);
12673 int64_t __attribute__((export_name("TS_CResult_BlindedPathDecodeErrorZ_clone_ptr"))) TS_CResult_BlindedPathDecodeErrorZ_clone_ptr(uint64_t arg) {
12674 LDKCResult_BlindedPathDecodeErrorZ* arg_conv = (LDKCResult_BlindedPathDecodeErrorZ*)untag_ptr(arg);
12675 int64_t ret_conv = CResult_BlindedPathDecodeErrorZ_clone_ptr(arg_conv);
12679 uint64_t __attribute__((export_name("TS_CResult_BlindedPathDecodeErrorZ_clone"))) TS_CResult_BlindedPathDecodeErrorZ_clone(uint64_t orig) {
12680 LDKCResult_BlindedPathDecodeErrorZ* orig_conv = (LDKCResult_BlindedPathDecodeErrorZ*)untag_ptr(orig);
12681 LDKCResult_BlindedPathDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathDecodeErrorZ), "LDKCResult_BlindedPathDecodeErrorZ");
12682 *ret_conv = CResult_BlindedPathDecodeErrorZ_clone(orig_conv);
12683 return tag_ptr(ret_conv, true);
12686 uint64_t __attribute__((export_name("TS_CResult_BlindedHopDecodeErrorZ_ok"))) TS_CResult_BlindedHopDecodeErrorZ_ok(uint64_t o) {
12687 LDKBlindedHop o_conv;
12688 o_conv.inner = untag_ptr(o);
12689 o_conv.is_owned = ptr_is_owned(o);
12690 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12691 o_conv = BlindedHop_clone(&o_conv);
12692 LDKCResult_BlindedHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopDecodeErrorZ), "LDKCResult_BlindedHopDecodeErrorZ");
12693 *ret_conv = CResult_BlindedHopDecodeErrorZ_ok(o_conv);
12694 return tag_ptr(ret_conv, true);
12697 uint64_t __attribute__((export_name("TS_CResult_BlindedHopDecodeErrorZ_err"))) TS_CResult_BlindedHopDecodeErrorZ_err(uint64_t e) {
12698 void* e_ptr = untag_ptr(e);
12699 CHECK_ACCESS(e_ptr);
12700 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
12701 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
12702 LDKCResult_BlindedHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopDecodeErrorZ), "LDKCResult_BlindedHopDecodeErrorZ");
12703 *ret_conv = CResult_BlindedHopDecodeErrorZ_err(e_conv);
12704 return tag_ptr(ret_conv, true);
12707 jboolean __attribute__((export_name("TS_CResult_BlindedHopDecodeErrorZ_is_ok"))) TS_CResult_BlindedHopDecodeErrorZ_is_ok(uint64_t o) {
12708 LDKCResult_BlindedHopDecodeErrorZ* o_conv = (LDKCResult_BlindedHopDecodeErrorZ*)untag_ptr(o);
12709 jboolean ret_conv = CResult_BlindedHopDecodeErrorZ_is_ok(o_conv);
12713 void __attribute__((export_name("TS_CResult_BlindedHopDecodeErrorZ_free"))) TS_CResult_BlindedHopDecodeErrorZ_free(uint64_t _res) {
12714 if (!ptr_is_owned(_res)) return;
12715 void* _res_ptr = untag_ptr(_res);
12716 CHECK_ACCESS(_res_ptr);
12717 LDKCResult_BlindedHopDecodeErrorZ _res_conv = *(LDKCResult_BlindedHopDecodeErrorZ*)(_res_ptr);
12718 FREE(untag_ptr(_res));
12719 CResult_BlindedHopDecodeErrorZ_free(_res_conv);
12722 static inline uint64_t CResult_BlindedHopDecodeErrorZ_clone_ptr(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR arg) {
12723 LDKCResult_BlindedHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopDecodeErrorZ), "LDKCResult_BlindedHopDecodeErrorZ");
12724 *ret_conv = CResult_BlindedHopDecodeErrorZ_clone(arg);
12725 return tag_ptr(ret_conv, true);
12727 int64_t __attribute__((export_name("TS_CResult_BlindedHopDecodeErrorZ_clone_ptr"))) TS_CResult_BlindedHopDecodeErrorZ_clone_ptr(uint64_t arg) {
12728 LDKCResult_BlindedHopDecodeErrorZ* arg_conv = (LDKCResult_BlindedHopDecodeErrorZ*)untag_ptr(arg);
12729 int64_t ret_conv = CResult_BlindedHopDecodeErrorZ_clone_ptr(arg_conv);
12733 uint64_t __attribute__((export_name("TS_CResult_BlindedHopDecodeErrorZ_clone"))) TS_CResult_BlindedHopDecodeErrorZ_clone(uint64_t orig) {
12734 LDKCResult_BlindedHopDecodeErrorZ* orig_conv = (LDKCResult_BlindedHopDecodeErrorZ*)untag_ptr(orig);
12735 LDKCResult_BlindedHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopDecodeErrorZ), "LDKCResult_BlindedHopDecodeErrorZ");
12736 *ret_conv = CResult_BlindedHopDecodeErrorZ_clone(orig_conv);
12737 return tag_ptr(ret_conv, true);
12740 void __attribute__((export_name("TS_CVec_ChannelDetailsZ_free"))) TS_CVec_ChannelDetailsZ_free(uint64_tArray _res) {
12741 LDKCVec_ChannelDetailsZ _res_constr;
12742 _res_constr.datalen = _res->arr_len;
12743 if (_res_constr.datalen > 0)
12744 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
12746 _res_constr.data = NULL;
12747 uint64_t* _res_vals = _res->elems;
12748 for (size_t q = 0; q < _res_constr.datalen; q++) {
12749 uint64_t _res_conv_16 = _res_vals[q];
12750 LDKChannelDetails _res_conv_16_conv;
12751 _res_conv_16_conv.inner = untag_ptr(_res_conv_16);
12752 _res_conv_16_conv.is_owned = ptr_is_owned(_res_conv_16);
12753 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_16_conv);
12754 _res_constr.data[q] = _res_conv_16_conv;
12757 CVec_ChannelDetailsZ_free(_res_constr);
12760 uint64_t __attribute__((export_name("TS_CResult_RouteLightningErrorZ_ok"))) TS_CResult_RouteLightningErrorZ_ok(uint64_t o) {
12762 o_conv.inner = untag_ptr(o);
12763 o_conv.is_owned = ptr_is_owned(o);
12764 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12765 o_conv = Route_clone(&o_conv);
12766 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
12767 *ret_conv = CResult_RouteLightningErrorZ_ok(o_conv);
12768 return tag_ptr(ret_conv, true);
12771 uint64_t __attribute__((export_name("TS_CResult_RouteLightningErrorZ_err"))) TS_CResult_RouteLightningErrorZ_err(uint64_t e) {
12772 LDKLightningError e_conv;
12773 e_conv.inner = untag_ptr(e);
12774 e_conv.is_owned = ptr_is_owned(e);
12775 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
12776 e_conv = LightningError_clone(&e_conv);
12777 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
12778 *ret_conv = CResult_RouteLightningErrorZ_err(e_conv);
12779 return tag_ptr(ret_conv, true);
12782 jboolean __attribute__((export_name("TS_CResult_RouteLightningErrorZ_is_ok"))) TS_CResult_RouteLightningErrorZ_is_ok(uint64_t o) {
12783 LDKCResult_RouteLightningErrorZ* o_conv = (LDKCResult_RouteLightningErrorZ*)untag_ptr(o);
12784 jboolean ret_conv = CResult_RouteLightningErrorZ_is_ok(o_conv);
12788 void __attribute__((export_name("TS_CResult_RouteLightningErrorZ_free"))) TS_CResult_RouteLightningErrorZ_free(uint64_t _res) {
12789 if (!ptr_is_owned(_res)) return;
12790 void* _res_ptr = untag_ptr(_res);
12791 CHECK_ACCESS(_res_ptr);
12792 LDKCResult_RouteLightningErrorZ _res_conv = *(LDKCResult_RouteLightningErrorZ*)(_res_ptr);
12793 FREE(untag_ptr(_res));
12794 CResult_RouteLightningErrorZ_free(_res_conv);
12797 static inline uint64_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg) {
12798 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
12799 *ret_conv = CResult_RouteLightningErrorZ_clone(arg);
12800 return tag_ptr(ret_conv, true);
12802 int64_t __attribute__((export_name("TS_CResult_RouteLightningErrorZ_clone_ptr"))) TS_CResult_RouteLightningErrorZ_clone_ptr(uint64_t arg) {
12803 LDKCResult_RouteLightningErrorZ* arg_conv = (LDKCResult_RouteLightningErrorZ*)untag_ptr(arg);
12804 int64_t ret_conv = CResult_RouteLightningErrorZ_clone_ptr(arg_conv);
12808 uint64_t __attribute__((export_name("TS_CResult_RouteLightningErrorZ_clone"))) TS_CResult_RouteLightningErrorZ_clone(uint64_t orig) {
12809 LDKCResult_RouteLightningErrorZ* orig_conv = (LDKCResult_RouteLightningErrorZ*)untag_ptr(orig);
12810 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
12811 *ret_conv = CResult_RouteLightningErrorZ_clone(orig_conv);
12812 return tag_ptr(ret_conv, true);
12815 void __attribute__((export_name("TS_CVec_RouteHopZ_free"))) TS_CVec_RouteHopZ_free(uint64_tArray _res) {
12816 LDKCVec_RouteHopZ _res_constr;
12817 _res_constr.datalen = _res->arr_len;
12818 if (_res_constr.datalen > 0)
12819 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
12821 _res_constr.data = NULL;
12822 uint64_t* _res_vals = _res->elems;
12823 for (size_t k = 0; k < _res_constr.datalen; k++) {
12824 uint64_t _res_conv_10 = _res_vals[k];
12825 LDKRouteHop _res_conv_10_conv;
12826 _res_conv_10_conv.inner = untag_ptr(_res_conv_10);
12827 _res_conv_10_conv.is_owned = ptr_is_owned(_res_conv_10);
12828 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_10_conv);
12829 _res_constr.data[k] = _res_conv_10_conv;
12832 CVec_RouteHopZ_free(_res_constr);
12835 uint64_t __attribute__((export_name("TS_COption_u64Z_some"))) TS_COption_u64Z_some(int64_t o) {
12836 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
12837 *ret_copy = COption_u64Z_some(o);
12838 uint64_t ret_ref = tag_ptr(ret_copy, true);
12842 uint64_t __attribute__((export_name("TS_COption_u64Z_none"))) TS_COption_u64Z_none() {
12843 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
12844 *ret_copy = COption_u64Z_none();
12845 uint64_t ret_ref = tag_ptr(ret_copy, true);
12849 void __attribute__((export_name("TS_COption_u64Z_free"))) TS_COption_u64Z_free(uint64_t _res) {
12850 if (!ptr_is_owned(_res)) return;
12851 void* _res_ptr = untag_ptr(_res);
12852 CHECK_ACCESS(_res_ptr);
12853 LDKCOption_u64Z _res_conv = *(LDKCOption_u64Z*)(_res_ptr);
12854 FREE(untag_ptr(_res));
12855 COption_u64Z_free(_res_conv);
12858 static inline uint64_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg) {
12859 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
12860 *ret_copy = COption_u64Z_clone(arg);
12861 uint64_t ret_ref = tag_ptr(ret_copy, true);
12864 int64_t __attribute__((export_name("TS_COption_u64Z_clone_ptr"))) TS_COption_u64Z_clone_ptr(uint64_t arg) {
12865 LDKCOption_u64Z* arg_conv = (LDKCOption_u64Z*)untag_ptr(arg);
12866 int64_t ret_conv = COption_u64Z_clone_ptr(arg_conv);
12870 uint64_t __attribute__((export_name("TS_COption_u64Z_clone"))) TS_COption_u64Z_clone(uint64_t orig) {
12871 LDKCOption_u64Z* orig_conv = (LDKCOption_u64Z*)untag_ptr(orig);
12872 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
12873 *ret_copy = COption_u64Z_clone(orig_conv);
12874 uint64_t ret_ref = tag_ptr(ret_copy, true);
12878 uint64_t __attribute__((export_name("TS_CResult_InFlightHtlcsDecodeErrorZ_ok"))) TS_CResult_InFlightHtlcsDecodeErrorZ_ok(uint64_t o) {
12879 LDKInFlightHtlcs o_conv;
12880 o_conv.inner = untag_ptr(o);
12881 o_conv.is_owned = ptr_is_owned(o);
12882 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12883 o_conv = InFlightHtlcs_clone(&o_conv);
12884 LDKCResult_InFlightHtlcsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ), "LDKCResult_InFlightHtlcsDecodeErrorZ");
12885 *ret_conv = CResult_InFlightHtlcsDecodeErrorZ_ok(o_conv);
12886 return tag_ptr(ret_conv, true);
12889 uint64_t __attribute__((export_name("TS_CResult_InFlightHtlcsDecodeErrorZ_err"))) TS_CResult_InFlightHtlcsDecodeErrorZ_err(uint64_t e) {
12890 void* e_ptr = untag_ptr(e);
12891 CHECK_ACCESS(e_ptr);
12892 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
12893 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
12894 LDKCResult_InFlightHtlcsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ), "LDKCResult_InFlightHtlcsDecodeErrorZ");
12895 *ret_conv = CResult_InFlightHtlcsDecodeErrorZ_err(e_conv);
12896 return tag_ptr(ret_conv, true);
12899 jboolean __attribute__((export_name("TS_CResult_InFlightHtlcsDecodeErrorZ_is_ok"))) TS_CResult_InFlightHtlcsDecodeErrorZ_is_ok(uint64_t o) {
12900 LDKCResult_InFlightHtlcsDecodeErrorZ* o_conv = (LDKCResult_InFlightHtlcsDecodeErrorZ*)untag_ptr(o);
12901 jboolean ret_conv = CResult_InFlightHtlcsDecodeErrorZ_is_ok(o_conv);
12905 void __attribute__((export_name("TS_CResult_InFlightHtlcsDecodeErrorZ_free"))) TS_CResult_InFlightHtlcsDecodeErrorZ_free(uint64_t _res) {
12906 if (!ptr_is_owned(_res)) return;
12907 void* _res_ptr = untag_ptr(_res);
12908 CHECK_ACCESS(_res_ptr);
12909 LDKCResult_InFlightHtlcsDecodeErrorZ _res_conv = *(LDKCResult_InFlightHtlcsDecodeErrorZ*)(_res_ptr);
12910 FREE(untag_ptr(_res));
12911 CResult_InFlightHtlcsDecodeErrorZ_free(_res_conv);
12914 static inline uint64_t CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR arg) {
12915 LDKCResult_InFlightHtlcsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ), "LDKCResult_InFlightHtlcsDecodeErrorZ");
12916 *ret_conv = CResult_InFlightHtlcsDecodeErrorZ_clone(arg);
12917 return tag_ptr(ret_conv, true);
12919 int64_t __attribute__((export_name("TS_CResult_InFlightHtlcsDecodeErrorZ_clone_ptr"))) TS_CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(uint64_t arg) {
12920 LDKCResult_InFlightHtlcsDecodeErrorZ* arg_conv = (LDKCResult_InFlightHtlcsDecodeErrorZ*)untag_ptr(arg);
12921 int64_t ret_conv = CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(arg_conv);
12925 uint64_t __attribute__((export_name("TS_CResult_InFlightHtlcsDecodeErrorZ_clone"))) TS_CResult_InFlightHtlcsDecodeErrorZ_clone(uint64_t orig) {
12926 LDKCResult_InFlightHtlcsDecodeErrorZ* orig_conv = (LDKCResult_InFlightHtlcsDecodeErrorZ*)untag_ptr(orig);
12927 LDKCResult_InFlightHtlcsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ), "LDKCResult_InFlightHtlcsDecodeErrorZ");
12928 *ret_conv = CResult_InFlightHtlcsDecodeErrorZ_clone(orig_conv);
12929 return tag_ptr(ret_conv, true);
12932 uint64_t __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_ok"))) TS_CResult_RouteHopDecodeErrorZ_ok(uint64_t o) {
12933 LDKRouteHop o_conv;
12934 o_conv.inner = untag_ptr(o);
12935 o_conv.is_owned = ptr_is_owned(o);
12936 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12937 o_conv = RouteHop_clone(&o_conv);
12938 LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
12939 *ret_conv = CResult_RouteHopDecodeErrorZ_ok(o_conv);
12940 return tag_ptr(ret_conv, true);
12943 uint64_t __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_err"))) TS_CResult_RouteHopDecodeErrorZ_err(uint64_t e) {
12944 void* e_ptr = untag_ptr(e);
12945 CHECK_ACCESS(e_ptr);
12946 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
12947 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
12948 LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
12949 *ret_conv = CResult_RouteHopDecodeErrorZ_err(e_conv);
12950 return tag_ptr(ret_conv, true);
12953 jboolean __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_is_ok"))) TS_CResult_RouteHopDecodeErrorZ_is_ok(uint64_t o) {
12954 LDKCResult_RouteHopDecodeErrorZ* o_conv = (LDKCResult_RouteHopDecodeErrorZ*)untag_ptr(o);
12955 jboolean ret_conv = CResult_RouteHopDecodeErrorZ_is_ok(o_conv);
12959 void __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_free"))) TS_CResult_RouteHopDecodeErrorZ_free(uint64_t _res) {
12960 if (!ptr_is_owned(_res)) return;
12961 void* _res_ptr = untag_ptr(_res);
12962 CHECK_ACCESS(_res_ptr);
12963 LDKCResult_RouteHopDecodeErrorZ _res_conv = *(LDKCResult_RouteHopDecodeErrorZ*)(_res_ptr);
12964 FREE(untag_ptr(_res));
12965 CResult_RouteHopDecodeErrorZ_free(_res_conv);
12968 static inline uint64_t CResult_RouteHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR arg) {
12969 LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
12970 *ret_conv = CResult_RouteHopDecodeErrorZ_clone(arg);
12971 return tag_ptr(ret_conv, true);
12973 int64_t __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_clone_ptr"))) TS_CResult_RouteHopDecodeErrorZ_clone_ptr(uint64_t arg) {
12974 LDKCResult_RouteHopDecodeErrorZ* arg_conv = (LDKCResult_RouteHopDecodeErrorZ*)untag_ptr(arg);
12975 int64_t ret_conv = CResult_RouteHopDecodeErrorZ_clone_ptr(arg_conv);
12979 uint64_t __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_clone"))) TS_CResult_RouteHopDecodeErrorZ_clone(uint64_t orig) {
12980 LDKCResult_RouteHopDecodeErrorZ* orig_conv = (LDKCResult_RouteHopDecodeErrorZ*)untag_ptr(orig);
12981 LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
12982 *ret_conv = CResult_RouteHopDecodeErrorZ_clone(orig_conv);
12983 return tag_ptr(ret_conv, true);
12986 void __attribute__((export_name("TS_CVec_CVec_RouteHopZZ_free"))) TS_CVec_CVec_RouteHopZZ_free(ptrArray _res) {
12987 LDKCVec_CVec_RouteHopZZ _res_constr;
12988 _res_constr.datalen = _res->arr_len;
12989 if (_res_constr.datalen > 0)
12990 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKCVec_RouteHopZ), "LDKCVec_CVec_RouteHopZZ Elements");
12992 _res_constr.data = NULL;
12993 uint64_tArray* _res_vals = (void*) _res->elems;
12994 for (size_t m = 0; m < _res_constr.datalen; m++) {
12995 uint64_tArray _res_conv_12 = _res_vals[m];
12996 LDKCVec_RouteHopZ _res_conv_12_constr;
12997 _res_conv_12_constr.datalen = _res_conv_12->arr_len;
12998 if (_res_conv_12_constr.datalen > 0)
12999 _res_conv_12_constr.data = MALLOC(_res_conv_12_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
13001 _res_conv_12_constr.data = NULL;
13002 uint64_t* _res_conv_12_vals = _res_conv_12->elems;
13003 for (size_t k = 0; k < _res_conv_12_constr.datalen; k++) {
13004 uint64_t _res_conv_12_conv_10 = _res_conv_12_vals[k];
13005 LDKRouteHop _res_conv_12_conv_10_conv;
13006 _res_conv_12_conv_10_conv.inner = untag_ptr(_res_conv_12_conv_10);
13007 _res_conv_12_conv_10_conv.is_owned = ptr_is_owned(_res_conv_12_conv_10);
13008 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_12_conv_10_conv);
13009 _res_conv_12_constr.data[k] = _res_conv_12_conv_10_conv;
13011 FREE(_res_conv_12);
13012 _res_constr.data[m] = _res_conv_12_constr;
13015 CVec_CVec_RouteHopZZ_free(_res_constr);
13018 uint64_t __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_ok"))) TS_CResult_RouteDecodeErrorZ_ok(uint64_t o) {
13020 o_conv.inner = untag_ptr(o);
13021 o_conv.is_owned = ptr_is_owned(o);
13022 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
13023 o_conv = Route_clone(&o_conv);
13024 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
13025 *ret_conv = CResult_RouteDecodeErrorZ_ok(o_conv);
13026 return tag_ptr(ret_conv, true);
13029 uint64_t __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_err"))) TS_CResult_RouteDecodeErrorZ_err(uint64_t e) {
13030 void* e_ptr = untag_ptr(e);
13031 CHECK_ACCESS(e_ptr);
13032 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
13033 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
13034 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
13035 *ret_conv = CResult_RouteDecodeErrorZ_err(e_conv);
13036 return tag_ptr(ret_conv, true);
13039 jboolean __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_is_ok"))) TS_CResult_RouteDecodeErrorZ_is_ok(uint64_t o) {
13040 LDKCResult_RouteDecodeErrorZ* o_conv = (LDKCResult_RouteDecodeErrorZ*)untag_ptr(o);
13041 jboolean ret_conv = CResult_RouteDecodeErrorZ_is_ok(o_conv);
13045 void __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_free"))) TS_CResult_RouteDecodeErrorZ_free(uint64_t _res) {
13046 if (!ptr_is_owned(_res)) return;
13047 void* _res_ptr = untag_ptr(_res);
13048 CHECK_ACCESS(_res_ptr);
13049 LDKCResult_RouteDecodeErrorZ _res_conv = *(LDKCResult_RouteDecodeErrorZ*)(_res_ptr);
13050 FREE(untag_ptr(_res));
13051 CResult_RouteDecodeErrorZ_free(_res_conv);
13054 static inline uint64_t CResult_RouteDecodeErrorZ_clone_ptr(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR arg) {
13055 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
13056 *ret_conv = CResult_RouteDecodeErrorZ_clone(arg);
13057 return tag_ptr(ret_conv, true);
13059 int64_t __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_clone_ptr"))) TS_CResult_RouteDecodeErrorZ_clone_ptr(uint64_t arg) {
13060 LDKCResult_RouteDecodeErrorZ* arg_conv = (LDKCResult_RouteDecodeErrorZ*)untag_ptr(arg);
13061 int64_t ret_conv = CResult_RouteDecodeErrorZ_clone_ptr(arg_conv);
13065 uint64_t __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_clone"))) TS_CResult_RouteDecodeErrorZ_clone(uint64_t orig) {
13066 LDKCResult_RouteDecodeErrorZ* orig_conv = (LDKCResult_RouteDecodeErrorZ*)untag_ptr(orig);
13067 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
13068 *ret_conv = CResult_RouteDecodeErrorZ_clone(orig_conv);
13069 return tag_ptr(ret_conv, true);
13072 uint64_t __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_ok"))) TS_CResult_RouteParametersDecodeErrorZ_ok(uint64_t o) {
13073 LDKRouteParameters o_conv;
13074 o_conv.inner = untag_ptr(o);
13075 o_conv.is_owned = ptr_is_owned(o);
13076 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
13077 o_conv = RouteParameters_clone(&o_conv);
13078 LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
13079 *ret_conv = CResult_RouteParametersDecodeErrorZ_ok(o_conv);
13080 return tag_ptr(ret_conv, true);
13083 uint64_t __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_err"))) TS_CResult_RouteParametersDecodeErrorZ_err(uint64_t e) {
13084 void* e_ptr = untag_ptr(e);
13085 CHECK_ACCESS(e_ptr);
13086 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
13087 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
13088 LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
13089 *ret_conv = CResult_RouteParametersDecodeErrorZ_err(e_conv);
13090 return tag_ptr(ret_conv, true);
13093 jboolean __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_is_ok"))) TS_CResult_RouteParametersDecodeErrorZ_is_ok(uint64_t o) {
13094 LDKCResult_RouteParametersDecodeErrorZ* o_conv = (LDKCResult_RouteParametersDecodeErrorZ*)untag_ptr(o);
13095 jboolean ret_conv = CResult_RouteParametersDecodeErrorZ_is_ok(o_conv);
13099 void __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_free"))) TS_CResult_RouteParametersDecodeErrorZ_free(uint64_t _res) {
13100 if (!ptr_is_owned(_res)) return;
13101 void* _res_ptr = untag_ptr(_res);
13102 CHECK_ACCESS(_res_ptr);
13103 LDKCResult_RouteParametersDecodeErrorZ _res_conv = *(LDKCResult_RouteParametersDecodeErrorZ*)(_res_ptr);
13104 FREE(untag_ptr(_res));
13105 CResult_RouteParametersDecodeErrorZ_free(_res_conv);
13108 static inline uint64_t CResult_RouteParametersDecodeErrorZ_clone_ptr(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR arg) {
13109 LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
13110 *ret_conv = CResult_RouteParametersDecodeErrorZ_clone(arg);
13111 return tag_ptr(ret_conv, true);
13113 int64_t __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_clone_ptr"))) TS_CResult_RouteParametersDecodeErrorZ_clone_ptr(uint64_t arg) {
13114 LDKCResult_RouteParametersDecodeErrorZ* arg_conv = (LDKCResult_RouteParametersDecodeErrorZ*)untag_ptr(arg);
13115 int64_t ret_conv = CResult_RouteParametersDecodeErrorZ_clone_ptr(arg_conv);
13119 uint64_t __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_clone"))) TS_CResult_RouteParametersDecodeErrorZ_clone(uint64_t orig) {
13120 LDKCResult_RouteParametersDecodeErrorZ* orig_conv = (LDKCResult_RouteParametersDecodeErrorZ*)untag_ptr(orig);
13121 LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
13122 *ret_conv = CResult_RouteParametersDecodeErrorZ_clone(orig_conv);
13123 return tag_ptr(ret_conv, true);
13126 void __attribute__((export_name("TS_CVec_RouteHintZ_free"))) TS_CVec_RouteHintZ_free(uint64_tArray _res) {
13127 LDKCVec_RouteHintZ _res_constr;
13128 _res_constr.datalen = _res->arr_len;
13129 if (_res_constr.datalen > 0)
13130 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKRouteHint), "LDKCVec_RouteHintZ Elements");
13132 _res_constr.data = NULL;
13133 uint64_t* _res_vals = _res->elems;
13134 for (size_t l = 0; l < _res_constr.datalen; l++) {
13135 uint64_t _res_conv_11 = _res_vals[l];
13136 LDKRouteHint _res_conv_11_conv;
13137 _res_conv_11_conv.inner = untag_ptr(_res_conv_11);
13138 _res_conv_11_conv.is_owned = ptr_is_owned(_res_conv_11);
13139 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_11_conv);
13140 _res_constr.data[l] = _res_conv_11_conv;
13143 CVec_RouteHintZ_free(_res_constr);
13146 void __attribute__((export_name("TS_CVec_u64Z_free"))) TS_CVec_u64Z_free(int64_tArray _res) {
13147 LDKCVec_u64Z _res_constr;
13148 _res_constr.datalen = _res->arr_len;
13149 if (_res_constr.datalen > 0)
13150 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
13152 _res_constr.data = NULL;
13153 int64_t* _res_vals = _res->elems;
13154 for (size_t i = 0; i < _res_constr.datalen; i++) {
13155 int64_t _res_conv_8 = _res_vals[i];
13156 _res_constr.data[i] = _res_conv_8;
13159 CVec_u64Z_free(_res_constr);
13162 uint64_t __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_ok"))) TS_CResult_PaymentParametersDecodeErrorZ_ok(uint64_t o) {
13163 LDKPaymentParameters o_conv;
13164 o_conv.inner = untag_ptr(o);
13165 o_conv.is_owned = ptr_is_owned(o);
13166 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
13167 o_conv = PaymentParameters_clone(&o_conv);
13168 LDKCResult_PaymentParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentParametersDecodeErrorZ), "LDKCResult_PaymentParametersDecodeErrorZ");
13169 *ret_conv = CResult_PaymentParametersDecodeErrorZ_ok(o_conv);
13170 return tag_ptr(ret_conv, true);
13173 uint64_t __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_err"))) TS_CResult_PaymentParametersDecodeErrorZ_err(uint64_t e) {
13174 void* e_ptr = untag_ptr(e);
13175 CHECK_ACCESS(e_ptr);
13176 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
13177 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
13178 LDKCResult_PaymentParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentParametersDecodeErrorZ), "LDKCResult_PaymentParametersDecodeErrorZ");
13179 *ret_conv = CResult_PaymentParametersDecodeErrorZ_err(e_conv);
13180 return tag_ptr(ret_conv, true);
13183 jboolean __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_is_ok"))) TS_CResult_PaymentParametersDecodeErrorZ_is_ok(uint64_t o) {
13184 LDKCResult_PaymentParametersDecodeErrorZ* o_conv = (LDKCResult_PaymentParametersDecodeErrorZ*)untag_ptr(o);
13185 jboolean ret_conv = CResult_PaymentParametersDecodeErrorZ_is_ok(o_conv);
13189 void __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_free"))) TS_CResult_PaymentParametersDecodeErrorZ_free(uint64_t _res) {
13190 if (!ptr_is_owned(_res)) return;
13191 void* _res_ptr = untag_ptr(_res);
13192 CHECK_ACCESS(_res_ptr);
13193 LDKCResult_PaymentParametersDecodeErrorZ _res_conv = *(LDKCResult_PaymentParametersDecodeErrorZ*)(_res_ptr);
13194 FREE(untag_ptr(_res));
13195 CResult_PaymentParametersDecodeErrorZ_free(_res_conv);
13198 static inline uint64_t CResult_PaymentParametersDecodeErrorZ_clone_ptr(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR arg) {
13199 LDKCResult_PaymentParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentParametersDecodeErrorZ), "LDKCResult_PaymentParametersDecodeErrorZ");
13200 *ret_conv = CResult_PaymentParametersDecodeErrorZ_clone(arg);
13201 return tag_ptr(ret_conv, true);
13203 int64_t __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_clone_ptr"))) TS_CResult_PaymentParametersDecodeErrorZ_clone_ptr(uint64_t arg) {
13204 LDKCResult_PaymentParametersDecodeErrorZ* arg_conv = (LDKCResult_PaymentParametersDecodeErrorZ*)untag_ptr(arg);
13205 int64_t ret_conv = CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg_conv);
13209 uint64_t __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_clone"))) TS_CResult_PaymentParametersDecodeErrorZ_clone(uint64_t orig) {
13210 LDKCResult_PaymentParametersDecodeErrorZ* orig_conv = (LDKCResult_PaymentParametersDecodeErrorZ*)untag_ptr(orig);
13211 LDKCResult_PaymentParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentParametersDecodeErrorZ), "LDKCResult_PaymentParametersDecodeErrorZ");
13212 *ret_conv = CResult_PaymentParametersDecodeErrorZ_clone(orig_conv);
13213 return tag_ptr(ret_conv, true);
13216 void __attribute__((export_name("TS_CVec_RouteHintHopZ_free"))) TS_CVec_RouteHintHopZ_free(uint64_tArray _res) {
13217 LDKCVec_RouteHintHopZ _res_constr;
13218 _res_constr.datalen = _res->arr_len;
13219 if (_res_constr.datalen > 0)
13220 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKRouteHintHop), "LDKCVec_RouteHintHopZ Elements");
13222 _res_constr.data = NULL;
13223 uint64_t* _res_vals = _res->elems;
13224 for (size_t o = 0; o < _res_constr.datalen; o++) {
13225 uint64_t _res_conv_14 = _res_vals[o];
13226 LDKRouteHintHop _res_conv_14_conv;
13227 _res_conv_14_conv.inner = untag_ptr(_res_conv_14);
13228 _res_conv_14_conv.is_owned = ptr_is_owned(_res_conv_14);
13229 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_14_conv);
13230 _res_constr.data[o] = _res_conv_14_conv;
13233 CVec_RouteHintHopZ_free(_res_constr);
13236 uint64_t __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_ok"))) TS_CResult_RouteHintDecodeErrorZ_ok(uint64_t o) {
13237 LDKRouteHint o_conv;
13238 o_conv.inner = untag_ptr(o);
13239 o_conv.is_owned = ptr_is_owned(o);
13240 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
13241 o_conv = RouteHint_clone(&o_conv);
13242 LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
13243 *ret_conv = CResult_RouteHintDecodeErrorZ_ok(o_conv);
13244 return tag_ptr(ret_conv, true);
13247 uint64_t __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_err"))) TS_CResult_RouteHintDecodeErrorZ_err(uint64_t e) {
13248 void* e_ptr = untag_ptr(e);
13249 CHECK_ACCESS(e_ptr);
13250 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
13251 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
13252 LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
13253 *ret_conv = CResult_RouteHintDecodeErrorZ_err(e_conv);
13254 return tag_ptr(ret_conv, true);
13257 jboolean __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_is_ok"))) TS_CResult_RouteHintDecodeErrorZ_is_ok(uint64_t o) {
13258 LDKCResult_RouteHintDecodeErrorZ* o_conv = (LDKCResult_RouteHintDecodeErrorZ*)untag_ptr(o);
13259 jboolean ret_conv = CResult_RouteHintDecodeErrorZ_is_ok(o_conv);
13263 void __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_free"))) TS_CResult_RouteHintDecodeErrorZ_free(uint64_t _res) {
13264 if (!ptr_is_owned(_res)) return;
13265 void* _res_ptr = untag_ptr(_res);
13266 CHECK_ACCESS(_res_ptr);
13267 LDKCResult_RouteHintDecodeErrorZ _res_conv = *(LDKCResult_RouteHintDecodeErrorZ*)(_res_ptr);
13268 FREE(untag_ptr(_res));
13269 CResult_RouteHintDecodeErrorZ_free(_res_conv);
13272 static inline uint64_t CResult_RouteHintDecodeErrorZ_clone_ptr(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR arg) {
13273 LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
13274 *ret_conv = CResult_RouteHintDecodeErrorZ_clone(arg);
13275 return tag_ptr(ret_conv, true);
13277 int64_t __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_clone_ptr"))) TS_CResult_RouteHintDecodeErrorZ_clone_ptr(uint64_t arg) {
13278 LDKCResult_RouteHintDecodeErrorZ* arg_conv = (LDKCResult_RouteHintDecodeErrorZ*)untag_ptr(arg);
13279 int64_t ret_conv = CResult_RouteHintDecodeErrorZ_clone_ptr(arg_conv);
13283 uint64_t __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_clone"))) TS_CResult_RouteHintDecodeErrorZ_clone(uint64_t orig) {
13284 LDKCResult_RouteHintDecodeErrorZ* orig_conv = (LDKCResult_RouteHintDecodeErrorZ*)untag_ptr(orig);
13285 LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
13286 *ret_conv = CResult_RouteHintDecodeErrorZ_clone(orig_conv);
13287 return tag_ptr(ret_conv, true);
13290 uint64_t __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_ok"))) TS_CResult_RouteHintHopDecodeErrorZ_ok(uint64_t o) {
13291 LDKRouteHintHop o_conv;
13292 o_conv.inner = untag_ptr(o);
13293 o_conv.is_owned = ptr_is_owned(o);
13294 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
13295 o_conv = RouteHintHop_clone(&o_conv);
13296 LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
13297 *ret_conv = CResult_RouteHintHopDecodeErrorZ_ok(o_conv);
13298 return tag_ptr(ret_conv, true);
13301 uint64_t __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_err"))) TS_CResult_RouteHintHopDecodeErrorZ_err(uint64_t e) {
13302 void* e_ptr = untag_ptr(e);
13303 CHECK_ACCESS(e_ptr);
13304 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
13305 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
13306 LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
13307 *ret_conv = CResult_RouteHintHopDecodeErrorZ_err(e_conv);
13308 return tag_ptr(ret_conv, true);
13311 jboolean __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_is_ok"))) TS_CResult_RouteHintHopDecodeErrorZ_is_ok(uint64_t o) {
13312 LDKCResult_RouteHintHopDecodeErrorZ* o_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)untag_ptr(o);
13313 jboolean ret_conv = CResult_RouteHintHopDecodeErrorZ_is_ok(o_conv);
13317 void __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_free"))) TS_CResult_RouteHintHopDecodeErrorZ_free(uint64_t _res) {
13318 if (!ptr_is_owned(_res)) return;
13319 void* _res_ptr = untag_ptr(_res);
13320 CHECK_ACCESS(_res_ptr);
13321 LDKCResult_RouteHintHopDecodeErrorZ _res_conv = *(LDKCResult_RouteHintHopDecodeErrorZ*)(_res_ptr);
13322 FREE(untag_ptr(_res));
13323 CResult_RouteHintHopDecodeErrorZ_free(_res_conv);
13326 static inline uint64_t CResult_RouteHintHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR arg) {
13327 LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
13328 *ret_conv = CResult_RouteHintHopDecodeErrorZ_clone(arg);
13329 return tag_ptr(ret_conv, true);
13331 int64_t __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr"))) TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr(uint64_t arg) {
13332 LDKCResult_RouteHintHopDecodeErrorZ* arg_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)untag_ptr(arg);
13333 int64_t ret_conv = CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg_conv);
13337 uint64_t __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_clone"))) TS_CResult_RouteHintHopDecodeErrorZ_clone(uint64_t orig) {
13338 LDKCResult_RouteHintHopDecodeErrorZ* orig_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)untag_ptr(orig);
13339 LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
13340 *ret_conv = CResult_RouteHintHopDecodeErrorZ_clone(orig_conv);
13341 return tag_ptr(ret_conv, true);
13344 uint64_t __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_ok"))) TS_CResult_PaymentPurposeDecodeErrorZ_ok(uint64_t o) {
13345 void* o_ptr = untag_ptr(o);
13346 CHECK_ACCESS(o_ptr);
13347 LDKPaymentPurpose o_conv = *(LDKPaymentPurpose*)(o_ptr);
13348 o_conv = PaymentPurpose_clone((LDKPaymentPurpose*)untag_ptr(o));
13349 LDKCResult_PaymentPurposeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPurposeDecodeErrorZ), "LDKCResult_PaymentPurposeDecodeErrorZ");
13350 *ret_conv = CResult_PaymentPurposeDecodeErrorZ_ok(o_conv);
13351 return tag_ptr(ret_conv, true);
13354 uint64_t __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_err"))) TS_CResult_PaymentPurposeDecodeErrorZ_err(uint64_t e) {
13355 void* e_ptr = untag_ptr(e);
13356 CHECK_ACCESS(e_ptr);
13357 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
13358 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
13359 LDKCResult_PaymentPurposeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPurposeDecodeErrorZ), "LDKCResult_PaymentPurposeDecodeErrorZ");
13360 *ret_conv = CResult_PaymentPurposeDecodeErrorZ_err(e_conv);
13361 return tag_ptr(ret_conv, true);
13364 jboolean __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_is_ok"))) TS_CResult_PaymentPurposeDecodeErrorZ_is_ok(uint64_t o) {
13365 LDKCResult_PaymentPurposeDecodeErrorZ* o_conv = (LDKCResult_PaymentPurposeDecodeErrorZ*)untag_ptr(o);
13366 jboolean ret_conv = CResult_PaymentPurposeDecodeErrorZ_is_ok(o_conv);
13370 void __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_free"))) TS_CResult_PaymentPurposeDecodeErrorZ_free(uint64_t _res) {
13371 if (!ptr_is_owned(_res)) return;
13372 void* _res_ptr = untag_ptr(_res);
13373 CHECK_ACCESS(_res_ptr);
13374 LDKCResult_PaymentPurposeDecodeErrorZ _res_conv = *(LDKCResult_PaymentPurposeDecodeErrorZ*)(_res_ptr);
13375 FREE(untag_ptr(_res));
13376 CResult_PaymentPurposeDecodeErrorZ_free(_res_conv);
13379 static inline uint64_t CResult_PaymentPurposeDecodeErrorZ_clone_ptr(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR arg) {
13380 LDKCResult_PaymentPurposeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPurposeDecodeErrorZ), "LDKCResult_PaymentPurposeDecodeErrorZ");
13381 *ret_conv = CResult_PaymentPurposeDecodeErrorZ_clone(arg);
13382 return tag_ptr(ret_conv, true);
13384 int64_t __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_clone_ptr"))) TS_CResult_PaymentPurposeDecodeErrorZ_clone_ptr(uint64_t arg) {
13385 LDKCResult_PaymentPurposeDecodeErrorZ* arg_conv = (LDKCResult_PaymentPurposeDecodeErrorZ*)untag_ptr(arg);
13386 int64_t ret_conv = CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg_conv);
13390 uint64_t __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_clone"))) TS_CResult_PaymentPurposeDecodeErrorZ_clone(uint64_t orig) {
13391 LDKCResult_PaymentPurposeDecodeErrorZ* orig_conv = (LDKCResult_PaymentPurposeDecodeErrorZ*)untag_ptr(orig);
13392 LDKCResult_PaymentPurposeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPurposeDecodeErrorZ), "LDKCResult_PaymentPurposeDecodeErrorZ");
13393 *ret_conv = CResult_PaymentPurposeDecodeErrorZ_clone(orig_conv);
13394 return tag_ptr(ret_conv, true);
13397 uint64_t __attribute__((export_name("TS_COption_ClosureReasonZ_some"))) TS_COption_ClosureReasonZ_some(uint64_t o) {
13398 void* o_ptr = untag_ptr(o);
13399 CHECK_ACCESS(o_ptr);
13400 LDKClosureReason o_conv = *(LDKClosureReason*)(o_ptr);
13401 o_conv = ClosureReason_clone((LDKClosureReason*)untag_ptr(o));
13402 LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
13403 *ret_copy = COption_ClosureReasonZ_some(o_conv);
13404 uint64_t ret_ref = tag_ptr(ret_copy, true);
13408 uint64_t __attribute__((export_name("TS_COption_ClosureReasonZ_none"))) TS_COption_ClosureReasonZ_none() {
13409 LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
13410 *ret_copy = COption_ClosureReasonZ_none();
13411 uint64_t ret_ref = tag_ptr(ret_copy, true);
13415 void __attribute__((export_name("TS_COption_ClosureReasonZ_free"))) TS_COption_ClosureReasonZ_free(uint64_t _res) {
13416 if (!ptr_is_owned(_res)) return;
13417 void* _res_ptr = untag_ptr(_res);
13418 CHECK_ACCESS(_res_ptr);
13419 LDKCOption_ClosureReasonZ _res_conv = *(LDKCOption_ClosureReasonZ*)(_res_ptr);
13420 FREE(untag_ptr(_res));
13421 COption_ClosureReasonZ_free(_res_conv);
13424 static inline uint64_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg) {
13425 LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
13426 *ret_copy = COption_ClosureReasonZ_clone(arg);
13427 uint64_t ret_ref = tag_ptr(ret_copy, true);
13430 int64_t __attribute__((export_name("TS_COption_ClosureReasonZ_clone_ptr"))) TS_COption_ClosureReasonZ_clone_ptr(uint64_t arg) {
13431 LDKCOption_ClosureReasonZ* arg_conv = (LDKCOption_ClosureReasonZ*)untag_ptr(arg);
13432 int64_t ret_conv = COption_ClosureReasonZ_clone_ptr(arg_conv);
13436 uint64_t __attribute__((export_name("TS_COption_ClosureReasonZ_clone"))) TS_COption_ClosureReasonZ_clone(uint64_t orig) {
13437 LDKCOption_ClosureReasonZ* orig_conv = (LDKCOption_ClosureReasonZ*)untag_ptr(orig);
13438 LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
13439 *ret_copy = COption_ClosureReasonZ_clone(orig_conv);
13440 uint64_t ret_ref = tag_ptr(ret_copy, true);
13444 uint64_t __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok(uint64_t o) {
13445 void* o_ptr = untag_ptr(o);
13446 CHECK_ACCESS(o_ptr);
13447 LDKCOption_ClosureReasonZ o_conv = *(LDKCOption_ClosureReasonZ*)(o_ptr);
13448 o_conv = COption_ClosureReasonZ_clone((LDKCOption_ClosureReasonZ*)untag_ptr(o));
13449 LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
13450 *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_ok(o_conv);
13451 return tag_ptr(ret_conv, true);
13454 uint64_t __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_err"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_err(uint64_t e) {
13455 void* e_ptr = untag_ptr(e);
13456 CHECK_ACCESS(e_ptr);
13457 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
13458 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
13459 LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
13460 *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_err(e_conv);
13461 return tag_ptr(ret_conv, true);
13464 jboolean __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(uint64_t o) {
13465 LDKCResult_COption_ClosureReasonZDecodeErrorZ* o_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)untag_ptr(o);
13466 jboolean ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o_conv);
13470 void __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_free"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_free(uint64_t _res) {
13471 if (!ptr_is_owned(_res)) return;
13472 void* _res_ptr = untag_ptr(_res);
13473 CHECK_ACCESS(_res_ptr);
13474 LDKCResult_COption_ClosureReasonZDecodeErrorZ _res_conv = *(LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(_res_ptr);
13475 FREE(untag_ptr(_res));
13476 CResult_COption_ClosureReasonZDecodeErrorZ_free(_res_conv);
13479 static inline uint64_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg) {
13480 LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
13481 *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_clone(arg);
13482 return tag_ptr(ret_conv, true);
13484 int64_t __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(uint64_t arg) {
13485 LDKCResult_COption_ClosureReasonZDecodeErrorZ* arg_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)untag_ptr(arg);
13486 int64_t ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg_conv);
13490 uint64_t __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone(uint64_t orig) {
13491 LDKCResult_COption_ClosureReasonZDecodeErrorZ* orig_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)untag_ptr(orig);
13492 LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
13493 *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig_conv);
13494 return tag_ptr(ret_conv, true);
13497 uint64_t __attribute__((export_name("TS_COption_HTLCDestinationZ_some"))) TS_COption_HTLCDestinationZ_some(uint64_t o) {
13498 void* o_ptr = untag_ptr(o);
13499 CHECK_ACCESS(o_ptr);
13500 LDKHTLCDestination o_conv = *(LDKHTLCDestination*)(o_ptr);
13501 o_conv = HTLCDestination_clone((LDKHTLCDestination*)untag_ptr(o));
13502 LDKCOption_HTLCDestinationZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCDestinationZ), "LDKCOption_HTLCDestinationZ");
13503 *ret_copy = COption_HTLCDestinationZ_some(o_conv);
13504 uint64_t ret_ref = tag_ptr(ret_copy, true);
13508 uint64_t __attribute__((export_name("TS_COption_HTLCDestinationZ_none"))) TS_COption_HTLCDestinationZ_none() {
13509 LDKCOption_HTLCDestinationZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCDestinationZ), "LDKCOption_HTLCDestinationZ");
13510 *ret_copy = COption_HTLCDestinationZ_none();
13511 uint64_t ret_ref = tag_ptr(ret_copy, true);
13515 void __attribute__((export_name("TS_COption_HTLCDestinationZ_free"))) TS_COption_HTLCDestinationZ_free(uint64_t _res) {
13516 if (!ptr_is_owned(_res)) return;
13517 void* _res_ptr = untag_ptr(_res);
13518 CHECK_ACCESS(_res_ptr);
13519 LDKCOption_HTLCDestinationZ _res_conv = *(LDKCOption_HTLCDestinationZ*)(_res_ptr);
13520 FREE(untag_ptr(_res));
13521 COption_HTLCDestinationZ_free(_res_conv);
13524 static inline uint64_t COption_HTLCDestinationZ_clone_ptr(LDKCOption_HTLCDestinationZ *NONNULL_PTR arg) {
13525 LDKCOption_HTLCDestinationZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCDestinationZ), "LDKCOption_HTLCDestinationZ");
13526 *ret_copy = COption_HTLCDestinationZ_clone(arg);
13527 uint64_t ret_ref = tag_ptr(ret_copy, true);
13530 int64_t __attribute__((export_name("TS_COption_HTLCDestinationZ_clone_ptr"))) TS_COption_HTLCDestinationZ_clone_ptr(uint64_t arg) {
13531 LDKCOption_HTLCDestinationZ* arg_conv = (LDKCOption_HTLCDestinationZ*)untag_ptr(arg);
13532 int64_t ret_conv = COption_HTLCDestinationZ_clone_ptr(arg_conv);
13536 uint64_t __attribute__((export_name("TS_COption_HTLCDestinationZ_clone"))) TS_COption_HTLCDestinationZ_clone(uint64_t orig) {
13537 LDKCOption_HTLCDestinationZ* orig_conv = (LDKCOption_HTLCDestinationZ*)untag_ptr(orig);
13538 LDKCOption_HTLCDestinationZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCDestinationZ), "LDKCOption_HTLCDestinationZ");
13539 *ret_copy = COption_HTLCDestinationZ_clone(orig_conv);
13540 uint64_t ret_ref = tag_ptr(ret_copy, true);
13544 uint64_t __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_ok"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_ok(uint64_t o) {
13545 void* o_ptr = untag_ptr(o);
13546 CHECK_ACCESS(o_ptr);
13547 LDKCOption_HTLCDestinationZ o_conv = *(LDKCOption_HTLCDestinationZ*)(o_ptr);
13548 o_conv = COption_HTLCDestinationZ_clone((LDKCOption_HTLCDestinationZ*)untag_ptr(o));
13549 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ), "LDKCResult_COption_HTLCDestinationZDecodeErrorZ");
13550 *ret_conv = CResult_COption_HTLCDestinationZDecodeErrorZ_ok(o_conv);
13551 return tag_ptr(ret_conv, true);
13554 uint64_t __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_err"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_err(uint64_t e) {
13555 void* e_ptr = untag_ptr(e);
13556 CHECK_ACCESS(e_ptr);
13557 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
13558 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
13559 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ), "LDKCResult_COption_HTLCDestinationZDecodeErrorZ");
13560 *ret_conv = CResult_COption_HTLCDestinationZDecodeErrorZ_err(e_conv);
13561 return tag_ptr(ret_conv, true);
13564 jboolean __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(uint64_t o) {
13565 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* o_conv = (LDKCResult_COption_HTLCDestinationZDecodeErrorZ*)untag_ptr(o);
13566 jboolean ret_conv = CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(o_conv);
13570 void __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_free"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_free(uint64_t _res) {
13571 if (!ptr_is_owned(_res)) return;
13572 void* _res_ptr = untag_ptr(_res);
13573 CHECK_ACCESS(_res_ptr);
13574 LDKCResult_COption_HTLCDestinationZDecodeErrorZ _res_conv = *(LDKCResult_COption_HTLCDestinationZDecodeErrorZ*)(_res_ptr);
13575 FREE(untag_ptr(_res));
13576 CResult_COption_HTLCDestinationZDecodeErrorZ_free(_res_conv);
13579 static inline uint64_t CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR arg) {
13580 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ), "LDKCResult_COption_HTLCDestinationZDecodeErrorZ");
13581 *ret_conv = CResult_COption_HTLCDestinationZDecodeErrorZ_clone(arg);
13582 return tag_ptr(ret_conv, true);
13584 int64_t __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(uint64_t arg) {
13585 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* arg_conv = (LDKCResult_COption_HTLCDestinationZDecodeErrorZ*)untag_ptr(arg);
13586 int64_t ret_conv = CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(arg_conv);
13590 uint64_t __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone(uint64_t orig) {
13591 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* orig_conv = (LDKCResult_COption_HTLCDestinationZDecodeErrorZ*)untag_ptr(orig);
13592 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ), "LDKCResult_COption_HTLCDestinationZDecodeErrorZ");
13593 *ret_conv = CResult_COption_HTLCDestinationZDecodeErrorZ_clone(orig_conv);
13594 return tag_ptr(ret_conv, true);
13597 uint64_t __attribute__((export_name("TS_COption_u128Z_some"))) TS_COption_u128Z_some(int8_tArray o) {
13599 CHECK(o->arr_len == 16);
13600 memcpy(o_ref.le_bytes, o->elems, 16); FREE(o);
13601 LDKCOption_u128Z *ret_copy = MALLOC(sizeof(LDKCOption_u128Z), "LDKCOption_u128Z");
13602 *ret_copy = COption_u128Z_some(o_ref);
13603 uint64_t ret_ref = tag_ptr(ret_copy, true);
13607 uint64_t __attribute__((export_name("TS_COption_u128Z_none"))) TS_COption_u128Z_none() {
13608 LDKCOption_u128Z *ret_copy = MALLOC(sizeof(LDKCOption_u128Z), "LDKCOption_u128Z");
13609 *ret_copy = COption_u128Z_none();
13610 uint64_t ret_ref = tag_ptr(ret_copy, true);
13614 void __attribute__((export_name("TS_COption_u128Z_free"))) TS_COption_u128Z_free(uint64_t _res) {
13615 if (!ptr_is_owned(_res)) return;
13616 void* _res_ptr = untag_ptr(_res);
13617 CHECK_ACCESS(_res_ptr);
13618 LDKCOption_u128Z _res_conv = *(LDKCOption_u128Z*)(_res_ptr);
13619 FREE(untag_ptr(_res));
13620 COption_u128Z_free(_res_conv);
13623 static inline uint64_t COption_u128Z_clone_ptr(LDKCOption_u128Z *NONNULL_PTR arg) {
13624 LDKCOption_u128Z *ret_copy = MALLOC(sizeof(LDKCOption_u128Z), "LDKCOption_u128Z");
13625 *ret_copy = COption_u128Z_clone(arg);
13626 uint64_t ret_ref = tag_ptr(ret_copy, true);
13629 int64_t __attribute__((export_name("TS_COption_u128Z_clone_ptr"))) TS_COption_u128Z_clone_ptr(uint64_t arg) {
13630 LDKCOption_u128Z* arg_conv = (LDKCOption_u128Z*)untag_ptr(arg);
13631 int64_t ret_conv = COption_u128Z_clone_ptr(arg_conv);
13635 uint64_t __attribute__((export_name("TS_COption_u128Z_clone"))) TS_COption_u128Z_clone(uint64_t orig) {
13636 LDKCOption_u128Z* orig_conv = (LDKCOption_u128Z*)untag_ptr(orig);
13637 LDKCOption_u128Z *ret_copy = MALLOC(sizeof(LDKCOption_u128Z), "LDKCOption_u128Z");
13638 *ret_copy = COption_u128Z_clone(orig_conv);
13639 uint64_t ret_ref = tag_ptr(ret_copy, true);
13643 uint64_t __attribute__((export_name("TS_COption_NetworkUpdateZ_some"))) TS_COption_NetworkUpdateZ_some(uint64_t o) {
13644 void* o_ptr = untag_ptr(o);
13645 CHECK_ACCESS(o_ptr);
13646 LDKNetworkUpdate o_conv = *(LDKNetworkUpdate*)(o_ptr);
13647 o_conv = NetworkUpdate_clone((LDKNetworkUpdate*)untag_ptr(o));
13648 LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
13649 *ret_copy = COption_NetworkUpdateZ_some(o_conv);
13650 uint64_t ret_ref = tag_ptr(ret_copy, true);
13654 uint64_t __attribute__((export_name("TS_COption_NetworkUpdateZ_none"))) TS_COption_NetworkUpdateZ_none() {
13655 LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
13656 *ret_copy = COption_NetworkUpdateZ_none();
13657 uint64_t ret_ref = tag_ptr(ret_copy, true);
13661 void __attribute__((export_name("TS_COption_NetworkUpdateZ_free"))) TS_COption_NetworkUpdateZ_free(uint64_t _res) {
13662 if (!ptr_is_owned(_res)) return;
13663 void* _res_ptr = untag_ptr(_res);
13664 CHECK_ACCESS(_res_ptr);
13665 LDKCOption_NetworkUpdateZ _res_conv = *(LDKCOption_NetworkUpdateZ*)(_res_ptr);
13666 FREE(untag_ptr(_res));
13667 COption_NetworkUpdateZ_free(_res_conv);
13670 static inline uint64_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg) {
13671 LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
13672 *ret_copy = COption_NetworkUpdateZ_clone(arg);
13673 uint64_t ret_ref = tag_ptr(ret_copy, true);
13676 int64_t __attribute__((export_name("TS_COption_NetworkUpdateZ_clone_ptr"))) TS_COption_NetworkUpdateZ_clone_ptr(uint64_t arg) {
13677 LDKCOption_NetworkUpdateZ* arg_conv = (LDKCOption_NetworkUpdateZ*)untag_ptr(arg);
13678 int64_t ret_conv = COption_NetworkUpdateZ_clone_ptr(arg_conv);
13682 uint64_t __attribute__((export_name("TS_COption_NetworkUpdateZ_clone"))) TS_COption_NetworkUpdateZ_clone(uint64_t orig) {
13683 LDKCOption_NetworkUpdateZ* orig_conv = (LDKCOption_NetworkUpdateZ*)untag_ptr(orig);
13684 LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
13685 *ret_copy = COption_NetworkUpdateZ_clone(orig_conv);
13686 uint64_t ret_ref = tag_ptr(ret_copy, true);
13690 void __attribute__((export_name("TS_CVec_SpendableOutputDescriptorZ_free"))) TS_CVec_SpendableOutputDescriptorZ_free(uint64_tArray _res) {
13691 LDKCVec_SpendableOutputDescriptorZ _res_constr;
13692 _res_constr.datalen = _res->arr_len;
13693 if (_res_constr.datalen > 0)
13694 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKSpendableOutputDescriptor), "LDKCVec_SpendableOutputDescriptorZ Elements");
13696 _res_constr.data = NULL;
13697 uint64_t* _res_vals = _res->elems;
13698 for (size_t b = 0; b < _res_constr.datalen; b++) {
13699 uint64_t _res_conv_27 = _res_vals[b];
13700 void* _res_conv_27_ptr = untag_ptr(_res_conv_27);
13701 CHECK_ACCESS(_res_conv_27_ptr);
13702 LDKSpendableOutputDescriptor _res_conv_27_conv = *(LDKSpendableOutputDescriptor*)(_res_conv_27_ptr);
13703 FREE(untag_ptr(_res_conv_27));
13704 _res_constr.data[b] = _res_conv_27_conv;
13707 CVec_SpendableOutputDescriptorZ_free(_res_constr);
13710 uint64_t __attribute__((export_name("TS_COption_EventZ_some"))) TS_COption_EventZ_some(uint64_t o) {
13711 void* o_ptr = untag_ptr(o);
13712 CHECK_ACCESS(o_ptr);
13713 LDKEvent o_conv = *(LDKEvent*)(o_ptr);
13714 o_conv = Event_clone((LDKEvent*)untag_ptr(o));
13715 LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
13716 *ret_copy = COption_EventZ_some(o_conv);
13717 uint64_t ret_ref = tag_ptr(ret_copy, true);
13721 uint64_t __attribute__((export_name("TS_COption_EventZ_none"))) TS_COption_EventZ_none() {
13722 LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
13723 *ret_copy = COption_EventZ_none();
13724 uint64_t ret_ref = tag_ptr(ret_copy, true);
13728 void __attribute__((export_name("TS_COption_EventZ_free"))) TS_COption_EventZ_free(uint64_t _res) {
13729 if (!ptr_is_owned(_res)) return;
13730 void* _res_ptr = untag_ptr(_res);
13731 CHECK_ACCESS(_res_ptr);
13732 LDKCOption_EventZ _res_conv = *(LDKCOption_EventZ*)(_res_ptr);
13733 FREE(untag_ptr(_res));
13734 COption_EventZ_free(_res_conv);
13737 static inline uint64_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg) {
13738 LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
13739 *ret_copy = COption_EventZ_clone(arg);
13740 uint64_t ret_ref = tag_ptr(ret_copy, true);
13743 int64_t __attribute__((export_name("TS_COption_EventZ_clone_ptr"))) TS_COption_EventZ_clone_ptr(uint64_t arg) {
13744 LDKCOption_EventZ* arg_conv = (LDKCOption_EventZ*)untag_ptr(arg);
13745 int64_t ret_conv = COption_EventZ_clone_ptr(arg_conv);
13749 uint64_t __attribute__((export_name("TS_COption_EventZ_clone"))) TS_COption_EventZ_clone(uint64_t orig) {
13750 LDKCOption_EventZ* orig_conv = (LDKCOption_EventZ*)untag_ptr(orig);
13751 LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
13752 *ret_copy = COption_EventZ_clone(orig_conv);
13753 uint64_t ret_ref = tag_ptr(ret_copy, true);
13757 uint64_t __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_ok"))) TS_CResult_COption_EventZDecodeErrorZ_ok(uint64_t o) {
13758 void* o_ptr = untag_ptr(o);
13759 CHECK_ACCESS(o_ptr);
13760 LDKCOption_EventZ o_conv = *(LDKCOption_EventZ*)(o_ptr);
13761 o_conv = COption_EventZ_clone((LDKCOption_EventZ*)untag_ptr(o));
13762 LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
13763 *ret_conv = CResult_COption_EventZDecodeErrorZ_ok(o_conv);
13764 return tag_ptr(ret_conv, true);
13767 uint64_t __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_err"))) TS_CResult_COption_EventZDecodeErrorZ_err(uint64_t e) {
13768 void* e_ptr = untag_ptr(e);
13769 CHECK_ACCESS(e_ptr);
13770 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
13771 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
13772 LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
13773 *ret_conv = CResult_COption_EventZDecodeErrorZ_err(e_conv);
13774 return tag_ptr(ret_conv, true);
13777 jboolean __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_is_ok"))) TS_CResult_COption_EventZDecodeErrorZ_is_ok(uint64_t o) {
13778 LDKCResult_COption_EventZDecodeErrorZ* o_conv = (LDKCResult_COption_EventZDecodeErrorZ*)untag_ptr(o);
13779 jboolean ret_conv = CResult_COption_EventZDecodeErrorZ_is_ok(o_conv);
13783 void __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_free"))) TS_CResult_COption_EventZDecodeErrorZ_free(uint64_t _res) {
13784 if (!ptr_is_owned(_res)) return;
13785 void* _res_ptr = untag_ptr(_res);
13786 CHECK_ACCESS(_res_ptr);
13787 LDKCResult_COption_EventZDecodeErrorZ _res_conv = *(LDKCResult_COption_EventZDecodeErrorZ*)(_res_ptr);
13788 FREE(untag_ptr(_res));
13789 CResult_COption_EventZDecodeErrorZ_free(_res_conv);
13792 static inline uint64_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg) {
13793 LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
13794 *ret_conv = CResult_COption_EventZDecodeErrorZ_clone(arg);
13795 return tag_ptr(ret_conv, true);
13797 int64_t __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_EventZDecodeErrorZ_clone_ptr(uint64_t arg) {
13798 LDKCResult_COption_EventZDecodeErrorZ* arg_conv = (LDKCResult_COption_EventZDecodeErrorZ*)untag_ptr(arg);
13799 int64_t ret_conv = CResult_COption_EventZDecodeErrorZ_clone_ptr(arg_conv);
13803 uint64_t __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_clone"))) TS_CResult_COption_EventZDecodeErrorZ_clone(uint64_t orig) {
13804 LDKCResult_COption_EventZDecodeErrorZ* orig_conv = (LDKCResult_COption_EventZDecodeErrorZ*)untag_ptr(orig);
13805 LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
13806 *ret_conv = CResult_COption_EventZDecodeErrorZ_clone(orig_conv);
13807 return tag_ptr(ret_conv, true);
13810 void __attribute__((export_name("TS_CVec_MessageSendEventZ_free"))) TS_CVec_MessageSendEventZ_free(uint64_tArray _res) {
13811 LDKCVec_MessageSendEventZ _res_constr;
13812 _res_constr.datalen = _res->arr_len;
13813 if (_res_constr.datalen > 0)
13814 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKMessageSendEvent), "LDKCVec_MessageSendEventZ Elements");
13816 _res_constr.data = NULL;
13817 uint64_t* _res_vals = _res->elems;
13818 for (size_t s = 0; s < _res_constr.datalen; s++) {
13819 uint64_t _res_conv_18 = _res_vals[s];
13820 void* _res_conv_18_ptr = untag_ptr(_res_conv_18);
13821 CHECK_ACCESS(_res_conv_18_ptr);
13822 LDKMessageSendEvent _res_conv_18_conv = *(LDKMessageSendEvent*)(_res_conv_18_ptr);
13823 FREE(untag_ptr(_res_conv_18));
13824 _res_constr.data[s] = _res_conv_18_conv;
13827 CVec_MessageSendEventZ_free(_res_constr);
13830 uint64_t __attribute__((export_name("TS_CResult_TxOutAccessErrorZ_ok"))) TS_CResult_TxOutAccessErrorZ_ok(uint64_t o) {
13831 void* o_ptr = untag_ptr(o);
13832 CHECK_ACCESS(o_ptr);
13833 LDKTxOut o_conv = *(LDKTxOut*)(o_ptr);
13834 o_conv = TxOut_clone((LDKTxOut*)untag_ptr(o));
13835 LDKCResult_TxOutAccessErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutAccessErrorZ), "LDKCResult_TxOutAccessErrorZ");
13836 *ret_conv = CResult_TxOutAccessErrorZ_ok(o_conv);
13837 return tag_ptr(ret_conv, true);
13840 uint64_t __attribute__((export_name("TS_CResult_TxOutAccessErrorZ_err"))) TS_CResult_TxOutAccessErrorZ_err(uint32_t e) {
13841 LDKAccessError e_conv = LDKAccessError_from_js(e);
13842 LDKCResult_TxOutAccessErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutAccessErrorZ), "LDKCResult_TxOutAccessErrorZ");
13843 *ret_conv = CResult_TxOutAccessErrorZ_err(e_conv);
13844 return tag_ptr(ret_conv, true);
13847 jboolean __attribute__((export_name("TS_CResult_TxOutAccessErrorZ_is_ok"))) TS_CResult_TxOutAccessErrorZ_is_ok(uint64_t o) {
13848 LDKCResult_TxOutAccessErrorZ* o_conv = (LDKCResult_TxOutAccessErrorZ*)untag_ptr(o);
13849 jboolean ret_conv = CResult_TxOutAccessErrorZ_is_ok(o_conv);
13853 void __attribute__((export_name("TS_CResult_TxOutAccessErrorZ_free"))) TS_CResult_TxOutAccessErrorZ_free(uint64_t _res) {
13854 if (!ptr_is_owned(_res)) return;
13855 void* _res_ptr = untag_ptr(_res);
13856 CHECK_ACCESS(_res_ptr);
13857 LDKCResult_TxOutAccessErrorZ _res_conv = *(LDKCResult_TxOutAccessErrorZ*)(_res_ptr);
13858 FREE(untag_ptr(_res));
13859 CResult_TxOutAccessErrorZ_free(_res_conv);
13862 static inline uint64_t CResult_TxOutAccessErrorZ_clone_ptr(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR arg) {
13863 LDKCResult_TxOutAccessErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutAccessErrorZ), "LDKCResult_TxOutAccessErrorZ");
13864 *ret_conv = CResult_TxOutAccessErrorZ_clone(arg);
13865 return tag_ptr(ret_conv, true);
13867 int64_t __attribute__((export_name("TS_CResult_TxOutAccessErrorZ_clone_ptr"))) TS_CResult_TxOutAccessErrorZ_clone_ptr(uint64_t arg) {
13868 LDKCResult_TxOutAccessErrorZ* arg_conv = (LDKCResult_TxOutAccessErrorZ*)untag_ptr(arg);
13869 int64_t ret_conv = CResult_TxOutAccessErrorZ_clone_ptr(arg_conv);
13873 uint64_t __attribute__((export_name("TS_CResult_TxOutAccessErrorZ_clone"))) TS_CResult_TxOutAccessErrorZ_clone(uint64_t orig) {
13874 LDKCResult_TxOutAccessErrorZ* orig_conv = (LDKCResult_TxOutAccessErrorZ*)untag_ptr(orig);
13875 LDKCResult_TxOutAccessErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutAccessErrorZ), "LDKCResult_TxOutAccessErrorZ");
13876 *ret_conv = CResult_TxOutAccessErrorZ_clone(orig_conv);
13877 return tag_ptr(ret_conv, true);
13880 static inline uint64_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg) {
13881 LDKC2Tuple_usizeTransactionZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
13882 *ret_conv = C2Tuple_usizeTransactionZ_clone(arg);
13883 return tag_ptr(ret_conv, true);
13885 int64_t __attribute__((export_name("TS_C2Tuple_usizeTransactionZ_clone_ptr"))) TS_C2Tuple_usizeTransactionZ_clone_ptr(uint64_t arg) {
13886 LDKC2Tuple_usizeTransactionZ* arg_conv = (LDKC2Tuple_usizeTransactionZ*)untag_ptr(arg);
13887 int64_t ret_conv = C2Tuple_usizeTransactionZ_clone_ptr(arg_conv);
13891 uint64_t __attribute__((export_name("TS_C2Tuple_usizeTransactionZ_clone"))) TS_C2Tuple_usizeTransactionZ_clone(uint64_t orig) {
13892 LDKC2Tuple_usizeTransactionZ* orig_conv = (LDKC2Tuple_usizeTransactionZ*)untag_ptr(orig);
13893 LDKC2Tuple_usizeTransactionZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
13894 *ret_conv = C2Tuple_usizeTransactionZ_clone(orig_conv);
13895 return tag_ptr(ret_conv, true);
13898 uint64_t __attribute__((export_name("TS_C2Tuple_usizeTransactionZ_new"))) TS_C2Tuple_usizeTransactionZ_new(uint32_t a, int8_tArray b) {
13899 LDKTransaction b_ref;
13900 b_ref.datalen = b->arr_len;
13901 b_ref.data = MALLOC(b_ref.datalen, "LDKTransaction Bytes");
13902 memcpy(b_ref.data, b->elems, b_ref.datalen); FREE(b);
13903 b_ref.data_is_owned = true;
13904 LDKC2Tuple_usizeTransactionZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
13905 *ret_conv = C2Tuple_usizeTransactionZ_new(a, b_ref);
13906 return tag_ptr(ret_conv, true);
13909 void __attribute__((export_name("TS_C2Tuple_usizeTransactionZ_free"))) TS_C2Tuple_usizeTransactionZ_free(uint64_t _res) {
13910 if (!ptr_is_owned(_res)) return;
13911 void* _res_ptr = untag_ptr(_res);
13912 CHECK_ACCESS(_res_ptr);
13913 LDKC2Tuple_usizeTransactionZ _res_conv = *(LDKC2Tuple_usizeTransactionZ*)(_res_ptr);
13914 FREE(untag_ptr(_res));
13915 C2Tuple_usizeTransactionZ_free(_res_conv);
13918 void __attribute__((export_name("TS_CVec_C2Tuple_usizeTransactionZZ_free"))) TS_CVec_C2Tuple_usizeTransactionZZ_free(uint64_tArray _res) {
13919 LDKCVec_C2Tuple_usizeTransactionZZ _res_constr;
13920 _res_constr.datalen = _res->arr_len;
13921 if (_res_constr.datalen > 0)
13922 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
13924 _res_constr.data = NULL;
13925 uint64_t* _res_vals = _res->elems;
13926 for (size_t c = 0; c < _res_constr.datalen; c++) {
13927 uint64_t _res_conv_28 = _res_vals[c];
13928 void* _res_conv_28_ptr = untag_ptr(_res_conv_28);
13929 CHECK_ACCESS(_res_conv_28_ptr);
13930 LDKC2Tuple_usizeTransactionZ _res_conv_28_conv = *(LDKC2Tuple_usizeTransactionZ*)(_res_conv_28_ptr);
13931 FREE(untag_ptr(_res_conv_28));
13932 _res_constr.data[c] = _res_conv_28_conv;
13935 CVec_C2Tuple_usizeTransactionZZ_free(_res_constr);
13938 static inline uint64_t C2Tuple_TxidBlockHashZ_clone_ptr(LDKC2Tuple_TxidBlockHashZ *NONNULL_PTR arg) {
13939 LDKC2Tuple_TxidBlockHashZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidBlockHashZ), "LDKC2Tuple_TxidBlockHashZ");
13940 *ret_conv = C2Tuple_TxidBlockHashZ_clone(arg);
13941 return tag_ptr(ret_conv, true);
13943 int64_t __attribute__((export_name("TS_C2Tuple_TxidBlockHashZ_clone_ptr"))) TS_C2Tuple_TxidBlockHashZ_clone_ptr(uint64_t arg) {
13944 LDKC2Tuple_TxidBlockHashZ* arg_conv = (LDKC2Tuple_TxidBlockHashZ*)untag_ptr(arg);
13945 int64_t ret_conv = C2Tuple_TxidBlockHashZ_clone_ptr(arg_conv);
13949 uint64_t __attribute__((export_name("TS_C2Tuple_TxidBlockHashZ_clone"))) TS_C2Tuple_TxidBlockHashZ_clone(uint64_t orig) {
13950 LDKC2Tuple_TxidBlockHashZ* orig_conv = (LDKC2Tuple_TxidBlockHashZ*)untag_ptr(orig);
13951 LDKC2Tuple_TxidBlockHashZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidBlockHashZ), "LDKC2Tuple_TxidBlockHashZ");
13952 *ret_conv = C2Tuple_TxidBlockHashZ_clone(orig_conv);
13953 return tag_ptr(ret_conv, true);
13956 uint64_t __attribute__((export_name("TS_C2Tuple_TxidBlockHashZ_new"))) TS_C2Tuple_TxidBlockHashZ_new(int8_tArray a, int8_tArray b) {
13957 LDKThirtyTwoBytes a_ref;
13958 CHECK(a->arr_len == 32);
13959 memcpy(a_ref.data, a->elems, 32); FREE(a);
13960 LDKThirtyTwoBytes b_ref;
13961 CHECK(b->arr_len == 32);
13962 memcpy(b_ref.data, b->elems, 32); FREE(b);
13963 LDKC2Tuple_TxidBlockHashZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidBlockHashZ), "LDKC2Tuple_TxidBlockHashZ");
13964 *ret_conv = C2Tuple_TxidBlockHashZ_new(a_ref, b_ref);
13965 return tag_ptr(ret_conv, true);
13968 void __attribute__((export_name("TS_C2Tuple_TxidBlockHashZ_free"))) TS_C2Tuple_TxidBlockHashZ_free(uint64_t _res) {
13969 if (!ptr_is_owned(_res)) return;
13970 void* _res_ptr = untag_ptr(_res);
13971 CHECK_ACCESS(_res_ptr);
13972 LDKC2Tuple_TxidBlockHashZ _res_conv = *(LDKC2Tuple_TxidBlockHashZ*)(_res_ptr);
13973 FREE(untag_ptr(_res));
13974 C2Tuple_TxidBlockHashZ_free(_res_conv);
13977 void __attribute__((export_name("TS_CVec_C2Tuple_TxidBlockHashZZ_free"))) TS_CVec_C2Tuple_TxidBlockHashZZ_free(uint64_tArray _res) {
13978 LDKCVec_C2Tuple_TxidBlockHashZZ _res_constr;
13979 _res_constr.datalen = _res->arr_len;
13980 if (_res_constr.datalen > 0)
13981 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_TxidBlockHashZ), "LDKCVec_C2Tuple_TxidBlockHashZZ Elements");
13983 _res_constr.data = NULL;
13984 uint64_t* _res_vals = _res->elems;
13985 for (size_t z = 0; z < _res_constr.datalen; z++) {
13986 uint64_t _res_conv_25 = _res_vals[z];
13987 void* _res_conv_25_ptr = untag_ptr(_res_conv_25);
13988 CHECK_ACCESS(_res_conv_25_ptr);
13989 LDKC2Tuple_TxidBlockHashZ _res_conv_25_conv = *(LDKC2Tuple_TxidBlockHashZ*)(_res_conv_25_ptr);
13990 FREE(untag_ptr(_res_conv_25));
13991 _res_constr.data[z] = _res_conv_25_conv;
13994 CVec_C2Tuple_TxidBlockHashZZ_free(_res_constr);
13997 void __attribute__((export_name("TS_CVec_MonitorEventZ_free"))) TS_CVec_MonitorEventZ_free(uint64_tArray _res) {
13998 LDKCVec_MonitorEventZ _res_constr;
13999 _res_constr.datalen = _res->arr_len;
14000 if (_res_constr.datalen > 0)
14001 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKMonitorEvent), "LDKCVec_MonitorEventZ Elements");
14003 _res_constr.data = NULL;
14004 uint64_t* _res_vals = _res->elems;
14005 for (size_t o = 0; o < _res_constr.datalen; o++) {
14006 uint64_t _res_conv_14 = _res_vals[o];
14007 void* _res_conv_14_ptr = untag_ptr(_res_conv_14);
14008 CHECK_ACCESS(_res_conv_14_ptr);
14009 LDKMonitorEvent _res_conv_14_conv = *(LDKMonitorEvent*)(_res_conv_14_ptr);
14010 FREE(untag_ptr(_res_conv_14));
14011 _res_constr.data[o] = _res_conv_14_conv;
14014 CVec_MonitorEventZ_free(_res_constr);
14017 static inline uint64_t C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR arg) {
14018 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ), "LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ");
14019 *ret_conv = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(arg);
14020 return tag_ptr(ret_conv, true);
14022 int64_t __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(uint64_t arg) {
14023 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* arg_conv = (LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)untag_ptr(arg);
14024 int64_t ret_conv = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(arg_conv);
14028 uint64_t __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(uint64_t orig) {
14029 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* orig_conv = (LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)untag_ptr(orig);
14030 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ), "LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ");
14031 *ret_conv = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(orig_conv);
14032 return tag_ptr(ret_conv, true);
14035 uint64_t __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(uint64_t a, uint64_tArray b, int8_tArray c) {
14036 LDKOutPoint a_conv;
14037 a_conv.inner = untag_ptr(a);
14038 a_conv.is_owned = ptr_is_owned(a);
14039 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
14040 a_conv = OutPoint_clone(&a_conv);
14041 LDKCVec_MonitorEventZ b_constr;
14042 b_constr.datalen = b->arr_len;
14043 if (b_constr.datalen > 0)
14044 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKMonitorEvent), "LDKCVec_MonitorEventZ Elements");
14046 b_constr.data = NULL;
14047 uint64_t* b_vals = b->elems;
14048 for (size_t o = 0; o < b_constr.datalen; o++) {
14049 uint64_t b_conv_14 = b_vals[o];
14050 void* b_conv_14_ptr = untag_ptr(b_conv_14);
14051 CHECK_ACCESS(b_conv_14_ptr);
14052 LDKMonitorEvent b_conv_14_conv = *(LDKMonitorEvent*)(b_conv_14_ptr);
14053 b_conv_14_conv = MonitorEvent_clone((LDKMonitorEvent*)untag_ptr(b_conv_14));
14054 b_constr.data[o] = b_conv_14_conv;
14057 LDKPublicKey c_ref;
14058 CHECK(c->arr_len == 33);
14059 memcpy(c_ref.compressed_form, c->elems, 33); FREE(c);
14060 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ), "LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ");
14061 *ret_conv = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(a_conv, b_constr, c_ref);
14062 return tag_ptr(ret_conv, true);
14065 void __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(uint64_t _res) {
14066 if (!ptr_is_owned(_res)) return;
14067 void* _res_ptr = untag_ptr(_res);
14068 CHECK_ACCESS(_res_ptr);
14069 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ _res_conv = *(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)(_res_ptr);
14070 FREE(untag_ptr(_res));
14071 C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(_res_conv);
14074 void __attribute__((export_name("TS_CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free"))) TS_CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(uint64_tArray _res) {
14075 LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ _res_constr;
14076 _res_constr.datalen = _res->arr_len;
14077 if (_res_constr.datalen > 0)
14078 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ), "LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ Elements");
14080 _res_constr.data = NULL;
14081 uint64_t* _res_vals = _res->elems;
14082 for (size_t x = 0; x < _res_constr.datalen; x++) {
14083 uint64_t _res_conv_49 = _res_vals[x];
14084 void* _res_conv_49_ptr = untag_ptr(_res_conv_49);
14085 CHECK_ACCESS(_res_conv_49_ptr);
14086 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ _res_conv_49_conv = *(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)(_res_conv_49_ptr);
14087 FREE(untag_ptr(_res_conv_49));
14088 _res_constr.data[x] = _res_conv_49_conv;
14091 CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res_constr);
14094 uint64_t __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_ok"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_ok(uint64_t o) {
14095 LDKFixedPenaltyScorer o_conv;
14096 o_conv.inner = untag_ptr(o);
14097 o_conv.is_owned = ptr_is_owned(o);
14098 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14099 o_conv = FixedPenaltyScorer_clone(&o_conv);
14100 LDKCResult_FixedPenaltyScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ), "LDKCResult_FixedPenaltyScorerDecodeErrorZ");
14101 *ret_conv = CResult_FixedPenaltyScorerDecodeErrorZ_ok(o_conv);
14102 return tag_ptr(ret_conv, true);
14105 uint64_t __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_err"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_err(uint64_t e) {
14106 void* e_ptr = untag_ptr(e);
14107 CHECK_ACCESS(e_ptr);
14108 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
14109 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
14110 LDKCResult_FixedPenaltyScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ), "LDKCResult_FixedPenaltyScorerDecodeErrorZ");
14111 *ret_conv = CResult_FixedPenaltyScorerDecodeErrorZ_err(e_conv);
14112 return tag_ptr(ret_conv, true);
14115 jboolean __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_is_ok"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(uint64_t o) {
14116 LDKCResult_FixedPenaltyScorerDecodeErrorZ* o_conv = (LDKCResult_FixedPenaltyScorerDecodeErrorZ*)untag_ptr(o);
14117 jboolean ret_conv = CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o_conv);
14121 void __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_free"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_free(uint64_t _res) {
14122 if (!ptr_is_owned(_res)) return;
14123 void* _res_ptr = untag_ptr(_res);
14124 CHECK_ACCESS(_res_ptr);
14125 LDKCResult_FixedPenaltyScorerDecodeErrorZ _res_conv = *(LDKCResult_FixedPenaltyScorerDecodeErrorZ*)(_res_ptr);
14126 FREE(untag_ptr(_res));
14127 CResult_FixedPenaltyScorerDecodeErrorZ_free(_res_conv);
14130 static inline uint64_t CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR arg) {
14131 LDKCResult_FixedPenaltyScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ), "LDKCResult_FixedPenaltyScorerDecodeErrorZ");
14132 *ret_conv = CResult_FixedPenaltyScorerDecodeErrorZ_clone(arg);
14133 return tag_ptr(ret_conv, true);
14135 int64_t __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(uint64_t arg) {
14136 LDKCResult_FixedPenaltyScorerDecodeErrorZ* arg_conv = (LDKCResult_FixedPenaltyScorerDecodeErrorZ*)untag_ptr(arg);
14137 int64_t ret_conv = CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg_conv);
14141 uint64_t __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone(uint64_t orig) {
14142 LDKCResult_FixedPenaltyScorerDecodeErrorZ* orig_conv = (LDKCResult_FixedPenaltyScorerDecodeErrorZ*)untag_ptr(orig);
14143 LDKCResult_FixedPenaltyScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ), "LDKCResult_FixedPenaltyScorerDecodeErrorZ");
14144 *ret_conv = CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig_conv);
14145 return tag_ptr(ret_conv, true);
14148 static inline uint64_t C2Tuple_u64u64Z_clone_ptr(LDKC2Tuple_u64u64Z *NONNULL_PTR arg) {
14149 LDKC2Tuple_u64u64Z* ret_conv = MALLOC(sizeof(LDKC2Tuple_u64u64Z), "LDKC2Tuple_u64u64Z");
14150 *ret_conv = C2Tuple_u64u64Z_clone(arg);
14151 return tag_ptr(ret_conv, true);
14153 int64_t __attribute__((export_name("TS_C2Tuple_u64u64Z_clone_ptr"))) TS_C2Tuple_u64u64Z_clone_ptr(uint64_t arg) {
14154 LDKC2Tuple_u64u64Z* arg_conv = (LDKC2Tuple_u64u64Z*)untag_ptr(arg);
14155 int64_t ret_conv = C2Tuple_u64u64Z_clone_ptr(arg_conv);
14159 uint64_t __attribute__((export_name("TS_C2Tuple_u64u64Z_clone"))) TS_C2Tuple_u64u64Z_clone(uint64_t orig) {
14160 LDKC2Tuple_u64u64Z* orig_conv = (LDKC2Tuple_u64u64Z*)untag_ptr(orig);
14161 LDKC2Tuple_u64u64Z* ret_conv = MALLOC(sizeof(LDKC2Tuple_u64u64Z), "LDKC2Tuple_u64u64Z");
14162 *ret_conv = C2Tuple_u64u64Z_clone(orig_conv);
14163 return tag_ptr(ret_conv, true);
14166 uint64_t __attribute__((export_name("TS_C2Tuple_u64u64Z_new"))) TS_C2Tuple_u64u64Z_new(int64_t a, int64_t b) {
14167 LDKC2Tuple_u64u64Z* ret_conv = MALLOC(sizeof(LDKC2Tuple_u64u64Z), "LDKC2Tuple_u64u64Z");
14168 *ret_conv = C2Tuple_u64u64Z_new(a, b);
14169 return tag_ptr(ret_conv, true);
14172 void __attribute__((export_name("TS_C2Tuple_u64u64Z_free"))) TS_C2Tuple_u64u64Z_free(uint64_t _res) {
14173 if (!ptr_is_owned(_res)) return;
14174 void* _res_ptr = untag_ptr(_res);
14175 CHECK_ACCESS(_res_ptr);
14176 LDKC2Tuple_u64u64Z _res_conv = *(LDKC2Tuple_u64u64Z*)(_res_ptr);
14177 FREE(untag_ptr(_res));
14178 C2Tuple_u64u64Z_free(_res_conv);
14181 uint64_t __attribute__((export_name("TS_COption_C2Tuple_u64u64ZZ_some"))) TS_COption_C2Tuple_u64u64ZZ_some(uint64_t o) {
14182 void* o_ptr = untag_ptr(o);
14183 CHECK_ACCESS(o_ptr);
14184 LDKC2Tuple_u64u64Z o_conv = *(LDKC2Tuple_u64u64Z*)(o_ptr);
14185 o_conv = C2Tuple_u64u64Z_clone((LDKC2Tuple_u64u64Z*)untag_ptr(o));
14186 LDKCOption_C2Tuple_u64u64ZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_u64u64ZZ), "LDKCOption_C2Tuple_u64u64ZZ");
14187 *ret_copy = COption_C2Tuple_u64u64ZZ_some(o_conv);
14188 uint64_t ret_ref = tag_ptr(ret_copy, true);
14192 uint64_t __attribute__((export_name("TS_COption_C2Tuple_u64u64ZZ_none"))) TS_COption_C2Tuple_u64u64ZZ_none() {
14193 LDKCOption_C2Tuple_u64u64ZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_u64u64ZZ), "LDKCOption_C2Tuple_u64u64ZZ");
14194 *ret_copy = COption_C2Tuple_u64u64ZZ_none();
14195 uint64_t ret_ref = tag_ptr(ret_copy, true);
14199 void __attribute__((export_name("TS_COption_C2Tuple_u64u64ZZ_free"))) TS_COption_C2Tuple_u64u64ZZ_free(uint64_t _res) {
14200 if (!ptr_is_owned(_res)) return;
14201 void* _res_ptr = untag_ptr(_res);
14202 CHECK_ACCESS(_res_ptr);
14203 LDKCOption_C2Tuple_u64u64ZZ _res_conv = *(LDKCOption_C2Tuple_u64u64ZZ*)(_res_ptr);
14204 FREE(untag_ptr(_res));
14205 COption_C2Tuple_u64u64ZZ_free(_res_conv);
14208 static inline uint64_t COption_C2Tuple_u64u64ZZ_clone_ptr(LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR arg) {
14209 LDKCOption_C2Tuple_u64u64ZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_u64u64ZZ), "LDKCOption_C2Tuple_u64u64ZZ");
14210 *ret_copy = COption_C2Tuple_u64u64ZZ_clone(arg);
14211 uint64_t ret_ref = tag_ptr(ret_copy, true);
14214 int64_t __attribute__((export_name("TS_COption_C2Tuple_u64u64ZZ_clone_ptr"))) TS_COption_C2Tuple_u64u64ZZ_clone_ptr(uint64_t arg) {
14215 LDKCOption_C2Tuple_u64u64ZZ* arg_conv = (LDKCOption_C2Tuple_u64u64ZZ*)untag_ptr(arg);
14216 int64_t ret_conv = COption_C2Tuple_u64u64ZZ_clone_ptr(arg_conv);
14220 uint64_t __attribute__((export_name("TS_COption_C2Tuple_u64u64ZZ_clone"))) TS_COption_C2Tuple_u64u64ZZ_clone(uint64_t orig) {
14221 LDKCOption_C2Tuple_u64u64ZZ* orig_conv = (LDKCOption_C2Tuple_u64u64ZZ*)untag_ptr(orig);
14222 LDKCOption_C2Tuple_u64u64ZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_u64u64ZZ), "LDKCOption_C2Tuple_u64u64ZZ");
14223 *ret_copy = COption_C2Tuple_u64u64ZZ_clone(orig_conv);
14224 uint64_t ret_ref = tag_ptr(ret_copy, true);
14228 void __attribute__((export_name("TS_CVec_NodeIdZ_free"))) TS_CVec_NodeIdZ_free(uint64_tArray _res) {
14229 LDKCVec_NodeIdZ _res_constr;
14230 _res_constr.datalen = _res->arr_len;
14231 if (_res_constr.datalen > 0)
14232 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKNodeId), "LDKCVec_NodeIdZ Elements");
14234 _res_constr.data = NULL;
14235 uint64_t* _res_vals = _res->elems;
14236 for (size_t i = 0; i < _res_constr.datalen; i++) {
14237 uint64_t _res_conv_8 = _res_vals[i];
14238 LDKNodeId _res_conv_8_conv;
14239 _res_conv_8_conv.inner = untag_ptr(_res_conv_8);
14240 _res_conv_8_conv.is_owned = ptr_is_owned(_res_conv_8);
14241 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_8_conv);
14242 _res_constr.data[i] = _res_conv_8_conv;
14245 CVec_NodeIdZ_free(_res_constr);
14248 uint64_t __attribute__((export_name("TS_CResult_ProbabilisticScorerDecodeErrorZ_ok"))) TS_CResult_ProbabilisticScorerDecodeErrorZ_ok(uint64_t o) {
14249 LDKProbabilisticScorer o_conv;
14250 o_conv.inner = untag_ptr(o);
14251 o_conv.is_owned = ptr_is_owned(o);
14252 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14253 // WARNING: we need a move here but no clone is available for LDKProbabilisticScorer
14255 LDKCResult_ProbabilisticScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ProbabilisticScorerDecodeErrorZ), "LDKCResult_ProbabilisticScorerDecodeErrorZ");
14256 *ret_conv = CResult_ProbabilisticScorerDecodeErrorZ_ok(o_conv);
14257 return tag_ptr(ret_conv, true);
14260 uint64_t __attribute__((export_name("TS_CResult_ProbabilisticScorerDecodeErrorZ_err"))) TS_CResult_ProbabilisticScorerDecodeErrorZ_err(uint64_t e) {
14261 void* e_ptr = untag_ptr(e);
14262 CHECK_ACCESS(e_ptr);
14263 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
14264 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
14265 LDKCResult_ProbabilisticScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ProbabilisticScorerDecodeErrorZ), "LDKCResult_ProbabilisticScorerDecodeErrorZ");
14266 *ret_conv = CResult_ProbabilisticScorerDecodeErrorZ_err(e_conv);
14267 return tag_ptr(ret_conv, true);
14270 jboolean __attribute__((export_name("TS_CResult_ProbabilisticScorerDecodeErrorZ_is_ok"))) TS_CResult_ProbabilisticScorerDecodeErrorZ_is_ok(uint64_t o) {
14271 LDKCResult_ProbabilisticScorerDecodeErrorZ* o_conv = (LDKCResult_ProbabilisticScorerDecodeErrorZ*)untag_ptr(o);
14272 jboolean ret_conv = CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o_conv);
14276 void __attribute__((export_name("TS_CResult_ProbabilisticScorerDecodeErrorZ_free"))) TS_CResult_ProbabilisticScorerDecodeErrorZ_free(uint64_t _res) {
14277 if (!ptr_is_owned(_res)) return;
14278 void* _res_ptr = untag_ptr(_res);
14279 CHECK_ACCESS(_res_ptr);
14280 LDKCResult_ProbabilisticScorerDecodeErrorZ _res_conv = *(LDKCResult_ProbabilisticScorerDecodeErrorZ*)(_res_ptr);
14281 FREE(untag_ptr(_res));
14282 CResult_ProbabilisticScorerDecodeErrorZ_free(_res_conv);
14285 uint64_t __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_ok"))) TS_CResult_InitFeaturesDecodeErrorZ_ok(uint64_t o) {
14286 LDKInitFeatures o_conv;
14287 o_conv.inner = untag_ptr(o);
14288 o_conv.is_owned = ptr_is_owned(o);
14289 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14290 o_conv = InitFeatures_clone(&o_conv);
14291 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
14292 *ret_conv = CResult_InitFeaturesDecodeErrorZ_ok(o_conv);
14293 return tag_ptr(ret_conv, true);
14296 uint64_t __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_err"))) TS_CResult_InitFeaturesDecodeErrorZ_err(uint64_t e) {
14297 void* e_ptr = untag_ptr(e);
14298 CHECK_ACCESS(e_ptr);
14299 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
14300 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
14301 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
14302 *ret_conv = CResult_InitFeaturesDecodeErrorZ_err(e_conv);
14303 return tag_ptr(ret_conv, true);
14306 jboolean __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_is_ok"))) TS_CResult_InitFeaturesDecodeErrorZ_is_ok(uint64_t o) {
14307 LDKCResult_InitFeaturesDecodeErrorZ* o_conv = (LDKCResult_InitFeaturesDecodeErrorZ*)untag_ptr(o);
14308 jboolean ret_conv = CResult_InitFeaturesDecodeErrorZ_is_ok(o_conv);
14312 void __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_free"))) TS_CResult_InitFeaturesDecodeErrorZ_free(uint64_t _res) {
14313 if (!ptr_is_owned(_res)) return;
14314 void* _res_ptr = untag_ptr(_res);
14315 CHECK_ACCESS(_res_ptr);
14316 LDKCResult_InitFeaturesDecodeErrorZ _res_conv = *(LDKCResult_InitFeaturesDecodeErrorZ*)(_res_ptr);
14317 FREE(untag_ptr(_res));
14318 CResult_InitFeaturesDecodeErrorZ_free(_res_conv);
14321 static inline uint64_t CResult_InitFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR arg) {
14322 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
14323 *ret_conv = CResult_InitFeaturesDecodeErrorZ_clone(arg);
14324 return tag_ptr(ret_conv, true);
14326 int64_t __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_clone_ptr"))) TS_CResult_InitFeaturesDecodeErrorZ_clone_ptr(uint64_t arg) {
14327 LDKCResult_InitFeaturesDecodeErrorZ* arg_conv = (LDKCResult_InitFeaturesDecodeErrorZ*)untag_ptr(arg);
14328 int64_t ret_conv = CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg_conv);
14332 uint64_t __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_clone"))) TS_CResult_InitFeaturesDecodeErrorZ_clone(uint64_t orig) {
14333 LDKCResult_InitFeaturesDecodeErrorZ* orig_conv = (LDKCResult_InitFeaturesDecodeErrorZ*)untag_ptr(orig);
14334 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
14335 *ret_conv = CResult_InitFeaturesDecodeErrorZ_clone(orig_conv);
14336 return tag_ptr(ret_conv, true);
14339 uint64_t __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_ok"))) TS_CResult_ChannelFeaturesDecodeErrorZ_ok(uint64_t o) {
14340 LDKChannelFeatures o_conv;
14341 o_conv.inner = untag_ptr(o);
14342 o_conv.is_owned = ptr_is_owned(o);
14343 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14344 o_conv = ChannelFeatures_clone(&o_conv);
14345 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
14346 *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_ok(o_conv);
14347 return tag_ptr(ret_conv, true);
14350 uint64_t __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_err"))) TS_CResult_ChannelFeaturesDecodeErrorZ_err(uint64_t e) {
14351 void* e_ptr = untag_ptr(e);
14352 CHECK_ACCESS(e_ptr);
14353 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
14354 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
14355 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
14356 *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_err(e_conv);
14357 return tag_ptr(ret_conv, true);
14360 jboolean __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok"))) TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok(uint64_t o) {
14361 LDKCResult_ChannelFeaturesDecodeErrorZ* o_conv = (LDKCResult_ChannelFeaturesDecodeErrorZ*)untag_ptr(o);
14362 jboolean ret_conv = CResult_ChannelFeaturesDecodeErrorZ_is_ok(o_conv);
14366 void __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_free"))) TS_CResult_ChannelFeaturesDecodeErrorZ_free(uint64_t _res) {
14367 if (!ptr_is_owned(_res)) return;
14368 void* _res_ptr = untag_ptr(_res);
14369 CHECK_ACCESS(_res_ptr);
14370 LDKCResult_ChannelFeaturesDecodeErrorZ _res_conv = *(LDKCResult_ChannelFeaturesDecodeErrorZ*)(_res_ptr);
14371 FREE(untag_ptr(_res));
14372 CResult_ChannelFeaturesDecodeErrorZ_free(_res_conv);
14375 static inline uint64_t CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR arg) {
14376 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
14377 *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_clone(arg);
14378 return tag_ptr(ret_conv, true);
14380 int64_t __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(uint64_t arg) {
14381 LDKCResult_ChannelFeaturesDecodeErrorZ* arg_conv = (LDKCResult_ChannelFeaturesDecodeErrorZ*)untag_ptr(arg);
14382 int64_t ret_conv = CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg_conv);
14386 uint64_t __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_clone"))) TS_CResult_ChannelFeaturesDecodeErrorZ_clone(uint64_t orig) {
14387 LDKCResult_ChannelFeaturesDecodeErrorZ* orig_conv = (LDKCResult_ChannelFeaturesDecodeErrorZ*)untag_ptr(orig);
14388 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
14389 *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_clone(orig_conv);
14390 return tag_ptr(ret_conv, true);
14393 uint64_t __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_ok"))) TS_CResult_NodeFeaturesDecodeErrorZ_ok(uint64_t o) {
14394 LDKNodeFeatures o_conv;
14395 o_conv.inner = untag_ptr(o);
14396 o_conv.is_owned = ptr_is_owned(o);
14397 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14398 o_conv = NodeFeatures_clone(&o_conv);
14399 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
14400 *ret_conv = CResult_NodeFeaturesDecodeErrorZ_ok(o_conv);
14401 return tag_ptr(ret_conv, true);
14404 uint64_t __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_err"))) TS_CResult_NodeFeaturesDecodeErrorZ_err(uint64_t e) {
14405 void* e_ptr = untag_ptr(e);
14406 CHECK_ACCESS(e_ptr);
14407 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
14408 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
14409 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
14410 *ret_conv = CResult_NodeFeaturesDecodeErrorZ_err(e_conv);
14411 return tag_ptr(ret_conv, true);
14414 jboolean __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_is_ok"))) TS_CResult_NodeFeaturesDecodeErrorZ_is_ok(uint64_t o) {
14415 LDKCResult_NodeFeaturesDecodeErrorZ* o_conv = (LDKCResult_NodeFeaturesDecodeErrorZ*)untag_ptr(o);
14416 jboolean ret_conv = CResult_NodeFeaturesDecodeErrorZ_is_ok(o_conv);
14420 void __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_free"))) TS_CResult_NodeFeaturesDecodeErrorZ_free(uint64_t _res) {
14421 if (!ptr_is_owned(_res)) return;
14422 void* _res_ptr = untag_ptr(_res);
14423 CHECK_ACCESS(_res_ptr);
14424 LDKCResult_NodeFeaturesDecodeErrorZ _res_conv = *(LDKCResult_NodeFeaturesDecodeErrorZ*)(_res_ptr);
14425 FREE(untag_ptr(_res));
14426 CResult_NodeFeaturesDecodeErrorZ_free(_res_conv);
14429 static inline uint64_t CResult_NodeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR arg) {
14430 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
14431 *ret_conv = CResult_NodeFeaturesDecodeErrorZ_clone(arg);
14432 return tag_ptr(ret_conv, true);
14434 int64_t __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_clone_ptr"))) TS_CResult_NodeFeaturesDecodeErrorZ_clone_ptr(uint64_t arg) {
14435 LDKCResult_NodeFeaturesDecodeErrorZ* arg_conv = (LDKCResult_NodeFeaturesDecodeErrorZ*)untag_ptr(arg);
14436 int64_t ret_conv = CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg_conv);
14440 uint64_t __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_clone"))) TS_CResult_NodeFeaturesDecodeErrorZ_clone(uint64_t orig) {
14441 LDKCResult_NodeFeaturesDecodeErrorZ* orig_conv = (LDKCResult_NodeFeaturesDecodeErrorZ*)untag_ptr(orig);
14442 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
14443 *ret_conv = CResult_NodeFeaturesDecodeErrorZ_clone(orig_conv);
14444 return tag_ptr(ret_conv, true);
14447 uint64_t __attribute__((export_name("TS_CResult_InvoiceFeaturesDecodeErrorZ_ok"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_ok(uint64_t o) {
14448 LDKInvoiceFeatures o_conv;
14449 o_conv.inner = untag_ptr(o);
14450 o_conv.is_owned = ptr_is_owned(o);
14451 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14452 o_conv = InvoiceFeatures_clone(&o_conv);
14453 LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
14454 *ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_ok(o_conv);
14455 return tag_ptr(ret_conv, true);
14458 uint64_t __attribute__((export_name("TS_CResult_InvoiceFeaturesDecodeErrorZ_err"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_err(uint64_t e) {
14459 void* e_ptr = untag_ptr(e);
14460 CHECK_ACCESS(e_ptr);
14461 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
14462 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
14463 LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
14464 *ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_err(e_conv);
14465 return tag_ptr(ret_conv, true);
14468 jboolean __attribute__((export_name("TS_CResult_InvoiceFeaturesDecodeErrorZ_is_ok"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_is_ok(uint64_t o) {
14469 LDKCResult_InvoiceFeaturesDecodeErrorZ* o_conv = (LDKCResult_InvoiceFeaturesDecodeErrorZ*)untag_ptr(o);
14470 jboolean ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o_conv);
14474 void __attribute__((export_name("TS_CResult_InvoiceFeaturesDecodeErrorZ_free"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_free(uint64_t _res) {
14475 if (!ptr_is_owned(_res)) return;
14476 void* _res_ptr = untag_ptr(_res);
14477 CHECK_ACCESS(_res_ptr);
14478 LDKCResult_InvoiceFeaturesDecodeErrorZ _res_conv = *(LDKCResult_InvoiceFeaturesDecodeErrorZ*)(_res_ptr);
14479 FREE(untag_ptr(_res));
14480 CResult_InvoiceFeaturesDecodeErrorZ_free(_res_conv);
14483 static inline uint64_t CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR arg) {
14484 LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
14485 *ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_clone(arg);
14486 return tag_ptr(ret_conv, true);
14488 int64_t __attribute__((export_name("TS_CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(uint64_t arg) {
14489 LDKCResult_InvoiceFeaturesDecodeErrorZ* arg_conv = (LDKCResult_InvoiceFeaturesDecodeErrorZ*)untag_ptr(arg);
14490 int64_t ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(arg_conv);
14494 uint64_t __attribute__((export_name("TS_CResult_InvoiceFeaturesDecodeErrorZ_clone"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_clone(uint64_t orig) {
14495 LDKCResult_InvoiceFeaturesDecodeErrorZ* orig_conv = (LDKCResult_InvoiceFeaturesDecodeErrorZ*)untag_ptr(orig);
14496 LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
14497 *ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_clone(orig_conv);
14498 return tag_ptr(ret_conv, true);
14501 uint64_t __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok(uint64_t o) {
14502 LDKChannelTypeFeatures o_conv;
14503 o_conv.inner = untag_ptr(o);
14504 o_conv.is_owned = ptr_is_owned(o);
14505 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14506 o_conv = ChannelTypeFeatures_clone(&o_conv);
14507 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ), "LDKCResult_ChannelTypeFeaturesDecodeErrorZ");
14508 *ret_conv = CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o_conv);
14509 return tag_ptr(ret_conv, true);
14512 uint64_t __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err(uint64_t e) {
14513 void* e_ptr = untag_ptr(e);
14514 CHECK_ACCESS(e_ptr);
14515 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
14516 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
14517 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ), "LDKCResult_ChannelTypeFeaturesDecodeErrorZ");
14518 *ret_conv = CResult_ChannelTypeFeaturesDecodeErrorZ_err(e_conv);
14519 return tag_ptr(ret_conv, true);
14522 jboolean __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(uint64_t o) {
14523 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* o_conv = (LDKCResult_ChannelTypeFeaturesDecodeErrorZ*)untag_ptr(o);
14524 jboolean ret_conv = CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o_conv);
14528 void __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free(uint64_t _res) {
14529 if (!ptr_is_owned(_res)) return;
14530 void* _res_ptr = untag_ptr(_res);
14531 CHECK_ACCESS(_res_ptr);
14532 LDKCResult_ChannelTypeFeaturesDecodeErrorZ _res_conv = *(LDKCResult_ChannelTypeFeaturesDecodeErrorZ*)(_res_ptr);
14533 FREE(untag_ptr(_res));
14534 CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res_conv);
14537 static inline uint64_t CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR arg) {
14538 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ), "LDKCResult_ChannelTypeFeaturesDecodeErrorZ");
14539 *ret_conv = CResult_ChannelTypeFeaturesDecodeErrorZ_clone(arg);
14540 return tag_ptr(ret_conv, true);
14542 int64_t __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(uint64_t arg) {
14543 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* arg_conv = (LDKCResult_ChannelTypeFeaturesDecodeErrorZ*)untag_ptr(arg);
14544 int64_t ret_conv = CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg_conv);
14548 uint64_t __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone(uint64_t orig) {
14549 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* orig_conv = (LDKCResult_ChannelTypeFeaturesDecodeErrorZ*)untag_ptr(orig);
14550 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ), "LDKCResult_ChannelTypeFeaturesDecodeErrorZ");
14551 *ret_conv = CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig_conv);
14552 return tag_ptr(ret_conv, true);
14555 uint64_t __attribute__((export_name("TS_CResult_OfferFeaturesDecodeErrorZ_ok"))) TS_CResult_OfferFeaturesDecodeErrorZ_ok(uint64_t o) {
14556 LDKOfferFeatures o_conv;
14557 o_conv.inner = untag_ptr(o);
14558 o_conv.is_owned = ptr_is_owned(o);
14559 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14560 o_conv = OfferFeatures_clone(&o_conv);
14561 LDKCResult_OfferFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OfferFeaturesDecodeErrorZ), "LDKCResult_OfferFeaturesDecodeErrorZ");
14562 *ret_conv = CResult_OfferFeaturesDecodeErrorZ_ok(o_conv);
14563 return tag_ptr(ret_conv, true);
14566 uint64_t __attribute__((export_name("TS_CResult_OfferFeaturesDecodeErrorZ_err"))) TS_CResult_OfferFeaturesDecodeErrorZ_err(uint64_t e) {
14567 void* e_ptr = untag_ptr(e);
14568 CHECK_ACCESS(e_ptr);
14569 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
14570 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
14571 LDKCResult_OfferFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OfferFeaturesDecodeErrorZ), "LDKCResult_OfferFeaturesDecodeErrorZ");
14572 *ret_conv = CResult_OfferFeaturesDecodeErrorZ_err(e_conv);
14573 return tag_ptr(ret_conv, true);
14576 jboolean __attribute__((export_name("TS_CResult_OfferFeaturesDecodeErrorZ_is_ok"))) TS_CResult_OfferFeaturesDecodeErrorZ_is_ok(uint64_t o) {
14577 LDKCResult_OfferFeaturesDecodeErrorZ* o_conv = (LDKCResult_OfferFeaturesDecodeErrorZ*)untag_ptr(o);
14578 jboolean ret_conv = CResult_OfferFeaturesDecodeErrorZ_is_ok(o_conv);
14582 void __attribute__((export_name("TS_CResult_OfferFeaturesDecodeErrorZ_free"))) TS_CResult_OfferFeaturesDecodeErrorZ_free(uint64_t _res) {
14583 if (!ptr_is_owned(_res)) return;
14584 void* _res_ptr = untag_ptr(_res);
14585 CHECK_ACCESS(_res_ptr);
14586 LDKCResult_OfferFeaturesDecodeErrorZ _res_conv = *(LDKCResult_OfferFeaturesDecodeErrorZ*)(_res_ptr);
14587 FREE(untag_ptr(_res));
14588 CResult_OfferFeaturesDecodeErrorZ_free(_res_conv);
14591 static inline uint64_t CResult_OfferFeaturesDecodeErrorZ_clone_ptr(LDKCResult_OfferFeaturesDecodeErrorZ *NONNULL_PTR arg) {
14592 LDKCResult_OfferFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OfferFeaturesDecodeErrorZ), "LDKCResult_OfferFeaturesDecodeErrorZ");
14593 *ret_conv = CResult_OfferFeaturesDecodeErrorZ_clone(arg);
14594 return tag_ptr(ret_conv, true);
14596 int64_t __attribute__((export_name("TS_CResult_OfferFeaturesDecodeErrorZ_clone_ptr"))) TS_CResult_OfferFeaturesDecodeErrorZ_clone_ptr(uint64_t arg) {
14597 LDKCResult_OfferFeaturesDecodeErrorZ* arg_conv = (LDKCResult_OfferFeaturesDecodeErrorZ*)untag_ptr(arg);
14598 int64_t ret_conv = CResult_OfferFeaturesDecodeErrorZ_clone_ptr(arg_conv);
14602 uint64_t __attribute__((export_name("TS_CResult_OfferFeaturesDecodeErrorZ_clone"))) TS_CResult_OfferFeaturesDecodeErrorZ_clone(uint64_t orig) {
14603 LDKCResult_OfferFeaturesDecodeErrorZ* orig_conv = (LDKCResult_OfferFeaturesDecodeErrorZ*)untag_ptr(orig);
14604 LDKCResult_OfferFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OfferFeaturesDecodeErrorZ), "LDKCResult_OfferFeaturesDecodeErrorZ");
14605 *ret_conv = CResult_OfferFeaturesDecodeErrorZ_clone(orig_conv);
14606 return tag_ptr(ret_conv, true);
14609 uint64_t __attribute__((export_name("TS_CResult_InvoiceRequestFeaturesDecodeErrorZ_ok"))) TS_CResult_InvoiceRequestFeaturesDecodeErrorZ_ok(uint64_t o) {
14610 LDKInvoiceRequestFeatures o_conv;
14611 o_conv.inner = untag_ptr(o);
14612 o_conv.is_owned = ptr_is_owned(o);
14613 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14614 o_conv = InvoiceRequestFeatures_clone(&o_conv);
14615 LDKCResult_InvoiceRequestFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceRequestFeaturesDecodeErrorZ), "LDKCResult_InvoiceRequestFeaturesDecodeErrorZ");
14616 *ret_conv = CResult_InvoiceRequestFeaturesDecodeErrorZ_ok(o_conv);
14617 return tag_ptr(ret_conv, true);
14620 uint64_t __attribute__((export_name("TS_CResult_InvoiceRequestFeaturesDecodeErrorZ_err"))) TS_CResult_InvoiceRequestFeaturesDecodeErrorZ_err(uint64_t e) {
14621 void* e_ptr = untag_ptr(e);
14622 CHECK_ACCESS(e_ptr);
14623 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
14624 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
14625 LDKCResult_InvoiceRequestFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceRequestFeaturesDecodeErrorZ), "LDKCResult_InvoiceRequestFeaturesDecodeErrorZ");
14626 *ret_conv = CResult_InvoiceRequestFeaturesDecodeErrorZ_err(e_conv);
14627 return tag_ptr(ret_conv, true);
14630 jboolean __attribute__((export_name("TS_CResult_InvoiceRequestFeaturesDecodeErrorZ_is_ok"))) TS_CResult_InvoiceRequestFeaturesDecodeErrorZ_is_ok(uint64_t o) {
14631 LDKCResult_InvoiceRequestFeaturesDecodeErrorZ* o_conv = (LDKCResult_InvoiceRequestFeaturesDecodeErrorZ*)untag_ptr(o);
14632 jboolean ret_conv = CResult_InvoiceRequestFeaturesDecodeErrorZ_is_ok(o_conv);
14636 void __attribute__((export_name("TS_CResult_InvoiceRequestFeaturesDecodeErrorZ_free"))) TS_CResult_InvoiceRequestFeaturesDecodeErrorZ_free(uint64_t _res) {
14637 if (!ptr_is_owned(_res)) return;
14638 void* _res_ptr = untag_ptr(_res);
14639 CHECK_ACCESS(_res_ptr);
14640 LDKCResult_InvoiceRequestFeaturesDecodeErrorZ _res_conv = *(LDKCResult_InvoiceRequestFeaturesDecodeErrorZ*)(_res_ptr);
14641 FREE(untag_ptr(_res));
14642 CResult_InvoiceRequestFeaturesDecodeErrorZ_free(_res_conv);
14645 static inline uint64_t CResult_InvoiceRequestFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InvoiceRequestFeaturesDecodeErrorZ *NONNULL_PTR arg) {
14646 LDKCResult_InvoiceRequestFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceRequestFeaturesDecodeErrorZ), "LDKCResult_InvoiceRequestFeaturesDecodeErrorZ");
14647 *ret_conv = CResult_InvoiceRequestFeaturesDecodeErrorZ_clone(arg);
14648 return tag_ptr(ret_conv, true);
14650 int64_t __attribute__((export_name("TS_CResult_InvoiceRequestFeaturesDecodeErrorZ_clone_ptr"))) TS_CResult_InvoiceRequestFeaturesDecodeErrorZ_clone_ptr(uint64_t arg) {
14651 LDKCResult_InvoiceRequestFeaturesDecodeErrorZ* arg_conv = (LDKCResult_InvoiceRequestFeaturesDecodeErrorZ*)untag_ptr(arg);
14652 int64_t ret_conv = CResult_InvoiceRequestFeaturesDecodeErrorZ_clone_ptr(arg_conv);
14656 uint64_t __attribute__((export_name("TS_CResult_InvoiceRequestFeaturesDecodeErrorZ_clone"))) TS_CResult_InvoiceRequestFeaturesDecodeErrorZ_clone(uint64_t orig) {
14657 LDKCResult_InvoiceRequestFeaturesDecodeErrorZ* orig_conv = (LDKCResult_InvoiceRequestFeaturesDecodeErrorZ*)untag_ptr(orig);
14658 LDKCResult_InvoiceRequestFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceRequestFeaturesDecodeErrorZ), "LDKCResult_InvoiceRequestFeaturesDecodeErrorZ");
14659 *ret_conv = CResult_InvoiceRequestFeaturesDecodeErrorZ_clone(orig_conv);
14660 return tag_ptr(ret_conv, true);
14663 uint64_t __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_ok"))) TS_CResult_NodeIdDecodeErrorZ_ok(uint64_t o) {
14665 o_conv.inner = untag_ptr(o);
14666 o_conv.is_owned = ptr_is_owned(o);
14667 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14668 o_conv = NodeId_clone(&o_conv);
14669 LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
14670 *ret_conv = CResult_NodeIdDecodeErrorZ_ok(o_conv);
14671 return tag_ptr(ret_conv, true);
14674 uint64_t __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_err"))) TS_CResult_NodeIdDecodeErrorZ_err(uint64_t e) {
14675 void* e_ptr = untag_ptr(e);
14676 CHECK_ACCESS(e_ptr);
14677 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
14678 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
14679 LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
14680 *ret_conv = CResult_NodeIdDecodeErrorZ_err(e_conv);
14681 return tag_ptr(ret_conv, true);
14684 jboolean __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_is_ok"))) TS_CResult_NodeIdDecodeErrorZ_is_ok(uint64_t o) {
14685 LDKCResult_NodeIdDecodeErrorZ* o_conv = (LDKCResult_NodeIdDecodeErrorZ*)untag_ptr(o);
14686 jboolean ret_conv = CResult_NodeIdDecodeErrorZ_is_ok(o_conv);
14690 void __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_free"))) TS_CResult_NodeIdDecodeErrorZ_free(uint64_t _res) {
14691 if (!ptr_is_owned(_res)) return;
14692 void* _res_ptr = untag_ptr(_res);
14693 CHECK_ACCESS(_res_ptr);
14694 LDKCResult_NodeIdDecodeErrorZ _res_conv = *(LDKCResult_NodeIdDecodeErrorZ*)(_res_ptr);
14695 FREE(untag_ptr(_res));
14696 CResult_NodeIdDecodeErrorZ_free(_res_conv);
14699 static inline uint64_t CResult_NodeIdDecodeErrorZ_clone_ptr(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR arg) {
14700 LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
14701 *ret_conv = CResult_NodeIdDecodeErrorZ_clone(arg);
14702 return tag_ptr(ret_conv, true);
14704 int64_t __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_clone_ptr"))) TS_CResult_NodeIdDecodeErrorZ_clone_ptr(uint64_t arg) {
14705 LDKCResult_NodeIdDecodeErrorZ* arg_conv = (LDKCResult_NodeIdDecodeErrorZ*)untag_ptr(arg);
14706 int64_t ret_conv = CResult_NodeIdDecodeErrorZ_clone_ptr(arg_conv);
14710 uint64_t __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_clone"))) TS_CResult_NodeIdDecodeErrorZ_clone(uint64_t orig) {
14711 LDKCResult_NodeIdDecodeErrorZ* orig_conv = (LDKCResult_NodeIdDecodeErrorZ*)untag_ptr(orig);
14712 LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
14713 *ret_conv = CResult_NodeIdDecodeErrorZ_clone(orig_conv);
14714 return tag_ptr(ret_conv, true);
14717 uint64_t __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok(uint64_t o) {
14718 void* o_ptr = untag_ptr(o);
14719 CHECK_ACCESS(o_ptr);
14720 LDKCOption_NetworkUpdateZ o_conv = *(LDKCOption_NetworkUpdateZ*)(o_ptr);
14721 o_conv = COption_NetworkUpdateZ_clone((LDKCOption_NetworkUpdateZ*)untag_ptr(o));
14722 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
14723 *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o_conv);
14724 return tag_ptr(ret_conv, true);
14727 uint64_t __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err(uint64_t e) {
14728 void* e_ptr = untag_ptr(e);
14729 CHECK_ACCESS(e_ptr);
14730 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
14731 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
14732 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
14733 *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_err(e_conv);
14734 return tag_ptr(ret_conv, true);
14737 jboolean __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(uint64_t o) {
14738 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* o_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)untag_ptr(o);
14739 jboolean ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o_conv);
14743 void __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free(uint64_t _res) {
14744 if (!ptr_is_owned(_res)) return;
14745 void* _res_ptr = untag_ptr(_res);
14746 CHECK_ACCESS(_res_ptr);
14747 LDKCResult_COption_NetworkUpdateZDecodeErrorZ _res_conv = *(LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(_res_ptr);
14748 FREE(untag_ptr(_res));
14749 CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res_conv);
14752 static inline uint64_t CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR arg) {
14753 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
14754 *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_clone(arg);
14755 return tag_ptr(ret_conv, true);
14757 int64_t __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(uint64_t arg) {
14758 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* arg_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)untag_ptr(arg);
14759 int64_t ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg_conv);
14763 uint64_t __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone(uint64_t orig) {
14764 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* orig_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)untag_ptr(orig);
14765 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
14766 *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig_conv);
14767 return tag_ptr(ret_conv, true);
14770 uint64_t __attribute__((export_name("TS_COption_AccessZ_some"))) TS_COption_AccessZ_some(uint64_t o) {
14771 void* o_ptr = untag_ptr(o);
14772 CHECK_ACCESS(o_ptr);
14773 LDKAccess o_conv = *(LDKAccess*)(o_ptr);
14774 if (o_conv.free == LDKAccess_JCalls_free) {
14775 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
14776 LDKAccess_JCalls_cloned(&o_conv);
14778 LDKCOption_AccessZ *ret_copy = MALLOC(sizeof(LDKCOption_AccessZ), "LDKCOption_AccessZ");
14779 *ret_copy = COption_AccessZ_some(o_conv);
14780 uint64_t ret_ref = tag_ptr(ret_copy, true);
14784 uint64_t __attribute__((export_name("TS_COption_AccessZ_none"))) TS_COption_AccessZ_none() {
14785 LDKCOption_AccessZ *ret_copy = MALLOC(sizeof(LDKCOption_AccessZ), "LDKCOption_AccessZ");
14786 *ret_copy = COption_AccessZ_none();
14787 uint64_t ret_ref = tag_ptr(ret_copy, true);
14791 void __attribute__((export_name("TS_COption_AccessZ_free"))) TS_COption_AccessZ_free(uint64_t _res) {
14792 if (!ptr_is_owned(_res)) return;
14793 void* _res_ptr = untag_ptr(_res);
14794 CHECK_ACCESS(_res_ptr);
14795 LDKCOption_AccessZ _res_conv = *(LDKCOption_AccessZ*)(_res_ptr);
14796 FREE(untag_ptr(_res));
14797 COption_AccessZ_free(_res_conv);
14800 uint64_t __attribute__((export_name("TS_CResult_boolLightningErrorZ_ok"))) TS_CResult_boolLightningErrorZ_ok(jboolean o) {
14801 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
14802 *ret_conv = CResult_boolLightningErrorZ_ok(o);
14803 return tag_ptr(ret_conv, true);
14806 uint64_t __attribute__((export_name("TS_CResult_boolLightningErrorZ_err"))) TS_CResult_boolLightningErrorZ_err(uint64_t e) {
14807 LDKLightningError e_conv;
14808 e_conv.inner = untag_ptr(e);
14809 e_conv.is_owned = ptr_is_owned(e);
14810 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
14811 e_conv = LightningError_clone(&e_conv);
14812 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
14813 *ret_conv = CResult_boolLightningErrorZ_err(e_conv);
14814 return tag_ptr(ret_conv, true);
14817 jboolean __attribute__((export_name("TS_CResult_boolLightningErrorZ_is_ok"))) TS_CResult_boolLightningErrorZ_is_ok(uint64_t o) {
14818 LDKCResult_boolLightningErrorZ* o_conv = (LDKCResult_boolLightningErrorZ*)untag_ptr(o);
14819 jboolean ret_conv = CResult_boolLightningErrorZ_is_ok(o_conv);
14823 void __attribute__((export_name("TS_CResult_boolLightningErrorZ_free"))) TS_CResult_boolLightningErrorZ_free(uint64_t _res) {
14824 if (!ptr_is_owned(_res)) return;
14825 void* _res_ptr = untag_ptr(_res);
14826 CHECK_ACCESS(_res_ptr);
14827 LDKCResult_boolLightningErrorZ _res_conv = *(LDKCResult_boolLightningErrorZ*)(_res_ptr);
14828 FREE(untag_ptr(_res));
14829 CResult_boolLightningErrorZ_free(_res_conv);
14832 static inline uint64_t CResult_boolLightningErrorZ_clone_ptr(LDKCResult_boolLightningErrorZ *NONNULL_PTR arg) {
14833 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
14834 *ret_conv = CResult_boolLightningErrorZ_clone(arg);
14835 return tag_ptr(ret_conv, true);
14837 int64_t __attribute__((export_name("TS_CResult_boolLightningErrorZ_clone_ptr"))) TS_CResult_boolLightningErrorZ_clone_ptr(uint64_t arg) {
14838 LDKCResult_boolLightningErrorZ* arg_conv = (LDKCResult_boolLightningErrorZ*)untag_ptr(arg);
14839 int64_t ret_conv = CResult_boolLightningErrorZ_clone_ptr(arg_conv);
14843 uint64_t __attribute__((export_name("TS_CResult_boolLightningErrorZ_clone"))) TS_CResult_boolLightningErrorZ_clone(uint64_t orig) {
14844 LDKCResult_boolLightningErrorZ* orig_conv = (LDKCResult_boolLightningErrorZ*)untag_ptr(orig);
14845 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
14846 *ret_conv = CResult_boolLightningErrorZ_clone(orig_conv);
14847 return tag_ptr(ret_conv, true);
14850 static inline uint64_t C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR arg) {
14851 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
14852 *ret_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(arg);
14853 return tag_ptr(ret_conv, true);
14855 int64_t __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(uint64_t arg) {
14856 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* arg_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)untag_ptr(arg);
14857 int64_t ret_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg_conv);
14861 uint64_t __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(uint64_t orig) {
14862 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* orig_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)untag_ptr(orig);
14863 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
14864 *ret_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig_conv);
14865 return tag_ptr(ret_conv, true);
14868 uint64_t __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(uint64_t a, uint64_t b, uint64_t c) {
14869 LDKChannelAnnouncement a_conv;
14870 a_conv.inner = untag_ptr(a);
14871 a_conv.is_owned = ptr_is_owned(a);
14872 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
14873 a_conv = ChannelAnnouncement_clone(&a_conv);
14874 LDKChannelUpdate b_conv;
14875 b_conv.inner = untag_ptr(b);
14876 b_conv.is_owned = ptr_is_owned(b);
14877 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
14878 b_conv = ChannelUpdate_clone(&b_conv);
14879 LDKChannelUpdate c_conv;
14880 c_conv.inner = untag_ptr(c);
14881 c_conv.is_owned = ptr_is_owned(c);
14882 CHECK_INNER_FIELD_ACCESS_OR_NULL(c_conv);
14883 c_conv = ChannelUpdate_clone(&c_conv);
14884 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
14885 *ret_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a_conv, b_conv, c_conv);
14886 return tag_ptr(ret_conv, true);
14889 void __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(uint64_t _res) {
14890 if (!ptr_is_owned(_res)) return;
14891 void* _res_ptr = untag_ptr(_res);
14892 CHECK_ACCESS(_res_ptr);
14893 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(_res_ptr);
14894 FREE(untag_ptr(_res));
14895 C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res_conv);
14898 uint64_t __attribute__((export_name("TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some"))) TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(uint64_t o) {
14899 void* o_ptr = untag_ptr(o);
14900 CHECK_ACCESS(o_ptr);
14901 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ o_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(o_ptr);
14902 o_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone((LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)untag_ptr(o));
14903 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret_copy = MALLOC(sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
14904 *ret_copy = COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(o_conv);
14905 uint64_t ret_ref = tag_ptr(ret_copy, true);
14909 uint64_t __attribute__((export_name("TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none"))) TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none() {
14910 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret_copy = MALLOC(sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
14911 *ret_copy = COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none();
14912 uint64_t ret_ref = tag_ptr(ret_copy, true);
14916 void __attribute__((export_name("TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free"))) TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(uint64_t _res) {
14917 if (!ptr_is_owned(_res)) return;
14918 void* _res_ptr = untag_ptr(_res);
14919 CHECK_ACCESS(_res_ptr);
14920 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res_conv = *(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ*)(_res_ptr);
14921 FREE(untag_ptr(_res));
14922 COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res_conv);
14925 static inline uint64_t COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *NONNULL_PTR arg) {
14926 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret_copy = MALLOC(sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
14927 *ret_copy = COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(arg);
14928 uint64_t ret_ref = tag_ptr(ret_copy, true);
14931 int64_t __attribute__((export_name("TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr"))) TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(uint64_t arg) {
14932 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* arg_conv = (LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ*)untag_ptr(arg);
14933 int64_t ret_conv = COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(arg_conv);
14937 uint64_t __attribute__((export_name("TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone"))) TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(uint64_t orig) {
14938 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* orig_conv = (LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ*)untag_ptr(orig);
14939 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret_copy = MALLOC(sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
14940 *ret_copy = COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(orig_conv);
14941 uint64_t ret_ref = tag_ptr(ret_copy, true);
14945 uint64_t __attribute__((export_name("TS_CResult_NoneLightningErrorZ_ok"))) TS_CResult_NoneLightningErrorZ_ok() {
14946 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
14947 *ret_conv = CResult_NoneLightningErrorZ_ok();
14948 return tag_ptr(ret_conv, true);
14951 uint64_t __attribute__((export_name("TS_CResult_NoneLightningErrorZ_err"))) TS_CResult_NoneLightningErrorZ_err(uint64_t e) {
14952 LDKLightningError e_conv;
14953 e_conv.inner = untag_ptr(e);
14954 e_conv.is_owned = ptr_is_owned(e);
14955 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
14956 e_conv = LightningError_clone(&e_conv);
14957 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
14958 *ret_conv = CResult_NoneLightningErrorZ_err(e_conv);
14959 return tag_ptr(ret_conv, true);
14962 jboolean __attribute__((export_name("TS_CResult_NoneLightningErrorZ_is_ok"))) TS_CResult_NoneLightningErrorZ_is_ok(uint64_t o) {
14963 LDKCResult_NoneLightningErrorZ* o_conv = (LDKCResult_NoneLightningErrorZ*)untag_ptr(o);
14964 jboolean ret_conv = CResult_NoneLightningErrorZ_is_ok(o_conv);
14968 void __attribute__((export_name("TS_CResult_NoneLightningErrorZ_free"))) TS_CResult_NoneLightningErrorZ_free(uint64_t _res) {
14969 if (!ptr_is_owned(_res)) return;
14970 void* _res_ptr = untag_ptr(_res);
14971 CHECK_ACCESS(_res_ptr);
14972 LDKCResult_NoneLightningErrorZ _res_conv = *(LDKCResult_NoneLightningErrorZ*)(_res_ptr);
14973 FREE(untag_ptr(_res));
14974 CResult_NoneLightningErrorZ_free(_res_conv);
14977 static inline uint64_t CResult_NoneLightningErrorZ_clone_ptr(LDKCResult_NoneLightningErrorZ *NONNULL_PTR arg) {
14978 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
14979 *ret_conv = CResult_NoneLightningErrorZ_clone(arg);
14980 return tag_ptr(ret_conv, true);
14982 int64_t __attribute__((export_name("TS_CResult_NoneLightningErrorZ_clone_ptr"))) TS_CResult_NoneLightningErrorZ_clone_ptr(uint64_t arg) {
14983 LDKCResult_NoneLightningErrorZ* arg_conv = (LDKCResult_NoneLightningErrorZ*)untag_ptr(arg);
14984 int64_t ret_conv = CResult_NoneLightningErrorZ_clone_ptr(arg_conv);
14988 uint64_t __attribute__((export_name("TS_CResult_NoneLightningErrorZ_clone"))) TS_CResult_NoneLightningErrorZ_clone(uint64_t orig) {
14989 LDKCResult_NoneLightningErrorZ* orig_conv = (LDKCResult_NoneLightningErrorZ*)untag_ptr(orig);
14990 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
14991 *ret_conv = CResult_NoneLightningErrorZ_clone(orig_conv);
14992 return tag_ptr(ret_conv, true);
14995 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_ok"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_ok(uint64_t o) {
14996 LDKChannelUpdateInfo o_conv;
14997 o_conv.inner = untag_ptr(o);
14998 o_conv.is_owned = ptr_is_owned(o);
14999 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
15000 o_conv = ChannelUpdateInfo_clone(&o_conv);
15001 LDKCResult_ChannelUpdateInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ), "LDKCResult_ChannelUpdateInfoDecodeErrorZ");
15002 *ret_conv = CResult_ChannelUpdateInfoDecodeErrorZ_ok(o_conv);
15003 return tag_ptr(ret_conv, true);
15006 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_err"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_err(uint64_t e) {
15007 void* e_ptr = untag_ptr(e);
15008 CHECK_ACCESS(e_ptr);
15009 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
15010 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
15011 LDKCResult_ChannelUpdateInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ), "LDKCResult_ChannelUpdateInfoDecodeErrorZ");
15012 *ret_conv = CResult_ChannelUpdateInfoDecodeErrorZ_err(e_conv);
15013 return tag_ptr(ret_conv, true);
15016 jboolean __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_is_ok"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(uint64_t o) {
15017 LDKCResult_ChannelUpdateInfoDecodeErrorZ* o_conv = (LDKCResult_ChannelUpdateInfoDecodeErrorZ*)untag_ptr(o);
15018 jboolean ret_conv = CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o_conv);
15022 void __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_free"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_free(uint64_t _res) {
15023 if (!ptr_is_owned(_res)) return;
15024 void* _res_ptr = untag_ptr(_res);
15025 CHECK_ACCESS(_res_ptr);
15026 LDKCResult_ChannelUpdateInfoDecodeErrorZ _res_conv = *(LDKCResult_ChannelUpdateInfoDecodeErrorZ*)(_res_ptr);
15027 FREE(untag_ptr(_res));
15028 CResult_ChannelUpdateInfoDecodeErrorZ_free(_res_conv);
15031 static inline uint64_t CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR arg) {
15032 LDKCResult_ChannelUpdateInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ), "LDKCResult_ChannelUpdateInfoDecodeErrorZ");
15033 *ret_conv = CResult_ChannelUpdateInfoDecodeErrorZ_clone(arg);
15034 return tag_ptr(ret_conv, true);
15036 int64_t __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(uint64_t arg) {
15037 LDKCResult_ChannelUpdateInfoDecodeErrorZ* arg_conv = (LDKCResult_ChannelUpdateInfoDecodeErrorZ*)untag_ptr(arg);
15038 int64_t ret_conv = CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg_conv);
15042 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone(uint64_t orig) {
15043 LDKCResult_ChannelUpdateInfoDecodeErrorZ* orig_conv = (LDKCResult_ChannelUpdateInfoDecodeErrorZ*)untag_ptr(orig);
15044 LDKCResult_ChannelUpdateInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ), "LDKCResult_ChannelUpdateInfoDecodeErrorZ");
15045 *ret_conv = CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig_conv);
15046 return tag_ptr(ret_conv, true);
15049 uint64_t __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_ok"))) TS_CResult_ChannelInfoDecodeErrorZ_ok(uint64_t o) {
15050 LDKChannelInfo o_conv;
15051 o_conv.inner = untag_ptr(o);
15052 o_conv.is_owned = ptr_is_owned(o);
15053 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
15054 o_conv = ChannelInfo_clone(&o_conv);
15055 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
15056 *ret_conv = CResult_ChannelInfoDecodeErrorZ_ok(o_conv);
15057 return tag_ptr(ret_conv, true);
15060 uint64_t __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_err"))) TS_CResult_ChannelInfoDecodeErrorZ_err(uint64_t e) {
15061 void* e_ptr = untag_ptr(e);
15062 CHECK_ACCESS(e_ptr);
15063 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
15064 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
15065 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
15066 *ret_conv = CResult_ChannelInfoDecodeErrorZ_err(e_conv);
15067 return tag_ptr(ret_conv, true);
15070 jboolean __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_is_ok"))) TS_CResult_ChannelInfoDecodeErrorZ_is_ok(uint64_t o) {
15071 LDKCResult_ChannelInfoDecodeErrorZ* o_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)untag_ptr(o);
15072 jboolean ret_conv = CResult_ChannelInfoDecodeErrorZ_is_ok(o_conv);
15076 void __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_free"))) TS_CResult_ChannelInfoDecodeErrorZ_free(uint64_t _res) {
15077 if (!ptr_is_owned(_res)) return;
15078 void* _res_ptr = untag_ptr(_res);
15079 CHECK_ACCESS(_res_ptr);
15080 LDKCResult_ChannelInfoDecodeErrorZ _res_conv = *(LDKCResult_ChannelInfoDecodeErrorZ*)(_res_ptr);
15081 FREE(untag_ptr(_res));
15082 CResult_ChannelInfoDecodeErrorZ_free(_res_conv);
15085 static inline uint64_t CResult_ChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR arg) {
15086 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
15087 *ret_conv = CResult_ChannelInfoDecodeErrorZ_clone(arg);
15088 return tag_ptr(ret_conv, true);
15090 int64_t __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr(uint64_t arg) {
15091 LDKCResult_ChannelInfoDecodeErrorZ* arg_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)untag_ptr(arg);
15092 int64_t ret_conv = CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg_conv);
15096 uint64_t __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_clone"))) TS_CResult_ChannelInfoDecodeErrorZ_clone(uint64_t orig) {
15097 LDKCResult_ChannelInfoDecodeErrorZ* orig_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)untag_ptr(orig);
15098 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
15099 *ret_conv = CResult_ChannelInfoDecodeErrorZ_clone(orig_conv);
15100 return tag_ptr(ret_conv, true);
15103 uint64_t __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_ok"))) TS_CResult_RoutingFeesDecodeErrorZ_ok(uint64_t o) {
15104 LDKRoutingFees o_conv;
15105 o_conv.inner = untag_ptr(o);
15106 o_conv.is_owned = ptr_is_owned(o);
15107 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
15108 o_conv = RoutingFees_clone(&o_conv);
15109 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
15110 *ret_conv = CResult_RoutingFeesDecodeErrorZ_ok(o_conv);
15111 return tag_ptr(ret_conv, true);
15114 uint64_t __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_err"))) TS_CResult_RoutingFeesDecodeErrorZ_err(uint64_t e) {
15115 void* e_ptr = untag_ptr(e);
15116 CHECK_ACCESS(e_ptr);
15117 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
15118 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
15119 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
15120 *ret_conv = CResult_RoutingFeesDecodeErrorZ_err(e_conv);
15121 return tag_ptr(ret_conv, true);
15124 jboolean __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_is_ok"))) TS_CResult_RoutingFeesDecodeErrorZ_is_ok(uint64_t o) {
15125 LDKCResult_RoutingFeesDecodeErrorZ* o_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)untag_ptr(o);
15126 jboolean ret_conv = CResult_RoutingFeesDecodeErrorZ_is_ok(o_conv);
15130 void __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_free"))) TS_CResult_RoutingFeesDecodeErrorZ_free(uint64_t _res) {
15131 if (!ptr_is_owned(_res)) return;
15132 void* _res_ptr = untag_ptr(_res);
15133 CHECK_ACCESS(_res_ptr);
15134 LDKCResult_RoutingFeesDecodeErrorZ _res_conv = *(LDKCResult_RoutingFeesDecodeErrorZ*)(_res_ptr);
15135 FREE(untag_ptr(_res));
15136 CResult_RoutingFeesDecodeErrorZ_free(_res_conv);
15139 static inline uint64_t CResult_RoutingFeesDecodeErrorZ_clone_ptr(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR arg) {
15140 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
15141 *ret_conv = CResult_RoutingFeesDecodeErrorZ_clone(arg);
15142 return tag_ptr(ret_conv, true);
15144 int64_t __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr"))) TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr(uint64_t arg) {
15145 LDKCResult_RoutingFeesDecodeErrorZ* arg_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)untag_ptr(arg);
15146 int64_t ret_conv = CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg_conv);
15150 uint64_t __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_clone"))) TS_CResult_RoutingFeesDecodeErrorZ_clone(uint64_t orig) {
15151 LDKCResult_RoutingFeesDecodeErrorZ* orig_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)untag_ptr(orig);
15152 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
15153 *ret_conv = CResult_RoutingFeesDecodeErrorZ_clone(orig_conv);
15154 return tag_ptr(ret_conv, true);
15157 void __attribute__((export_name("TS_CVec_NetAddressZ_free"))) TS_CVec_NetAddressZ_free(uint64_tArray _res) {
15158 LDKCVec_NetAddressZ _res_constr;
15159 _res_constr.datalen = _res->arr_len;
15160 if (_res_constr.datalen > 0)
15161 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
15163 _res_constr.data = NULL;
15164 uint64_t* _res_vals = _res->elems;
15165 for (size_t m = 0; m < _res_constr.datalen; m++) {
15166 uint64_t _res_conv_12 = _res_vals[m];
15167 void* _res_conv_12_ptr = untag_ptr(_res_conv_12);
15168 CHECK_ACCESS(_res_conv_12_ptr);
15169 LDKNetAddress _res_conv_12_conv = *(LDKNetAddress*)(_res_conv_12_ptr);
15170 FREE(untag_ptr(_res_conv_12));
15171 _res_constr.data[m] = _res_conv_12_conv;
15174 CVec_NetAddressZ_free(_res_constr);
15177 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_ok"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_ok(uint64_t o) {
15178 LDKNodeAnnouncementInfo o_conv;
15179 o_conv.inner = untag_ptr(o);
15180 o_conv.is_owned = ptr_is_owned(o);
15181 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
15182 o_conv = NodeAnnouncementInfo_clone(&o_conv);
15183 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
15184 *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o_conv);
15185 return tag_ptr(ret_conv, true);
15188 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_err"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_err(uint64_t e) {
15189 void* e_ptr = untag_ptr(e);
15190 CHECK_ACCESS(e_ptr);
15191 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
15192 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
15193 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
15194 *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_err(e_conv);
15195 return tag_ptr(ret_conv, true);
15198 jboolean __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(uint64_t o) {
15199 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* o_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)untag_ptr(o);
15200 jboolean ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o_conv);
15204 void __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free(uint64_t _res) {
15205 if (!ptr_is_owned(_res)) return;
15206 void* _res_ptr = untag_ptr(_res);
15207 CHECK_ACCESS(_res_ptr);
15208 LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res_conv = *(LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(_res_ptr);
15209 FREE(untag_ptr(_res));
15210 CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res_conv);
15213 static inline uint64_t CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR arg) {
15214 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
15215 *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_clone(arg);
15216 return tag_ptr(ret_conv, true);
15218 int64_t __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(uint64_t arg) {
15219 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* arg_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)untag_ptr(arg);
15220 int64_t ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg_conv);
15224 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone(uint64_t orig) {
15225 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* orig_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)untag_ptr(orig);
15226 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
15227 *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig_conv);
15228 return tag_ptr(ret_conv, true);
15231 uint64_t __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_ok"))) TS_CResult_NodeAliasDecodeErrorZ_ok(uint64_t o) {
15232 LDKNodeAlias o_conv;
15233 o_conv.inner = untag_ptr(o);
15234 o_conv.is_owned = ptr_is_owned(o);
15235 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
15236 o_conv = NodeAlias_clone(&o_conv);
15237 LDKCResult_NodeAliasDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAliasDecodeErrorZ), "LDKCResult_NodeAliasDecodeErrorZ");
15238 *ret_conv = CResult_NodeAliasDecodeErrorZ_ok(o_conv);
15239 return tag_ptr(ret_conv, true);
15242 uint64_t __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_err"))) TS_CResult_NodeAliasDecodeErrorZ_err(uint64_t e) {
15243 void* e_ptr = untag_ptr(e);
15244 CHECK_ACCESS(e_ptr);
15245 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
15246 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
15247 LDKCResult_NodeAliasDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAliasDecodeErrorZ), "LDKCResult_NodeAliasDecodeErrorZ");
15248 *ret_conv = CResult_NodeAliasDecodeErrorZ_err(e_conv);
15249 return tag_ptr(ret_conv, true);
15252 jboolean __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_is_ok"))) TS_CResult_NodeAliasDecodeErrorZ_is_ok(uint64_t o) {
15253 LDKCResult_NodeAliasDecodeErrorZ* o_conv = (LDKCResult_NodeAliasDecodeErrorZ*)untag_ptr(o);
15254 jboolean ret_conv = CResult_NodeAliasDecodeErrorZ_is_ok(o_conv);
15258 void __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_free"))) TS_CResult_NodeAliasDecodeErrorZ_free(uint64_t _res) {
15259 if (!ptr_is_owned(_res)) return;
15260 void* _res_ptr = untag_ptr(_res);
15261 CHECK_ACCESS(_res_ptr);
15262 LDKCResult_NodeAliasDecodeErrorZ _res_conv = *(LDKCResult_NodeAliasDecodeErrorZ*)(_res_ptr);
15263 FREE(untag_ptr(_res));
15264 CResult_NodeAliasDecodeErrorZ_free(_res_conv);
15267 static inline uint64_t CResult_NodeAliasDecodeErrorZ_clone_ptr(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR arg) {
15268 LDKCResult_NodeAliasDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAliasDecodeErrorZ), "LDKCResult_NodeAliasDecodeErrorZ");
15269 *ret_conv = CResult_NodeAliasDecodeErrorZ_clone(arg);
15270 return tag_ptr(ret_conv, true);
15272 int64_t __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_clone_ptr"))) TS_CResult_NodeAliasDecodeErrorZ_clone_ptr(uint64_t arg) {
15273 LDKCResult_NodeAliasDecodeErrorZ* arg_conv = (LDKCResult_NodeAliasDecodeErrorZ*)untag_ptr(arg);
15274 int64_t ret_conv = CResult_NodeAliasDecodeErrorZ_clone_ptr(arg_conv);
15278 uint64_t __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_clone"))) TS_CResult_NodeAliasDecodeErrorZ_clone(uint64_t orig) {
15279 LDKCResult_NodeAliasDecodeErrorZ* orig_conv = (LDKCResult_NodeAliasDecodeErrorZ*)untag_ptr(orig);
15280 LDKCResult_NodeAliasDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAliasDecodeErrorZ), "LDKCResult_NodeAliasDecodeErrorZ");
15281 *ret_conv = CResult_NodeAliasDecodeErrorZ_clone(orig_conv);
15282 return tag_ptr(ret_conv, true);
15285 uint64_t __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_ok"))) TS_CResult_NodeInfoDecodeErrorZ_ok(uint64_t o) {
15286 LDKNodeInfo o_conv;
15287 o_conv.inner = untag_ptr(o);
15288 o_conv.is_owned = ptr_is_owned(o);
15289 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
15290 o_conv = NodeInfo_clone(&o_conv);
15291 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
15292 *ret_conv = CResult_NodeInfoDecodeErrorZ_ok(o_conv);
15293 return tag_ptr(ret_conv, true);
15296 uint64_t __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_err"))) TS_CResult_NodeInfoDecodeErrorZ_err(uint64_t e) {
15297 void* e_ptr = untag_ptr(e);
15298 CHECK_ACCESS(e_ptr);
15299 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
15300 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
15301 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
15302 *ret_conv = CResult_NodeInfoDecodeErrorZ_err(e_conv);
15303 return tag_ptr(ret_conv, true);
15306 jboolean __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_is_ok"))) TS_CResult_NodeInfoDecodeErrorZ_is_ok(uint64_t o) {
15307 LDKCResult_NodeInfoDecodeErrorZ* o_conv = (LDKCResult_NodeInfoDecodeErrorZ*)untag_ptr(o);
15308 jboolean ret_conv = CResult_NodeInfoDecodeErrorZ_is_ok(o_conv);
15312 void __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_free"))) TS_CResult_NodeInfoDecodeErrorZ_free(uint64_t _res) {
15313 if (!ptr_is_owned(_res)) return;
15314 void* _res_ptr = untag_ptr(_res);
15315 CHECK_ACCESS(_res_ptr);
15316 LDKCResult_NodeInfoDecodeErrorZ _res_conv = *(LDKCResult_NodeInfoDecodeErrorZ*)(_res_ptr);
15317 FREE(untag_ptr(_res));
15318 CResult_NodeInfoDecodeErrorZ_free(_res_conv);
15321 static inline uint64_t CResult_NodeInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR arg) {
15322 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
15323 *ret_conv = CResult_NodeInfoDecodeErrorZ_clone(arg);
15324 return tag_ptr(ret_conv, true);
15326 int64_t __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_clone_ptr"))) TS_CResult_NodeInfoDecodeErrorZ_clone_ptr(uint64_t arg) {
15327 LDKCResult_NodeInfoDecodeErrorZ* arg_conv = (LDKCResult_NodeInfoDecodeErrorZ*)untag_ptr(arg);
15328 int64_t ret_conv = CResult_NodeInfoDecodeErrorZ_clone_ptr(arg_conv);
15332 uint64_t __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_clone"))) TS_CResult_NodeInfoDecodeErrorZ_clone(uint64_t orig) {
15333 LDKCResult_NodeInfoDecodeErrorZ* orig_conv = (LDKCResult_NodeInfoDecodeErrorZ*)untag_ptr(orig);
15334 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
15335 *ret_conv = CResult_NodeInfoDecodeErrorZ_clone(orig_conv);
15336 return tag_ptr(ret_conv, true);
15339 uint64_t __attribute__((export_name("TS_CResult_NetworkGraphDecodeErrorZ_ok"))) TS_CResult_NetworkGraphDecodeErrorZ_ok(uint64_t o) {
15340 LDKNetworkGraph o_conv;
15341 o_conv.inner = untag_ptr(o);
15342 o_conv.is_owned = ptr_is_owned(o);
15343 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
15344 // WARNING: we need a move here but no clone is available for LDKNetworkGraph
15346 LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
15347 *ret_conv = CResult_NetworkGraphDecodeErrorZ_ok(o_conv);
15348 return tag_ptr(ret_conv, true);
15351 uint64_t __attribute__((export_name("TS_CResult_NetworkGraphDecodeErrorZ_err"))) TS_CResult_NetworkGraphDecodeErrorZ_err(uint64_t e) {
15352 void* e_ptr = untag_ptr(e);
15353 CHECK_ACCESS(e_ptr);
15354 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
15355 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
15356 LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
15357 *ret_conv = CResult_NetworkGraphDecodeErrorZ_err(e_conv);
15358 return tag_ptr(ret_conv, true);
15361 jboolean __attribute__((export_name("TS_CResult_NetworkGraphDecodeErrorZ_is_ok"))) TS_CResult_NetworkGraphDecodeErrorZ_is_ok(uint64_t o) {
15362 LDKCResult_NetworkGraphDecodeErrorZ* o_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)untag_ptr(o);
15363 jboolean ret_conv = CResult_NetworkGraphDecodeErrorZ_is_ok(o_conv);
15367 void __attribute__((export_name("TS_CResult_NetworkGraphDecodeErrorZ_free"))) TS_CResult_NetworkGraphDecodeErrorZ_free(uint64_t _res) {
15368 if (!ptr_is_owned(_res)) return;
15369 void* _res_ptr = untag_ptr(_res);
15370 CHECK_ACCESS(_res_ptr);
15371 LDKCResult_NetworkGraphDecodeErrorZ _res_conv = *(LDKCResult_NetworkGraphDecodeErrorZ*)(_res_ptr);
15372 FREE(untag_ptr(_res));
15373 CResult_NetworkGraphDecodeErrorZ_free(_res_conv);
15376 uint64_t __attribute__((export_name("TS_COption_CVec_NetAddressZZ_some"))) TS_COption_CVec_NetAddressZZ_some(uint64_tArray o) {
15377 LDKCVec_NetAddressZ o_constr;
15378 o_constr.datalen = o->arr_len;
15379 if (o_constr.datalen > 0)
15380 o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
15382 o_constr.data = NULL;
15383 uint64_t* o_vals = o->elems;
15384 for (size_t m = 0; m < o_constr.datalen; m++) {
15385 uint64_t o_conv_12 = o_vals[m];
15386 void* o_conv_12_ptr = untag_ptr(o_conv_12);
15387 CHECK_ACCESS(o_conv_12_ptr);
15388 LDKNetAddress o_conv_12_conv = *(LDKNetAddress*)(o_conv_12_ptr);
15389 o_conv_12_conv = NetAddress_clone((LDKNetAddress*)untag_ptr(o_conv_12));
15390 o_constr.data[m] = o_conv_12_conv;
15393 LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ");
15394 *ret_copy = COption_CVec_NetAddressZZ_some(o_constr);
15395 uint64_t ret_ref = tag_ptr(ret_copy, true);
15399 uint64_t __attribute__((export_name("TS_COption_CVec_NetAddressZZ_none"))) TS_COption_CVec_NetAddressZZ_none() {
15400 LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ");
15401 *ret_copy = COption_CVec_NetAddressZZ_none();
15402 uint64_t ret_ref = tag_ptr(ret_copy, true);
15406 void __attribute__((export_name("TS_COption_CVec_NetAddressZZ_free"))) TS_COption_CVec_NetAddressZZ_free(uint64_t _res) {
15407 if (!ptr_is_owned(_res)) return;
15408 void* _res_ptr = untag_ptr(_res);
15409 CHECK_ACCESS(_res_ptr);
15410 LDKCOption_CVec_NetAddressZZ _res_conv = *(LDKCOption_CVec_NetAddressZZ*)(_res_ptr);
15411 FREE(untag_ptr(_res));
15412 COption_CVec_NetAddressZZ_free(_res_conv);
15415 static inline uint64_t COption_CVec_NetAddressZZ_clone_ptr(LDKCOption_CVec_NetAddressZZ *NONNULL_PTR arg) {
15416 LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ");
15417 *ret_copy = COption_CVec_NetAddressZZ_clone(arg);
15418 uint64_t ret_ref = tag_ptr(ret_copy, true);
15421 int64_t __attribute__((export_name("TS_COption_CVec_NetAddressZZ_clone_ptr"))) TS_COption_CVec_NetAddressZZ_clone_ptr(uint64_t arg) {
15422 LDKCOption_CVec_NetAddressZZ* arg_conv = (LDKCOption_CVec_NetAddressZZ*)untag_ptr(arg);
15423 int64_t ret_conv = COption_CVec_NetAddressZZ_clone_ptr(arg_conv);
15427 uint64_t __attribute__((export_name("TS_COption_CVec_NetAddressZZ_clone"))) TS_COption_CVec_NetAddressZZ_clone(uint64_t orig) {
15428 LDKCOption_CVec_NetAddressZZ* orig_conv = (LDKCOption_CVec_NetAddressZZ*)untag_ptr(orig);
15429 LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ");
15430 *ret_copy = COption_CVec_NetAddressZZ_clone(orig_conv);
15431 uint64_t ret_ref = tag_ptr(ret_copy, true);
15435 uint64_t __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(uint64_t o) {
15436 LDKDelayedPaymentOutputDescriptor o_conv;
15437 o_conv.inner = untag_ptr(o);
15438 o_conv.is_owned = ptr_is_owned(o);
15439 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
15440 o_conv = DelayedPaymentOutputDescriptor_clone(&o_conv);
15441 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
15442 *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o_conv);
15443 return tag_ptr(ret_conv, true);
15446 uint64_t __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(uint64_t e) {
15447 void* e_ptr = untag_ptr(e);
15448 CHECK_ACCESS(e_ptr);
15449 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
15450 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
15451 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
15452 *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e_conv);
15453 return tag_ptr(ret_conv, true);
15456 jboolean __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(uint64_t o) {
15457 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* o_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(o);
15458 jboolean ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o_conv);
15462 void __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(uint64_t _res) {
15463 if (!ptr_is_owned(_res)) return;
15464 void* _res_ptr = untag_ptr(_res);
15465 CHECK_ACCESS(_res_ptr);
15466 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res_conv = *(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(_res_ptr);
15467 FREE(untag_ptr(_res));
15468 CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res_conv);
15471 static inline uint64_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg) {
15472 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
15473 *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(arg);
15474 return tag_ptr(ret_conv, true);
15476 int64_t __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(uint64_t arg) {
15477 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* arg_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(arg);
15478 int64_t ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg_conv);
15482 uint64_t __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(uint64_t orig) {
15483 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(orig);
15484 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
15485 *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig_conv);
15486 return tag_ptr(ret_conv, true);
15489 uint64_t __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(uint64_t o) {
15490 LDKStaticPaymentOutputDescriptor o_conv;
15491 o_conv.inner = untag_ptr(o);
15492 o_conv.is_owned = ptr_is_owned(o);
15493 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
15494 o_conv = StaticPaymentOutputDescriptor_clone(&o_conv);
15495 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
15496 *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o_conv);
15497 return tag_ptr(ret_conv, true);
15500 uint64_t __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(uint64_t e) {
15501 void* e_ptr = untag_ptr(e);
15502 CHECK_ACCESS(e_ptr);
15503 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
15504 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
15505 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
15506 *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e_conv);
15507 return tag_ptr(ret_conv, true);
15510 jboolean __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(uint64_t o) {
15511 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* o_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(o);
15512 jboolean ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o_conv);
15516 void __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(uint64_t _res) {
15517 if (!ptr_is_owned(_res)) return;
15518 void* _res_ptr = untag_ptr(_res);
15519 CHECK_ACCESS(_res_ptr);
15520 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res_conv = *(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(_res_ptr);
15521 FREE(untag_ptr(_res));
15522 CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res_conv);
15525 static inline uint64_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg) {
15526 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
15527 *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(arg);
15528 return tag_ptr(ret_conv, true);
15530 int64_t __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(uint64_t arg) {
15531 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* arg_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(arg);
15532 int64_t ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg_conv);
15536 uint64_t __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(uint64_t orig) {
15537 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(orig);
15538 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
15539 *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig_conv);
15540 return tag_ptr(ret_conv, true);
15543 uint64_t __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok(uint64_t o) {
15544 void* o_ptr = untag_ptr(o);
15545 CHECK_ACCESS(o_ptr);
15546 LDKSpendableOutputDescriptor o_conv = *(LDKSpendableOutputDescriptor*)(o_ptr);
15547 o_conv = SpendableOutputDescriptor_clone((LDKSpendableOutputDescriptor*)untag_ptr(o));
15548 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
15549 *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o_conv);
15550 return tag_ptr(ret_conv, true);
15553 uint64_t __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_err"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_err(uint64_t e) {
15554 void* e_ptr = untag_ptr(e);
15555 CHECK_ACCESS(e_ptr);
15556 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
15557 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
15558 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
15559 *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_err(e_conv);
15560 return tag_ptr(ret_conv, true);
15563 jboolean __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(uint64_t o) {
15564 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* o_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)untag_ptr(o);
15565 jboolean ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o_conv);
15569 void __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free(uint64_t _res) {
15570 if (!ptr_is_owned(_res)) return;
15571 void* _res_ptr = untag_ptr(_res);
15572 CHECK_ACCESS(_res_ptr);
15573 LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res_conv = *(LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(_res_ptr);
15574 FREE(untag_ptr(_res));
15575 CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res_conv);
15578 static inline uint64_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg) {
15579 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
15580 *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_clone(arg);
15581 return tag_ptr(ret_conv, true);
15583 int64_t __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(uint64_t arg) {
15584 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* arg_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)untag_ptr(arg);
15585 int64_t ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg_conv);
15589 uint64_t __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone(uint64_t orig) {
15590 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)untag_ptr(orig);
15591 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
15592 *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig_conv);
15593 return tag_ptr(ret_conv, true);
15596 void __attribute__((export_name("TS_CVec_PaymentPreimageZ_free"))) TS_CVec_PaymentPreimageZ_free(ptrArray _res) {
15597 LDKCVec_PaymentPreimageZ _res_constr;
15598 _res_constr.datalen = _res->arr_len;
15599 if (_res_constr.datalen > 0)
15600 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_PaymentPreimageZ Elements");
15602 _res_constr.data = NULL;
15603 int8_tArray* _res_vals = (void*) _res->elems;
15604 for (size_t m = 0; m < _res_constr.datalen; m++) {
15605 int8_tArray _res_conv_12 = _res_vals[m];
15606 LDKThirtyTwoBytes _res_conv_12_ref;
15607 CHECK(_res_conv_12->arr_len == 32);
15608 memcpy(_res_conv_12_ref.data, _res_conv_12->elems, 32); FREE(_res_conv_12);
15609 _res_constr.data[m] = _res_conv_12_ref;
15612 CVec_PaymentPreimageZ_free(_res_constr);
15615 static inline uint64_t C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR arg) {
15616 LDKC2Tuple_SignatureCVec_SignatureZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
15617 *ret_conv = C2Tuple_SignatureCVec_SignatureZZ_clone(arg);
15618 return tag_ptr(ret_conv, true);
15620 int64_t __attribute__((export_name("TS_C2Tuple_SignatureCVec_SignatureZZ_clone_ptr"))) TS_C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(uint64_t arg) {
15621 LDKC2Tuple_SignatureCVec_SignatureZZ* arg_conv = (LDKC2Tuple_SignatureCVec_SignatureZZ*)untag_ptr(arg);
15622 int64_t ret_conv = C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg_conv);
15626 uint64_t __attribute__((export_name("TS_C2Tuple_SignatureCVec_SignatureZZ_clone"))) TS_C2Tuple_SignatureCVec_SignatureZZ_clone(uint64_t orig) {
15627 LDKC2Tuple_SignatureCVec_SignatureZZ* orig_conv = (LDKC2Tuple_SignatureCVec_SignatureZZ*)untag_ptr(orig);
15628 LDKC2Tuple_SignatureCVec_SignatureZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
15629 *ret_conv = C2Tuple_SignatureCVec_SignatureZZ_clone(orig_conv);
15630 return tag_ptr(ret_conv, true);
15633 uint64_t __attribute__((export_name("TS_C2Tuple_SignatureCVec_SignatureZZ_new"))) TS_C2Tuple_SignatureCVec_SignatureZZ_new(int8_tArray a, ptrArray b) {
15634 LDKSignature a_ref;
15635 CHECK(a->arr_len == 64);
15636 memcpy(a_ref.compact_form, a->elems, 64); FREE(a);
15637 LDKCVec_SignatureZ b_constr;
15638 b_constr.datalen = b->arr_len;
15639 if (b_constr.datalen > 0)
15640 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
15642 b_constr.data = NULL;
15643 int8_tArray* b_vals = (void*) b->elems;
15644 for (size_t m = 0; m < b_constr.datalen; m++) {
15645 int8_tArray b_conv_12 = b_vals[m];
15646 LDKSignature b_conv_12_ref;
15647 CHECK(b_conv_12->arr_len == 64);
15648 memcpy(b_conv_12_ref.compact_form, b_conv_12->elems, 64); FREE(b_conv_12);
15649 b_constr.data[m] = b_conv_12_ref;
15652 LDKC2Tuple_SignatureCVec_SignatureZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
15653 *ret_conv = C2Tuple_SignatureCVec_SignatureZZ_new(a_ref, b_constr);
15654 return tag_ptr(ret_conv, true);
15657 void __attribute__((export_name("TS_C2Tuple_SignatureCVec_SignatureZZ_free"))) TS_C2Tuple_SignatureCVec_SignatureZZ_free(uint64_t _res) {
15658 if (!ptr_is_owned(_res)) return;
15659 void* _res_ptr = untag_ptr(_res);
15660 CHECK_ACCESS(_res_ptr);
15661 LDKC2Tuple_SignatureCVec_SignatureZZ _res_conv = *(LDKC2Tuple_SignatureCVec_SignatureZZ*)(_res_ptr);
15662 FREE(untag_ptr(_res));
15663 C2Tuple_SignatureCVec_SignatureZZ_free(_res_conv);
15666 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(uint64_t o) {
15667 void* o_ptr = untag_ptr(o);
15668 CHECK_ACCESS(o_ptr);
15669 LDKC2Tuple_SignatureCVec_SignatureZZ o_conv = *(LDKC2Tuple_SignatureCVec_SignatureZZ*)(o_ptr);
15670 o_conv = C2Tuple_SignatureCVec_SignatureZZ_clone((LDKC2Tuple_SignatureCVec_SignatureZZ*)untag_ptr(o));
15671 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
15672 *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o_conv);
15673 return tag_ptr(ret_conv, true);
15676 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err() {
15677 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
15678 *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err();
15679 return tag_ptr(ret_conv, true);
15682 jboolean __attribute__((export_name("TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(uint64_t o) {
15683 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* o_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)untag_ptr(o);
15684 jboolean ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o_conv);
15688 void __attribute__((export_name("TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(uint64_t _res) {
15689 if (!ptr_is_owned(_res)) return;
15690 void* _res_ptr = untag_ptr(_res);
15691 CHECK_ACCESS(_res_ptr);
15692 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ _res_conv = *(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(_res_ptr);
15693 FREE(untag_ptr(_res));
15694 CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res_conv);
15697 static inline uint64_t CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR arg) {
15698 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
15699 *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(arg);
15700 return tag_ptr(ret_conv, true);
15702 int64_t __attribute__((export_name("TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(uint64_t arg) {
15703 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* arg_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)untag_ptr(arg);
15704 int64_t ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg_conv);
15708 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(uint64_t orig) {
15709 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* orig_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)untag_ptr(orig);
15710 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
15711 *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig_conv);
15712 return tag_ptr(ret_conv, true);
15715 uint64_t __attribute__((export_name("TS_CResult_SignatureNoneZ_ok"))) TS_CResult_SignatureNoneZ_ok(int8_tArray o) {
15716 LDKSignature o_ref;
15717 CHECK(o->arr_len == 64);
15718 memcpy(o_ref.compact_form, o->elems, 64); FREE(o);
15719 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
15720 *ret_conv = CResult_SignatureNoneZ_ok(o_ref);
15721 return tag_ptr(ret_conv, true);
15724 uint64_t __attribute__((export_name("TS_CResult_SignatureNoneZ_err"))) TS_CResult_SignatureNoneZ_err() {
15725 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
15726 *ret_conv = CResult_SignatureNoneZ_err();
15727 return tag_ptr(ret_conv, true);
15730 jboolean __attribute__((export_name("TS_CResult_SignatureNoneZ_is_ok"))) TS_CResult_SignatureNoneZ_is_ok(uint64_t o) {
15731 LDKCResult_SignatureNoneZ* o_conv = (LDKCResult_SignatureNoneZ*)untag_ptr(o);
15732 jboolean ret_conv = CResult_SignatureNoneZ_is_ok(o_conv);
15736 void __attribute__((export_name("TS_CResult_SignatureNoneZ_free"))) TS_CResult_SignatureNoneZ_free(uint64_t _res) {
15737 if (!ptr_is_owned(_res)) return;
15738 void* _res_ptr = untag_ptr(_res);
15739 CHECK_ACCESS(_res_ptr);
15740 LDKCResult_SignatureNoneZ _res_conv = *(LDKCResult_SignatureNoneZ*)(_res_ptr);
15741 FREE(untag_ptr(_res));
15742 CResult_SignatureNoneZ_free(_res_conv);
15745 static inline uint64_t CResult_SignatureNoneZ_clone_ptr(LDKCResult_SignatureNoneZ *NONNULL_PTR arg) {
15746 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
15747 *ret_conv = CResult_SignatureNoneZ_clone(arg);
15748 return tag_ptr(ret_conv, true);
15750 int64_t __attribute__((export_name("TS_CResult_SignatureNoneZ_clone_ptr"))) TS_CResult_SignatureNoneZ_clone_ptr(uint64_t arg) {
15751 LDKCResult_SignatureNoneZ* arg_conv = (LDKCResult_SignatureNoneZ*)untag_ptr(arg);
15752 int64_t ret_conv = CResult_SignatureNoneZ_clone_ptr(arg_conv);
15756 uint64_t __attribute__((export_name("TS_CResult_SignatureNoneZ_clone"))) TS_CResult_SignatureNoneZ_clone(uint64_t orig) {
15757 LDKCResult_SignatureNoneZ* orig_conv = (LDKCResult_SignatureNoneZ*)untag_ptr(orig);
15758 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
15759 *ret_conv = CResult_SignatureNoneZ_clone(orig_conv);
15760 return tag_ptr(ret_conv, true);
15763 static inline uint64_t C2Tuple_SignatureSignatureZ_clone_ptr(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR arg) {
15764 LDKC2Tuple_SignatureSignatureZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureSignatureZ), "LDKC2Tuple_SignatureSignatureZ");
15765 *ret_conv = C2Tuple_SignatureSignatureZ_clone(arg);
15766 return tag_ptr(ret_conv, true);
15768 int64_t __attribute__((export_name("TS_C2Tuple_SignatureSignatureZ_clone_ptr"))) TS_C2Tuple_SignatureSignatureZ_clone_ptr(uint64_t arg) {
15769 LDKC2Tuple_SignatureSignatureZ* arg_conv = (LDKC2Tuple_SignatureSignatureZ*)untag_ptr(arg);
15770 int64_t ret_conv = C2Tuple_SignatureSignatureZ_clone_ptr(arg_conv);
15774 uint64_t __attribute__((export_name("TS_C2Tuple_SignatureSignatureZ_clone"))) TS_C2Tuple_SignatureSignatureZ_clone(uint64_t orig) {
15775 LDKC2Tuple_SignatureSignatureZ* orig_conv = (LDKC2Tuple_SignatureSignatureZ*)untag_ptr(orig);
15776 LDKC2Tuple_SignatureSignatureZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureSignatureZ), "LDKC2Tuple_SignatureSignatureZ");
15777 *ret_conv = C2Tuple_SignatureSignatureZ_clone(orig_conv);
15778 return tag_ptr(ret_conv, true);
15781 uint64_t __attribute__((export_name("TS_C2Tuple_SignatureSignatureZ_new"))) TS_C2Tuple_SignatureSignatureZ_new(int8_tArray a, int8_tArray b) {
15782 LDKSignature a_ref;
15783 CHECK(a->arr_len == 64);
15784 memcpy(a_ref.compact_form, a->elems, 64); FREE(a);
15785 LDKSignature b_ref;
15786 CHECK(b->arr_len == 64);
15787 memcpy(b_ref.compact_form, b->elems, 64); FREE(b);
15788 LDKC2Tuple_SignatureSignatureZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureSignatureZ), "LDKC2Tuple_SignatureSignatureZ");
15789 *ret_conv = C2Tuple_SignatureSignatureZ_new(a_ref, b_ref);
15790 return tag_ptr(ret_conv, true);
15793 void __attribute__((export_name("TS_C2Tuple_SignatureSignatureZ_free"))) TS_C2Tuple_SignatureSignatureZ_free(uint64_t _res) {
15794 if (!ptr_is_owned(_res)) return;
15795 void* _res_ptr = untag_ptr(_res);
15796 CHECK_ACCESS(_res_ptr);
15797 LDKC2Tuple_SignatureSignatureZ _res_conv = *(LDKC2Tuple_SignatureSignatureZ*)(_res_ptr);
15798 FREE(untag_ptr(_res));
15799 C2Tuple_SignatureSignatureZ_free(_res_conv);
15802 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_SignatureSignatureZNoneZ_ok"))) TS_CResult_C2Tuple_SignatureSignatureZNoneZ_ok(uint64_t o) {
15803 void* o_ptr = untag_ptr(o);
15804 CHECK_ACCESS(o_ptr);
15805 LDKC2Tuple_SignatureSignatureZ o_conv = *(LDKC2Tuple_SignatureSignatureZ*)(o_ptr);
15806 o_conv = C2Tuple_SignatureSignatureZ_clone((LDKC2Tuple_SignatureSignatureZ*)untag_ptr(o));
15807 LDKCResult_C2Tuple_SignatureSignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureSignatureZNoneZ), "LDKCResult_C2Tuple_SignatureSignatureZNoneZ");
15808 *ret_conv = CResult_C2Tuple_SignatureSignatureZNoneZ_ok(o_conv);
15809 return tag_ptr(ret_conv, true);
15812 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_SignatureSignatureZNoneZ_err"))) TS_CResult_C2Tuple_SignatureSignatureZNoneZ_err() {
15813 LDKCResult_C2Tuple_SignatureSignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureSignatureZNoneZ), "LDKCResult_C2Tuple_SignatureSignatureZNoneZ");
15814 *ret_conv = CResult_C2Tuple_SignatureSignatureZNoneZ_err();
15815 return tag_ptr(ret_conv, true);
15818 jboolean __attribute__((export_name("TS_CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok"))) TS_CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(uint64_t o) {
15819 LDKCResult_C2Tuple_SignatureSignatureZNoneZ* o_conv = (LDKCResult_C2Tuple_SignatureSignatureZNoneZ*)untag_ptr(o);
15820 jboolean ret_conv = CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(o_conv);
15824 void __attribute__((export_name("TS_CResult_C2Tuple_SignatureSignatureZNoneZ_free"))) TS_CResult_C2Tuple_SignatureSignatureZNoneZ_free(uint64_t _res) {
15825 if (!ptr_is_owned(_res)) return;
15826 void* _res_ptr = untag_ptr(_res);
15827 CHECK_ACCESS(_res_ptr);
15828 LDKCResult_C2Tuple_SignatureSignatureZNoneZ _res_conv = *(LDKCResult_C2Tuple_SignatureSignatureZNoneZ*)(_res_ptr);
15829 FREE(untag_ptr(_res));
15830 CResult_C2Tuple_SignatureSignatureZNoneZ_free(_res_conv);
15833 static inline uint64_t CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR arg) {
15834 LDKCResult_C2Tuple_SignatureSignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureSignatureZNoneZ), "LDKCResult_C2Tuple_SignatureSignatureZNoneZ");
15835 *ret_conv = CResult_C2Tuple_SignatureSignatureZNoneZ_clone(arg);
15836 return tag_ptr(ret_conv, true);
15838 int64_t __attribute__((export_name("TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr"))) TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(uint64_t arg) {
15839 LDKCResult_C2Tuple_SignatureSignatureZNoneZ* arg_conv = (LDKCResult_C2Tuple_SignatureSignatureZNoneZ*)untag_ptr(arg);
15840 int64_t ret_conv = CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(arg_conv);
15844 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone"))) TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone(uint64_t orig) {
15845 LDKCResult_C2Tuple_SignatureSignatureZNoneZ* orig_conv = (LDKCResult_C2Tuple_SignatureSignatureZNoneZ*)untag_ptr(orig);
15846 LDKCResult_C2Tuple_SignatureSignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureSignatureZNoneZ), "LDKCResult_C2Tuple_SignatureSignatureZNoneZ");
15847 *ret_conv = CResult_C2Tuple_SignatureSignatureZNoneZ_clone(orig_conv);
15848 return tag_ptr(ret_conv, true);
15851 uint64_t __attribute__((export_name("TS_CResult_SecretKeyNoneZ_ok"))) TS_CResult_SecretKeyNoneZ_ok(int8_tArray o) {
15852 LDKSecretKey o_ref;
15853 CHECK(o->arr_len == 32);
15854 memcpy(o_ref.bytes, o->elems, 32); FREE(o);
15855 LDKCResult_SecretKeyNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SecretKeyNoneZ), "LDKCResult_SecretKeyNoneZ");
15856 *ret_conv = CResult_SecretKeyNoneZ_ok(o_ref);
15857 return tag_ptr(ret_conv, true);
15860 uint64_t __attribute__((export_name("TS_CResult_SecretKeyNoneZ_err"))) TS_CResult_SecretKeyNoneZ_err() {
15861 LDKCResult_SecretKeyNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SecretKeyNoneZ), "LDKCResult_SecretKeyNoneZ");
15862 *ret_conv = CResult_SecretKeyNoneZ_err();
15863 return tag_ptr(ret_conv, true);
15866 jboolean __attribute__((export_name("TS_CResult_SecretKeyNoneZ_is_ok"))) TS_CResult_SecretKeyNoneZ_is_ok(uint64_t o) {
15867 LDKCResult_SecretKeyNoneZ* o_conv = (LDKCResult_SecretKeyNoneZ*)untag_ptr(o);
15868 jboolean ret_conv = CResult_SecretKeyNoneZ_is_ok(o_conv);
15872 void __attribute__((export_name("TS_CResult_SecretKeyNoneZ_free"))) TS_CResult_SecretKeyNoneZ_free(uint64_t _res) {
15873 if (!ptr_is_owned(_res)) return;
15874 void* _res_ptr = untag_ptr(_res);
15875 CHECK_ACCESS(_res_ptr);
15876 LDKCResult_SecretKeyNoneZ _res_conv = *(LDKCResult_SecretKeyNoneZ*)(_res_ptr);
15877 FREE(untag_ptr(_res));
15878 CResult_SecretKeyNoneZ_free(_res_conv);
15881 static inline uint64_t CResult_SecretKeyNoneZ_clone_ptr(LDKCResult_SecretKeyNoneZ *NONNULL_PTR arg) {
15882 LDKCResult_SecretKeyNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SecretKeyNoneZ), "LDKCResult_SecretKeyNoneZ");
15883 *ret_conv = CResult_SecretKeyNoneZ_clone(arg);
15884 return tag_ptr(ret_conv, true);
15886 int64_t __attribute__((export_name("TS_CResult_SecretKeyNoneZ_clone_ptr"))) TS_CResult_SecretKeyNoneZ_clone_ptr(uint64_t arg) {
15887 LDKCResult_SecretKeyNoneZ* arg_conv = (LDKCResult_SecretKeyNoneZ*)untag_ptr(arg);
15888 int64_t ret_conv = CResult_SecretKeyNoneZ_clone_ptr(arg_conv);
15892 uint64_t __attribute__((export_name("TS_CResult_SecretKeyNoneZ_clone"))) TS_CResult_SecretKeyNoneZ_clone(uint64_t orig) {
15893 LDKCResult_SecretKeyNoneZ* orig_conv = (LDKCResult_SecretKeyNoneZ*)untag_ptr(orig);
15894 LDKCResult_SecretKeyNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SecretKeyNoneZ), "LDKCResult_SecretKeyNoneZ");
15895 *ret_conv = CResult_SecretKeyNoneZ_clone(orig_conv);
15896 return tag_ptr(ret_conv, true);
15899 uint64_t __attribute__((export_name("TS_CResult_PublicKeyNoneZ_ok"))) TS_CResult_PublicKeyNoneZ_ok(int8_tArray o) {
15900 LDKPublicKey o_ref;
15901 CHECK(o->arr_len == 33);
15902 memcpy(o_ref.compressed_form, o->elems, 33); FREE(o);
15903 LDKCResult_PublicKeyNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyNoneZ), "LDKCResult_PublicKeyNoneZ");
15904 *ret_conv = CResult_PublicKeyNoneZ_ok(o_ref);
15905 return tag_ptr(ret_conv, true);
15908 uint64_t __attribute__((export_name("TS_CResult_PublicKeyNoneZ_err"))) TS_CResult_PublicKeyNoneZ_err() {
15909 LDKCResult_PublicKeyNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyNoneZ), "LDKCResult_PublicKeyNoneZ");
15910 *ret_conv = CResult_PublicKeyNoneZ_err();
15911 return tag_ptr(ret_conv, true);
15914 jboolean __attribute__((export_name("TS_CResult_PublicKeyNoneZ_is_ok"))) TS_CResult_PublicKeyNoneZ_is_ok(uint64_t o) {
15915 LDKCResult_PublicKeyNoneZ* o_conv = (LDKCResult_PublicKeyNoneZ*)untag_ptr(o);
15916 jboolean ret_conv = CResult_PublicKeyNoneZ_is_ok(o_conv);
15920 void __attribute__((export_name("TS_CResult_PublicKeyNoneZ_free"))) TS_CResult_PublicKeyNoneZ_free(uint64_t _res) {
15921 if (!ptr_is_owned(_res)) return;
15922 void* _res_ptr = untag_ptr(_res);
15923 CHECK_ACCESS(_res_ptr);
15924 LDKCResult_PublicKeyNoneZ _res_conv = *(LDKCResult_PublicKeyNoneZ*)(_res_ptr);
15925 FREE(untag_ptr(_res));
15926 CResult_PublicKeyNoneZ_free(_res_conv);
15929 static inline uint64_t CResult_PublicKeyNoneZ_clone_ptr(LDKCResult_PublicKeyNoneZ *NONNULL_PTR arg) {
15930 LDKCResult_PublicKeyNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyNoneZ), "LDKCResult_PublicKeyNoneZ");
15931 *ret_conv = CResult_PublicKeyNoneZ_clone(arg);
15932 return tag_ptr(ret_conv, true);
15934 int64_t __attribute__((export_name("TS_CResult_PublicKeyNoneZ_clone_ptr"))) TS_CResult_PublicKeyNoneZ_clone_ptr(uint64_t arg) {
15935 LDKCResult_PublicKeyNoneZ* arg_conv = (LDKCResult_PublicKeyNoneZ*)untag_ptr(arg);
15936 int64_t ret_conv = CResult_PublicKeyNoneZ_clone_ptr(arg_conv);
15940 uint64_t __attribute__((export_name("TS_CResult_PublicKeyNoneZ_clone"))) TS_CResult_PublicKeyNoneZ_clone(uint64_t orig) {
15941 LDKCResult_PublicKeyNoneZ* orig_conv = (LDKCResult_PublicKeyNoneZ*)untag_ptr(orig);
15942 LDKCResult_PublicKeyNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyNoneZ), "LDKCResult_PublicKeyNoneZ");
15943 *ret_conv = CResult_PublicKeyNoneZ_clone(orig_conv);
15944 return tag_ptr(ret_conv, true);
15947 uint64_t __attribute__((export_name("TS_COption_ScalarZ_some"))) TS_COption_ScalarZ_some(uint64_t o) {
15948 void* o_ptr = untag_ptr(o);
15949 CHECK_ACCESS(o_ptr);
15950 LDKBigEndianScalar o_conv = *(LDKBigEndianScalar*)(o_ptr);
15951 // WARNING: we may need a move here but no clone is available for LDKBigEndianScalar
15952 LDKCOption_ScalarZ *ret_copy = MALLOC(sizeof(LDKCOption_ScalarZ), "LDKCOption_ScalarZ");
15953 *ret_copy = COption_ScalarZ_some(o_conv);
15954 uint64_t ret_ref = tag_ptr(ret_copy, true);
15958 uint64_t __attribute__((export_name("TS_COption_ScalarZ_none"))) TS_COption_ScalarZ_none() {
15959 LDKCOption_ScalarZ *ret_copy = MALLOC(sizeof(LDKCOption_ScalarZ), "LDKCOption_ScalarZ");
15960 *ret_copy = COption_ScalarZ_none();
15961 uint64_t ret_ref = tag_ptr(ret_copy, true);
15965 void __attribute__((export_name("TS_COption_ScalarZ_free"))) TS_COption_ScalarZ_free(uint64_t _res) {
15966 if (!ptr_is_owned(_res)) return;
15967 void* _res_ptr = untag_ptr(_res);
15968 CHECK_ACCESS(_res_ptr);
15969 LDKCOption_ScalarZ _res_conv = *(LDKCOption_ScalarZ*)(_res_ptr);
15970 FREE(untag_ptr(_res));
15971 COption_ScalarZ_free(_res_conv);
15974 uint64_t __attribute__((export_name("TS_CResult_SharedSecretNoneZ_ok"))) TS_CResult_SharedSecretNoneZ_ok(int8_tArray o) {
15975 LDKThirtyTwoBytes o_ref;
15976 CHECK(o->arr_len == 32);
15977 memcpy(o_ref.data, o->elems, 32); FREE(o);
15978 LDKCResult_SharedSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SharedSecretNoneZ), "LDKCResult_SharedSecretNoneZ");
15979 *ret_conv = CResult_SharedSecretNoneZ_ok(o_ref);
15980 return tag_ptr(ret_conv, true);
15983 uint64_t __attribute__((export_name("TS_CResult_SharedSecretNoneZ_err"))) TS_CResult_SharedSecretNoneZ_err() {
15984 LDKCResult_SharedSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SharedSecretNoneZ), "LDKCResult_SharedSecretNoneZ");
15985 *ret_conv = CResult_SharedSecretNoneZ_err();
15986 return tag_ptr(ret_conv, true);
15989 jboolean __attribute__((export_name("TS_CResult_SharedSecretNoneZ_is_ok"))) TS_CResult_SharedSecretNoneZ_is_ok(uint64_t o) {
15990 LDKCResult_SharedSecretNoneZ* o_conv = (LDKCResult_SharedSecretNoneZ*)untag_ptr(o);
15991 jboolean ret_conv = CResult_SharedSecretNoneZ_is_ok(o_conv);
15995 void __attribute__((export_name("TS_CResult_SharedSecretNoneZ_free"))) TS_CResult_SharedSecretNoneZ_free(uint64_t _res) {
15996 if (!ptr_is_owned(_res)) return;
15997 void* _res_ptr = untag_ptr(_res);
15998 CHECK_ACCESS(_res_ptr);
15999 LDKCResult_SharedSecretNoneZ _res_conv = *(LDKCResult_SharedSecretNoneZ*)(_res_ptr);
16000 FREE(untag_ptr(_res));
16001 CResult_SharedSecretNoneZ_free(_res_conv);
16004 static inline uint64_t CResult_SharedSecretNoneZ_clone_ptr(LDKCResult_SharedSecretNoneZ *NONNULL_PTR arg) {
16005 LDKCResult_SharedSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SharedSecretNoneZ), "LDKCResult_SharedSecretNoneZ");
16006 *ret_conv = CResult_SharedSecretNoneZ_clone(arg);
16007 return tag_ptr(ret_conv, true);
16009 int64_t __attribute__((export_name("TS_CResult_SharedSecretNoneZ_clone_ptr"))) TS_CResult_SharedSecretNoneZ_clone_ptr(uint64_t arg) {
16010 LDKCResult_SharedSecretNoneZ* arg_conv = (LDKCResult_SharedSecretNoneZ*)untag_ptr(arg);
16011 int64_t ret_conv = CResult_SharedSecretNoneZ_clone_ptr(arg_conv);
16015 uint64_t __attribute__((export_name("TS_CResult_SharedSecretNoneZ_clone"))) TS_CResult_SharedSecretNoneZ_clone(uint64_t orig) {
16016 LDKCResult_SharedSecretNoneZ* orig_conv = (LDKCResult_SharedSecretNoneZ*)untag_ptr(orig);
16017 LDKCResult_SharedSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SharedSecretNoneZ), "LDKCResult_SharedSecretNoneZ");
16018 *ret_conv = CResult_SharedSecretNoneZ_clone(orig_conv);
16019 return tag_ptr(ret_conv, true);
16022 uint64_t __attribute__((export_name("TS_CResult_SignDecodeErrorZ_ok"))) TS_CResult_SignDecodeErrorZ_ok(uint64_t o) {
16023 void* o_ptr = untag_ptr(o);
16024 CHECK_ACCESS(o_ptr);
16025 LDKSign o_conv = *(LDKSign*)(o_ptr);
16026 if (o_conv.free == LDKSign_JCalls_free) {
16027 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
16028 LDKSign_JCalls_cloned(&o_conv);
16030 LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
16031 *ret_conv = CResult_SignDecodeErrorZ_ok(o_conv);
16032 return tag_ptr(ret_conv, true);
16035 uint64_t __attribute__((export_name("TS_CResult_SignDecodeErrorZ_err"))) TS_CResult_SignDecodeErrorZ_err(uint64_t e) {
16036 void* e_ptr = untag_ptr(e);
16037 CHECK_ACCESS(e_ptr);
16038 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
16039 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
16040 LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
16041 *ret_conv = CResult_SignDecodeErrorZ_err(e_conv);
16042 return tag_ptr(ret_conv, true);
16045 jboolean __attribute__((export_name("TS_CResult_SignDecodeErrorZ_is_ok"))) TS_CResult_SignDecodeErrorZ_is_ok(uint64_t o) {
16046 LDKCResult_SignDecodeErrorZ* o_conv = (LDKCResult_SignDecodeErrorZ*)untag_ptr(o);
16047 jboolean ret_conv = CResult_SignDecodeErrorZ_is_ok(o_conv);
16051 void __attribute__((export_name("TS_CResult_SignDecodeErrorZ_free"))) TS_CResult_SignDecodeErrorZ_free(uint64_t _res) {
16052 if (!ptr_is_owned(_res)) return;
16053 void* _res_ptr = untag_ptr(_res);
16054 CHECK_ACCESS(_res_ptr);
16055 LDKCResult_SignDecodeErrorZ _res_conv = *(LDKCResult_SignDecodeErrorZ*)(_res_ptr);
16056 FREE(untag_ptr(_res));
16057 CResult_SignDecodeErrorZ_free(_res_conv);
16060 static inline uint64_t CResult_SignDecodeErrorZ_clone_ptr(LDKCResult_SignDecodeErrorZ *NONNULL_PTR arg) {
16061 LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
16062 *ret_conv = CResult_SignDecodeErrorZ_clone(arg);
16063 return tag_ptr(ret_conv, true);
16065 int64_t __attribute__((export_name("TS_CResult_SignDecodeErrorZ_clone_ptr"))) TS_CResult_SignDecodeErrorZ_clone_ptr(uint64_t arg) {
16066 LDKCResult_SignDecodeErrorZ* arg_conv = (LDKCResult_SignDecodeErrorZ*)untag_ptr(arg);
16067 int64_t ret_conv = CResult_SignDecodeErrorZ_clone_ptr(arg_conv);
16071 uint64_t __attribute__((export_name("TS_CResult_SignDecodeErrorZ_clone"))) TS_CResult_SignDecodeErrorZ_clone(uint64_t orig) {
16072 LDKCResult_SignDecodeErrorZ* orig_conv = (LDKCResult_SignDecodeErrorZ*)untag_ptr(orig);
16073 LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
16074 *ret_conv = CResult_SignDecodeErrorZ_clone(orig_conv);
16075 return tag_ptr(ret_conv, true);
16078 void __attribute__((export_name("TS_CVec_U5Z_free"))) TS_CVec_U5Z_free(ptrArray _res) {
16079 LDKCVec_U5Z _res_constr;
16080 _res_constr.datalen = _res->arr_len;
16081 if (_res_constr.datalen > 0)
16082 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKU5), "LDKCVec_U5Z Elements");
16084 _res_constr.data = NULL;
16085 int8_t* _res_vals = (void*) _res->elems;
16086 for (size_t h = 0; h < _res_constr.datalen; h++) {
16087 int8_t _res_conv_7 = _res_vals[h];
16089 _res_constr.data[h] = (LDKU5){ ._0 = _res_conv_7 };
16092 CVec_U5Z_free(_res_constr);
16095 uint64_t __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_ok"))) TS_CResult_RecoverableSignatureNoneZ_ok(int8_tArray o) {
16096 LDKRecoverableSignature o_ref;
16097 CHECK(o->arr_len == 68);
16098 memcpy(o_ref.serialized_form, o->elems, 68); FREE(o);
16099 LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
16100 *ret_conv = CResult_RecoverableSignatureNoneZ_ok(o_ref);
16101 return tag_ptr(ret_conv, true);
16104 uint64_t __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_err"))) TS_CResult_RecoverableSignatureNoneZ_err() {
16105 LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
16106 *ret_conv = CResult_RecoverableSignatureNoneZ_err();
16107 return tag_ptr(ret_conv, true);
16110 jboolean __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_is_ok"))) TS_CResult_RecoverableSignatureNoneZ_is_ok(uint64_t o) {
16111 LDKCResult_RecoverableSignatureNoneZ* o_conv = (LDKCResult_RecoverableSignatureNoneZ*)untag_ptr(o);
16112 jboolean ret_conv = CResult_RecoverableSignatureNoneZ_is_ok(o_conv);
16116 void __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_free"))) TS_CResult_RecoverableSignatureNoneZ_free(uint64_t _res) {
16117 if (!ptr_is_owned(_res)) return;
16118 void* _res_ptr = untag_ptr(_res);
16119 CHECK_ACCESS(_res_ptr);
16120 LDKCResult_RecoverableSignatureNoneZ _res_conv = *(LDKCResult_RecoverableSignatureNoneZ*)(_res_ptr);
16121 FREE(untag_ptr(_res));
16122 CResult_RecoverableSignatureNoneZ_free(_res_conv);
16125 static inline uint64_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg) {
16126 LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
16127 *ret_conv = CResult_RecoverableSignatureNoneZ_clone(arg);
16128 return tag_ptr(ret_conv, true);
16130 int64_t __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_clone_ptr"))) TS_CResult_RecoverableSignatureNoneZ_clone_ptr(uint64_t arg) {
16131 LDKCResult_RecoverableSignatureNoneZ* arg_conv = (LDKCResult_RecoverableSignatureNoneZ*)untag_ptr(arg);
16132 int64_t ret_conv = CResult_RecoverableSignatureNoneZ_clone_ptr(arg_conv);
16136 uint64_t __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_clone"))) TS_CResult_RecoverableSignatureNoneZ_clone(uint64_t orig) {
16137 LDKCResult_RecoverableSignatureNoneZ* orig_conv = (LDKCResult_RecoverableSignatureNoneZ*)untag_ptr(orig);
16138 LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
16139 *ret_conv = CResult_RecoverableSignatureNoneZ_clone(orig_conv);
16140 return tag_ptr(ret_conv, true);
16143 void __attribute__((export_name("TS_CVec_u8Z_free"))) TS_CVec_u8Z_free(int8_tArray _res) {
16144 LDKCVec_u8Z _res_ref;
16145 _res_ref.datalen = _res->arr_len;
16146 _res_ref.data = MALLOC(_res_ref.datalen, "LDKCVec_u8Z Bytes");
16147 memcpy(_res_ref.data, _res->elems, _res_ref.datalen); FREE(_res);
16148 CVec_u8Z_free(_res_ref);
16151 void __attribute__((export_name("TS_CVec_CVec_u8ZZ_free"))) TS_CVec_CVec_u8ZZ_free(ptrArray _res) {
16152 LDKCVec_CVec_u8ZZ _res_constr;
16153 _res_constr.datalen = _res->arr_len;
16154 if (_res_constr.datalen > 0)
16155 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKCVec_u8Z), "LDKCVec_CVec_u8ZZ Elements");
16157 _res_constr.data = NULL;
16158 int8_tArray* _res_vals = (void*) _res->elems;
16159 for (size_t m = 0; m < _res_constr.datalen; m++) {
16160 int8_tArray _res_conv_12 = _res_vals[m];
16161 LDKCVec_u8Z _res_conv_12_ref;
16162 _res_conv_12_ref.datalen = _res_conv_12->arr_len;
16163 _res_conv_12_ref.data = MALLOC(_res_conv_12_ref.datalen, "LDKCVec_u8Z Bytes");
16164 memcpy(_res_conv_12_ref.data, _res_conv_12->elems, _res_conv_12_ref.datalen); FREE(_res_conv_12);
16165 _res_constr.data[m] = _res_conv_12_ref;
16168 CVec_CVec_u8ZZ_free(_res_constr);
16171 uint64_t __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_ok"))) TS_CResult_CVec_CVec_u8ZZNoneZ_ok(ptrArray o) {
16172 LDKCVec_CVec_u8ZZ o_constr;
16173 o_constr.datalen = o->arr_len;
16174 if (o_constr.datalen > 0)
16175 o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKCVec_u8Z), "LDKCVec_CVec_u8ZZ Elements");
16177 o_constr.data = NULL;
16178 int8_tArray* o_vals = (void*) o->elems;
16179 for (size_t m = 0; m < o_constr.datalen; m++) {
16180 int8_tArray o_conv_12 = o_vals[m];
16181 LDKCVec_u8Z o_conv_12_ref;
16182 o_conv_12_ref.datalen = o_conv_12->arr_len;
16183 o_conv_12_ref.data = MALLOC(o_conv_12_ref.datalen, "LDKCVec_u8Z Bytes");
16184 memcpy(o_conv_12_ref.data, o_conv_12->elems, o_conv_12_ref.datalen); FREE(o_conv_12);
16185 o_constr.data[m] = o_conv_12_ref;
16188 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
16189 *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_ok(o_constr);
16190 return tag_ptr(ret_conv, true);
16193 uint64_t __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_err"))) TS_CResult_CVec_CVec_u8ZZNoneZ_err() {
16194 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
16195 *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_err();
16196 return tag_ptr(ret_conv, true);
16199 jboolean __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_is_ok"))) TS_CResult_CVec_CVec_u8ZZNoneZ_is_ok(uint64_t o) {
16200 LDKCResult_CVec_CVec_u8ZZNoneZ* o_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)untag_ptr(o);
16201 jboolean ret_conv = CResult_CVec_CVec_u8ZZNoneZ_is_ok(o_conv);
16205 void __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_free"))) TS_CResult_CVec_CVec_u8ZZNoneZ_free(uint64_t _res) {
16206 if (!ptr_is_owned(_res)) return;
16207 void* _res_ptr = untag_ptr(_res);
16208 CHECK_ACCESS(_res_ptr);
16209 LDKCResult_CVec_CVec_u8ZZNoneZ _res_conv = *(LDKCResult_CVec_CVec_u8ZZNoneZ*)(_res_ptr);
16210 FREE(untag_ptr(_res));
16211 CResult_CVec_CVec_u8ZZNoneZ_free(_res_conv);
16214 static inline uint64_t CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR arg) {
16215 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
16216 *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_clone(arg);
16217 return tag_ptr(ret_conv, true);
16219 int64_t __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_clone_ptr"))) TS_CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(uint64_t arg) {
16220 LDKCResult_CVec_CVec_u8ZZNoneZ* arg_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)untag_ptr(arg);
16221 int64_t ret_conv = CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg_conv);
16225 uint64_t __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_clone"))) TS_CResult_CVec_CVec_u8ZZNoneZ_clone(uint64_t orig) {
16226 LDKCResult_CVec_CVec_u8ZZNoneZ* orig_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)untag_ptr(orig);
16227 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
16228 *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_clone(orig_conv);
16229 return tag_ptr(ret_conv, true);
16232 uint64_t __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_ok"))) TS_CResult_InMemorySignerDecodeErrorZ_ok(uint64_t o) {
16233 LDKInMemorySigner o_conv;
16234 o_conv.inner = untag_ptr(o);
16235 o_conv.is_owned = ptr_is_owned(o);
16236 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
16237 o_conv = InMemorySigner_clone(&o_conv);
16238 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
16239 *ret_conv = CResult_InMemorySignerDecodeErrorZ_ok(o_conv);
16240 return tag_ptr(ret_conv, true);
16243 uint64_t __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_err"))) TS_CResult_InMemorySignerDecodeErrorZ_err(uint64_t e) {
16244 void* e_ptr = untag_ptr(e);
16245 CHECK_ACCESS(e_ptr);
16246 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
16247 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
16248 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
16249 *ret_conv = CResult_InMemorySignerDecodeErrorZ_err(e_conv);
16250 return tag_ptr(ret_conv, true);
16253 jboolean __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_is_ok"))) TS_CResult_InMemorySignerDecodeErrorZ_is_ok(uint64_t o) {
16254 LDKCResult_InMemorySignerDecodeErrorZ* o_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)untag_ptr(o);
16255 jboolean ret_conv = CResult_InMemorySignerDecodeErrorZ_is_ok(o_conv);
16259 void __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_free"))) TS_CResult_InMemorySignerDecodeErrorZ_free(uint64_t _res) {
16260 if (!ptr_is_owned(_res)) return;
16261 void* _res_ptr = untag_ptr(_res);
16262 CHECK_ACCESS(_res_ptr);
16263 LDKCResult_InMemorySignerDecodeErrorZ _res_conv = *(LDKCResult_InMemorySignerDecodeErrorZ*)(_res_ptr);
16264 FREE(untag_ptr(_res));
16265 CResult_InMemorySignerDecodeErrorZ_free(_res_conv);
16268 static inline uint64_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg) {
16269 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
16270 *ret_conv = CResult_InMemorySignerDecodeErrorZ_clone(arg);
16271 return tag_ptr(ret_conv, true);
16273 int64_t __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr"))) TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr(uint64_t arg) {
16274 LDKCResult_InMemorySignerDecodeErrorZ* arg_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)untag_ptr(arg);
16275 int64_t ret_conv = CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg_conv);
16279 uint64_t __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_clone"))) TS_CResult_InMemorySignerDecodeErrorZ_clone(uint64_t orig) {
16280 LDKCResult_InMemorySignerDecodeErrorZ* orig_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)untag_ptr(orig);
16281 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
16282 *ret_conv = CResult_InMemorySignerDecodeErrorZ_clone(orig_conv);
16283 return tag_ptr(ret_conv, true);
16286 void __attribute__((export_name("TS_CVec_TxOutZ_free"))) TS_CVec_TxOutZ_free(uint64_tArray _res) {
16287 LDKCVec_TxOutZ _res_constr;
16288 _res_constr.datalen = _res->arr_len;
16289 if (_res_constr.datalen > 0)
16290 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKTxOut), "LDKCVec_TxOutZ Elements");
16292 _res_constr.data = NULL;
16293 uint64_t* _res_vals = _res->elems;
16294 for (size_t h = 0; h < _res_constr.datalen; h++) {
16295 uint64_t _res_conv_7 = _res_vals[h];
16296 void* _res_conv_7_ptr = untag_ptr(_res_conv_7);
16297 CHECK_ACCESS(_res_conv_7_ptr);
16298 LDKTxOut _res_conv_7_conv = *(LDKTxOut*)(_res_conv_7_ptr);
16299 FREE(untag_ptr(_res_conv_7));
16300 _res_constr.data[h] = _res_conv_7_conv;
16303 CVec_TxOutZ_free(_res_constr);
16306 uint64_t __attribute__((export_name("TS_CResult_TransactionNoneZ_ok"))) TS_CResult_TransactionNoneZ_ok(int8_tArray o) {
16307 LDKTransaction o_ref;
16308 o_ref.datalen = o->arr_len;
16309 o_ref.data = MALLOC(o_ref.datalen, "LDKTransaction Bytes");
16310 memcpy(o_ref.data, o->elems, o_ref.datalen); FREE(o);
16311 o_ref.data_is_owned = true;
16312 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
16313 *ret_conv = CResult_TransactionNoneZ_ok(o_ref);
16314 return tag_ptr(ret_conv, true);
16317 uint64_t __attribute__((export_name("TS_CResult_TransactionNoneZ_err"))) TS_CResult_TransactionNoneZ_err() {
16318 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
16319 *ret_conv = CResult_TransactionNoneZ_err();
16320 return tag_ptr(ret_conv, true);
16323 jboolean __attribute__((export_name("TS_CResult_TransactionNoneZ_is_ok"))) TS_CResult_TransactionNoneZ_is_ok(uint64_t o) {
16324 LDKCResult_TransactionNoneZ* o_conv = (LDKCResult_TransactionNoneZ*)untag_ptr(o);
16325 jboolean ret_conv = CResult_TransactionNoneZ_is_ok(o_conv);
16329 void __attribute__((export_name("TS_CResult_TransactionNoneZ_free"))) TS_CResult_TransactionNoneZ_free(uint64_t _res) {
16330 if (!ptr_is_owned(_res)) return;
16331 void* _res_ptr = untag_ptr(_res);
16332 CHECK_ACCESS(_res_ptr);
16333 LDKCResult_TransactionNoneZ _res_conv = *(LDKCResult_TransactionNoneZ*)(_res_ptr);
16334 FREE(untag_ptr(_res));
16335 CResult_TransactionNoneZ_free(_res_conv);
16338 static inline uint64_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg) {
16339 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
16340 *ret_conv = CResult_TransactionNoneZ_clone(arg);
16341 return tag_ptr(ret_conv, true);
16343 int64_t __attribute__((export_name("TS_CResult_TransactionNoneZ_clone_ptr"))) TS_CResult_TransactionNoneZ_clone_ptr(uint64_t arg) {
16344 LDKCResult_TransactionNoneZ* arg_conv = (LDKCResult_TransactionNoneZ*)untag_ptr(arg);
16345 int64_t ret_conv = CResult_TransactionNoneZ_clone_ptr(arg_conv);
16349 uint64_t __attribute__((export_name("TS_CResult_TransactionNoneZ_clone"))) TS_CResult_TransactionNoneZ_clone(uint64_t orig) {
16350 LDKCResult_TransactionNoneZ* orig_conv = (LDKCResult_TransactionNoneZ*)untag_ptr(orig);
16351 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
16352 *ret_conv = CResult_TransactionNoneZ_clone(orig_conv);
16353 return tag_ptr(ret_conv, true);
16356 uint64_t __attribute__((export_name("TS_COption_u16Z_some"))) TS_COption_u16Z_some(int16_t o) {
16357 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
16358 *ret_copy = COption_u16Z_some(o);
16359 uint64_t ret_ref = tag_ptr(ret_copy, true);
16363 uint64_t __attribute__((export_name("TS_COption_u16Z_none"))) TS_COption_u16Z_none() {
16364 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
16365 *ret_copy = COption_u16Z_none();
16366 uint64_t ret_ref = tag_ptr(ret_copy, true);
16370 void __attribute__((export_name("TS_COption_u16Z_free"))) TS_COption_u16Z_free(uint64_t _res) {
16371 if (!ptr_is_owned(_res)) return;
16372 void* _res_ptr = untag_ptr(_res);
16373 CHECK_ACCESS(_res_ptr);
16374 LDKCOption_u16Z _res_conv = *(LDKCOption_u16Z*)(_res_ptr);
16375 FREE(untag_ptr(_res));
16376 COption_u16Z_free(_res_conv);
16379 static inline uint64_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg) {
16380 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
16381 *ret_copy = COption_u16Z_clone(arg);
16382 uint64_t ret_ref = tag_ptr(ret_copy, true);
16385 int64_t __attribute__((export_name("TS_COption_u16Z_clone_ptr"))) TS_COption_u16Z_clone_ptr(uint64_t arg) {
16386 LDKCOption_u16Z* arg_conv = (LDKCOption_u16Z*)untag_ptr(arg);
16387 int64_t ret_conv = COption_u16Z_clone_ptr(arg_conv);
16391 uint64_t __attribute__((export_name("TS_COption_u16Z_clone"))) TS_COption_u16Z_clone(uint64_t orig) {
16392 LDKCOption_u16Z* orig_conv = (LDKCOption_u16Z*)untag_ptr(orig);
16393 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
16394 *ret_copy = COption_u16Z_clone(orig_conv);
16395 uint64_t ret_ref = tag_ptr(ret_copy, true);
16399 uint64_t __attribute__((export_name("TS_CResult_NoneAPIErrorZ_ok"))) TS_CResult_NoneAPIErrorZ_ok() {
16400 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
16401 *ret_conv = CResult_NoneAPIErrorZ_ok();
16402 return tag_ptr(ret_conv, true);
16405 uint64_t __attribute__((export_name("TS_CResult_NoneAPIErrorZ_err"))) TS_CResult_NoneAPIErrorZ_err(uint64_t e) {
16406 void* e_ptr = untag_ptr(e);
16407 CHECK_ACCESS(e_ptr);
16408 LDKAPIError e_conv = *(LDKAPIError*)(e_ptr);
16409 e_conv = APIError_clone((LDKAPIError*)untag_ptr(e));
16410 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
16411 *ret_conv = CResult_NoneAPIErrorZ_err(e_conv);
16412 return tag_ptr(ret_conv, true);
16415 jboolean __attribute__((export_name("TS_CResult_NoneAPIErrorZ_is_ok"))) TS_CResult_NoneAPIErrorZ_is_ok(uint64_t o) {
16416 LDKCResult_NoneAPIErrorZ* o_conv = (LDKCResult_NoneAPIErrorZ*)untag_ptr(o);
16417 jboolean ret_conv = CResult_NoneAPIErrorZ_is_ok(o_conv);
16421 void __attribute__((export_name("TS_CResult_NoneAPIErrorZ_free"))) TS_CResult_NoneAPIErrorZ_free(uint64_t _res) {
16422 if (!ptr_is_owned(_res)) return;
16423 void* _res_ptr = untag_ptr(_res);
16424 CHECK_ACCESS(_res_ptr);
16425 LDKCResult_NoneAPIErrorZ _res_conv = *(LDKCResult_NoneAPIErrorZ*)(_res_ptr);
16426 FREE(untag_ptr(_res));
16427 CResult_NoneAPIErrorZ_free(_res_conv);
16430 static inline uint64_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg) {
16431 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
16432 *ret_conv = CResult_NoneAPIErrorZ_clone(arg);
16433 return tag_ptr(ret_conv, true);
16435 int64_t __attribute__((export_name("TS_CResult_NoneAPIErrorZ_clone_ptr"))) TS_CResult_NoneAPIErrorZ_clone_ptr(uint64_t arg) {
16436 LDKCResult_NoneAPIErrorZ* arg_conv = (LDKCResult_NoneAPIErrorZ*)untag_ptr(arg);
16437 int64_t ret_conv = CResult_NoneAPIErrorZ_clone_ptr(arg_conv);
16441 uint64_t __attribute__((export_name("TS_CResult_NoneAPIErrorZ_clone"))) TS_CResult_NoneAPIErrorZ_clone(uint64_t orig) {
16442 LDKCResult_NoneAPIErrorZ* orig_conv = (LDKCResult_NoneAPIErrorZ*)untag_ptr(orig);
16443 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
16444 *ret_conv = CResult_NoneAPIErrorZ_clone(orig_conv);
16445 return tag_ptr(ret_conv, true);
16448 void __attribute__((export_name("TS_CVec_CResult_NoneAPIErrorZZ_free"))) TS_CVec_CResult_NoneAPIErrorZZ_free(uint64_tArray _res) {
16449 LDKCVec_CResult_NoneAPIErrorZZ _res_constr;
16450 _res_constr.datalen = _res->arr_len;
16451 if (_res_constr.datalen > 0)
16452 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKCResult_NoneAPIErrorZ), "LDKCVec_CResult_NoneAPIErrorZZ Elements");
16454 _res_constr.data = NULL;
16455 uint64_t* _res_vals = _res->elems;
16456 for (size_t w = 0; w < _res_constr.datalen; w++) {
16457 uint64_t _res_conv_22 = _res_vals[w];
16458 void* _res_conv_22_ptr = untag_ptr(_res_conv_22);
16459 CHECK_ACCESS(_res_conv_22_ptr);
16460 LDKCResult_NoneAPIErrorZ _res_conv_22_conv = *(LDKCResult_NoneAPIErrorZ*)(_res_conv_22_ptr);
16461 FREE(untag_ptr(_res_conv_22));
16462 _res_constr.data[w] = _res_conv_22_conv;
16465 CVec_CResult_NoneAPIErrorZZ_free(_res_constr);
16468 void __attribute__((export_name("TS_CVec_APIErrorZ_free"))) TS_CVec_APIErrorZ_free(uint64_tArray _res) {
16469 LDKCVec_APIErrorZ _res_constr;
16470 _res_constr.datalen = _res->arr_len;
16471 if (_res_constr.datalen > 0)
16472 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKAPIError), "LDKCVec_APIErrorZ Elements");
16474 _res_constr.data = NULL;
16475 uint64_t* _res_vals = _res->elems;
16476 for (size_t k = 0; k < _res_constr.datalen; k++) {
16477 uint64_t _res_conv_10 = _res_vals[k];
16478 void* _res_conv_10_ptr = untag_ptr(_res_conv_10);
16479 CHECK_ACCESS(_res_conv_10_ptr);
16480 LDKAPIError _res_conv_10_conv = *(LDKAPIError*)(_res_conv_10_ptr);
16481 FREE(untag_ptr(_res_conv_10));
16482 _res_constr.data[k] = _res_conv_10_conv;
16485 CVec_APIErrorZ_free(_res_constr);
16488 uint64_t __attribute__((export_name("TS_CResult__u832APIErrorZ_ok"))) TS_CResult__u832APIErrorZ_ok(int8_tArray o) {
16489 LDKThirtyTwoBytes o_ref;
16490 CHECK(o->arr_len == 32);
16491 memcpy(o_ref.data, o->elems, 32); FREE(o);
16492 LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
16493 *ret_conv = CResult__u832APIErrorZ_ok(o_ref);
16494 return tag_ptr(ret_conv, true);
16497 uint64_t __attribute__((export_name("TS_CResult__u832APIErrorZ_err"))) TS_CResult__u832APIErrorZ_err(uint64_t e) {
16498 void* e_ptr = untag_ptr(e);
16499 CHECK_ACCESS(e_ptr);
16500 LDKAPIError e_conv = *(LDKAPIError*)(e_ptr);
16501 e_conv = APIError_clone((LDKAPIError*)untag_ptr(e));
16502 LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
16503 *ret_conv = CResult__u832APIErrorZ_err(e_conv);
16504 return tag_ptr(ret_conv, true);
16507 jboolean __attribute__((export_name("TS_CResult__u832APIErrorZ_is_ok"))) TS_CResult__u832APIErrorZ_is_ok(uint64_t o) {
16508 LDKCResult__u832APIErrorZ* o_conv = (LDKCResult__u832APIErrorZ*)untag_ptr(o);
16509 jboolean ret_conv = CResult__u832APIErrorZ_is_ok(o_conv);
16513 void __attribute__((export_name("TS_CResult__u832APIErrorZ_free"))) TS_CResult__u832APIErrorZ_free(uint64_t _res) {
16514 if (!ptr_is_owned(_res)) return;
16515 void* _res_ptr = untag_ptr(_res);
16516 CHECK_ACCESS(_res_ptr);
16517 LDKCResult__u832APIErrorZ _res_conv = *(LDKCResult__u832APIErrorZ*)(_res_ptr);
16518 FREE(untag_ptr(_res));
16519 CResult__u832APIErrorZ_free(_res_conv);
16522 static inline uint64_t CResult__u832APIErrorZ_clone_ptr(LDKCResult__u832APIErrorZ *NONNULL_PTR arg) {
16523 LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
16524 *ret_conv = CResult__u832APIErrorZ_clone(arg);
16525 return tag_ptr(ret_conv, true);
16527 int64_t __attribute__((export_name("TS_CResult__u832APIErrorZ_clone_ptr"))) TS_CResult__u832APIErrorZ_clone_ptr(uint64_t arg) {
16528 LDKCResult__u832APIErrorZ* arg_conv = (LDKCResult__u832APIErrorZ*)untag_ptr(arg);
16529 int64_t ret_conv = CResult__u832APIErrorZ_clone_ptr(arg_conv);
16533 uint64_t __attribute__((export_name("TS_CResult__u832APIErrorZ_clone"))) TS_CResult__u832APIErrorZ_clone(uint64_t orig) {
16534 LDKCResult__u832APIErrorZ* orig_conv = (LDKCResult__u832APIErrorZ*)untag_ptr(orig);
16535 LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
16536 *ret_conv = CResult__u832APIErrorZ_clone(orig_conv);
16537 return tag_ptr(ret_conv, true);
16540 uint64_t __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_ok"))) TS_CResult_NonePaymentSendFailureZ_ok() {
16541 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
16542 *ret_conv = CResult_NonePaymentSendFailureZ_ok();
16543 return tag_ptr(ret_conv, true);
16546 uint64_t __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_err"))) TS_CResult_NonePaymentSendFailureZ_err(uint64_t e) {
16547 void* e_ptr = untag_ptr(e);
16548 CHECK_ACCESS(e_ptr);
16549 LDKPaymentSendFailure e_conv = *(LDKPaymentSendFailure*)(e_ptr);
16550 e_conv = PaymentSendFailure_clone((LDKPaymentSendFailure*)untag_ptr(e));
16551 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
16552 *ret_conv = CResult_NonePaymentSendFailureZ_err(e_conv);
16553 return tag_ptr(ret_conv, true);
16556 jboolean __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_is_ok"))) TS_CResult_NonePaymentSendFailureZ_is_ok(uint64_t o) {
16557 LDKCResult_NonePaymentSendFailureZ* o_conv = (LDKCResult_NonePaymentSendFailureZ*)untag_ptr(o);
16558 jboolean ret_conv = CResult_NonePaymentSendFailureZ_is_ok(o_conv);
16562 void __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_free"))) TS_CResult_NonePaymentSendFailureZ_free(uint64_t _res) {
16563 if (!ptr_is_owned(_res)) return;
16564 void* _res_ptr = untag_ptr(_res);
16565 CHECK_ACCESS(_res_ptr);
16566 LDKCResult_NonePaymentSendFailureZ _res_conv = *(LDKCResult_NonePaymentSendFailureZ*)(_res_ptr);
16567 FREE(untag_ptr(_res));
16568 CResult_NonePaymentSendFailureZ_free(_res_conv);
16571 static inline uint64_t CResult_NonePaymentSendFailureZ_clone_ptr(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR arg) {
16572 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
16573 *ret_conv = CResult_NonePaymentSendFailureZ_clone(arg);
16574 return tag_ptr(ret_conv, true);
16576 int64_t __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_clone_ptr"))) TS_CResult_NonePaymentSendFailureZ_clone_ptr(uint64_t arg) {
16577 LDKCResult_NonePaymentSendFailureZ* arg_conv = (LDKCResult_NonePaymentSendFailureZ*)untag_ptr(arg);
16578 int64_t ret_conv = CResult_NonePaymentSendFailureZ_clone_ptr(arg_conv);
16582 uint64_t __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_clone"))) TS_CResult_NonePaymentSendFailureZ_clone(uint64_t orig) {
16583 LDKCResult_NonePaymentSendFailureZ* orig_conv = (LDKCResult_NonePaymentSendFailureZ*)untag_ptr(orig);
16584 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
16585 *ret_conv = CResult_NonePaymentSendFailureZ_clone(orig_conv);
16586 return tag_ptr(ret_conv, true);
16589 uint64_t __attribute__((export_name("TS_CResult_PaymentHashPaymentSendFailureZ_ok"))) TS_CResult_PaymentHashPaymentSendFailureZ_ok(int8_tArray o) {
16590 LDKThirtyTwoBytes o_ref;
16591 CHECK(o->arr_len == 32);
16592 memcpy(o_ref.data, o->elems, 32); FREE(o);
16593 LDKCResult_PaymentHashPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentHashPaymentSendFailureZ), "LDKCResult_PaymentHashPaymentSendFailureZ");
16594 *ret_conv = CResult_PaymentHashPaymentSendFailureZ_ok(o_ref);
16595 return tag_ptr(ret_conv, true);
16598 uint64_t __attribute__((export_name("TS_CResult_PaymentHashPaymentSendFailureZ_err"))) TS_CResult_PaymentHashPaymentSendFailureZ_err(uint64_t e) {
16599 void* e_ptr = untag_ptr(e);
16600 CHECK_ACCESS(e_ptr);
16601 LDKPaymentSendFailure e_conv = *(LDKPaymentSendFailure*)(e_ptr);
16602 e_conv = PaymentSendFailure_clone((LDKPaymentSendFailure*)untag_ptr(e));
16603 LDKCResult_PaymentHashPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentHashPaymentSendFailureZ), "LDKCResult_PaymentHashPaymentSendFailureZ");
16604 *ret_conv = CResult_PaymentHashPaymentSendFailureZ_err(e_conv);
16605 return tag_ptr(ret_conv, true);
16608 jboolean __attribute__((export_name("TS_CResult_PaymentHashPaymentSendFailureZ_is_ok"))) TS_CResult_PaymentHashPaymentSendFailureZ_is_ok(uint64_t o) {
16609 LDKCResult_PaymentHashPaymentSendFailureZ* o_conv = (LDKCResult_PaymentHashPaymentSendFailureZ*)untag_ptr(o);
16610 jboolean ret_conv = CResult_PaymentHashPaymentSendFailureZ_is_ok(o_conv);
16614 void __attribute__((export_name("TS_CResult_PaymentHashPaymentSendFailureZ_free"))) TS_CResult_PaymentHashPaymentSendFailureZ_free(uint64_t _res) {
16615 if (!ptr_is_owned(_res)) return;
16616 void* _res_ptr = untag_ptr(_res);
16617 CHECK_ACCESS(_res_ptr);
16618 LDKCResult_PaymentHashPaymentSendFailureZ _res_conv = *(LDKCResult_PaymentHashPaymentSendFailureZ*)(_res_ptr);
16619 FREE(untag_ptr(_res));
16620 CResult_PaymentHashPaymentSendFailureZ_free(_res_conv);
16623 static inline uint64_t CResult_PaymentHashPaymentSendFailureZ_clone_ptr(LDKCResult_PaymentHashPaymentSendFailureZ *NONNULL_PTR arg) {
16624 LDKCResult_PaymentHashPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentHashPaymentSendFailureZ), "LDKCResult_PaymentHashPaymentSendFailureZ");
16625 *ret_conv = CResult_PaymentHashPaymentSendFailureZ_clone(arg);
16626 return tag_ptr(ret_conv, true);
16628 int64_t __attribute__((export_name("TS_CResult_PaymentHashPaymentSendFailureZ_clone_ptr"))) TS_CResult_PaymentHashPaymentSendFailureZ_clone_ptr(uint64_t arg) {
16629 LDKCResult_PaymentHashPaymentSendFailureZ* arg_conv = (LDKCResult_PaymentHashPaymentSendFailureZ*)untag_ptr(arg);
16630 int64_t ret_conv = CResult_PaymentHashPaymentSendFailureZ_clone_ptr(arg_conv);
16634 uint64_t __attribute__((export_name("TS_CResult_PaymentHashPaymentSendFailureZ_clone"))) TS_CResult_PaymentHashPaymentSendFailureZ_clone(uint64_t orig) {
16635 LDKCResult_PaymentHashPaymentSendFailureZ* orig_conv = (LDKCResult_PaymentHashPaymentSendFailureZ*)untag_ptr(orig);
16636 LDKCResult_PaymentHashPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentHashPaymentSendFailureZ), "LDKCResult_PaymentHashPaymentSendFailureZ");
16637 *ret_conv = CResult_PaymentHashPaymentSendFailureZ_clone(orig_conv);
16638 return tag_ptr(ret_conv, true);
16641 static inline uint64_t C2Tuple_PaymentHashPaymentIdZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR arg) {
16642 LDKC2Tuple_PaymentHashPaymentIdZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentIdZ), "LDKC2Tuple_PaymentHashPaymentIdZ");
16643 *ret_conv = C2Tuple_PaymentHashPaymentIdZ_clone(arg);
16644 return tag_ptr(ret_conv, true);
16646 int64_t __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentIdZ_clone_ptr"))) TS_C2Tuple_PaymentHashPaymentIdZ_clone_ptr(uint64_t arg) {
16647 LDKC2Tuple_PaymentHashPaymentIdZ* arg_conv = (LDKC2Tuple_PaymentHashPaymentIdZ*)untag_ptr(arg);
16648 int64_t ret_conv = C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg_conv);
16652 uint64_t __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentIdZ_clone"))) TS_C2Tuple_PaymentHashPaymentIdZ_clone(uint64_t orig) {
16653 LDKC2Tuple_PaymentHashPaymentIdZ* orig_conv = (LDKC2Tuple_PaymentHashPaymentIdZ*)untag_ptr(orig);
16654 LDKC2Tuple_PaymentHashPaymentIdZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentIdZ), "LDKC2Tuple_PaymentHashPaymentIdZ");
16655 *ret_conv = C2Tuple_PaymentHashPaymentIdZ_clone(orig_conv);
16656 return tag_ptr(ret_conv, true);
16659 uint64_t __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentIdZ_new"))) TS_C2Tuple_PaymentHashPaymentIdZ_new(int8_tArray a, int8_tArray b) {
16660 LDKThirtyTwoBytes a_ref;
16661 CHECK(a->arr_len == 32);
16662 memcpy(a_ref.data, a->elems, 32); FREE(a);
16663 LDKThirtyTwoBytes b_ref;
16664 CHECK(b->arr_len == 32);
16665 memcpy(b_ref.data, b->elems, 32); FREE(b);
16666 LDKC2Tuple_PaymentHashPaymentIdZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentIdZ), "LDKC2Tuple_PaymentHashPaymentIdZ");
16667 *ret_conv = C2Tuple_PaymentHashPaymentIdZ_new(a_ref, b_ref);
16668 return tag_ptr(ret_conv, true);
16671 void __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentIdZ_free"))) TS_C2Tuple_PaymentHashPaymentIdZ_free(uint64_t _res) {
16672 if (!ptr_is_owned(_res)) return;
16673 void* _res_ptr = untag_ptr(_res);
16674 CHECK_ACCESS(_res_ptr);
16675 LDKC2Tuple_PaymentHashPaymentIdZ _res_conv = *(LDKC2Tuple_PaymentHashPaymentIdZ*)(_res_ptr);
16676 FREE(untag_ptr(_res));
16677 C2Tuple_PaymentHashPaymentIdZ_free(_res_conv);
16680 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(uint64_t o) {
16681 void* o_ptr = untag_ptr(o);
16682 CHECK_ACCESS(o_ptr);
16683 LDKC2Tuple_PaymentHashPaymentIdZ o_conv = *(LDKC2Tuple_PaymentHashPaymentIdZ*)(o_ptr);
16684 o_conv = C2Tuple_PaymentHashPaymentIdZ_clone((LDKC2Tuple_PaymentHashPaymentIdZ*)untag_ptr(o));
16685 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ");
16686 *ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o_conv);
16687 return tag_ptr(ret_conv, true);
16690 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(uint64_t e) {
16691 void* e_ptr = untag_ptr(e);
16692 CHECK_ACCESS(e_ptr);
16693 LDKPaymentSendFailure e_conv = *(LDKPaymentSendFailure*)(e_ptr);
16694 e_conv = PaymentSendFailure_clone((LDKPaymentSendFailure*)untag_ptr(e));
16695 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ");
16696 *ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e_conv);
16697 return tag_ptr(ret_conv, true);
16700 jboolean __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(uint64_t o) {
16701 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* o_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)untag_ptr(o);
16702 jboolean ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o_conv);
16706 void __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(uint64_t _res) {
16707 if (!ptr_is_owned(_res)) return;
16708 void* _res_ptr = untag_ptr(_res);
16709 CHECK_ACCESS(_res_ptr);
16710 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ _res_conv = *(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)(_res_ptr);
16711 FREE(untag_ptr(_res));
16712 CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res_conv);
16715 static inline uint64_t CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR arg) {
16716 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ");
16717 *ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(arg);
16718 return tag_ptr(ret_conv, true);
16720 int64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(uint64_t arg) {
16721 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* arg_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)untag_ptr(arg);
16722 int64_t ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg_conv);
16726 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(uint64_t orig) {
16727 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* orig_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)untag_ptr(orig);
16728 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ");
16729 *ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig_conv);
16730 return tag_ptr(ret_conv, true);
16733 void __attribute__((export_name("TS_CVec_ThirtyTwoBytesZ_free"))) TS_CVec_ThirtyTwoBytesZ_free(ptrArray _res) {
16734 LDKCVec_ThirtyTwoBytesZ _res_constr;
16735 _res_constr.datalen = _res->arr_len;
16736 if (_res_constr.datalen > 0)
16737 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_ThirtyTwoBytesZ Elements");
16739 _res_constr.data = NULL;
16740 int8_tArray* _res_vals = (void*) _res->elems;
16741 for (size_t m = 0; m < _res_constr.datalen; m++) {
16742 int8_tArray _res_conv_12 = _res_vals[m];
16743 LDKThirtyTwoBytes _res_conv_12_ref;
16744 CHECK(_res_conv_12->arr_len == 32);
16745 memcpy(_res_conv_12_ref.data, _res_conv_12->elems, 32); FREE(_res_conv_12);
16746 _res_constr.data[m] = _res_conv_12_ref;
16749 CVec_ThirtyTwoBytesZ_free(_res_constr);
16752 static inline uint64_t C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR arg) {
16753 LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
16754 *ret_conv = C2Tuple_PaymentHashPaymentSecretZ_clone(arg);
16755 return tag_ptr(ret_conv, true);
16757 int64_t __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentSecretZ_clone_ptr"))) TS_C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(uint64_t arg) {
16758 LDKC2Tuple_PaymentHashPaymentSecretZ* arg_conv = (LDKC2Tuple_PaymentHashPaymentSecretZ*)untag_ptr(arg);
16759 int64_t ret_conv = C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg_conv);
16763 uint64_t __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentSecretZ_clone"))) TS_C2Tuple_PaymentHashPaymentSecretZ_clone(uint64_t orig) {
16764 LDKC2Tuple_PaymentHashPaymentSecretZ* orig_conv = (LDKC2Tuple_PaymentHashPaymentSecretZ*)untag_ptr(orig);
16765 LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
16766 *ret_conv = C2Tuple_PaymentHashPaymentSecretZ_clone(orig_conv);
16767 return tag_ptr(ret_conv, true);
16770 uint64_t __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentSecretZ_new"))) TS_C2Tuple_PaymentHashPaymentSecretZ_new(int8_tArray a, int8_tArray b) {
16771 LDKThirtyTwoBytes a_ref;
16772 CHECK(a->arr_len == 32);
16773 memcpy(a_ref.data, a->elems, 32); FREE(a);
16774 LDKThirtyTwoBytes b_ref;
16775 CHECK(b->arr_len == 32);
16776 memcpy(b_ref.data, b->elems, 32); FREE(b);
16777 LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
16778 *ret_conv = C2Tuple_PaymentHashPaymentSecretZ_new(a_ref, b_ref);
16779 return tag_ptr(ret_conv, true);
16782 void __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentSecretZ_free"))) TS_C2Tuple_PaymentHashPaymentSecretZ_free(uint64_t _res) {
16783 if (!ptr_is_owned(_res)) return;
16784 void* _res_ptr = untag_ptr(_res);
16785 CHECK_ACCESS(_res_ptr);
16786 LDKC2Tuple_PaymentHashPaymentSecretZ _res_conv = *(LDKC2Tuple_PaymentHashPaymentSecretZ*)(_res_ptr);
16787 FREE(untag_ptr(_res));
16788 C2Tuple_PaymentHashPaymentSecretZ_free(_res_conv);
16791 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(uint64_t o) {
16792 void* o_ptr = untag_ptr(o);
16793 CHECK_ACCESS(o_ptr);
16794 LDKC2Tuple_PaymentHashPaymentSecretZ o_conv = *(LDKC2Tuple_PaymentHashPaymentSecretZ*)(o_ptr);
16795 o_conv = C2Tuple_PaymentHashPaymentSecretZ_clone((LDKC2Tuple_PaymentHashPaymentSecretZ*)untag_ptr(o));
16796 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ");
16797 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o_conv);
16798 return tag_ptr(ret_conv, true);
16801 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err() {
16802 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ");
16803 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err();
16804 return tag_ptr(ret_conv, true);
16807 jboolean __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(uint64_t o) {
16808 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* o_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ*)untag_ptr(o);
16809 jboolean ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o_conv);
16813 void __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(uint64_t _res) {
16814 if (!ptr_is_owned(_res)) return;
16815 void* _res_ptr = untag_ptr(_res);
16816 CHECK_ACCESS(_res_ptr);
16817 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ _res_conv = *(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ*)(_res_ptr);
16818 FREE(untag_ptr(_res));
16819 CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res_conv);
16822 static inline uint64_t CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR arg) {
16823 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ");
16824 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(arg);
16825 return tag_ptr(ret_conv, true);
16827 int64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(uint64_t arg) {
16828 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* arg_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ*)untag_ptr(arg);
16829 int64_t ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg_conv);
16833 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(uint64_t orig) {
16834 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* orig_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ*)untag_ptr(orig);
16835 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ");
16836 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig_conv);
16837 return tag_ptr(ret_conv, true);
16840 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(uint64_t o) {
16841 void* o_ptr = untag_ptr(o);
16842 CHECK_ACCESS(o_ptr);
16843 LDKC2Tuple_PaymentHashPaymentSecretZ o_conv = *(LDKC2Tuple_PaymentHashPaymentSecretZ*)(o_ptr);
16844 o_conv = C2Tuple_PaymentHashPaymentSecretZ_clone((LDKC2Tuple_PaymentHashPaymentSecretZ*)untag_ptr(o));
16845 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ");
16846 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o_conv);
16847 return tag_ptr(ret_conv, true);
16850 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(uint64_t e) {
16851 void* e_ptr = untag_ptr(e);
16852 CHECK_ACCESS(e_ptr);
16853 LDKAPIError e_conv = *(LDKAPIError*)(e_ptr);
16854 e_conv = APIError_clone((LDKAPIError*)untag_ptr(e));
16855 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ");
16856 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e_conv);
16857 return tag_ptr(ret_conv, true);
16860 jboolean __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(uint64_t o) {
16861 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* o_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ*)untag_ptr(o);
16862 jboolean ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o_conv);
16866 void __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(uint64_t _res) {
16867 if (!ptr_is_owned(_res)) return;
16868 void* _res_ptr = untag_ptr(_res);
16869 CHECK_ACCESS(_res_ptr);
16870 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ _res_conv = *(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ*)(_res_ptr);
16871 FREE(untag_ptr(_res));
16872 CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res_conv);
16875 static inline uint64_t CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR arg) {
16876 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ");
16877 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(arg);
16878 return tag_ptr(ret_conv, true);
16880 int64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(uint64_t arg) {
16881 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* arg_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ*)untag_ptr(arg);
16882 int64_t ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg_conv);
16886 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(uint64_t orig) {
16887 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* orig_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ*)untag_ptr(orig);
16888 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ");
16889 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig_conv);
16890 return tag_ptr(ret_conv, true);
16893 uint64_t __attribute__((export_name("TS_CResult_PaymentSecretNoneZ_ok"))) TS_CResult_PaymentSecretNoneZ_ok(int8_tArray o) {
16894 LDKThirtyTwoBytes o_ref;
16895 CHECK(o->arr_len == 32);
16896 memcpy(o_ref.data, o->elems, 32); FREE(o);
16897 LDKCResult_PaymentSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretNoneZ), "LDKCResult_PaymentSecretNoneZ");
16898 *ret_conv = CResult_PaymentSecretNoneZ_ok(o_ref);
16899 return tag_ptr(ret_conv, true);
16902 uint64_t __attribute__((export_name("TS_CResult_PaymentSecretNoneZ_err"))) TS_CResult_PaymentSecretNoneZ_err() {
16903 LDKCResult_PaymentSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretNoneZ), "LDKCResult_PaymentSecretNoneZ");
16904 *ret_conv = CResult_PaymentSecretNoneZ_err();
16905 return tag_ptr(ret_conv, true);
16908 jboolean __attribute__((export_name("TS_CResult_PaymentSecretNoneZ_is_ok"))) TS_CResult_PaymentSecretNoneZ_is_ok(uint64_t o) {
16909 LDKCResult_PaymentSecretNoneZ* o_conv = (LDKCResult_PaymentSecretNoneZ*)untag_ptr(o);
16910 jboolean ret_conv = CResult_PaymentSecretNoneZ_is_ok(o_conv);
16914 void __attribute__((export_name("TS_CResult_PaymentSecretNoneZ_free"))) TS_CResult_PaymentSecretNoneZ_free(uint64_t _res) {
16915 if (!ptr_is_owned(_res)) return;
16916 void* _res_ptr = untag_ptr(_res);
16917 CHECK_ACCESS(_res_ptr);
16918 LDKCResult_PaymentSecretNoneZ _res_conv = *(LDKCResult_PaymentSecretNoneZ*)(_res_ptr);
16919 FREE(untag_ptr(_res));
16920 CResult_PaymentSecretNoneZ_free(_res_conv);
16923 static inline uint64_t CResult_PaymentSecretNoneZ_clone_ptr(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR arg) {
16924 LDKCResult_PaymentSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretNoneZ), "LDKCResult_PaymentSecretNoneZ");
16925 *ret_conv = CResult_PaymentSecretNoneZ_clone(arg);
16926 return tag_ptr(ret_conv, true);
16928 int64_t __attribute__((export_name("TS_CResult_PaymentSecretNoneZ_clone_ptr"))) TS_CResult_PaymentSecretNoneZ_clone_ptr(uint64_t arg) {
16929 LDKCResult_PaymentSecretNoneZ* arg_conv = (LDKCResult_PaymentSecretNoneZ*)untag_ptr(arg);
16930 int64_t ret_conv = CResult_PaymentSecretNoneZ_clone_ptr(arg_conv);
16934 uint64_t __attribute__((export_name("TS_CResult_PaymentSecretNoneZ_clone"))) TS_CResult_PaymentSecretNoneZ_clone(uint64_t orig) {
16935 LDKCResult_PaymentSecretNoneZ* orig_conv = (LDKCResult_PaymentSecretNoneZ*)untag_ptr(orig);
16936 LDKCResult_PaymentSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretNoneZ), "LDKCResult_PaymentSecretNoneZ");
16937 *ret_conv = CResult_PaymentSecretNoneZ_clone(orig_conv);
16938 return tag_ptr(ret_conv, true);
16941 uint64_t __attribute__((export_name("TS_CResult_PaymentSecretAPIErrorZ_ok"))) TS_CResult_PaymentSecretAPIErrorZ_ok(int8_tArray o) {
16942 LDKThirtyTwoBytes o_ref;
16943 CHECK(o->arr_len == 32);
16944 memcpy(o_ref.data, o->elems, 32); FREE(o);
16945 LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
16946 *ret_conv = CResult_PaymentSecretAPIErrorZ_ok(o_ref);
16947 return tag_ptr(ret_conv, true);
16950 uint64_t __attribute__((export_name("TS_CResult_PaymentSecretAPIErrorZ_err"))) TS_CResult_PaymentSecretAPIErrorZ_err(uint64_t e) {
16951 void* e_ptr = untag_ptr(e);
16952 CHECK_ACCESS(e_ptr);
16953 LDKAPIError e_conv = *(LDKAPIError*)(e_ptr);
16954 e_conv = APIError_clone((LDKAPIError*)untag_ptr(e));
16955 LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
16956 *ret_conv = CResult_PaymentSecretAPIErrorZ_err(e_conv);
16957 return tag_ptr(ret_conv, true);
16960 jboolean __attribute__((export_name("TS_CResult_PaymentSecretAPIErrorZ_is_ok"))) TS_CResult_PaymentSecretAPIErrorZ_is_ok(uint64_t o) {
16961 LDKCResult_PaymentSecretAPIErrorZ* o_conv = (LDKCResult_PaymentSecretAPIErrorZ*)untag_ptr(o);
16962 jboolean ret_conv = CResult_PaymentSecretAPIErrorZ_is_ok(o_conv);
16966 void __attribute__((export_name("TS_CResult_PaymentSecretAPIErrorZ_free"))) TS_CResult_PaymentSecretAPIErrorZ_free(uint64_t _res) {
16967 if (!ptr_is_owned(_res)) return;
16968 void* _res_ptr = untag_ptr(_res);
16969 CHECK_ACCESS(_res_ptr);
16970 LDKCResult_PaymentSecretAPIErrorZ _res_conv = *(LDKCResult_PaymentSecretAPIErrorZ*)(_res_ptr);
16971 FREE(untag_ptr(_res));
16972 CResult_PaymentSecretAPIErrorZ_free(_res_conv);
16975 static inline uint64_t CResult_PaymentSecretAPIErrorZ_clone_ptr(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR arg) {
16976 LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
16977 *ret_conv = CResult_PaymentSecretAPIErrorZ_clone(arg);
16978 return tag_ptr(ret_conv, true);
16980 int64_t __attribute__((export_name("TS_CResult_PaymentSecretAPIErrorZ_clone_ptr"))) TS_CResult_PaymentSecretAPIErrorZ_clone_ptr(uint64_t arg) {
16981 LDKCResult_PaymentSecretAPIErrorZ* arg_conv = (LDKCResult_PaymentSecretAPIErrorZ*)untag_ptr(arg);
16982 int64_t ret_conv = CResult_PaymentSecretAPIErrorZ_clone_ptr(arg_conv);
16986 uint64_t __attribute__((export_name("TS_CResult_PaymentSecretAPIErrorZ_clone"))) TS_CResult_PaymentSecretAPIErrorZ_clone(uint64_t orig) {
16987 LDKCResult_PaymentSecretAPIErrorZ* orig_conv = (LDKCResult_PaymentSecretAPIErrorZ*)untag_ptr(orig);
16988 LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
16989 *ret_conv = CResult_PaymentSecretAPIErrorZ_clone(orig_conv);
16990 return tag_ptr(ret_conv, true);
16993 uint64_t __attribute__((export_name("TS_CResult_PaymentPreimageAPIErrorZ_ok"))) TS_CResult_PaymentPreimageAPIErrorZ_ok(int8_tArray o) {
16994 LDKThirtyTwoBytes o_ref;
16995 CHECK(o->arr_len == 32);
16996 memcpy(o_ref.data, o->elems, 32); FREE(o);
16997 LDKCResult_PaymentPreimageAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPreimageAPIErrorZ), "LDKCResult_PaymentPreimageAPIErrorZ");
16998 *ret_conv = CResult_PaymentPreimageAPIErrorZ_ok(o_ref);
16999 return tag_ptr(ret_conv, true);
17002 uint64_t __attribute__((export_name("TS_CResult_PaymentPreimageAPIErrorZ_err"))) TS_CResult_PaymentPreimageAPIErrorZ_err(uint64_t e) {
17003 void* e_ptr = untag_ptr(e);
17004 CHECK_ACCESS(e_ptr);
17005 LDKAPIError e_conv = *(LDKAPIError*)(e_ptr);
17006 e_conv = APIError_clone((LDKAPIError*)untag_ptr(e));
17007 LDKCResult_PaymentPreimageAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPreimageAPIErrorZ), "LDKCResult_PaymentPreimageAPIErrorZ");
17008 *ret_conv = CResult_PaymentPreimageAPIErrorZ_err(e_conv);
17009 return tag_ptr(ret_conv, true);
17012 jboolean __attribute__((export_name("TS_CResult_PaymentPreimageAPIErrorZ_is_ok"))) TS_CResult_PaymentPreimageAPIErrorZ_is_ok(uint64_t o) {
17013 LDKCResult_PaymentPreimageAPIErrorZ* o_conv = (LDKCResult_PaymentPreimageAPIErrorZ*)untag_ptr(o);
17014 jboolean ret_conv = CResult_PaymentPreimageAPIErrorZ_is_ok(o_conv);
17018 void __attribute__((export_name("TS_CResult_PaymentPreimageAPIErrorZ_free"))) TS_CResult_PaymentPreimageAPIErrorZ_free(uint64_t _res) {
17019 if (!ptr_is_owned(_res)) return;
17020 void* _res_ptr = untag_ptr(_res);
17021 CHECK_ACCESS(_res_ptr);
17022 LDKCResult_PaymentPreimageAPIErrorZ _res_conv = *(LDKCResult_PaymentPreimageAPIErrorZ*)(_res_ptr);
17023 FREE(untag_ptr(_res));
17024 CResult_PaymentPreimageAPIErrorZ_free(_res_conv);
17027 static inline uint64_t CResult_PaymentPreimageAPIErrorZ_clone_ptr(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR arg) {
17028 LDKCResult_PaymentPreimageAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPreimageAPIErrorZ), "LDKCResult_PaymentPreimageAPIErrorZ");
17029 *ret_conv = CResult_PaymentPreimageAPIErrorZ_clone(arg);
17030 return tag_ptr(ret_conv, true);
17032 int64_t __attribute__((export_name("TS_CResult_PaymentPreimageAPIErrorZ_clone_ptr"))) TS_CResult_PaymentPreimageAPIErrorZ_clone_ptr(uint64_t arg) {
17033 LDKCResult_PaymentPreimageAPIErrorZ* arg_conv = (LDKCResult_PaymentPreimageAPIErrorZ*)untag_ptr(arg);
17034 int64_t ret_conv = CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg_conv);
17038 uint64_t __attribute__((export_name("TS_CResult_PaymentPreimageAPIErrorZ_clone"))) TS_CResult_PaymentPreimageAPIErrorZ_clone(uint64_t orig) {
17039 LDKCResult_PaymentPreimageAPIErrorZ* orig_conv = (LDKCResult_PaymentPreimageAPIErrorZ*)untag_ptr(orig);
17040 LDKCResult_PaymentPreimageAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPreimageAPIErrorZ), "LDKCResult_PaymentPreimageAPIErrorZ");
17041 *ret_conv = CResult_PaymentPreimageAPIErrorZ_clone(orig_conv);
17042 return tag_ptr(ret_conv, true);
17045 uint64_t __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_ok"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(uint64_t o) {
17046 LDKCounterpartyForwardingInfo o_conv;
17047 o_conv.inner = untag_ptr(o);
17048 o_conv.is_owned = ptr_is_owned(o);
17049 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17050 o_conv = CounterpartyForwardingInfo_clone(&o_conv);
17051 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ), "LDKCResult_CounterpartyForwardingInfoDecodeErrorZ");
17052 *ret_conv = CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o_conv);
17053 return tag_ptr(ret_conv, true);
17056 uint64_t __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_err"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_err(uint64_t e) {
17057 void* e_ptr = untag_ptr(e);
17058 CHECK_ACCESS(e_ptr);
17059 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
17060 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
17061 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ), "LDKCResult_CounterpartyForwardingInfoDecodeErrorZ");
17062 *ret_conv = CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e_conv);
17063 return tag_ptr(ret_conv, true);
17066 jboolean __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(uint64_t o) {
17067 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* o_conv = (LDKCResult_CounterpartyForwardingInfoDecodeErrorZ*)untag_ptr(o);
17068 jboolean ret_conv = CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o_conv);
17072 void __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_free"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_free(uint64_t _res) {
17073 if (!ptr_is_owned(_res)) return;
17074 void* _res_ptr = untag_ptr(_res);
17075 CHECK_ACCESS(_res_ptr);
17076 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ _res_conv = *(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ*)(_res_ptr);
17077 FREE(untag_ptr(_res));
17078 CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res_conv);
17081 static inline uint64_t CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR arg) {
17082 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ), "LDKCResult_CounterpartyForwardingInfoDecodeErrorZ");
17083 *ret_conv = CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(arg);
17084 return tag_ptr(ret_conv, true);
17086 int64_t __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(uint64_t arg) {
17087 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* arg_conv = (LDKCResult_CounterpartyForwardingInfoDecodeErrorZ*)untag_ptr(arg);
17088 int64_t ret_conv = CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg_conv);
17092 uint64_t __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(uint64_t orig) {
17093 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* orig_conv = (LDKCResult_CounterpartyForwardingInfoDecodeErrorZ*)untag_ptr(orig);
17094 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ), "LDKCResult_CounterpartyForwardingInfoDecodeErrorZ");
17095 *ret_conv = CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig_conv);
17096 return tag_ptr(ret_conv, true);
17099 uint64_t __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_ok"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_ok(uint64_t o) {
17100 LDKChannelCounterparty o_conv;
17101 o_conv.inner = untag_ptr(o);
17102 o_conv.is_owned = ptr_is_owned(o);
17103 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17104 o_conv = ChannelCounterparty_clone(&o_conv);
17105 LDKCResult_ChannelCounterpartyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ), "LDKCResult_ChannelCounterpartyDecodeErrorZ");
17106 *ret_conv = CResult_ChannelCounterpartyDecodeErrorZ_ok(o_conv);
17107 return tag_ptr(ret_conv, true);
17110 uint64_t __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_err"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_err(uint64_t e) {
17111 void* e_ptr = untag_ptr(e);
17112 CHECK_ACCESS(e_ptr);
17113 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
17114 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
17115 LDKCResult_ChannelCounterpartyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ), "LDKCResult_ChannelCounterpartyDecodeErrorZ");
17116 *ret_conv = CResult_ChannelCounterpartyDecodeErrorZ_err(e_conv);
17117 return tag_ptr(ret_conv, true);
17120 jboolean __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_is_ok"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_is_ok(uint64_t o) {
17121 LDKCResult_ChannelCounterpartyDecodeErrorZ* o_conv = (LDKCResult_ChannelCounterpartyDecodeErrorZ*)untag_ptr(o);
17122 jboolean ret_conv = CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o_conv);
17126 void __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_free"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_free(uint64_t _res) {
17127 if (!ptr_is_owned(_res)) return;
17128 void* _res_ptr = untag_ptr(_res);
17129 CHECK_ACCESS(_res_ptr);
17130 LDKCResult_ChannelCounterpartyDecodeErrorZ _res_conv = *(LDKCResult_ChannelCounterpartyDecodeErrorZ*)(_res_ptr);
17131 FREE(untag_ptr(_res));
17132 CResult_ChannelCounterpartyDecodeErrorZ_free(_res_conv);
17135 static inline uint64_t CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR arg) {
17136 LDKCResult_ChannelCounterpartyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ), "LDKCResult_ChannelCounterpartyDecodeErrorZ");
17137 *ret_conv = CResult_ChannelCounterpartyDecodeErrorZ_clone(arg);
17138 return tag_ptr(ret_conv, true);
17140 int64_t __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(uint64_t arg) {
17141 LDKCResult_ChannelCounterpartyDecodeErrorZ* arg_conv = (LDKCResult_ChannelCounterpartyDecodeErrorZ*)untag_ptr(arg);
17142 int64_t ret_conv = CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg_conv);
17146 uint64_t __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_clone"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_clone(uint64_t orig) {
17147 LDKCResult_ChannelCounterpartyDecodeErrorZ* orig_conv = (LDKCResult_ChannelCounterpartyDecodeErrorZ*)untag_ptr(orig);
17148 LDKCResult_ChannelCounterpartyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ), "LDKCResult_ChannelCounterpartyDecodeErrorZ");
17149 *ret_conv = CResult_ChannelCounterpartyDecodeErrorZ_clone(orig_conv);
17150 return tag_ptr(ret_conv, true);
17153 uint64_t __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_ok"))) TS_CResult_ChannelDetailsDecodeErrorZ_ok(uint64_t o) {
17154 LDKChannelDetails o_conv;
17155 o_conv.inner = untag_ptr(o);
17156 o_conv.is_owned = ptr_is_owned(o);
17157 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17158 o_conv = ChannelDetails_clone(&o_conv);
17159 LDKCResult_ChannelDetailsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelDetailsDecodeErrorZ), "LDKCResult_ChannelDetailsDecodeErrorZ");
17160 *ret_conv = CResult_ChannelDetailsDecodeErrorZ_ok(o_conv);
17161 return tag_ptr(ret_conv, true);
17164 uint64_t __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_err"))) TS_CResult_ChannelDetailsDecodeErrorZ_err(uint64_t e) {
17165 void* e_ptr = untag_ptr(e);
17166 CHECK_ACCESS(e_ptr);
17167 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
17168 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
17169 LDKCResult_ChannelDetailsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelDetailsDecodeErrorZ), "LDKCResult_ChannelDetailsDecodeErrorZ");
17170 *ret_conv = CResult_ChannelDetailsDecodeErrorZ_err(e_conv);
17171 return tag_ptr(ret_conv, true);
17174 jboolean __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_is_ok"))) TS_CResult_ChannelDetailsDecodeErrorZ_is_ok(uint64_t o) {
17175 LDKCResult_ChannelDetailsDecodeErrorZ* o_conv = (LDKCResult_ChannelDetailsDecodeErrorZ*)untag_ptr(o);
17176 jboolean ret_conv = CResult_ChannelDetailsDecodeErrorZ_is_ok(o_conv);
17180 void __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_free"))) TS_CResult_ChannelDetailsDecodeErrorZ_free(uint64_t _res) {
17181 if (!ptr_is_owned(_res)) return;
17182 void* _res_ptr = untag_ptr(_res);
17183 CHECK_ACCESS(_res_ptr);
17184 LDKCResult_ChannelDetailsDecodeErrorZ _res_conv = *(LDKCResult_ChannelDetailsDecodeErrorZ*)(_res_ptr);
17185 FREE(untag_ptr(_res));
17186 CResult_ChannelDetailsDecodeErrorZ_free(_res_conv);
17189 static inline uint64_t CResult_ChannelDetailsDecodeErrorZ_clone_ptr(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR arg) {
17190 LDKCResult_ChannelDetailsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelDetailsDecodeErrorZ), "LDKCResult_ChannelDetailsDecodeErrorZ");
17191 *ret_conv = CResult_ChannelDetailsDecodeErrorZ_clone(arg);
17192 return tag_ptr(ret_conv, true);
17194 int64_t __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelDetailsDecodeErrorZ_clone_ptr(uint64_t arg) {
17195 LDKCResult_ChannelDetailsDecodeErrorZ* arg_conv = (LDKCResult_ChannelDetailsDecodeErrorZ*)untag_ptr(arg);
17196 int64_t ret_conv = CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg_conv);
17200 uint64_t __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_clone"))) TS_CResult_ChannelDetailsDecodeErrorZ_clone(uint64_t orig) {
17201 LDKCResult_ChannelDetailsDecodeErrorZ* orig_conv = (LDKCResult_ChannelDetailsDecodeErrorZ*)untag_ptr(orig);
17202 LDKCResult_ChannelDetailsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelDetailsDecodeErrorZ), "LDKCResult_ChannelDetailsDecodeErrorZ");
17203 *ret_conv = CResult_ChannelDetailsDecodeErrorZ_clone(orig_conv);
17204 return tag_ptr(ret_conv, true);
17207 uint64_t __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_ok"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_ok(uint64_t o) {
17208 LDKPhantomRouteHints o_conv;
17209 o_conv.inner = untag_ptr(o);
17210 o_conv.is_owned = ptr_is_owned(o);
17211 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17212 o_conv = PhantomRouteHints_clone(&o_conv);
17213 LDKCResult_PhantomRouteHintsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ), "LDKCResult_PhantomRouteHintsDecodeErrorZ");
17214 *ret_conv = CResult_PhantomRouteHintsDecodeErrorZ_ok(o_conv);
17215 return tag_ptr(ret_conv, true);
17218 uint64_t __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_err"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_err(uint64_t e) {
17219 void* e_ptr = untag_ptr(e);
17220 CHECK_ACCESS(e_ptr);
17221 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
17222 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
17223 LDKCResult_PhantomRouteHintsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ), "LDKCResult_PhantomRouteHintsDecodeErrorZ");
17224 *ret_conv = CResult_PhantomRouteHintsDecodeErrorZ_err(e_conv);
17225 return tag_ptr(ret_conv, true);
17228 jboolean __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_is_ok"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_is_ok(uint64_t o) {
17229 LDKCResult_PhantomRouteHintsDecodeErrorZ* o_conv = (LDKCResult_PhantomRouteHintsDecodeErrorZ*)untag_ptr(o);
17230 jboolean ret_conv = CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o_conv);
17234 void __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_free"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_free(uint64_t _res) {
17235 if (!ptr_is_owned(_res)) return;
17236 void* _res_ptr = untag_ptr(_res);
17237 CHECK_ACCESS(_res_ptr);
17238 LDKCResult_PhantomRouteHintsDecodeErrorZ _res_conv = *(LDKCResult_PhantomRouteHintsDecodeErrorZ*)(_res_ptr);
17239 FREE(untag_ptr(_res));
17240 CResult_PhantomRouteHintsDecodeErrorZ_free(_res_conv);
17243 static inline uint64_t CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR arg) {
17244 LDKCResult_PhantomRouteHintsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ), "LDKCResult_PhantomRouteHintsDecodeErrorZ");
17245 *ret_conv = CResult_PhantomRouteHintsDecodeErrorZ_clone(arg);
17246 return tag_ptr(ret_conv, true);
17248 int64_t __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(uint64_t arg) {
17249 LDKCResult_PhantomRouteHintsDecodeErrorZ* arg_conv = (LDKCResult_PhantomRouteHintsDecodeErrorZ*)untag_ptr(arg);
17250 int64_t ret_conv = CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg_conv);
17254 uint64_t __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_clone"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_clone(uint64_t orig) {
17255 LDKCResult_PhantomRouteHintsDecodeErrorZ* orig_conv = (LDKCResult_PhantomRouteHintsDecodeErrorZ*)untag_ptr(orig);
17256 LDKCResult_PhantomRouteHintsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ), "LDKCResult_PhantomRouteHintsDecodeErrorZ");
17257 *ret_conv = CResult_PhantomRouteHintsDecodeErrorZ_clone(orig_conv);
17258 return tag_ptr(ret_conv, true);
17261 void __attribute__((export_name("TS_CVec_ChannelMonitorZ_free"))) TS_CVec_ChannelMonitorZ_free(uint64_tArray _res) {
17262 LDKCVec_ChannelMonitorZ _res_constr;
17263 _res_constr.datalen = _res->arr_len;
17264 if (_res_constr.datalen > 0)
17265 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKChannelMonitor), "LDKCVec_ChannelMonitorZ Elements");
17267 _res_constr.data = NULL;
17268 uint64_t* _res_vals = _res->elems;
17269 for (size_t q = 0; q < _res_constr.datalen; q++) {
17270 uint64_t _res_conv_16 = _res_vals[q];
17271 LDKChannelMonitor _res_conv_16_conv;
17272 _res_conv_16_conv.inner = untag_ptr(_res_conv_16);
17273 _res_conv_16_conv.is_owned = ptr_is_owned(_res_conv_16);
17274 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_16_conv);
17275 _res_constr.data[q] = _res_conv_16_conv;
17278 CVec_ChannelMonitorZ_free(_res_constr);
17281 uint64_t __attribute__((export_name("TS_C2Tuple_BlockHashChannelManagerZ_new"))) TS_C2Tuple_BlockHashChannelManagerZ_new(int8_tArray a, uint64_t b) {
17282 LDKThirtyTwoBytes a_ref;
17283 CHECK(a->arr_len == 32);
17284 memcpy(a_ref.data, a->elems, 32); FREE(a);
17285 LDKChannelManager b_conv;
17286 b_conv.inner = untag_ptr(b);
17287 b_conv.is_owned = ptr_is_owned(b);
17288 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
17289 // WARNING: we need a move here but no clone is available for LDKChannelManager
17291 LDKC2Tuple_BlockHashChannelManagerZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelManagerZ), "LDKC2Tuple_BlockHashChannelManagerZ");
17292 *ret_conv = C2Tuple_BlockHashChannelManagerZ_new(a_ref, b_conv);
17293 return tag_ptr(ret_conv, true);
17296 void __attribute__((export_name("TS_C2Tuple_BlockHashChannelManagerZ_free"))) TS_C2Tuple_BlockHashChannelManagerZ_free(uint64_t _res) {
17297 if (!ptr_is_owned(_res)) return;
17298 void* _res_ptr = untag_ptr(_res);
17299 CHECK_ACCESS(_res_ptr);
17300 LDKC2Tuple_BlockHashChannelManagerZ _res_conv = *(LDKC2Tuple_BlockHashChannelManagerZ*)(_res_ptr);
17301 FREE(untag_ptr(_res));
17302 C2Tuple_BlockHashChannelManagerZ_free(_res_conv);
17305 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(uint64_t o) {
17306 void* o_ptr = untag_ptr(o);
17307 CHECK_ACCESS(o_ptr);
17308 LDKC2Tuple_BlockHashChannelManagerZ o_conv = *(LDKC2Tuple_BlockHashChannelManagerZ*)(o_ptr);
17309 // WARNING: we may need a move here but no clone is available for LDKC2Tuple_BlockHashChannelManagerZ
17310 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ");
17311 *ret_conv = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o_conv);
17312 return tag_ptr(ret_conv, true);
17315 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(uint64_t e) {
17316 void* e_ptr = untag_ptr(e);
17317 CHECK_ACCESS(e_ptr);
17318 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
17319 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
17320 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ");
17321 *ret_conv = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e_conv);
17322 return tag_ptr(ret_conv, true);
17325 jboolean __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(uint64_t o) {
17326 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* o_conv = (LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)untag_ptr(o);
17327 jboolean ret_conv = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o_conv);
17331 void __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(uint64_t _res) {
17332 if (!ptr_is_owned(_res)) return;
17333 void* _res_ptr = untag_ptr(_res);
17334 CHECK_ACCESS(_res_ptr);
17335 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res_conv = *(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)(_res_ptr);
17336 FREE(untag_ptr(_res));
17337 CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res_conv);
17340 uint64_t __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_ok"))) TS_CResult_ChannelConfigDecodeErrorZ_ok(uint64_t o) {
17341 LDKChannelConfig o_conv;
17342 o_conv.inner = untag_ptr(o);
17343 o_conv.is_owned = ptr_is_owned(o);
17344 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17345 o_conv = ChannelConfig_clone(&o_conv);
17346 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
17347 *ret_conv = CResult_ChannelConfigDecodeErrorZ_ok(o_conv);
17348 return tag_ptr(ret_conv, true);
17351 uint64_t __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_err"))) TS_CResult_ChannelConfigDecodeErrorZ_err(uint64_t e) {
17352 void* e_ptr = untag_ptr(e);
17353 CHECK_ACCESS(e_ptr);
17354 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
17355 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
17356 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
17357 *ret_conv = CResult_ChannelConfigDecodeErrorZ_err(e_conv);
17358 return tag_ptr(ret_conv, true);
17361 jboolean __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_is_ok"))) TS_CResult_ChannelConfigDecodeErrorZ_is_ok(uint64_t o) {
17362 LDKCResult_ChannelConfigDecodeErrorZ* o_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)untag_ptr(o);
17363 jboolean ret_conv = CResult_ChannelConfigDecodeErrorZ_is_ok(o_conv);
17367 void __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_free"))) TS_CResult_ChannelConfigDecodeErrorZ_free(uint64_t _res) {
17368 if (!ptr_is_owned(_res)) return;
17369 void* _res_ptr = untag_ptr(_res);
17370 CHECK_ACCESS(_res_ptr);
17371 LDKCResult_ChannelConfigDecodeErrorZ _res_conv = *(LDKCResult_ChannelConfigDecodeErrorZ*)(_res_ptr);
17372 FREE(untag_ptr(_res));
17373 CResult_ChannelConfigDecodeErrorZ_free(_res_conv);
17376 static inline uint64_t CResult_ChannelConfigDecodeErrorZ_clone_ptr(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR arg) {
17377 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
17378 *ret_conv = CResult_ChannelConfigDecodeErrorZ_clone(arg);
17379 return tag_ptr(ret_conv, true);
17381 int64_t __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr(uint64_t arg) {
17382 LDKCResult_ChannelConfigDecodeErrorZ* arg_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)untag_ptr(arg);
17383 int64_t ret_conv = CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg_conv);
17387 uint64_t __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_clone"))) TS_CResult_ChannelConfigDecodeErrorZ_clone(uint64_t orig) {
17388 LDKCResult_ChannelConfigDecodeErrorZ* orig_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)untag_ptr(orig);
17389 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
17390 *ret_conv = CResult_ChannelConfigDecodeErrorZ_clone(orig_conv);
17391 return tag_ptr(ret_conv, true);
17394 uint64_t __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_ok"))) TS_CResult_OutPointDecodeErrorZ_ok(uint64_t o) {
17395 LDKOutPoint o_conv;
17396 o_conv.inner = untag_ptr(o);
17397 o_conv.is_owned = ptr_is_owned(o);
17398 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17399 o_conv = OutPoint_clone(&o_conv);
17400 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
17401 *ret_conv = CResult_OutPointDecodeErrorZ_ok(o_conv);
17402 return tag_ptr(ret_conv, true);
17405 uint64_t __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_err"))) TS_CResult_OutPointDecodeErrorZ_err(uint64_t e) {
17406 void* e_ptr = untag_ptr(e);
17407 CHECK_ACCESS(e_ptr);
17408 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
17409 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
17410 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
17411 *ret_conv = CResult_OutPointDecodeErrorZ_err(e_conv);
17412 return tag_ptr(ret_conv, true);
17415 jboolean __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_is_ok"))) TS_CResult_OutPointDecodeErrorZ_is_ok(uint64_t o) {
17416 LDKCResult_OutPointDecodeErrorZ* o_conv = (LDKCResult_OutPointDecodeErrorZ*)untag_ptr(o);
17417 jboolean ret_conv = CResult_OutPointDecodeErrorZ_is_ok(o_conv);
17421 void __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_free"))) TS_CResult_OutPointDecodeErrorZ_free(uint64_t _res) {
17422 if (!ptr_is_owned(_res)) return;
17423 void* _res_ptr = untag_ptr(_res);
17424 CHECK_ACCESS(_res_ptr);
17425 LDKCResult_OutPointDecodeErrorZ _res_conv = *(LDKCResult_OutPointDecodeErrorZ*)(_res_ptr);
17426 FREE(untag_ptr(_res));
17427 CResult_OutPointDecodeErrorZ_free(_res_conv);
17430 static inline uint64_t CResult_OutPointDecodeErrorZ_clone_ptr(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR arg) {
17431 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
17432 *ret_conv = CResult_OutPointDecodeErrorZ_clone(arg);
17433 return tag_ptr(ret_conv, true);
17435 int64_t __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_clone_ptr"))) TS_CResult_OutPointDecodeErrorZ_clone_ptr(uint64_t arg) {
17436 LDKCResult_OutPointDecodeErrorZ* arg_conv = (LDKCResult_OutPointDecodeErrorZ*)untag_ptr(arg);
17437 int64_t ret_conv = CResult_OutPointDecodeErrorZ_clone_ptr(arg_conv);
17441 uint64_t __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_clone"))) TS_CResult_OutPointDecodeErrorZ_clone(uint64_t orig) {
17442 LDKCResult_OutPointDecodeErrorZ* orig_conv = (LDKCResult_OutPointDecodeErrorZ*)untag_ptr(orig);
17443 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
17444 *ret_conv = CResult_OutPointDecodeErrorZ_clone(orig_conv);
17445 return tag_ptr(ret_conv, true);
17448 uint64_t __attribute__((export_name("TS_COption_TypeZ_some"))) TS_COption_TypeZ_some(uint64_t o) {
17449 void* o_ptr = untag_ptr(o);
17450 CHECK_ACCESS(o_ptr);
17451 LDKType o_conv = *(LDKType*)(o_ptr);
17452 if (o_conv.free == LDKType_JCalls_free) {
17453 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
17454 LDKType_JCalls_cloned(&o_conv);
17456 LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
17457 *ret_copy = COption_TypeZ_some(o_conv);
17458 uint64_t ret_ref = tag_ptr(ret_copy, true);
17462 uint64_t __attribute__((export_name("TS_COption_TypeZ_none"))) TS_COption_TypeZ_none() {
17463 LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
17464 *ret_copy = COption_TypeZ_none();
17465 uint64_t ret_ref = tag_ptr(ret_copy, true);
17469 void __attribute__((export_name("TS_COption_TypeZ_free"))) TS_COption_TypeZ_free(uint64_t _res) {
17470 if (!ptr_is_owned(_res)) return;
17471 void* _res_ptr = untag_ptr(_res);
17472 CHECK_ACCESS(_res_ptr);
17473 LDKCOption_TypeZ _res_conv = *(LDKCOption_TypeZ*)(_res_ptr);
17474 FREE(untag_ptr(_res));
17475 COption_TypeZ_free(_res_conv);
17478 static inline uint64_t COption_TypeZ_clone_ptr(LDKCOption_TypeZ *NONNULL_PTR arg) {
17479 LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
17480 *ret_copy = COption_TypeZ_clone(arg);
17481 uint64_t ret_ref = tag_ptr(ret_copy, true);
17484 int64_t __attribute__((export_name("TS_COption_TypeZ_clone_ptr"))) TS_COption_TypeZ_clone_ptr(uint64_t arg) {
17485 LDKCOption_TypeZ* arg_conv = (LDKCOption_TypeZ*)untag_ptr(arg);
17486 int64_t ret_conv = COption_TypeZ_clone_ptr(arg_conv);
17490 uint64_t __attribute__((export_name("TS_COption_TypeZ_clone"))) TS_COption_TypeZ_clone(uint64_t orig) {
17491 LDKCOption_TypeZ* orig_conv = (LDKCOption_TypeZ*)untag_ptr(orig);
17492 LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
17493 *ret_copy = COption_TypeZ_clone(orig_conv);
17494 uint64_t ret_ref = tag_ptr(ret_copy, true);
17498 uint64_t __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_ok"))) TS_CResult_COption_TypeZDecodeErrorZ_ok(uint64_t o) {
17499 void* o_ptr = untag_ptr(o);
17500 CHECK_ACCESS(o_ptr);
17501 LDKCOption_TypeZ o_conv = *(LDKCOption_TypeZ*)(o_ptr);
17502 o_conv = COption_TypeZ_clone((LDKCOption_TypeZ*)untag_ptr(o));
17503 LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
17504 *ret_conv = CResult_COption_TypeZDecodeErrorZ_ok(o_conv);
17505 return tag_ptr(ret_conv, true);
17508 uint64_t __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_err"))) TS_CResult_COption_TypeZDecodeErrorZ_err(uint64_t e) {
17509 void* e_ptr = untag_ptr(e);
17510 CHECK_ACCESS(e_ptr);
17511 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
17512 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
17513 LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
17514 *ret_conv = CResult_COption_TypeZDecodeErrorZ_err(e_conv);
17515 return tag_ptr(ret_conv, true);
17518 jboolean __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_is_ok"))) TS_CResult_COption_TypeZDecodeErrorZ_is_ok(uint64_t o) {
17519 LDKCResult_COption_TypeZDecodeErrorZ* o_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)untag_ptr(o);
17520 jboolean ret_conv = CResult_COption_TypeZDecodeErrorZ_is_ok(o_conv);
17524 void __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_free"))) TS_CResult_COption_TypeZDecodeErrorZ_free(uint64_t _res) {
17525 if (!ptr_is_owned(_res)) return;
17526 void* _res_ptr = untag_ptr(_res);
17527 CHECK_ACCESS(_res_ptr);
17528 LDKCResult_COption_TypeZDecodeErrorZ _res_conv = *(LDKCResult_COption_TypeZDecodeErrorZ*)(_res_ptr);
17529 FREE(untag_ptr(_res));
17530 CResult_COption_TypeZDecodeErrorZ_free(_res_conv);
17533 static inline uint64_t CResult_COption_TypeZDecodeErrorZ_clone_ptr(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR arg) {
17534 LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
17535 *ret_conv = CResult_COption_TypeZDecodeErrorZ_clone(arg);
17536 return tag_ptr(ret_conv, true);
17538 int64_t __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr(uint64_t arg) {
17539 LDKCResult_COption_TypeZDecodeErrorZ* arg_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)untag_ptr(arg);
17540 int64_t ret_conv = CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg_conv);
17544 uint64_t __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_clone"))) TS_CResult_COption_TypeZDecodeErrorZ_clone(uint64_t orig) {
17545 LDKCResult_COption_TypeZDecodeErrorZ* orig_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)untag_ptr(orig);
17546 LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
17547 *ret_conv = CResult_COption_TypeZDecodeErrorZ_clone(orig_conv);
17548 return tag_ptr(ret_conv, true);
17551 uint64_t __attribute__((export_name("TS_CResult_PaymentIdPaymentErrorZ_ok"))) TS_CResult_PaymentIdPaymentErrorZ_ok(int8_tArray o) {
17552 LDKThirtyTwoBytes o_ref;
17553 CHECK(o->arr_len == 32);
17554 memcpy(o_ref.data, o->elems, 32); FREE(o);
17555 LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
17556 *ret_conv = CResult_PaymentIdPaymentErrorZ_ok(o_ref);
17557 return tag_ptr(ret_conv, true);
17560 uint64_t __attribute__((export_name("TS_CResult_PaymentIdPaymentErrorZ_err"))) TS_CResult_PaymentIdPaymentErrorZ_err(uint64_t e) {
17561 void* e_ptr = untag_ptr(e);
17562 CHECK_ACCESS(e_ptr);
17563 LDKPaymentError e_conv = *(LDKPaymentError*)(e_ptr);
17564 e_conv = PaymentError_clone((LDKPaymentError*)untag_ptr(e));
17565 LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
17566 *ret_conv = CResult_PaymentIdPaymentErrorZ_err(e_conv);
17567 return tag_ptr(ret_conv, true);
17570 jboolean __attribute__((export_name("TS_CResult_PaymentIdPaymentErrorZ_is_ok"))) TS_CResult_PaymentIdPaymentErrorZ_is_ok(uint64_t o) {
17571 LDKCResult_PaymentIdPaymentErrorZ* o_conv = (LDKCResult_PaymentIdPaymentErrorZ*)untag_ptr(o);
17572 jboolean ret_conv = CResult_PaymentIdPaymentErrorZ_is_ok(o_conv);
17576 void __attribute__((export_name("TS_CResult_PaymentIdPaymentErrorZ_free"))) TS_CResult_PaymentIdPaymentErrorZ_free(uint64_t _res) {
17577 if (!ptr_is_owned(_res)) return;
17578 void* _res_ptr = untag_ptr(_res);
17579 CHECK_ACCESS(_res_ptr);
17580 LDKCResult_PaymentIdPaymentErrorZ _res_conv = *(LDKCResult_PaymentIdPaymentErrorZ*)(_res_ptr);
17581 FREE(untag_ptr(_res));
17582 CResult_PaymentIdPaymentErrorZ_free(_res_conv);
17585 static inline uint64_t CResult_PaymentIdPaymentErrorZ_clone_ptr(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR arg) {
17586 LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
17587 *ret_conv = CResult_PaymentIdPaymentErrorZ_clone(arg);
17588 return tag_ptr(ret_conv, true);
17590 int64_t __attribute__((export_name("TS_CResult_PaymentIdPaymentErrorZ_clone_ptr"))) TS_CResult_PaymentIdPaymentErrorZ_clone_ptr(uint64_t arg) {
17591 LDKCResult_PaymentIdPaymentErrorZ* arg_conv = (LDKCResult_PaymentIdPaymentErrorZ*)untag_ptr(arg);
17592 int64_t ret_conv = CResult_PaymentIdPaymentErrorZ_clone_ptr(arg_conv);
17596 uint64_t __attribute__((export_name("TS_CResult_PaymentIdPaymentErrorZ_clone"))) TS_CResult_PaymentIdPaymentErrorZ_clone(uint64_t orig) {
17597 LDKCResult_PaymentIdPaymentErrorZ* orig_conv = (LDKCResult_PaymentIdPaymentErrorZ*)untag_ptr(orig);
17598 LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
17599 *ret_conv = CResult_PaymentIdPaymentErrorZ_clone(orig_conv);
17600 return tag_ptr(ret_conv, true);
17603 uint64_t __attribute__((export_name("TS_CResult_NonePaymentErrorZ_ok"))) TS_CResult_NonePaymentErrorZ_ok() {
17604 LDKCResult_NonePaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentErrorZ), "LDKCResult_NonePaymentErrorZ");
17605 *ret_conv = CResult_NonePaymentErrorZ_ok();
17606 return tag_ptr(ret_conv, true);
17609 uint64_t __attribute__((export_name("TS_CResult_NonePaymentErrorZ_err"))) TS_CResult_NonePaymentErrorZ_err(uint64_t e) {
17610 void* e_ptr = untag_ptr(e);
17611 CHECK_ACCESS(e_ptr);
17612 LDKPaymentError e_conv = *(LDKPaymentError*)(e_ptr);
17613 e_conv = PaymentError_clone((LDKPaymentError*)untag_ptr(e));
17614 LDKCResult_NonePaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentErrorZ), "LDKCResult_NonePaymentErrorZ");
17615 *ret_conv = CResult_NonePaymentErrorZ_err(e_conv);
17616 return tag_ptr(ret_conv, true);
17619 jboolean __attribute__((export_name("TS_CResult_NonePaymentErrorZ_is_ok"))) TS_CResult_NonePaymentErrorZ_is_ok(uint64_t o) {
17620 LDKCResult_NonePaymentErrorZ* o_conv = (LDKCResult_NonePaymentErrorZ*)untag_ptr(o);
17621 jboolean ret_conv = CResult_NonePaymentErrorZ_is_ok(o_conv);
17625 void __attribute__((export_name("TS_CResult_NonePaymentErrorZ_free"))) TS_CResult_NonePaymentErrorZ_free(uint64_t _res) {
17626 if (!ptr_is_owned(_res)) return;
17627 void* _res_ptr = untag_ptr(_res);
17628 CHECK_ACCESS(_res_ptr);
17629 LDKCResult_NonePaymentErrorZ _res_conv = *(LDKCResult_NonePaymentErrorZ*)(_res_ptr);
17630 FREE(untag_ptr(_res));
17631 CResult_NonePaymentErrorZ_free(_res_conv);
17634 static inline uint64_t CResult_NonePaymentErrorZ_clone_ptr(LDKCResult_NonePaymentErrorZ *NONNULL_PTR arg) {
17635 LDKCResult_NonePaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentErrorZ), "LDKCResult_NonePaymentErrorZ");
17636 *ret_conv = CResult_NonePaymentErrorZ_clone(arg);
17637 return tag_ptr(ret_conv, true);
17639 int64_t __attribute__((export_name("TS_CResult_NonePaymentErrorZ_clone_ptr"))) TS_CResult_NonePaymentErrorZ_clone_ptr(uint64_t arg) {
17640 LDKCResult_NonePaymentErrorZ* arg_conv = (LDKCResult_NonePaymentErrorZ*)untag_ptr(arg);
17641 int64_t ret_conv = CResult_NonePaymentErrorZ_clone_ptr(arg_conv);
17645 uint64_t __attribute__((export_name("TS_CResult_NonePaymentErrorZ_clone"))) TS_CResult_NonePaymentErrorZ_clone(uint64_t orig) {
17646 LDKCResult_NonePaymentErrorZ* orig_conv = (LDKCResult_NonePaymentErrorZ*)untag_ptr(orig);
17647 LDKCResult_NonePaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentErrorZ), "LDKCResult_NonePaymentErrorZ");
17648 *ret_conv = CResult_NonePaymentErrorZ_clone(orig_conv);
17649 return tag_ptr(ret_conv, true);
17652 uint64_t __attribute__((export_name("TS_CResult_StringErrorZ_ok"))) TS_CResult_StringErrorZ_ok(jstring o) {
17653 LDKStr o_conv = str_ref_to_owned_c(o);
17654 LDKCResult_StringErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StringErrorZ), "LDKCResult_StringErrorZ");
17655 *ret_conv = CResult_StringErrorZ_ok(o_conv);
17656 return tag_ptr(ret_conv, true);
17659 uint64_t __attribute__((export_name("TS_CResult_StringErrorZ_err"))) TS_CResult_StringErrorZ_err(uint32_t e) {
17660 LDKSecp256k1Error e_conv = LDKSecp256k1Error_from_js(e);
17661 LDKCResult_StringErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StringErrorZ), "LDKCResult_StringErrorZ");
17662 *ret_conv = CResult_StringErrorZ_err(e_conv);
17663 return tag_ptr(ret_conv, true);
17666 jboolean __attribute__((export_name("TS_CResult_StringErrorZ_is_ok"))) TS_CResult_StringErrorZ_is_ok(uint64_t o) {
17667 LDKCResult_StringErrorZ* o_conv = (LDKCResult_StringErrorZ*)untag_ptr(o);
17668 jboolean ret_conv = CResult_StringErrorZ_is_ok(o_conv);
17672 void __attribute__((export_name("TS_CResult_StringErrorZ_free"))) TS_CResult_StringErrorZ_free(uint64_t _res) {
17673 if (!ptr_is_owned(_res)) return;
17674 void* _res_ptr = untag_ptr(_res);
17675 CHECK_ACCESS(_res_ptr);
17676 LDKCResult_StringErrorZ _res_conv = *(LDKCResult_StringErrorZ*)(_res_ptr);
17677 FREE(untag_ptr(_res));
17678 CResult_StringErrorZ_free(_res_conv);
17681 static inline uint64_t CResult_StringErrorZ_clone_ptr(LDKCResult_StringErrorZ *NONNULL_PTR arg) {
17682 LDKCResult_StringErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StringErrorZ), "LDKCResult_StringErrorZ");
17683 *ret_conv = CResult_StringErrorZ_clone(arg);
17684 return tag_ptr(ret_conv, true);
17686 int64_t __attribute__((export_name("TS_CResult_StringErrorZ_clone_ptr"))) TS_CResult_StringErrorZ_clone_ptr(uint64_t arg) {
17687 LDKCResult_StringErrorZ* arg_conv = (LDKCResult_StringErrorZ*)untag_ptr(arg);
17688 int64_t ret_conv = CResult_StringErrorZ_clone_ptr(arg_conv);
17692 uint64_t __attribute__((export_name("TS_CResult_StringErrorZ_clone"))) TS_CResult_StringErrorZ_clone(uint64_t orig) {
17693 LDKCResult_StringErrorZ* orig_conv = (LDKCResult_StringErrorZ*)untag_ptr(orig);
17694 LDKCResult_StringErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StringErrorZ), "LDKCResult_StringErrorZ");
17695 *ret_conv = CResult_StringErrorZ_clone(orig_conv);
17696 return tag_ptr(ret_conv, true);
17699 uint64_t __attribute__((export_name("TS_CResult_PublicKeyErrorZ_ok"))) TS_CResult_PublicKeyErrorZ_ok(int8_tArray o) {
17700 LDKPublicKey o_ref;
17701 CHECK(o->arr_len == 33);
17702 memcpy(o_ref.compressed_form, o->elems, 33); FREE(o);
17703 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
17704 *ret_conv = CResult_PublicKeyErrorZ_ok(o_ref);
17705 return tag_ptr(ret_conv, true);
17708 uint64_t __attribute__((export_name("TS_CResult_PublicKeyErrorZ_err"))) TS_CResult_PublicKeyErrorZ_err(uint32_t e) {
17709 LDKSecp256k1Error e_conv = LDKSecp256k1Error_from_js(e);
17710 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
17711 *ret_conv = CResult_PublicKeyErrorZ_err(e_conv);
17712 return tag_ptr(ret_conv, true);
17715 jboolean __attribute__((export_name("TS_CResult_PublicKeyErrorZ_is_ok"))) TS_CResult_PublicKeyErrorZ_is_ok(uint64_t o) {
17716 LDKCResult_PublicKeyErrorZ* o_conv = (LDKCResult_PublicKeyErrorZ*)untag_ptr(o);
17717 jboolean ret_conv = CResult_PublicKeyErrorZ_is_ok(o_conv);
17721 void __attribute__((export_name("TS_CResult_PublicKeyErrorZ_free"))) TS_CResult_PublicKeyErrorZ_free(uint64_t _res) {
17722 if (!ptr_is_owned(_res)) return;
17723 void* _res_ptr = untag_ptr(_res);
17724 CHECK_ACCESS(_res_ptr);
17725 LDKCResult_PublicKeyErrorZ _res_conv = *(LDKCResult_PublicKeyErrorZ*)(_res_ptr);
17726 FREE(untag_ptr(_res));
17727 CResult_PublicKeyErrorZ_free(_res_conv);
17730 static inline uint64_t CResult_PublicKeyErrorZ_clone_ptr(LDKCResult_PublicKeyErrorZ *NONNULL_PTR arg) {
17731 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
17732 *ret_conv = CResult_PublicKeyErrorZ_clone(arg);
17733 return tag_ptr(ret_conv, true);
17735 int64_t __attribute__((export_name("TS_CResult_PublicKeyErrorZ_clone_ptr"))) TS_CResult_PublicKeyErrorZ_clone_ptr(uint64_t arg) {
17736 LDKCResult_PublicKeyErrorZ* arg_conv = (LDKCResult_PublicKeyErrorZ*)untag_ptr(arg);
17737 int64_t ret_conv = CResult_PublicKeyErrorZ_clone_ptr(arg_conv);
17741 uint64_t __attribute__((export_name("TS_CResult_PublicKeyErrorZ_clone"))) TS_CResult_PublicKeyErrorZ_clone(uint64_t orig) {
17742 LDKCResult_PublicKeyErrorZ* orig_conv = (LDKCResult_PublicKeyErrorZ*)untag_ptr(orig);
17743 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
17744 *ret_conv = CResult_PublicKeyErrorZ_clone(orig_conv);
17745 return tag_ptr(ret_conv, true);
17748 uint64_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_ok"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_ok(uint64_t o) {
17749 LDKChannelMonitorUpdate o_conv;
17750 o_conv.inner = untag_ptr(o);
17751 o_conv.is_owned = ptr_is_owned(o);
17752 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17753 o_conv = ChannelMonitorUpdate_clone(&o_conv);
17754 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
17755 *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o_conv);
17756 return tag_ptr(ret_conv, true);
17759 uint64_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_err"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_err(uint64_t e) {
17760 void* e_ptr = untag_ptr(e);
17761 CHECK_ACCESS(e_ptr);
17762 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
17763 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
17764 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
17765 *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_err(e_conv);
17766 return tag_ptr(ret_conv, true);
17769 jboolean __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(uint64_t o) {
17770 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* o_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)untag_ptr(o);
17771 jboolean ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o_conv);
17775 void __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free(uint64_t _res) {
17776 if (!ptr_is_owned(_res)) return;
17777 void* _res_ptr = untag_ptr(_res);
17778 CHECK_ACCESS(_res_ptr);
17779 LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res_conv = *(LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(_res_ptr);
17780 FREE(untag_ptr(_res));
17781 CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res_conv);
17784 static inline uint64_t CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR arg) {
17785 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
17786 *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_clone(arg);
17787 return tag_ptr(ret_conv, true);
17789 int64_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(uint64_t arg) {
17790 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* arg_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)untag_ptr(arg);
17791 int64_t ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg_conv);
17795 uint64_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone(uint64_t orig) {
17796 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* orig_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)untag_ptr(orig);
17797 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
17798 *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig_conv);
17799 return tag_ptr(ret_conv, true);
17802 uint64_t __attribute__((export_name("TS_COption_MonitorEventZ_some"))) TS_COption_MonitorEventZ_some(uint64_t o) {
17803 void* o_ptr = untag_ptr(o);
17804 CHECK_ACCESS(o_ptr);
17805 LDKMonitorEvent o_conv = *(LDKMonitorEvent*)(o_ptr);
17806 o_conv = MonitorEvent_clone((LDKMonitorEvent*)untag_ptr(o));
17807 LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
17808 *ret_copy = COption_MonitorEventZ_some(o_conv);
17809 uint64_t ret_ref = tag_ptr(ret_copy, true);
17813 uint64_t __attribute__((export_name("TS_COption_MonitorEventZ_none"))) TS_COption_MonitorEventZ_none() {
17814 LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
17815 *ret_copy = COption_MonitorEventZ_none();
17816 uint64_t ret_ref = tag_ptr(ret_copy, true);
17820 void __attribute__((export_name("TS_COption_MonitorEventZ_free"))) TS_COption_MonitorEventZ_free(uint64_t _res) {
17821 if (!ptr_is_owned(_res)) return;
17822 void* _res_ptr = untag_ptr(_res);
17823 CHECK_ACCESS(_res_ptr);
17824 LDKCOption_MonitorEventZ _res_conv = *(LDKCOption_MonitorEventZ*)(_res_ptr);
17825 FREE(untag_ptr(_res));
17826 COption_MonitorEventZ_free(_res_conv);
17829 static inline uint64_t COption_MonitorEventZ_clone_ptr(LDKCOption_MonitorEventZ *NONNULL_PTR arg) {
17830 LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
17831 *ret_copy = COption_MonitorEventZ_clone(arg);
17832 uint64_t ret_ref = tag_ptr(ret_copy, true);
17835 int64_t __attribute__((export_name("TS_COption_MonitorEventZ_clone_ptr"))) TS_COption_MonitorEventZ_clone_ptr(uint64_t arg) {
17836 LDKCOption_MonitorEventZ* arg_conv = (LDKCOption_MonitorEventZ*)untag_ptr(arg);
17837 int64_t ret_conv = COption_MonitorEventZ_clone_ptr(arg_conv);
17841 uint64_t __attribute__((export_name("TS_COption_MonitorEventZ_clone"))) TS_COption_MonitorEventZ_clone(uint64_t orig) {
17842 LDKCOption_MonitorEventZ* orig_conv = (LDKCOption_MonitorEventZ*)untag_ptr(orig);
17843 LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
17844 *ret_copy = COption_MonitorEventZ_clone(orig_conv);
17845 uint64_t ret_ref = tag_ptr(ret_copy, true);
17849 uint64_t __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_ok"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_ok(uint64_t o) {
17850 void* o_ptr = untag_ptr(o);
17851 CHECK_ACCESS(o_ptr);
17852 LDKCOption_MonitorEventZ o_conv = *(LDKCOption_MonitorEventZ*)(o_ptr);
17853 o_conv = COption_MonitorEventZ_clone((LDKCOption_MonitorEventZ*)untag_ptr(o));
17854 LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
17855 *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_ok(o_conv);
17856 return tag_ptr(ret_conv, true);
17859 uint64_t __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_err"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_err(uint64_t e) {
17860 void* e_ptr = untag_ptr(e);
17861 CHECK_ACCESS(e_ptr);
17862 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
17863 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
17864 LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
17865 *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_err(e_conv);
17866 return tag_ptr(ret_conv, true);
17869 jboolean __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok(uint64_t o) {
17870 LDKCResult_COption_MonitorEventZDecodeErrorZ* o_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)untag_ptr(o);
17871 jboolean ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o_conv);
17875 void __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_free"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_free(uint64_t _res) {
17876 if (!ptr_is_owned(_res)) return;
17877 void* _res_ptr = untag_ptr(_res);
17878 CHECK_ACCESS(_res_ptr);
17879 LDKCResult_COption_MonitorEventZDecodeErrorZ _res_conv = *(LDKCResult_COption_MonitorEventZDecodeErrorZ*)(_res_ptr);
17880 FREE(untag_ptr(_res));
17881 CResult_COption_MonitorEventZDecodeErrorZ_free(_res_conv);
17884 static inline uint64_t CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR arg) {
17885 LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
17886 *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_clone(arg);
17887 return tag_ptr(ret_conv, true);
17889 int64_t __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(uint64_t arg) {
17890 LDKCResult_COption_MonitorEventZDecodeErrorZ* arg_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)untag_ptr(arg);
17891 int64_t ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg_conv);
17895 uint64_t __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_clone"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_clone(uint64_t orig) {
17896 LDKCResult_COption_MonitorEventZDecodeErrorZ* orig_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)untag_ptr(orig);
17897 LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
17898 *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_clone(orig_conv);
17899 return tag_ptr(ret_conv, true);
17902 uint64_t __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_ok"))) TS_CResult_HTLCUpdateDecodeErrorZ_ok(uint64_t o) {
17903 LDKHTLCUpdate o_conv;
17904 o_conv.inner = untag_ptr(o);
17905 o_conv.is_owned = ptr_is_owned(o);
17906 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17907 o_conv = HTLCUpdate_clone(&o_conv);
17908 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
17909 *ret_conv = CResult_HTLCUpdateDecodeErrorZ_ok(o_conv);
17910 return tag_ptr(ret_conv, true);
17913 uint64_t __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_err"))) TS_CResult_HTLCUpdateDecodeErrorZ_err(uint64_t e) {
17914 void* e_ptr = untag_ptr(e);
17915 CHECK_ACCESS(e_ptr);
17916 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
17917 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
17918 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
17919 *ret_conv = CResult_HTLCUpdateDecodeErrorZ_err(e_conv);
17920 return tag_ptr(ret_conv, true);
17923 jboolean __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_is_ok"))) TS_CResult_HTLCUpdateDecodeErrorZ_is_ok(uint64_t o) {
17924 LDKCResult_HTLCUpdateDecodeErrorZ* o_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)untag_ptr(o);
17925 jboolean ret_conv = CResult_HTLCUpdateDecodeErrorZ_is_ok(o_conv);
17929 void __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_free"))) TS_CResult_HTLCUpdateDecodeErrorZ_free(uint64_t _res) {
17930 if (!ptr_is_owned(_res)) return;
17931 void* _res_ptr = untag_ptr(_res);
17932 CHECK_ACCESS(_res_ptr);
17933 LDKCResult_HTLCUpdateDecodeErrorZ _res_conv = *(LDKCResult_HTLCUpdateDecodeErrorZ*)(_res_ptr);
17934 FREE(untag_ptr(_res));
17935 CResult_HTLCUpdateDecodeErrorZ_free(_res_conv);
17938 static inline uint64_t CResult_HTLCUpdateDecodeErrorZ_clone_ptr(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR arg) {
17939 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
17940 *ret_conv = CResult_HTLCUpdateDecodeErrorZ_clone(arg);
17941 return tag_ptr(ret_conv, true);
17943 int64_t __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr"))) TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr(uint64_t arg) {
17944 LDKCResult_HTLCUpdateDecodeErrorZ* arg_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)untag_ptr(arg);
17945 int64_t ret_conv = CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg_conv);
17949 uint64_t __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_clone"))) TS_CResult_HTLCUpdateDecodeErrorZ_clone(uint64_t orig) {
17950 LDKCResult_HTLCUpdateDecodeErrorZ* orig_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)untag_ptr(orig);
17951 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
17952 *ret_conv = CResult_HTLCUpdateDecodeErrorZ_clone(orig_conv);
17953 return tag_ptr(ret_conv, true);
17956 static inline uint64_t C2Tuple_OutPointScriptZ_clone_ptr(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR arg) {
17957 LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
17958 *ret_conv = C2Tuple_OutPointScriptZ_clone(arg);
17959 return tag_ptr(ret_conv, true);
17961 int64_t __attribute__((export_name("TS_C2Tuple_OutPointScriptZ_clone_ptr"))) TS_C2Tuple_OutPointScriptZ_clone_ptr(uint64_t arg) {
17962 LDKC2Tuple_OutPointScriptZ* arg_conv = (LDKC2Tuple_OutPointScriptZ*)untag_ptr(arg);
17963 int64_t ret_conv = C2Tuple_OutPointScriptZ_clone_ptr(arg_conv);
17967 uint64_t __attribute__((export_name("TS_C2Tuple_OutPointScriptZ_clone"))) TS_C2Tuple_OutPointScriptZ_clone(uint64_t orig) {
17968 LDKC2Tuple_OutPointScriptZ* orig_conv = (LDKC2Tuple_OutPointScriptZ*)untag_ptr(orig);
17969 LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
17970 *ret_conv = C2Tuple_OutPointScriptZ_clone(orig_conv);
17971 return tag_ptr(ret_conv, true);
17974 uint64_t __attribute__((export_name("TS_C2Tuple_OutPointScriptZ_new"))) TS_C2Tuple_OutPointScriptZ_new(uint64_t a, int8_tArray b) {
17975 LDKOutPoint a_conv;
17976 a_conv.inner = untag_ptr(a);
17977 a_conv.is_owned = ptr_is_owned(a);
17978 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
17979 a_conv = OutPoint_clone(&a_conv);
17981 b_ref.datalen = b->arr_len;
17982 b_ref.data = MALLOC(b_ref.datalen, "LDKCVec_u8Z Bytes");
17983 memcpy(b_ref.data, b->elems, b_ref.datalen); FREE(b);
17984 LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
17985 *ret_conv = C2Tuple_OutPointScriptZ_new(a_conv, b_ref);
17986 return tag_ptr(ret_conv, true);
17989 void __attribute__((export_name("TS_C2Tuple_OutPointScriptZ_free"))) TS_C2Tuple_OutPointScriptZ_free(uint64_t _res) {
17990 if (!ptr_is_owned(_res)) return;
17991 void* _res_ptr = untag_ptr(_res);
17992 CHECK_ACCESS(_res_ptr);
17993 LDKC2Tuple_OutPointScriptZ _res_conv = *(LDKC2Tuple_OutPointScriptZ*)(_res_ptr);
17994 FREE(untag_ptr(_res));
17995 C2Tuple_OutPointScriptZ_free(_res_conv);
17998 static inline uint64_t C2Tuple_u32ScriptZ_clone_ptr(LDKC2Tuple_u32ScriptZ *NONNULL_PTR arg) {
17999 LDKC2Tuple_u32ScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
18000 *ret_conv = C2Tuple_u32ScriptZ_clone(arg);
18001 return tag_ptr(ret_conv, true);
18003 int64_t __attribute__((export_name("TS_C2Tuple_u32ScriptZ_clone_ptr"))) TS_C2Tuple_u32ScriptZ_clone_ptr(uint64_t arg) {
18004 LDKC2Tuple_u32ScriptZ* arg_conv = (LDKC2Tuple_u32ScriptZ*)untag_ptr(arg);
18005 int64_t ret_conv = C2Tuple_u32ScriptZ_clone_ptr(arg_conv);
18009 uint64_t __attribute__((export_name("TS_C2Tuple_u32ScriptZ_clone"))) TS_C2Tuple_u32ScriptZ_clone(uint64_t orig) {
18010 LDKC2Tuple_u32ScriptZ* orig_conv = (LDKC2Tuple_u32ScriptZ*)untag_ptr(orig);
18011 LDKC2Tuple_u32ScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
18012 *ret_conv = C2Tuple_u32ScriptZ_clone(orig_conv);
18013 return tag_ptr(ret_conv, true);
18016 uint64_t __attribute__((export_name("TS_C2Tuple_u32ScriptZ_new"))) TS_C2Tuple_u32ScriptZ_new(int32_t a, int8_tArray b) {
18018 b_ref.datalen = b->arr_len;
18019 b_ref.data = MALLOC(b_ref.datalen, "LDKCVec_u8Z Bytes");
18020 memcpy(b_ref.data, b->elems, b_ref.datalen); FREE(b);
18021 LDKC2Tuple_u32ScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
18022 *ret_conv = C2Tuple_u32ScriptZ_new(a, b_ref);
18023 return tag_ptr(ret_conv, true);
18026 void __attribute__((export_name("TS_C2Tuple_u32ScriptZ_free"))) TS_C2Tuple_u32ScriptZ_free(uint64_t _res) {
18027 if (!ptr_is_owned(_res)) return;
18028 void* _res_ptr = untag_ptr(_res);
18029 CHECK_ACCESS(_res_ptr);
18030 LDKC2Tuple_u32ScriptZ _res_conv = *(LDKC2Tuple_u32ScriptZ*)(_res_ptr);
18031 FREE(untag_ptr(_res));
18032 C2Tuple_u32ScriptZ_free(_res_conv);
18035 void __attribute__((export_name("TS_CVec_C2Tuple_u32ScriptZZ_free"))) TS_CVec_C2Tuple_u32ScriptZZ_free(uint64_tArray _res) {
18036 LDKCVec_C2Tuple_u32ScriptZZ _res_constr;
18037 _res_constr.datalen = _res->arr_len;
18038 if (_res_constr.datalen > 0)
18039 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_u32ScriptZ), "LDKCVec_C2Tuple_u32ScriptZZ Elements");
18041 _res_constr.data = NULL;
18042 uint64_t* _res_vals = _res->elems;
18043 for (size_t v = 0; v < _res_constr.datalen; v++) {
18044 uint64_t _res_conv_21 = _res_vals[v];
18045 void* _res_conv_21_ptr = untag_ptr(_res_conv_21);
18046 CHECK_ACCESS(_res_conv_21_ptr);
18047 LDKC2Tuple_u32ScriptZ _res_conv_21_conv = *(LDKC2Tuple_u32ScriptZ*)(_res_conv_21_ptr);
18048 FREE(untag_ptr(_res_conv_21));
18049 _res_constr.data[v] = _res_conv_21_conv;
18052 CVec_C2Tuple_u32ScriptZZ_free(_res_constr);
18055 static inline uint64_t C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR arg) {
18056 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
18057 *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(arg);
18058 return tag_ptr(ret_conv, true);
18060 int64_t __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(uint64_t arg) {
18061 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* arg_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)untag_ptr(arg);
18062 int64_t ret_conv = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg_conv);
18066 uint64_t __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(uint64_t orig) {
18067 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* orig_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)untag_ptr(orig);
18068 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
18069 *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig_conv);
18070 return tag_ptr(ret_conv, true);
18073 uint64_t __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(int8_tArray a, uint64_tArray b) {
18074 LDKThirtyTwoBytes a_ref;
18075 CHECK(a->arr_len == 32);
18076 memcpy(a_ref.data, a->elems, 32); FREE(a);
18077 LDKCVec_C2Tuple_u32ScriptZZ b_constr;
18078 b_constr.datalen = b->arr_len;
18079 if (b_constr.datalen > 0)
18080 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKC2Tuple_u32ScriptZ), "LDKCVec_C2Tuple_u32ScriptZZ Elements");
18082 b_constr.data = NULL;
18083 uint64_t* b_vals = b->elems;
18084 for (size_t v = 0; v < b_constr.datalen; v++) {
18085 uint64_t b_conv_21 = b_vals[v];
18086 void* b_conv_21_ptr = untag_ptr(b_conv_21);
18087 CHECK_ACCESS(b_conv_21_ptr);
18088 LDKC2Tuple_u32ScriptZ b_conv_21_conv = *(LDKC2Tuple_u32ScriptZ*)(b_conv_21_ptr);
18089 b_conv_21_conv = C2Tuple_u32ScriptZ_clone((LDKC2Tuple_u32ScriptZ*)untag_ptr(b_conv_21));
18090 b_constr.data[v] = b_conv_21_conv;
18093 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
18094 *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a_ref, b_constr);
18095 return tag_ptr(ret_conv, true);
18098 void __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(uint64_t _res) {
18099 if (!ptr_is_owned(_res)) return;
18100 void* _res_ptr = untag_ptr(_res);
18101 CHECK_ACCESS(_res_ptr);
18102 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(_res_ptr);
18103 FREE(untag_ptr(_res));
18104 C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res_conv);
18107 void __attribute__((export_name("TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free"))) TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(uint64_tArray _res) {
18108 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ _res_constr;
18109 _res_constr.datalen = _res->arr_len;
18110 if (_res_constr.datalen > 0)
18111 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ Elements");
18113 _res_constr.data = NULL;
18114 uint64_t* _res_vals = _res->elems;
18115 for (size_t o = 0; o < _res_constr.datalen; o++) {
18116 uint64_t _res_conv_40 = _res_vals[o];
18117 void* _res_conv_40_ptr = untag_ptr(_res_conv_40);
18118 CHECK_ACCESS(_res_conv_40_ptr);
18119 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res_conv_40_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(_res_conv_40_ptr);
18120 FREE(untag_ptr(_res_conv_40));
18121 _res_constr.data[o] = _res_conv_40_conv;
18124 CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res_constr);
18127 void __attribute__((export_name("TS_CVec_EventZ_free"))) TS_CVec_EventZ_free(uint64_tArray _res) {
18128 LDKCVec_EventZ _res_constr;
18129 _res_constr.datalen = _res->arr_len;
18130 if (_res_constr.datalen > 0)
18131 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKEvent), "LDKCVec_EventZ Elements");
18133 _res_constr.data = NULL;
18134 uint64_t* _res_vals = _res->elems;
18135 for (size_t h = 0; h < _res_constr.datalen; h++) {
18136 uint64_t _res_conv_7 = _res_vals[h];
18137 void* _res_conv_7_ptr = untag_ptr(_res_conv_7);
18138 CHECK_ACCESS(_res_conv_7_ptr);
18139 LDKEvent _res_conv_7_conv = *(LDKEvent*)(_res_conv_7_ptr);
18140 FREE(untag_ptr(_res_conv_7));
18141 _res_constr.data[h] = _res_conv_7_conv;
18144 CVec_EventZ_free(_res_constr);
18147 void __attribute__((export_name("TS_CVec_TransactionZ_free"))) TS_CVec_TransactionZ_free(ptrArray _res) {
18148 LDKCVec_TransactionZ _res_constr;
18149 _res_constr.datalen = _res->arr_len;
18150 if (_res_constr.datalen > 0)
18151 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKTransaction), "LDKCVec_TransactionZ Elements");
18153 _res_constr.data = NULL;
18154 int8_tArray* _res_vals = (void*) _res->elems;
18155 for (size_t m = 0; m < _res_constr.datalen; m++) {
18156 int8_tArray _res_conv_12 = _res_vals[m];
18157 LDKTransaction _res_conv_12_ref;
18158 _res_conv_12_ref.datalen = _res_conv_12->arr_len;
18159 _res_conv_12_ref.data = MALLOC(_res_conv_12_ref.datalen, "LDKTransaction Bytes");
18160 memcpy(_res_conv_12_ref.data, _res_conv_12->elems, _res_conv_12_ref.datalen); FREE(_res_conv_12);
18161 _res_conv_12_ref.data_is_owned = true;
18162 _res_constr.data[m] = _res_conv_12_ref;
18165 CVec_TransactionZ_free(_res_constr);
18168 static inline uint64_t C2Tuple_u32TxOutZ_clone_ptr(LDKC2Tuple_u32TxOutZ *NONNULL_PTR arg) {
18169 LDKC2Tuple_u32TxOutZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
18170 *ret_conv = C2Tuple_u32TxOutZ_clone(arg);
18171 return tag_ptr(ret_conv, true);
18173 int64_t __attribute__((export_name("TS_C2Tuple_u32TxOutZ_clone_ptr"))) TS_C2Tuple_u32TxOutZ_clone_ptr(uint64_t arg) {
18174 LDKC2Tuple_u32TxOutZ* arg_conv = (LDKC2Tuple_u32TxOutZ*)untag_ptr(arg);
18175 int64_t ret_conv = C2Tuple_u32TxOutZ_clone_ptr(arg_conv);
18179 uint64_t __attribute__((export_name("TS_C2Tuple_u32TxOutZ_clone"))) TS_C2Tuple_u32TxOutZ_clone(uint64_t orig) {
18180 LDKC2Tuple_u32TxOutZ* orig_conv = (LDKC2Tuple_u32TxOutZ*)untag_ptr(orig);
18181 LDKC2Tuple_u32TxOutZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
18182 *ret_conv = C2Tuple_u32TxOutZ_clone(orig_conv);
18183 return tag_ptr(ret_conv, true);
18186 uint64_t __attribute__((export_name("TS_C2Tuple_u32TxOutZ_new"))) TS_C2Tuple_u32TxOutZ_new(int32_t a, uint64_t b) {
18187 void* b_ptr = untag_ptr(b);
18188 CHECK_ACCESS(b_ptr);
18189 LDKTxOut b_conv = *(LDKTxOut*)(b_ptr);
18190 b_conv = TxOut_clone((LDKTxOut*)untag_ptr(b));
18191 LDKC2Tuple_u32TxOutZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
18192 *ret_conv = C2Tuple_u32TxOutZ_new(a, b_conv);
18193 return tag_ptr(ret_conv, true);
18196 void __attribute__((export_name("TS_C2Tuple_u32TxOutZ_free"))) TS_C2Tuple_u32TxOutZ_free(uint64_t _res) {
18197 if (!ptr_is_owned(_res)) return;
18198 void* _res_ptr = untag_ptr(_res);
18199 CHECK_ACCESS(_res_ptr);
18200 LDKC2Tuple_u32TxOutZ _res_conv = *(LDKC2Tuple_u32TxOutZ*)(_res_ptr);
18201 FREE(untag_ptr(_res));
18202 C2Tuple_u32TxOutZ_free(_res_conv);
18205 void __attribute__((export_name("TS_CVec_C2Tuple_u32TxOutZZ_free"))) TS_CVec_C2Tuple_u32TxOutZZ_free(uint64_tArray _res) {
18206 LDKCVec_C2Tuple_u32TxOutZZ _res_constr;
18207 _res_constr.datalen = _res->arr_len;
18208 if (_res_constr.datalen > 0)
18209 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_u32TxOutZ), "LDKCVec_C2Tuple_u32TxOutZZ Elements");
18211 _res_constr.data = NULL;
18212 uint64_t* _res_vals = _res->elems;
18213 for (size_t u = 0; u < _res_constr.datalen; u++) {
18214 uint64_t _res_conv_20 = _res_vals[u];
18215 void* _res_conv_20_ptr = untag_ptr(_res_conv_20);
18216 CHECK_ACCESS(_res_conv_20_ptr);
18217 LDKC2Tuple_u32TxOutZ _res_conv_20_conv = *(LDKC2Tuple_u32TxOutZ*)(_res_conv_20_ptr);
18218 FREE(untag_ptr(_res_conv_20));
18219 _res_constr.data[u] = _res_conv_20_conv;
18222 CVec_C2Tuple_u32TxOutZZ_free(_res_constr);
18225 static inline uint64_t C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR arg) {
18226 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
18227 *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(arg);
18228 return tag_ptr(ret_conv, true);
18230 int64_t __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(uint64_t arg) {
18231 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* arg_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)untag_ptr(arg);
18232 int64_t ret_conv = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg_conv);
18236 uint64_t __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(uint64_t orig) {
18237 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* orig_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)untag_ptr(orig);
18238 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
18239 *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig_conv);
18240 return tag_ptr(ret_conv, true);
18243 uint64_t __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(int8_tArray a, uint64_tArray b) {
18244 LDKThirtyTwoBytes a_ref;
18245 CHECK(a->arr_len == 32);
18246 memcpy(a_ref.data, a->elems, 32); FREE(a);
18247 LDKCVec_C2Tuple_u32TxOutZZ b_constr;
18248 b_constr.datalen = b->arr_len;
18249 if (b_constr.datalen > 0)
18250 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKC2Tuple_u32TxOutZ), "LDKCVec_C2Tuple_u32TxOutZZ Elements");
18252 b_constr.data = NULL;
18253 uint64_t* b_vals = b->elems;
18254 for (size_t u = 0; u < b_constr.datalen; u++) {
18255 uint64_t b_conv_20 = b_vals[u];
18256 void* b_conv_20_ptr = untag_ptr(b_conv_20);
18257 CHECK_ACCESS(b_conv_20_ptr);
18258 LDKC2Tuple_u32TxOutZ b_conv_20_conv = *(LDKC2Tuple_u32TxOutZ*)(b_conv_20_ptr);
18259 b_conv_20_conv = C2Tuple_u32TxOutZ_clone((LDKC2Tuple_u32TxOutZ*)untag_ptr(b_conv_20));
18260 b_constr.data[u] = b_conv_20_conv;
18263 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
18264 *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a_ref, b_constr);
18265 return tag_ptr(ret_conv, true);
18268 void __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(uint64_t _res) {
18269 if (!ptr_is_owned(_res)) return;
18270 void* _res_ptr = untag_ptr(_res);
18271 CHECK_ACCESS(_res_ptr);
18272 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(_res_ptr);
18273 FREE(untag_ptr(_res));
18274 C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res_conv);
18277 void __attribute__((export_name("TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free"))) TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(uint64_tArray _res) {
18278 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ _res_constr;
18279 _res_constr.datalen = _res->arr_len;
18280 if (_res_constr.datalen > 0)
18281 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ Elements");
18283 _res_constr.data = NULL;
18284 uint64_t* _res_vals = _res->elems;
18285 for (size_t n = 0; n < _res_constr.datalen; n++) {
18286 uint64_t _res_conv_39 = _res_vals[n];
18287 void* _res_conv_39_ptr = untag_ptr(_res_conv_39);
18288 CHECK_ACCESS(_res_conv_39_ptr);
18289 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res_conv_39_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(_res_conv_39_ptr);
18290 FREE(untag_ptr(_res_conv_39));
18291 _res_constr.data[n] = _res_conv_39_conv;
18294 CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res_constr);
18297 void __attribute__((export_name("TS_CVec_BalanceZ_free"))) TS_CVec_BalanceZ_free(uint64_tArray _res) {
18298 LDKCVec_BalanceZ _res_constr;
18299 _res_constr.datalen = _res->arr_len;
18300 if (_res_constr.datalen > 0)
18301 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKBalance), "LDKCVec_BalanceZ Elements");
18303 _res_constr.data = NULL;
18304 uint64_t* _res_vals = _res->elems;
18305 for (size_t j = 0; j < _res_constr.datalen; j++) {
18306 uint64_t _res_conv_9 = _res_vals[j];
18307 void* _res_conv_9_ptr = untag_ptr(_res_conv_9);
18308 CHECK_ACCESS(_res_conv_9_ptr);
18309 LDKBalance _res_conv_9_conv = *(LDKBalance*)(_res_conv_9_ptr);
18310 FREE(untag_ptr(_res_conv_9));
18311 _res_constr.data[j] = _res_conv_9_conv;
18314 CVec_BalanceZ_free(_res_constr);
18317 static inline uint64_t C2Tuple_BlockHashChannelMonitorZ_clone_ptr(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR arg) {
18318 LDKC2Tuple_BlockHashChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
18319 *ret_conv = C2Tuple_BlockHashChannelMonitorZ_clone(arg);
18320 return tag_ptr(ret_conv, true);
18322 int64_t __attribute__((export_name("TS_C2Tuple_BlockHashChannelMonitorZ_clone_ptr"))) TS_C2Tuple_BlockHashChannelMonitorZ_clone_ptr(uint64_t arg) {
18323 LDKC2Tuple_BlockHashChannelMonitorZ* arg_conv = (LDKC2Tuple_BlockHashChannelMonitorZ*)untag_ptr(arg);
18324 int64_t ret_conv = C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg_conv);
18328 uint64_t __attribute__((export_name("TS_C2Tuple_BlockHashChannelMonitorZ_clone"))) TS_C2Tuple_BlockHashChannelMonitorZ_clone(uint64_t orig) {
18329 LDKC2Tuple_BlockHashChannelMonitorZ* orig_conv = (LDKC2Tuple_BlockHashChannelMonitorZ*)untag_ptr(orig);
18330 LDKC2Tuple_BlockHashChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
18331 *ret_conv = C2Tuple_BlockHashChannelMonitorZ_clone(orig_conv);
18332 return tag_ptr(ret_conv, true);
18335 uint64_t __attribute__((export_name("TS_C2Tuple_BlockHashChannelMonitorZ_new"))) TS_C2Tuple_BlockHashChannelMonitorZ_new(int8_tArray a, uint64_t b) {
18336 LDKThirtyTwoBytes a_ref;
18337 CHECK(a->arr_len == 32);
18338 memcpy(a_ref.data, a->elems, 32); FREE(a);
18339 LDKChannelMonitor b_conv;
18340 b_conv.inner = untag_ptr(b);
18341 b_conv.is_owned = ptr_is_owned(b);
18342 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
18343 b_conv = ChannelMonitor_clone(&b_conv);
18344 LDKC2Tuple_BlockHashChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
18345 *ret_conv = C2Tuple_BlockHashChannelMonitorZ_new(a_ref, b_conv);
18346 return tag_ptr(ret_conv, true);
18349 void __attribute__((export_name("TS_C2Tuple_BlockHashChannelMonitorZ_free"))) TS_C2Tuple_BlockHashChannelMonitorZ_free(uint64_t _res) {
18350 if (!ptr_is_owned(_res)) return;
18351 void* _res_ptr = untag_ptr(_res);
18352 CHECK_ACCESS(_res_ptr);
18353 LDKC2Tuple_BlockHashChannelMonitorZ _res_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(_res_ptr);
18354 FREE(untag_ptr(_res));
18355 C2Tuple_BlockHashChannelMonitorZ_free(_res_conv);
18358 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(uint64_t o) {
18359 void* o_ptr = untag_ptr(o);
18360 CHECK_ACCESS(o_ptr);
18361 LDKC2Tuple_BlockHashChannelMonitorZ o_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(o_ptr);
18362 o_conv = C2Tuple_BlockHashChannelMonitorZ_clone((LDKC2Tuple_BlockHashChannelMonitorZ*)untag_ptr(o));
18363 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
18364 *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o_conv);
18365 return tag_ptr(ret_conv, true);
18368 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(uint64_t e) {
18369 void* e_ptr = untag_ptr(e);
18370 CHECK_ACCESS(e_ptr);
18371 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
18372 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
18373 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
18374 *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e_conv);
18375 return tag_ptr(ret_conv, true);
18378 jboolean __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(uint64_t o) {
18379 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* o_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)untag_ptr(o);
18380 jboolean ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o_conv);
18384 void __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(uint64_t _res) {
18385 if (!ptr_is_owned(_res)) return;
18386 void* _res_ptr = untag_ptr(_res);
18387 CHECK_ACCESS(_res_ptr);
18388 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ _res_conv = *(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(_res_ptr);
18389 FREE(untag_ptr(_res));
18390 CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res_conv);
18393 static inline uint64_t CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR arg) {
18394 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
18395 *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(arg);
18396 return tag_ptr(ret_conv, true);
18398 int64_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(uint64_t arg) {
18399 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* arg_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)untag_ptr(arg);
18400 int64_t ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg_conv);
18404 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(uint64_t orig) {
18405 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* orig_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)untag_ptr(orig);
18406 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
18407 *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig_conv);
18408 return tag_ptr(ret_conv, true);
18411 static inline uint64_t C2Tuple_PublicKeyTypeZ_clone_ptr(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR arg) {
18412 LDKC2Tuple_PublicKeyTypeZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ");
18413 *ret_conv = C2Tuple_PublicKeyTypeZ_clone(arg);
18414 return tag_ptr(ret_conv, true);
18416 int64_t __attribute__((export_name("TS_C2Tuple_PublicKeyTypeZ_clone_ptr"))) TS_C2Tuple_PublicKeyTypeZ_clone_ptr(uint64_t arg) {
18417 LDKC2Tuple_PublicKeyTypeZ* arg_conv = (LDKC2Tuple_PublicKeyTypeZ*)untag_ptr(arg);
18418 int64_t ret_conv = C2Tuple_PublicKeyTypeZ_clone_ptr(arg_conv);
18422 uint64_t __attribute__((export_name("TS_C2Tuple_PublicKeyTypeZ_clone"))) TS_C2Tuple_PublicKeyTypeZ_clone(uint64_t orig) {
18423 LDKC2Tuple_PublicKeyTypeZ* orig_conv = (LDKC2Tuple_PublicKeyTypeZ*)untag_ptr(orig);
18424 LDKC2Tuple_PublicKeyTypeZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ");
18425 *ret_conv = C2Tuple_PublicKeyTypeZ_clone(orig_conv);
18426 return tag_ptr(ret_conv, true);
18429 uint64_t __attribute__((export_name("TS_C2Tuple_PublicKeyTypeZ_new"))) TS_C2Tuple_PublicKeyTypeZ_new(int8_tArray a, uint64_t b) {
18430 LDKPublicKey a_ref;
18431 CHECK(a->arr_len == 33);
18432 memcpy(a_ref.compressed_form, a->elems, 33); FREE(a);
18433 void* b_ptr = untag_ptr(b);
18434 CHECK_ACCESS(b_ptr);
18435 LDKType b_conv = *(LDKType*)(b_ptr);
18436 if (b_conv.free == LDKType_JCalls_free) {
18437 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
18438 LDKType_JCalls_cloned(&b_conv);
18440 LDKC2Tuple_PublicKeyTypeZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ");
18441 *ret_conv = C2Tuple_PublicKeyTypeZ_new(a_ref, b_conv);
18442 return tag_ptr(ret_conv, true);
18445 void __attribute__((export_name("TS_C2Tuple_PublicKeyTypeZ_free"))) TS_C2Tuple_PublicKeyTypeZ_free(uint64_t _res) {
18446 if (!ptr_is_owned(_res)) return;
18447 void* _res_ptr = untag_ptr(_res);
18448 CHECK_ACCESS(_res_ptr);
18449 LDKC2Tuple_PublicKeyTypeZ _res_conv = *(LDKC2Tuple_PublicKeyTypeZ*)(_res_ptr);
18450 FREE(untag_ptr(_res));
18451 C2Tuple_PublicKeyTypeZ_free(_res_conv);
18454 void __attribute__((export_name("TS_CVec_C2Tuple_PublicKeyTypeZZ_free"))) TS_CVec_C2Tuple_PublicKeyTypeZZ_free(uint64_tArray _res) {
18455 LDKCVec_C2Tuple_PublicKeyTypeZZ _res_constr;
18456 _res_constr.datalen = _res->arr_len;
18457 if (_res_constr.datalen > 0)
18458 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKCVec_C2Tuple_PublicKeyTypeZZ Elements");
18460 _res_constr.data = NULL;
18461 uint64_t* _res_vals = _res->elems;
18462 for (size_t z = 0; z < _res_constr.datalen; z++) {
18463 uint64_t _res_conv_25 = _res_vals[z];
18464 void* _res_conv_25_ptr = untag_ptr(_res_conv_25);
18465 CHECK_ACCESS(_res_conv_25_ptr);
18466 LDKC2Tuple_PublicKeyTypeZ _res_conv_25_conv = *(LDKC2Tuple_PublicKeyTypeZ*)(_res_conv_25_ptr);
18467 FREE(untag_ptr(_res_conv_25));
18468 _res_constr.data[z] = _res_conv_25_conv;
18471 CVec_C2Tuple_PublicKeyTypeZZ_free(_res_constr);
18474 uint64_t __attribute__((export_name("TS_COption_CustomOnionMessageContentsZ_some"))) TS_COption_CustomOnionMessageContentsZ_some(uint64_t o) {
18475 void* o_ptr = untag_ptr(o);
18476 CHECK_ACCESS(o_ptr);
18477 LDKCustomOnionMessageContents o_conv = *(LDKCustomOnionMessageContents*)(o_ptr);
18478 if (o_conv.free == LDKCustomOnionMessageContents_JCalls_free) {
18479 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
18480 LDKCustomOnionMessageContents_JCalls_cloned(&o_conv);
18482 LDKCOption_CustomOnionMessageContentsZ *ret_copy = MALLOC(sizeof(LDKCOption_CustomOnionMessageContentsZ), "LDKCOption_CustomOnionMessageContentsZ");
18483 *ret_copy = COption_CustomOnionMessageContentsZ_some(o_conv);
18484 uint64_t ret_ref = tag_ptr(ret_copy, true);
18488 uint64_t __attribute__((export_name("TS_COption_CustomOnionMessageContentsZ_none"))) TS_COption_CustomOnionMessageContentsZ_none() {
18489 LDKCOption_CustomOnionMessageContentsZ *ret_copy = MALLOC(sizeof(LDKCOption_CustomOnionMessageContentsZ), "LDKCOption_CustomOnionMessageContentsZ");
18490 *ret_copy = COption_CustomOnionMessageContentsZ_none();
18491 uint64_t ret_ref = tag_ptr(ret_copy, true);
18495 void __attribute__((export_name("TS_COption_CustomOnionMessageContentsZ_free"))) TS_COption_CustomOnionMessageContentsZ_free(uint64_t _res) {
18496 if (!ptr_is_owned(_res)) return;
18497 void* _res_ptr = untag_ptr(_res);
18498 CHECK_ACCESS(_res_ptr);
18499 LDKCOption_CustomOnionMessageContentsZ _res_conv = *(LDKCOption_CustomOnionMessageContentsZ*)(_res_ptr);
18500 FREE(untag_ptr(_res));
18501 COption_CustomOnionMessageContentsZ_free(_res_conv);
18504 static inline uint64_t COption_CustomOnionMessageContentsZ_clone_ptr(LDKCOption_CustomOnionMessageContentsZ *NONNULL_PTR arg) {
18505 LDKCOption_CustomOnionMessageContentsZ *ret_copy = MALLOC(sizeof(LDKCOption_CustomOnionMessageContentsZ), "LDKCOption_CustomOnionMessageContentsZ");
18506 *ret_copy = COption_CustomOnionMessageContentsZ_clone(arg);
18507 uint64_t ret_ref = tag_ptr(ret_copy, true);
18510 int64_t __attribute__((export_name("TS_COption_CustomOnionMessageContentsZ_clone_ptr"))) TS_COption_CustomOnionMessageContentsZ_clone_ptr(uint64_t arg) {
18511 LDKCOption_CustomOnionMessageContentsZ* arg_conv = (LDKCOption_CustomOnionMessageContentsZ*)untag_ptr(arg);
18512 int64_t ret_conv = COption_CustomOnionMessageContentsZ_clone_ptr(arg_conv);
18516 uint64_t __attribute__((export_name("TS_COption_CustomOnionMessageContentsZ_clone"))) TS_COption_CustomOnionMessageContentsZ_clone(uint64_t orig) {
18517 LDKCOption_CustomOnionMessageContentsZ* orig_conv = (LDKCOption_CustomOnionMessageContentsZ*)untag_ptr(orig);
18518 LDKCOption_CustomOnionMessageContentsZ *ret_copy = MALLOC(sizeof(LDKCOption_CustomOnionMessageContentsZ), "LDKCOption_CustomOnionMessageContentsZ");
18519 *ret_copy = COption_CustomOnionMessageContentsZ_clone(orig_conv);
18520 uint64_t ret_ref = tag_ptr(ret_copy, true);
18524 uint64_t __attribute__((export_name("TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_ok"))) TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_ok(uint64_t o) {
18525 void* o_ptr = untag_ptr(o);
18526 CHECK_ACCESS(o_ptr);
18527 LDKCOption_CustomOnionMessageContentsZ o_conv = *(LDKCOption_CustomOnionMessageContentsZ*)(o_ptr);
18528 o_conv = COption_CustomOnionMessageContentsZ_clone((LDKCOption_CustomOnionMessageContentsZ*)untag_ptr(o));
18529 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ), "LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ");
18530 *ret_conv = CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_ok(o_conv);
18531 return tag_ptr(ret_conv, true);
18534 uint64_t __attribute__((export_name("TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_err"))) TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_err(uint64_t e) {
18535 void* e_ptr = untag_ptr(e);
18536 CHECK_ACCESS(e_ptr);
18537 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
18538 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
18539 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ), "LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ");
18540 *ret_conv = CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_err(e_conv);
18541 return tag_ptr(ret_conv, true);
18544 jboolean __attribute__((export_name("TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_is_ok"))) TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_is_ok(uint64_t o) {
18545 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* o_conv = (LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ*)untag_ptr(o);
18546 jboolean ret_conv = CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_is_ok(o_conv);
18550 void __attribute__((export_name("TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_free"))) TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_free(uint64_t _res) {
18551 if (!ptr_is_owned(_res)) return;
18552 void* _res_ptr = untag_ptr(_res);
18553 CHECK_ACCESS(_res_ptr);
18554 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ _res_conv = *(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ*)(_res_ptr);
18555 FREE(untag_ptr(_res));
18556 CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_free(_res_conv);
18559 static inline uint64_t CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone_ptr(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR arg) {
18560 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ), "LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ");
18561 *ret_conv = CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone(arg);
18562 return tag_ptr(ret_conv, true);
18564 int64_t __attribute__((export_name("TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone_ptr(uint64_t arg) {
18565 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* arg_conv = (LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ*)untag_ptr(arg);
18566 int64_t ret_conv = CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone_ptr(arg_conv);
18570 uint64_t __attribute__((export_name("TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone"))) TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone(uint64_t orig) {
18571 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* orig_conv = (LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ*)untag_ptr(orig);
18572 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ), "LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ");
18573 *ret_conv = CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone(orig_conv);
18574 return tag_ptr(ret_conv, true);
18577 uint64_t __attribute__((export_name("TS_COption_NetAddressZ_some"))) TS_COption_NetAddressZ_some(uint64_t o) {
18578 void* o_ptr = untag_ptr(o);
18579 CHECK_ACCESS(o_ptr);
18580 LDKNetAddress o_conv = *(LDKNetAddress*)(o_ptr);
18581 o_conv = NetAddress_clone((LDKNetAddress*)untag_ptr(o));
18582 LDKCOption_NetAddressZ *ret_copy = MALLOC(sizeof(LDKCOption_NetAddressZ), "LDKCOption_NetAddressZ");
18583 *ret_copy = COption_NetAddressZ_some(o_conv);
18584 uint64_t ret_ref = tag_ptr(ret_copy, true);
18588 uint64_t __attribute__((export_name("TS_COption_NetAddressZ_none"))) TS_COption_NetAddressZ_none() {
18589 LDKCOption_NetAddressZ *ret_copy = MALLOC(sizeof(LDKCOption_NetAddressZ), "LDKCOption_NetAddressZ");
18590 *ret_copy = COption_NetAddressZ_none();
18591 uint64_t ret_ref = tag_ptr(ret_copy, true);
18595 void __attribute__((export_name("TS_COption_NetAddressZ_free"))) TS_COption_NetAddressZ_free(uint64_t _res) {
18596 if (!ptr_is_owned(_res)) return;
18597 void* _res_ptr = untag_ptr(_res);
18598 CHECK_ACCESS(_res_ptr);
18599 LDKCOption_NetAddressZ _res_conv = *(LDKCOption_NetAddressZ*)(_res_ptr);
18600 FREE(untag_ptr(_res));
18601 COption_NetAddressZ_free(_res_conv);
18604 static inline uint64_t COption_NetAddressZ_clone_ptr(LDKCOption_NetAddressZ *NONNULL_PTR arg) {
18605 LDKCOption_NetAddressZ *ret_copy = MALLOC(sizeof(LDKCOption_NetAddressZ), "LDKCOption_NetAddressZ");
18606 *ret_copy = COption_NetAddressZ_clone(arg);
18607 uint64_t ret_ref = tag_ptr(ret_copy, true);
18610 int64_t __attribute__((export_name("TS_COption_NetAddressZ_clone_ptr"))) TS_COption_NetAddressZ_clone_ptr(uint64_t arg) {
18611 LDKCOption_NetAddressZ* arg_conv = (LDKCOption_NetAddressZ*)untag_ptr(arg);
18612 int64_t ret_conv = COption_NetAddressZ_clone_ptr(arg_conv);
18616 uint64_t __attribute__((export_name("TS_COption_NetAddressZ_clone"))) TS_COption_NetAddressZ_clone(uint64_t orig) {
18617 LDKCOption_NetAddressZ* orig_conv = (LDKCOption_NetAddressZ*)untag_ptr(orig);
18618 LDKCOption_NetAddressZ *ret_copy = MALLOC(sizeof(LDKCOption_NetAddressZ), "LDKCOption_NetAddressZ");
18619 *ret_copy = COption_NetAddressZ_clone(orig_conv);
18620 uint64_t ret_ref = tag_ptr(ret_copy, true);
18624 uint64_t __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_ok"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_ok(int8_tArray o) {
18626 o_ref.datalen = o->arr_len;
18627 o_ref.data = MALLOC(o_ref.datalen, "LDKCVec_u8Z Bytes");
18628 memcpy(o_ref.data, o->elems, o_ref.datalen); FREE(o);
18629 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
18630 *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_ok(o_ref);
18631 return tag_ptr(ret_conv, true);
18634 uint64_t __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_err"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_err(uint64_t e) {
18635 LDKPeerHandleError e_conv;
18636 e_conv.inner = untag_ptr(e);
18637 e_conv.is_owned = ptr_is_owned(e);
18638 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
18639 e_conv = PeerHandleError_clone(&e_conv);
18640 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
18641 *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_err(e_conv);
18642 return tag_ptr(ret_conv, true);
18645 jboolean __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok(uint64_t o) {
18646 LDKCResult_CVec_u8ZPeerHandleErrorZ* o_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)untag_ptr(o);
18647 jboolean ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o_conv);
18651 void __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_free"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_free(uint64_t _res) {
18652 if (!ptr_is_owned(_res)) return;
18653 void* _res_ptr = untag_ptr(_res);
18654 CHECK_ACCESS(_res_ptr);
18655 LDKCResult_CVec_u8ZPeerHandleErrorZ _res_conv = *(LDKCResult_CVec_u8ZPeerHandleErrorZ*)(_res_ptr);
18656 FREE(untag_ptr(_res));
18657 CResult_CVec_u8ZPeerHandleErrorZ_free(_res_conv);
18660 static inline uint64_t CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR arg) {
18661 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
18662 *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_clone(arg);
18663 return tag_ptr(ret_conv, true);
18665 int64_t __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(uint64_t arg) {
18666 LDKCResult_CVec_u8ZPeerHandleErrorZ* arg_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)untag_ptr(arg);
18667 int64_t ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg_conv);
18671 uint64_t __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_clone"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_clone(uint64_t orig) {
18672 LDKCResult_CVec_u8ZPeerHandleErrorZ* orig_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)untag_ptr(orig);
18673 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
18674 *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_clone(orig_conv);
18675 return tag_ptr(ret_conv, true);
18678 uint64_t __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_ok"))) TS_CResult_NonePeerHandleErrorZ_ok() {
18679 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
18680 *ret_conv = CResult_NonePeerHandleErrorZ_ok();
18681 return tag_ptr(ret_conv, true);
18684 uint64_t __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_err"))) TS_CResult_NonePeerHandleErrorZ_err(uint64_t e) {
18685 LDKPeerHandleError e_conv;
18686 e_conv.inner = untag_ptr(e);
18687 e_conv.is_owned = ptr_is_owned(e);
18688 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
18689 e_conv = PeerHandleError_clone(&e_conv);
18690 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
18691 *ret_conv = CResult_NonePeerHandleErrorZ_err(e_conv);
18692 return tag_ptr(ret_conv, true);
18695 jboolean __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_is_ok"))) TS_CResult_NonePeerHandleErrorZ_is_ok(uint64_t o) {
18696 LDKCResult_NonePeerHandleErrorZ* o_conv = (LDKCResult_NonePeerHandleErrorZ*)untag_ptr(o);
18697 jboolean ret_conv = CResult_NonePeerHandleErrorZ_is_ok(o_conv);
18701 void __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_free"))) TS_CResult_NonePeerHandleErrorZ_free(uint64_t _res) {
18702 if (!ptr_is_owned(_res)) return;
18703 void* _res_ptr = untag_ptr(_res);
18704 CHECK_ACCESS(_res_ptr);
18705 LDKCResult_NonePeerHandleErrorZ _res_conv = *(LDKCResult_NonePeerHandleErrorZ*)(_res_ptr);
18706 FREE(untag_ptr(_res));
18707 CResult_NonePeerHandleErrorZ_free(_res_conv);
18710 static inline uint64_t CResult_NonePeerHandleErrorZ_clone_ptr(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR arg) {
18711 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
18712 *ret_conv = CResult_NonePeerHandleErrorZ_clone(arg);
18713 return tag_ptr(ret_conv, true);
18715 int64_t __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_clone_ptr"))) TS_CResult_NonePeerHandleErrorZ_clone_ptr(uint64_t arg) {
18716 LDKCResult_NonePeerHandleErrorZ* arg_conv = (LDKCResult_NonePeerHandleErrorZ*)untag_ptr(arg);
18717 int64_t ret_conv = CResult_NonePeerHandleErrorZ_clone_ptr(arg_conv);
18721 uint64_t __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_clone"))) TS_CResult_NonePeerHandleErrorZ_clone(uint64_t orig) {
18722 LDKCResult_NonePeerHandleErrorZ* orig_conv = (LDKCResult_NonePeerHandleErrorZ*)untag_ptr(orig);
18723 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
18724 *ret_conv = CResult_NonePeerHandleErrorZ_clone(orig_conv);
18725 return tag_ptr(ret_conv, true);
18728 uint64_t __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_ok"))) TS_CResult_boolPeerHandleErrorZ_ok(jboolean o) {
18729 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
18730 *ret_conv = CResult_boolPeerHandleErrorZ_ok(o);
18731 return tag_ptr(ret_conv, true);
18734 uint64_t __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_err"))) TS_CResult_boolPeerHandleErrorZ_err(uint64_t e) {
18735 LDKPeerHandleError e_conv;
18736 e_conv.inner = untag_ptr(e);
18737 e_conv.is_owned = ptr_is_owned(e);
18738 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
18739 e_conv = PeerHandleError_clone(&e_conv);
18740 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
18741 *ret_conv = CResult_boolPeerHandleErrorZ_err(e_conv);
18742 return tag_ptr(ret_conv, true);
18745 jboolean __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_is_ok"))) TS_CResult_boolPeerHandleErrorZ_is_ok(uint64_t o) {
18746 LDKCResult_boolPeerHandleErrorZ* o_conv = (LDKCResult_boolPeerHandleErrorZ*)untag_ptr(o);
18747 jboolean ret_conv = CResult_boolPeerHandleErrorZ_is_ok(o_conv);
18751 void __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_free"))) TS_CResult_boolPeerHandleErrorZ_free(uint64_t _res) {
18752 if (!ptr_is_owned(_res)) return;
18753 void* _res_ptr = untag_ptr(_res);
18754 CHECK_ACCESS(_res_ptr);
18755 LDKCResult_boolPeerHandleErrorZ _res_conv = *(LDKCResult_boolPeerHandleErrorZ*)(_res_ptr);
18756 FREE(untag_ptr(_res));
18757 CResult_boolPeerHandleErrorZ_free(_res_conv);
18760 static inline uint64_t CResult_boolPeerHandleErrorZ_clone_ptr(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR arg) {
18761 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
18762 *ret_conv = CResult_boolPeerHandleErrorZ_clone(arg);
18763 return tag_ptr(ret_conv, true);
18765 int64_t __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_clone_ptr"))) TS_CResult_boolPeerHandleErrorZ_clone_ptr(uint64_t arg) {
18766 LDKCResult_boolPeerHandleErrorZ* arg_conv = (LDKCResult_boolPeerHandleErrorZ*)untag_ptr(arg);
18767 int64_t ret_conv = CResult_boolPeerHandleErrorZ_clone_ptr(arg_conv);
18771 uint64_t __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_clone"))) TS_CResult_boolPeerHandleErrorZ_clone(uint64_t orig) {
18772 LDKCResult_boolPeerHandleErrorZ* orig_conv = (LDKCResult_boolPeerHandleErrorZ*)untag_ptr(orig);
18773 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
18774 *ret_conv = CResult_boolPeerHandleErrorZ_clone(orig_conv);
18775 return tag_ptr(ret_conv, true);
18778 uint64_t __attribute__((export_name("TS_CResult_NoneSendErrorZ_ok"))) TS_CResult_NoneSendErrorZ_ok() {
18779 LDKCResult_NoneSendErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSendErrorZ), "LDKCResult_NoneSendErrorZ");
18780 *ret_conv = CResult_NoneSendErrorZ_ok();
18781 return tag_ptr(ret_conv, true);
18784 uint64_t __attribute__((export_name("TS_CResult_NoneSendErrorZ_err"))) TS_CResult_NoneSendErrorZ_err(uint64_t e) {
18785 void* e_ptr = untag_ptr(e);
18786 CHECK_ACCESS(e_ptr);
18787 LDKSendError e_conv = *(LDKSendError*)(e_ptr);
18788 e_conv = SendError_clone((LDKSendError*)untag_ptr(e));
18789 LDKCResult_NoneSendErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSendErrorZ), "LDKCResult_NoneSendErrorZ");
18790 *ret_conv = CResult_NoneSendErrorZ_err(e_conv);
18791 return tag_ptr(ret_conv, true);
18794 jboolean __attribute__((export_name("TS_CResult_NoneSendErrorZ_is_ok"))) TS_CResult_NoneSendErrorZ_is_ok(uint64_t o) {
18795 LDKCResult_NoneSendErrorZ* o_conv = (LDKCResult_NoneSendErrorZ*)untag_ptr(o);
18796 jboolean ret_conv = CResult_NoneSendErrorZ_is_ok(o_conv);
18800 void __attribute__((export_name("TS_CResult_NoneSendErrorZ_free"))) TS_CResult_NoneSendErrorZ_free(uint64_t _res) {
18801 if (!ptr_is_owned(_res)) return;
18802 void* _res_ptr = untag_ptr(_res);
18803 CHECK_ACCESS(_res_ptr);
18804 LDKCResult_NoneSendErrorZ _res_conv = *(LDKCResult_NoneSendErrorZ*)(_res_ptr);
18805 FREE(untag_ptr(_res));
18806 CResult_NoneSendErrorZ_free(_res_conv);
18809 uint64_t __attribute__((export_name("TS_CResult_u32GraphSyncErrorZ_ok"))) TS_CResult_u32GraphSyncErrorZ_ok(int32_t o) {
18810 LDKCResult_u32GraphSyncErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_u32GraphSyncErrorZ), "LDKCResult_u32GraphSyncErrorZ");
18811 *ret_conv = CResult_u32GraphSyncErrorZ_ok(o);
18812 return tag_ptr(ret_conv, true);
18815 uint64_t __attribute__((export_name("TS_CResult_u32GraphSyncErrorZ_err"))) TS_CResult_u32GraphSyncErrorZ_err(uint64_t e) {
18816 void* e_ptr = untag_ptr(e);
18817 CHECK_ACCESS(e_ptr);
18818 LDKGraphSyncError e_conv = *(LDKGraphSyncError*)(e_ptr);
18819 e_conv = GraphSyncError_clone((LDKGraphSyncError*)untag_ptr(e));
18820 LDKCResult_u32GraphSyncErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_u32GraphSyncErrorZ), "LDKCResult_u32GraphSyncErrorZ");
18821 *ret_conv = CResult_u32GraphSyncErrorZ_err(e_conv);
18822 return tag_ptr(ret_conv, true);
18825 jboolean __attribute__((export_name("TS_CResult_u32GraphSyncErrorZ_is_ok"))) TS_CResult_u32GraphSyncErrorZ_is_ok(uint64_t o) {
18826 LDKCResult_u32GraphSyncErrorZ* o_conv = (LDKCResult_u32GraphSyncErrorZ*)untag_ptr(o);
18827 jboolean ret_conv = CResult_u32GraphSyncErrorZ_is_ok(o_conv);
18831 void __attribute__((export_name("TS_CResult_u32GraphSyncErrorZ_free"))) TS_CResult_u32GraphSyncErrorZ_free(uint64_t _res) {
18832 if (!ptr_is_owned(_res)) return;
18833 void* _res_ptr = untag_ptr(_res);
18834 CHECK_ACCESS(_res_ptr);
18835 LDKCResult_u32GraphSyncErrorZ _res_conv = *(LDKCResult_u32GraphSyncErrorZ*)(_res_ptr);
18836 FREE(untag_ptr(_res));
18837 CResult_u32GraphSyncErrorZ_free(_res_conv);
18840 uint64_t __attribute__((export_name("TS_CResult_SiPrefixParseErrorZ_ok"))) TS_CResult_SiPrefixParseErrorZ_ok(uint32_t o) {
18841 LDKSiPrefix o_conv = LDKSiPrefix_from_js(o);
18842 LDKCResult_SiPrefixParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixParseErrorZ), "LDKCResult_SiPrefixParseErrorZ");
18843 *ret_conv = CResult_SiPrefixParseErrorZ_ok(o_conv);
18844 return tag_ptr(ret_conv, true);
18847 uint64_t __attribute__((export_name("TS_CResult_SiPrefixParseErrorZ_err"))) TS_CResult_SiPrefixParseErrorZ_err(uint64_t e) {
18848 void* e_ptr = untag_ptr(e);
18849 CHECK_ACCESS(e_ptr);
18850 LDKParseError e_conv = *(LDKParseError*)(e_ptr);
18851 e_conv = ParseError_clone((LDKParseError*)untag_ptr(e));
18852 LDKCResult_SiPrefixParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixParseErrorZ), "LDKCResult_SiPrefixParseErrorZ");
18853 *ret_conv = CResult_SiPrefixParseErrorZ_err(e_conv);
18854 return tag_ptr(ret_conv, true);
18857 jboolean __attribute__((export_name("TS_CResult_SiPrefixParseErrorZ_is_ok"))) TS_CResult_SiPrefixParseErrorZ_is_ok(uint64_t o) {
18858 LDKCResult_SiPrefixParseErrorZ* o_conv = (LDKCResult_SiPrefixParseErrorZ*)untag_ptr(o);
18859 jboolean ret_conv = CResult_SiPrefixParseErrorZ_is_ok(o_conv);
18863 void __attribute__((export_name("TS_CResult_SiPrefixParseErrorZ_free"))) TS_CResult_SiPrefixParseErrorZ_free(uint64_t _res) {
18864 if (!ptr_is_owned(_res)) return;
18865 void* _res_ptr = untag_ptr(_res);
18866 CHECK_ACCESS(_res_ptr);
18867 LDKCResult_SiPrefixParseErrorZ _res_conv = *(LDKCResult_SiPrefixParseErrorZ*)(_res_ptr);
18868 FREE(untag_ptr(_res));
18869 CResult_SiPrefixParseErrorZ_free(_res_conv);
18872 static inline uint64_t CResult_SiPrefixParseErrorZ_clone_ptr(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR arg) {
18873 LDKCResult_SiPrefixParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixParseErrorZ), "LDKCResult_SiPrefixParseErrorZ");
18874 *ret_conv = CResult_SiPrefixParseErrorZ_clone(arg);
18875 return tag_ptr(ret_conv, true);
18877 int64_t __attribute__((export_name("TS_CResult_SiPrefixParseErrorZ_clone_ptr"))) TS_CResult_SiPrefixParseErrorZ_clone_ptr(uint64_t arg) {
18878 LDKCResult_SiPrefixParseErrorZ* arg_conv = (LDKCResult_SiPrefixParseErrorZ*)untag_ptr(arg);
18879 int64_t ret_conv = CResult_SiPrefixParseErrorZ_clone_ptr(arg_conv);
18883 uint64_t __attribute__((export_name("TS_CResult_SiPrefixParseErrorZ_clone"))) TS_CResult_SiPrefixParseErrorZ_clone(uint64_t orig) {
18884 LDKCResult_SiPrefixParseErrorZ* orig_conv = (LDKCResult_SiPrefixParseErrorZ*)untag_ptr(orig);
18885 LDKCResult_SiPrefixParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixParseErrorZ), "LDKCResult_SiPrefixParseErrorZ");
18886 *ret_conv = CResult_SiPrefixParseErrorZ_clone(orig_conv);
18887 return tag_ptr(ret_conv, true);
18890 uint64_t __attribute__((export_name("TS_CResult_InvoiceParseOrSemanticErrorZ_ok"))) TS_CResult_InvoiceParseOrSemanticErrorZ_ok(uint64_t o) {
18892 o_conv.inner = untag_ptr(o);
18893 o_conv.is_owned = ptr_is_owned(o);
18894 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
18895 o_conv = Invoice_clone(&o_conv);
18896 LDKCResult_InvoiceParseOrSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceParseOrSemanticErrorZ), "LDKCResult_InvoiceParseOrSemanticErrorZ");
18897 *ret_conv = CResult_InvoiceParseOrSemanticErrorZ_ok(o_conv);
18898 return tag_ptr(ret_conv, true);
18901 uint64_t __attribute__((export_name("TS_CResult_InvoiceParseOrSemanticErrorZ_err"))) TS_CResult_InvoiceParseOrSemanticErrorZ_err(uint64_t e) {
18902 void* e_ptr = untag_ptr(e);
18903 CHECK_ACCESS(e_ptr);
18904 LDKParseOrSemanticError e_conv = *(LDKParseOrSemanticError*)(e_ptr);
18905 e_conv = ParseOrSemanticError_clone((LDKParseOrSemanticError*)untag_ptr(e));
18906 LDKCResult_InvoiceParseOrSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceParseOrSemanticErrorZ), "LDKCResult_InvoiceParseOrSemanticErrorZ");
18907 *ret_conv = CResult_InvoiceParseOrSemanticErrorZ_err(e_conv);
18908 return tag_ptr(ret_conv, true);
18911 jboolean __attribute__((export_name("TS_CResult_InvoiceParseOrSemanticErrorZ_is_ok"))) TS_CResult_InvoiceParseOrSemanticErrorZ_is_ok(uint64_t o) {
18912 LDKCResult_InvoiceParseOrSemanticErrorZ* o_conv = (LDKCResult_InvoiceParseOrSemanticErrorZ*)untag_ptr(o);
18913 jboolean ret_conv = CResult_InvoiceParseOrSemanticErrorZ_is_ok(o_conv);
18917 void __attribute__((export_name("TS_CResult_InvoiceParseOrSemanticErrorZ_free"))) TS_CResult_InvoiceParseOrSemanticErrorZ_free(uint64_t _res) {
18918 if (!ptr_is_owned(_res)) return;
18919 void* _res_ptr = untag_ptr(_res);
18920 CHECK_ACCESS(_res_ptr);
18921 LDKCResult_InvoiceParseOrSemanticErrorZ _res_conv = *(LDKCResult_InvoiceParseOrSemanticErrorZ*)(_res_ptr);
18922 FREE(untag_ptr(_res));
18923 CResult_InvoiceParseOrSemanticErrorZ_free(_res_conv);
18926 static inline uint64_t CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR arg) {
18927 LDKCResult_InvoiceParseOrSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceParseOrSemanticErrorZ), "LDKCResult_InvoiceParseOrSemanticErrorZ");
18928 *ret_conv = CResult_InvoiceParseOrSemanticErrorZ_clone(arg);
18929 return tag_ptr(ret_conv, true);
18931 int64_t __attribute__((export_name("TS_CResult_InvoiceParseOrSemanticErrorZ_clone_ptr"))) TS_CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(uint64_t arg) {
18932 LDKCResult_InvoiceParseOrSemanticErrorZ* arg_conv = (LDKCResult_InvoiceParseOrSemanticErrorZ*)untag_ptr(arg);
18933 int64_t ret_conv = CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(arg_conv);
18937 uint64_t __attribute__((export_name("TS_CResult_InvoiceParseOrSemanticErrorZ_clone"))) TS_CResult_InvoiceParseOrSemanticErrorZ_clone(uint64_t orig) {
18938 LDKCResult_InvoiceParseOrSemanticErrorZ* orig_conv = (LDKCResult_InvoiceParseOrSemanticErrorZ*)untag_ptr(orig);
18939 LDKCResult_InvoiceParseOrSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceParseOrSemanticErrorZ), "LDKCResult_InvoiceParseOrSemanticErrorZ");
18940 *ret_conv = CResult_InvoiceParseOrSemanticErrorZ_clone(orig_conv);
18941 return tag_ptr(ret_conv, true);
18944 uint64_t __attribute__((export_name("TS_CResult_SignedRawInvoiceParseErrorZ_ok"))) TS_CResult_SignedRawInvoiceParseErrorZ_ok(uint64_t o) {
18945 LDKSignedRawInvoice o_conv;
18946 o_conv.inner = untag_ptr(o);
18947 o_conv.is_owned = ptr_is_owned(o);
18948 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
18949 o_conv = SignedRawInvoice_clone(&o_conv);
18950 LDKCResult_SignedRawInvoiceParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceParseErrorZ), "LDKCResult_SignedRawInvoiceParseErrorZ");
18951 *ret_conv = CResult_SignedRawInvoiceParseErrorZ_ok(o_conv);
18952 return tag_ptr(ret_conv, true);
18955 uint64_t __attribute__((export_name("TS_CResult_SignedRawInvoiceParseErrorZ_err"))) TS_CResult_SignedRawInvoiceParseErrorZ_err(uint64_t e) {
18956 void* e_ptr = untag_ptr(e);
18957 CHECK_ACCESS(e_ptr);
18958 LDKParseError e_conv = *(LDKParseError*)(e_ptr);
18959 e_conv = ParseError_clone((LDKParseError*)untag_ptr(e));
18960 LDKCResult_SignedRawInvoiceParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceParseErrorZ), "LDKCResult_SignedRawInvoiceParseErrorZ");
18961 *ret_conv = CResult_SignedRawInvoiceParseErrorZ_err(e_conv);
18962 return tag_ptr(ret_conv, true);
18965 jboolean __attribute__((export_name("TS_CResult_SignedRawInvoiceParseErrorZ_is_ok"))) TS_CResult_SignedRawInvoiceParseErrorZ_is_ok(uint64_t o) {
18966 LDKCResult_SignedRawInvoiceParseErrorZ* o_conv = (LDKCResult_SignedRawInvoiceParseErrorZ*)untag_ptr(o);
18967 jboolean ret_conv = CResult_SignedRawInvoiceParseErrorZ_is_ok(o_conv);
18971 void __attribute__((export_name("TS_CResult_SignedRawInvoiceParseErrorZ_free"))) TS_CResult_SignedRawInvoiceParseErrorZ_free(uint64_t _res) {
18972 if (!ptr_is_owned(_res)) return;
18973 void* _res_ptr = untag_ptr(_res);
18974 CHECK_ACCESS(_res_ptr);
18975 LDKCResult_SignedRawInvoiceParseErrorZ _res_conv = *(LDKCResult_SignedRawInvoiceParseErrorZ*)(_res_ptr);
18976 FREE(untag_ptr(_res));
18977 CResult_SignedRawInvoiceParseErrorZ_free(_res_conv);
18980 static inline uint64_t CResult_SignedRawInvoiceParseErrorZ_clone_ptr(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR arg) {
18981 LDKCResult_SignedRawInvoiceParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceParseErrorZ), "LDKCResult_SignedRawInvoiceParseErrorZ");
18982 *ret_conv = CResult_SignedRawInvoiceParseErrorZ_clone(arg);
18983 return tag_ptr(ret_conv, true);
18985 int64_t __attribute__((export_name("TS_CResult_SignedRawInvoiceParseErrorZ_clone_ptr"))) TS_CResult_SignedRawInvoiceParseErrorZ_clone_ptr(uint64_t arg) {
18986 LDKCResult_SignedRawInvoiceParseErrorZ* arg_conv = (LDKCResult_SignedRawInvoiceParseErrorZ*)untag_ptr(arg);
18987 int64_t ret_conv = CResult_SignedRawInvoiceParseErrorZ_clone_ptr(arg_conv);
18991 uint64_t __attribute__((export_name("TS_CResult_SignedRawInvoiceParseErrorZ_clone"))) TS_CResult_SignedRawInvoiceParseErrorZ_clone(uint64_t orig) {
18992 LDKCResult_SignedRawInvoiceParseErrorZ* orig_conv = (LDKCResult_SignedRawInvoiceParseErrorZ*)untag_ptr(orig);
18993 LDKCResult_SignedRawInvoiceParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceParseErrorZ), "LDKCResult_SignedRawInvoiceParseErrorZ");
18994 *ret_conv = CResult_SignedRawInvoiceParseErrorZ_clone(orig_conv);
18995 return tag_ptr(ret_conv, true);
18998 static inline uint64_t C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR arg) {
18999 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
19000 *ret_conv = C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(arg);
19001 return tag_ptr(ret_conv, true);
19003 int64_t __attribute__((export_name("TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(uint64_t arg) {
19004 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* arg_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)untag_ptr(arg);
19005 int64_t ret_conv = C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg_conv);
19009 uint64_t __attribute__((export_name("TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(uint64_t orig) {
19010 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* orig_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)untag_ptr(orig);
19011 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
19012 *ret_conv = C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig_conv);
19013 return tag_ptr(ret_conv, true);
19016 uint64_t __attribute__((export_name("TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_new"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(uint64_t a, int8_tArray b, uint64_t c) {
19017 LDKRawInvoice a_conv;
19018 a_conv.inner = untag_ptr(a);
19019 a_conv.is_owned = ptr_is_owned(a);
19020 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
19021 a_conv = RawInvoice_clone(&a_conv);
19022 LDKThirtyTwoBytes b_ref;
19023 CHECK(b->arr_len == 32);
19024 memcpy(b_ref.data, b->elems, 32); FREE(b);
19025 LDKInvoiceSignature c_conv;
19026 c_conv.inner = untag_ptr(c);
19027 c_conv.is_owned = ptr_is_owned(c);
19028 CHECK_INNER_FIELD_ACCESS_OR_NULL(c_conv);
19029 c_conv = InvoiceSignature_clone(&c_conv);
19030 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
19031 *ret_conv = C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a_conv, b_ref, c_conv);
19032 return tag_ptr(ret_conv, true);
19035 void __attribute__((export_name("TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_free"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(uint64_t _res) {
19036 if (!ptr_is_owned(_res)) return;
19037 void* _res_ptr = untag_ptr(_res);
19038 CHECK_ACCESS(_res_ptr);
19039 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ _res_conv = *(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(_res_ptr);
19040 FREE(untag_ptr(_res));
19041 C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res_conv);
19044 uint64_t __attribute__((export_name("TS_CResult_PayeePubKeyErrorZ_ok"))) TS_CResult_PayeePubKeyErrorZ_ok(uint64_t o) {
19045 LDKPayeePubKey o_conv;
19046 o_conv.inner = untag_ptr(o);
19047 o_conv.is_owned = ptr_is_owned(o);
19048 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19049 o_conv = PayeePubKey_clone(&o_conv);
19050 LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
19051 *ret_conv = CResult_PayeePubKeyErrorZ_ok(o_conv);
19052 return tag_ptr(ret_conv, true);
19055 uint64_t __attribute__((export_name("TS_CResult_PayeePubKeyErrorZ_err"))) TS_CResult_PayeePubKeyErrorZ_err(uint32_t e) {
19056 LDKSecp256k1Error e_conv = LDKSecp256k1Error_from_js(e);
19057 LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
19058 *ret_conv = CResult_PayeePubKeyErrorZ_err(e_conv);
19059 return tag_ptr(ret_conv, true);
19062 jboolean __attribute__((export_name("TS_CResult_PayeePubKeyErrorZ_is_ok"))) TS_CResult_PayeePubKeyErrorZ_is_ok(uint64_t o) {
19063 LDKCResult_PayeePubKeyErrorZ* o_conv = (LDKCResult_PayeePubKeyErrorZ*)untag_ptr(o);
19064 jboolean ret_conv = CResult_PayeePubKeyErrorZ_is_ok(o_conv);
19068 void __attribute__((export_name("TS_CResult_PayeePubKeyErrorZ_free"))) TS_CResult_PayeePubKeyErrorZ_free(uint64_t _res) {
19069 if (!ptr_is_owned(_res)) return;
19070 void* _res_ptr = untag_ptr(_res);
19071 CHECK_ACCESS(_res_ptr);
19072 LDKCResult_PayeePubKeyErrorZ _res_conv = *(LDKCResult_PayeePubKeyErrorZ*)(_res_ptr);
19073 FREE(untag_ptr(_res));
19074 CResult_PayeePubKeyErrorZ_free(_res_conv);
19077 static inline uint64_t CResult_PayeePubKeyErrorZ_clone_ptr(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR arg) {
19078 LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
19079 *ret_conv = CResult_PayeePubKeyErrorZ_clone(arg);
19080 return tag_ptr(ret_conv, true);
19082 int64_t __attribute__((export_name("TS_CResult_PayeePubKeyErrorZ_clone_ptr"))) TS_CResult_PayeePubKeyErrorZ_clone_ptr(uint64_t arg) {
19083 LDKCResult_PayeePubKeyErrorZ* arg_conv = (LDKCResult_PayeePubKeyErrorZ*)untag_ptr(arg);
19084 int64_t ret_conv = CResult_PayeePubKeyErrorZ_clone_ptr(arg_conv);
19088 uint64_t __attribute__((export_name("TS_CResult_PayeePubKeyErrorZ_clone"))) TS_CResult_PayeePubKeyErrorZ_clone(uint64_t orig) {
19089 LDKCResult_PayeePubKeyErrorZ* orig_conv = (LDKCResult_PayeePubKeyErrorZ*)untag_ptr(orig);
19090 LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
19091 *ret_conv = CResult_PayeePubKeyErrorZ_clone(orig_conv);
19092 return tag_ptr(ret_conv, true);
19095 void __attribute__((export_name("TS_CVec_PrivateRouteZ_free"))) TS_CVec_PrivateRouteZ_free(uint64_tArray _res) {
19096 LDKCVec_PrivateRouteZ _res_constr;
19097 _res_constr.datalen = _res->arr_len;
19098 if (_res_constr.datalen > 0)
19099 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKPrivateRoute), "LDKCVec_PrivateRouteZ Elements");
19101 _res_constr.data = NULL;
19102 uint64_t* _res_vals = _res->elems;
19103 for (size_t o = 0; o < _res_constr.datalen; o++) {
19104 uint64_t _res_conv_14 = _res_vals[o];
19105 LDKPrivateRoute _res_conv_14_conv;
19106 _res_conv_14_conv.inner = untag_ptr(_res_conv_14);
19107 _res_conv_14_conv.is_owned = ptr_is_owned(_res_conv_14);
19108 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_14_conv);
19109 _res_constr.data[o] = _res_conv_14_conv;
19112 CVec_PrivateRouteZ_free(_res_constr);
19115 uint64_t __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_ok"))) TS_CResult_PositiveTimestampCreationErrorZ_ok(uint64_t o) {
19116 LDKPositiveTimestamp o_conv;
19117 o_conv.inner = untag_ptr(o);
19118 o_conv.is_owned = ptr_is_owned(o);
19119 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19120 o_conv = PositiveTimestamp_clone(&o_conv);
19121 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
19122 *ret_conv = CResult_PositiveTimestampCreationErrorZ_ok(o_conv);
19123 return tag_ptr(ret_conv, true);
19126 uint64_t __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_err"))) TS_CResult_PositiveTimestampCreationErrorZ_err(uint32_t e) {
19127 LDKCreationError e_conv = LDKCreationError_from_js(e);
19128 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
19129 *ret_conv = CResult_PositiveTimestampCreationErrorZ_err(e_conv);
19130 return tag_ptr(ret_conv, true);
19133 jboolean __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_is_ok"))) TS_CResult_PositiveTimestampCreationErrorZ_is_ok(uint64_t o) {
19134 LDKCResult_PositiveTimestampCreationErrorZ* o_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)untag_ptr(o);
19135 jboolean ret_conv = CResult_PositiveTimestampCreationErrorZ_is_ok(o_conv);
19139 void __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_free"))) TS_CResult_PositiveTimestampCreationErrorZ_free(uint64_t _res) {
19140 if (!ptr_is_owned(_res)) return;
19141 void* _res_ptr = untag_ptr(_res);
19142 CHECK_ACCESS(_res_ptr);
19143 LDKCResult_PositiveTimestampCreationErrorZ _res_conv = *(LDKCResult_PositiveTimestampCreationErrorZ*)(_res_ptr);
19144 FREE(untag_ptr(_res));
19145 CResult_PositiveTimestampCreationErrorZ_free(_res_conv);
19148 static inline uint64_t CResult_PositiveTimestampCreationErrorZ_clone_ptr(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR arg) {
19149 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
19150 *ret_conv = CResult_PositiveTimestampCreationErrorZ_clone(arg);
19151 return tag_ptr(ret_conv, true);
19153 int64_t __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr"))) TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr(uint64_t arg) {
19154 LDKCResult_PositiveTimestampCreationErrorZ* arg_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)untag_ptr(arg);
19155 int64_t ret_conv = CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg_conv);
19159 uint64_t __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_clone"))) TS_CResult_PositiveTimestampCreationErrorZ_clone(uint64_t orig) {
19160 LDKCResult_PositiveTimestampCreationErrorZ* orig_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)untag_ptr(orig);
19161 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
19162 *ret_conv = CResult_PositiveTimestampCreationErrorZ_clone(orig_conv);
19163 return tag_ptr(ret_conv, true);
19166 uint64_t __attribute__((export_name("TS_CResult_NoneSemanticErrorZ_ok"))) TS_CResult_NoneSemanticErrorZ_ok() {
19167 LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
19168 *ret_conv = CResult_NoneSemanticErrorZ_ok();
19169 return tag_ptr(ret_conv, true);
19172 uint64_t __attribute__((export_name("TS_CResult_NoneSemanticErrorZ_err"))) TS_CResult_NoneSemanticErrorZ_err(uint32_t e) {
19173 LDKSemanticError e_conv = LDKSemanticError_from_js(e);
19174 LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
19175 *ret_conv = CResult_NoneSemanticErrorZ_err(e_conv);
19176 return tag_ptr(ret_conv, true);
19179 jboolean __attribute__((export_name("TS_CResult_NoneSemanticErrorZ_is_ok"))) TS_CResult_NoneSemanticErrorZ_is_ok(uint64_t o) {
19180 LDKCResult_NoneSemanticErrorZ* o_conv = (LDKCResult_NoneSemanticErrorZ*)untag_ptr(o);
19181 jboolean ret_conv = CResult_NoneSemanticErrorZ_is_ok(o_conv);
19185 void __attribute__((export_name("TS_CResult_NoneSemanticErrorZ_free"))) TS_CResult_NoneSemanticErrorZ_free(uint64_t _res) {
19186 if (!ptr_is_owned(_res)) return;
19187 void* _res_ptr = untag_ptr(_res);
19188 CHECK_ACCESS(_res_ptr);
19189 LDKCResult_NoneSemanticErrorZ _res_conv = *(LDKCResult_NoneSemanticErrorZ*)(_res_ptr);
19190 FREE(untag_ptr(_res));
19191 CResult_NoneSemanticErrorZ_free(_res_conv);
19194 static inline uint64_t CResult_NoneSemanticErrorZ_clone_ptr(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR arg) {
19195 LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
19196 *ret_conv = CResult_NoneSemanticErrorZ_clone(arg);
19197 return tag_ptr(ret_conv, true);
19199 int64_t __attribute__((export_name("TS_CResult_NoneSemanticErrorZ_clone_ptr"))) TS_CResult_NoneSemanticErrorZ_clone_ptr(uint64_t arg) {
19200 LDKCResult_NoneSemanticErrorZ* arg_conv = (LDKCResult_NoneSemanticErrorZ*)untag_ptr(arg);
19201 int64_t ret_conv = CResult_NoneSemanticErrorZ_clone_ptr(arg_conv);
19205 uint64_t __attribute__((export_name("TS_CResult_NoneSemanticErrorZ_clone"))) TS_CResult_NoneSemanticErrorZ_clone(uint64_t orig) {
19206 LDKCResult_NoneSemanticErrorZ* orig_conv = (LDKCResult_NoneSemanticErrorZ*)untag_ptr(orig);
19207 LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
19208 *ret_conv = CResult_NoneSemanticErrorZ_clone(orig_conv);
19209 return tag_ptr(ret_conv, true);
19212 uint64_t __attribute__((export_name("TS_CResult_InvoiceSemanticErrorZ_ok"))) TS_CResult_InvoiceSemanticErrorZ_ok(uint64_t o) {
19214 o_conv.inner = untag_ptr(o);
19215 o_conv.is_owned = ptr_is_owned(o);
19216 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19217 o_conv = Invoice_clone(&o_conv);
19218 LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
19219 *ret_conv = CResult_InvoiceSemanticErrorZ_ok(o_conv);
19220 return tag_ptr(ret_conv, true);
19223 uint64_t __attribute__((export_name("TS_CResult_InvoiceSemanticErrorZ_err"))) TS_CResult_InvoiceSemanticErrorZ_err(uint32_t e) {
19224 LDKSemanticError e_conv = LDKSemanticError_from_js(e);
19225 LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
19226 *ret_conv = CResult_InvoiceSemanticErrorZ_err(e_conv);
19227 return tag_ptr(ret_conv, true);
19230 jboolean __attribute__((export_name("TS_CResult_InvoiceSemanticErrorZ_is_ok"))) TS_CResult_InvoiceSemanticErrorZ_is_ok(uint64_t o) {
19231 LDKCResult_InvoiceSemanticErrorZ* o_conv = (LDKCResult_InvoiceSemanticErrorZ*)untag_ptr(o);
19232 jboolean ret_conv = CResult_InvoiceSemanticErrorZ_is_ok(o_conv);
19236 void __attribute__((export_name("TS_CResult_InvoiceSemanticErrorZ_free"))) TS_CResult_InvoiceSemanticErrorZ_free(uint64_t _res) {
19237 if (!ptr_is_owned(_res)) return;
19238 void* _res_ptr = untag_ptr(_res);
19239 CHECK_ACCESS(_res_ptr);
19240 LDKCResult_InvoiceSemanticErrorZ _res_conv = *(LDKCResult_InvoiceSemanticErrorZ*)(_res_ptr);
19241 FREE(untag_ptr(_res));
19242 CResult_InvoiceSemanticErrorZ_free(_res_conv);
19245 static inline uint64_t CResult_InvoiceSemanticErrorZ_clone_ptr(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR arg) {
19246 LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
19247 *ret_conv = CResult_InvoiceSemanticErrorZ_clone(arg);
19248 return tag_ptr(ret_conv, true);
19250 int64_t __attribute__((export_name("TS_CResult_InvoiceSemanticErrorZ_clone_ptr"))) TS_CResult_InvoiceSemanticErrorZ_clone_ptr(uint64_t arg) {
19251 LDKCResult_InvoiceSemanticErrorZ* arg_conv = (LDKCResult_InvoiceSemanticErrorZ*)untag_ptr(arg);
19252 int64_t ret_conv = CResult_InvoiceSemanticErrorZ_clone_ptr(arg_conv);
19256 uint64_t __attribute__((export_name("TS_CResult_InvoiceSemanticErrorZ_clone"))) TS_CResult_InvoiceSemanticErrorZ_clone(uint64_t orig) {
19257 LDKCResult_InvoiceSemanticErrorZ* orig_conv = (LDKCResult_InvoiceSemanticErrorZ*)untag_ptr(orig);
19258 LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
19259 *ret_conv = CResult_InvoiceSemanticErrorZ_clone(orig_conv);
19260 return tag_ptr(ret_conv, true);
19263 uint64_t __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_ok"))) TS_CResult_DescriptionCreationErrorZ_ok(uint64_t o) {
19264 LDKDescription o_conv;
19265 o_conv.inner = untag_ptr(o);
19266 o_conv.is_owned = ptr_is_owned(o);
19267 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19268 o_conv = Description_clone(&o_conv);
19269 LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
19270 *ret_conv = CResult_DescriptionCreationErrorZ_ok(o_conv);
19271 return tag_ptr(ret_conv, true);
19274 uint64_t __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_err"))) TS_CResult_DescriptionCreationErrorZ_err(uint32_t e) {
19275 LDKCreationError e_conv = LDKCreationError_from_js(e);
19276 LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
19277 *ret_conv = CResult_DescriptionCreationErrorZ_err(e_conv);
19278 return tag_ptr(ret_conv, true);
19281 jboolean __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_is_ok"))) TS_CResult_DescriptionCreationErrorZ_is_ok(uint64_t o) {
19282 LDKCResult_DescriptionCreationErrorZ* o_conv = (LDKCResult_DescriptionCreationErrorZ*)untag_ptr(o);
19283 jboolean ret_conv = CResult_DescriptionCreationErrorZ_is_ok(o_conv);
19287 void __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_free"))) TS_CResult_DescriptionCreationErrorZ_free(uint64_t _res) {
19288 if (!ptr_is_owned(_res)) return;
19289 void* _res_ptr = untag_ptr(_res);
19290 CHECK_ACCESS(_res_ptr);
19291 LDKCResult_DescriptionCreationErrorZ _res_conv = *(LDKCResult_DescriptionCreationErrorZ*)(_res_ptr);
19292 FREE(untag_ptr(_res));
19293 CResult_DescriptionCreationErrorZ_free(_res_conv);
19296 static inline uint64_t CResult_DescriptionCreationErrorZ_clone_ptr(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR arg) {
19297 LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
19298 *ret_conv = CResult_DescriptionCreationErrorZ_clone(arg);
19299 return tag_ptr(ret_conv, true);
19301 int64_t __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_clone_ptr"))) TS_CResult_DescriptionCreationErrorZ_clone_ptr(uint64_t arg) {
19302 LDKCResult_DescriptionCreationErrorZ* arg_conv = (LDKCResult_DescriptionCreationErrorZ*)untag_ptr(arg);
19303 int64_t ret_conv = CResult_DescriptionCreationErrorZ_clone_ptr(arg_conv);
19307 uint64_t __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_clone"))) TS_CResult_DescriptionCreationErrorZ_clone(uint64_t orig) {
19308 LDKCResult_DescriptionCreationErrorZ* orig_conv = (LDKCResult_DescriptionCreationErrorZ*)untag_ptr(orig);
19309 LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
19310 *ret_conv = CResult_DescriptionCreationErrorZ_clone(orig_conv);
19311 return tag_ptr(ret_conv, true);
19314 uint64_t __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_ok"))) TS_CResult_PrivateRouteCreationErrorZ_ok(uint64_t o) {
19315 LDKPrivateRoute o_conv;
19316 o_conv.inner = untag_ptr(o);
19317 o_conv.is_owned = ptr_is_owned(o);
19318 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19319 o_conv = PrivateRoute_clone(&o_conv);
19320 LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
19321 *ret_conv = CResult_PrivateRouteCreationErrorZ_ok(o_conv);
19322 return tag_ptr(ret_conv, true);
19325 uint64_t __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_err"))) TS_CResult_PrivateRouteCreationErrorZ_err(uint32_t e) {
19326 LDKCreationError e_conv = LDKCreationError_from_js(e);
19327 LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
19328 *ret_conv = CResult_PrivateRouteCreationErrorZ_err(e_conv);
19329 return tag_ptr(ret_conv, true);
19332 jboolean __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_is_ok"))) TS_CResult_PrivateRouteCreationErrorZ_is_ok(uint64_t o) {
19333 LDKCResult_PrivateRouteCreationErrorZ* o_conv = (LDKCResult_PrivateRouteCreationErrorZ*)untag_ptr(o);
19334 jboolean ret_conv = CResult_PrivateRouteCreationErrorZ_is_ok(o_conv);
19338 void __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_free"))) TS_CResult_PrivateRouteCreationErrorZ_free(uint64_t _res) {
19339 if (!ptr_is_owned(_res)) return;
19340 void* _res_ptr = untag_ptr(_res);
19341 CHECK_ACCESS(_res_ptr);
19342 LDKCResult_PrivateRouteCreationErrorZ _res_conv = *(LDKCResult_PrivateRouteCreationErrorZ*)(_res_ptr);
19343 FREE(untag_ptr(_res));
19344 CResult_PrivateRouteCreationErrorZ_free(_res_conv);
19347 static inline uint64_t CResult_PrivateRouteCreationErrorZ_clone_ptr(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR arg) {
19348 LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
19349 *ret_conv = CResult_PrivateRouteCreationErrorZ_clone(arg);
19350 return tag_ptr(ret_conv, true);
19352 int64_t __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_clone_ptr"))) TS_CResult_PrivateRouteCreationErrorZ_clone_ptr(uint64_t arg) {
19353 LDKCResult_PrivateRouteCreationErrorZ* arg_conv = (LDKCResult_PrivateRouteCreationErrorZ*)untag_ptr(arg);
19354 int64_t ret_conv = CResult_PrivateRouteCreationErrorZ_clone_ptr(arg_conv);
19358 uint64_t __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_clone"))) TS_CResult_PrivateRouteCreationErrorZ_clone(uint64_t orig) {
19359 LDKCResult_PrivateRouteCreationErrorZ* orig_conv = (LDKCResult_PrivateRouteCreationErrorZ*)untag_ptr(orig);
19360 LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
19361 *ret_conv = CResult_PrivateRouteCreationErrorZ_clone(orig_conv);
19362 return tag_ptr(ret_conv, true);
19365 uint64_t __attribute__((export_name("TS_CResult_NoneErrorZ_ok"))) TS_CResult_NoneErrorZ_ok() {
19366 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
19367 *ret_conv = CResult_NoneErrorZ_ok();
19368 return tag_ptr(ret_conv, true);
19371 uint64_t __attribute__((export_name("TS_CResult_NoneErrorZ_err"))) TS_CResult_NoneErrorZ_err(uint32_t e) {
19372 LDKIOError e_conv = LDKIOError_from_js(e);
19373 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
19374 *ret_conv = CResult_NoneErrorZ_err(e_conv);
19375 return tag_ptr(ret_conv, true);
19378 jboolean __attribute__((export_name("TS_CResult_NoneErrorZ_is_ok"))) TS_CResult_NoneErrorZ_is_ok(uint64_t o) {
19379 LDKCResult_NoneErrorZ* o_conv = (LDKCResult_NoneErrorZ*)untag_ptr(o);
19380 jboolean ret_conv = CResult_NoneErrorZ_is_ok(o_conv);
19384 void __attribute__((export_name("TS_CResult_NoneErrorZ_free"))) TS_CResult_NoneErrorZ_free(uint64_t _res) {
19385 if (!ptr_is_owned(_res)) return;
19386 void* _res_ptr = untag_ptr(_res);
19387 CHECK_ACCESS(_res_ptr);
19388 LDKCResult_NoneErrorZ _res_conv = *(LDKCResult_NoneErrorZ*)(_res_ptr);
19389 FREE(untag_ptr(_res));
19390 CResult_NoneErrorZ_free(_res_conv);
19393 static inline uint64_t CResult_NoneErrorZ_clone_ptr(LDKCResult_NoneErrorZ *NONNULL_PTR arg) {
19394 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
19395 *ret_conv = CResult_NoneErrorZ_clone(arg);
19396 return tag_ptr(ret_conv, true);
19398 int64_t __attribute__((export_name("TS_CResult_NoneErrorZ_clone_ptr"))) TS_CResult_NoneErrorZ_clone_ptr(uint64_t arg) {
19399 LDKCResult_NoneErrorZ* arg_conv = (LDKCResult_NoneErrorZ*)untag_ptr(arg);
19400 int64_t ret_conv = CResult_NoneErrorZ_clone_ptr(arg_conv);
19404 uint64_t __attribute__((export_name("TS_CResult_NoneErrorZ_clone"))) TS_CResult_NoneErrorZ_clone(uint64_t orig) {
19405 LDKCResult_NoneErrorZ* orig_conv = (LDKCResult_NoneErrorZ*)untag_ptr(orig);
19406 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
19407 *ret_conv = CResult_NoneErrorZ_clone(orig_conv);
19408 return tag_ptr(ret_conv, true);
19411 uint64_t __attribute__((export_name("TS_CResult_NetAddressDecodeErrorZ_ok"))) TS_CResult_NetAddressDecodeErrorZ_ok(uint64_t o) {
19412 void* o_ptr = untag_ptr(o);
19413 CHECK_ACCESS(o_ptr);
19414 LDKNetAddress o_conv = *(LDKNetAddress*)(o_ptr);
19415 o_conv = NetAddress_clone((LDKNetAddress*)untag_ptr(o));
19416 LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
19417 *ret_conv = CResult_NetAddressDecodeErrorZ_ok(o_conv);
19418 return tag_ptr(ret_conv, true);
19421 uint64_t __attribute__((export_name("TS_CResult_NetAddressDecodeErrorZ_err"))) TS_CResult_NetAddressDecodeErrorZ_err(uint64_t e) {
19422 void* e_ptr = untag_ptr(e);
19423 CHECK_ACCESS(e_ptr);
19424 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
19425 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
19426 LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
19427 *ret_conv = CResult_NetAddressDecodeErrorZ_err(e_conv);
19428 return tag_ptr(ret_conv, true);
19431 jboolean __attribute__((export_name("TS_CResult_NetAddressDecodeErrorZ_is_ok"))) TS_CResult_NetAddressDecodeErrorZ_is_ok(uint64_t o) {
19432 LDKCResult_NetAddressDecodeErrorZ* o_conv = (LDKCResult_NetAddressDecodeErrorZ*)untag_ptr(o);
19433 jboolean ret_conv = CResult_NetAddressDecodeErrorZ_is_ok(o_conv);
19437 void __attribute__((export_name("TS_CResult_NetAddressDecodeErrorZ_free"))) TS_CResult_NetAddressDecodeErrorZ_free(uint64_t _res) {
19438 if (!ptr_is_owned(_res)) return;
19439 void* _res_ptr = untag_ptr(_res);
19440 CHECK_ACCESS(_res_ptr);
19441 LDKCResult_NetAddressDecodeErrorZ _res_conv = *(LDKCResult_NetAddressDecodeErrorZ*)(_res_ptr);
19442 FREE(untag_ptr(_res));
19443 CResult_NetAddressDecodeErrorZ_free(_res_conv);
19446 static inline uint64_t CResult_NetAddressDecodeErrorZ_clone_ptr(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR arg) {
19447 LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
19448 *ret_conv = CResult_NetAddressDecodeErrorZ_clone(arg);
19449 return tag_ptr(ret_conv, true);
19451 int64_t __attribute__((export_name("TS_CResult_NetAddressDecodeErrorZ_clone_ptr"))) TS_CResult_NetAddressDecodeErrorZ_clone_ptr(uint64_t arg) {
19452 LDKCResult_NetAddressDecodeErrorZ* arg_conv = (LDKCResult_NetAddressDecodeErrorZ*)untag_ptr(arg);
19453 int64_t ret_conv = CResult_NetAddressDecodeErrorZ_clone_ptr(arg_conv);
19457 uint64_t __attribute__((export_name("TS_CResult_NetAddressDecodeErrorZ_clone"))) TS_CResult_NetAddressDecodeErrorZ_clone(uint64_t orig) {
19458 LDKCResult_NetAddressDecodeErrorZ* orig_conv = (LDKCResult_NetAddressDecodeErrorZ*)untag_ptr(orig);
19459 LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
19460 *ret_conv = CResult_NetAddressDecodeErrorZ_clone(orig_conv);
19461 return tag_ptr(ret_conv, true);
19464 void __attribute__((export_name("TS_CVec_UpdateAddHTLCZ_free"))) TS_CVec_UpdateAddHTLCZ_free(uint64_tArray _res) {
19465 LDKCVec_UpdateAddHTLCZ _res_constr;
19466 _res_constr.datalen = _res->arr_len;
19467 if (_res_constr.datalen > 0)
19468 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateAddHTLC), "LDKCVec_UpdateAddHTLCZ Elements");
19470 _res_constr.data = NULL;
19471 uint64_t* _res_vals = _res->elems;
19472 for (size_t p = 0; p < _res_constr.datalen; p++) {
19473 uint64_t _res_conv_15 = _res_vals[p];
19474 LDKUpdateAddHTLC _res_conv_15_conv;
19475 _res_conv_15_conv.inner = untag_ptr(_res_conv_15);
19476 _res_conv_15_conv.is_owned = ptr_is_owned(_res_conv_15);
19477 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_15_conv);
19478 _res_constr.data[p] = _res_conv_15_conv;
19481 CVec_UpdateAddHTLCZ_free(_res_constr);
19484 void __attribute__((export_name("TS_CVec_UpdateFulfillHTLCZ_free"))) TS_CVec_UpdateFulfillHTLCZ_free(uint64_tArray _res) {
19485 LDKCVec_UpdateFulfillHTLCZ _res_constr;
19486 _res_constr.datalen = _res->arr_len;
19487 if (_res_constr.datalen > 0)
19488 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateFulfillHTLC), "LDKCVec_UpdateFulfillHTLCZ Elements");
19490 _res_constr.data = NULL;
19491 uint64_t* _res_vals = _res->elems;
19492 for (size_t t = 0; t < _res_constr.datalen; t++) {
19493 uint64_t _res_conv_19 = _res_vals[t];
19494 LDKUpdateFulfillHTLC _res_conv_19_conv;
19495 _res_conv_19_conv.inner = untag_ptr(_res_conv_19);
19496 _res_conv_19_conv.is_owned = ptr_is_owned(_res_conv_19);
19497 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_19_conv);
19498 _res_constr.data[t] = _res_conv_19_conv;
19501 CVec_UpdateFulfillHTLCZ_free(_res_constr);
19504 void __attribute__((export_name("TS_CVec_UpdateFailHTLCZ_free"))) TS_CVec_UpdateFailHTLCZ_free(uint64_tArray _res) {
19505 LDKCVec_UpdateFailHTLCZ _res_constr;
19506 _res_constr.datalen = _res->arr_len;
19507 if (_res_constr.datalen > 0)
19508 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateFailHTLC), "LDKCVec_UpdateFailHTLCZ Elements");
19510 _res_constr.data = NULL;
19511 uint64_t* _res_vals = _res->elems;
19512 for (size_t q = 0; q < _res_constr.datalen; q++) {
19513 uint64_t _res_conv_16 = _res_vals[q];
19514 LDKUpdateFailHTLC _res_conv_16_conv;
19515 _res_conv_16_conv.inner = untag_ptr(_res_conv_16);
19516 _res_conv_16_conv.is_owned = ptr_is_owned(_res_conv_16);
19517 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_16_conv);
19518 _res_constr.data[q] = _res_conv_16_conv;
19521 CVec_UpdateFailHTLCZ_free(_res_constr);
19524 void __attribute__((export_name("TS_CVec_UpdateFailMalformedHTLCZ_free"))) TS_CVec_UpdateFailMalformedHTLCZ_free(uint64_tArray _res) {
19525 LDKCVec_UpdateFailMalformedHTLCZ _res_constr;
19526 _res_constr.datalen = _res->arr_len;
19527 if (_res_constr.datalen > 0)
19528 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateFailMalformedHTLC), "LDKCVec_UpdateFailMalformedHTLCZ Elements");
19530 _res_constr.data = NULL;
19531 uint64_t* _res_vals = _res->elems;
19532 for (size_t z = 0; z < _res_constr.datalen; z++) {
19533 uint64_t _res_conv_25 = _res_vals[z];
19534 LDKUpdateFailMalformedHTLC _res_conv_25_conv;
19535 _res_conv_25_conv.inner = untag_ptr(_res_conv_25);
19536 _res_conv_25_conv.is_owned = ptr_is_owned(_res_conv_25);
19537 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_25_conv);
19538 _res_constr.data[z] = _res_conv_25_conv;
19541 CVec_UpdateFailMalformedHTLCZ_free(_res_constr);
19544 uint64_t __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_ok"))) TS_CResult_AcceptChannelDecodeErrorZ_ok(uint64_t o) {
19545 LDKAcceptChannel o_conv;
19546 o_conv.inner = untag_ptr(o);
19547 o_conv.is_owned = ptr_is_owned(o);
19548 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19549 o_conv = AcceptChannel_clone(&o_conv);
19550 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
19551 *ret_conv = CResult_AcceptChannelDecodeErrorZ_ok(o_conv);
19552 return tag_ptr(ret_conv, true);
19555 uint64_t __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_err"))) TS_CResult_AcceptChannelDecodeErrorZ_err(uint64_t e) {
19556 void* e_ptr = untag_ptr(e);
19557 CHECK_ACCESS(e_ptr);
19558 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
19559 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
19560 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
19561 *ret_conv = CResult_AcceptChannelDecodeErrorZ_err(e_conv);
19562 return tag_ptr(ret_conv, true);
19565 jboolean __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_is_ok"))) TS_CResult_AcceptChannelDecodeErrorZ_is_ok(uint64_t o) {
19566 LDKCResult_AcceptChannelDecodeErrorZ* o_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)untag_ptr(o);
19567 jboolean ret_conv = CResult_AcceptChannelDecodeErrorZ_is_ok(o_conv);
19571 void __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_free"))) TS_CResult_AcceptChannelDecodeErrorZ_free(uint64_t _res) {
19572 if (!ptr_is_owned(_res)) return;
19573 void* _res_ptr = untag_ptr(_res);
19574 CHECK_ACCESS(_res_ptr);
19575 LDKCResult_AcceptChannelDecodeErrorZ _res_conv = *(LDKCResult_AcceptChannelDecodeErrorZ*)(_res_ptr);
19576 FREE(untag_ptr(_res));
19577 CResult_AcceptChannelDecodeErrorZ_free(_res_conv);
19580 static inline uint64_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg) {
19581 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
19582 *ret_conv = CResult_AcceptChannelDecodeErrorZ_clone(arg);
19583 return tag_ptr(ret_conv, true);
19585 int64_t __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr"))) TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr(uint64_t arg) {
19586 LDKCResult_AcceptChannelDecodeErrorZ* arg_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)untag_ptr(arg);
19587 int64_t ret_conv = CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg_conv);
19591 uint64_t __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_clone"))) TS_CResult_AcceptChannelDecodeErrorZ_clone(uint64_t orig) {
19592 LDKCResult_AcceptChannelDecodeErrorZ* orig_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)untag_ptr(orig);
19593 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
19594 *ret_conv = CResult_AcceptChannelDecodeErrorZ_clone(orig_conv);
19595 return tag_ptr(ret_conv, true);
19598 uint64_t __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok(uint64_t o) {
19599 LDKAnnouncementSignatures o_conv;
19600 o_conv.inner = untag_ptr(o);
19601 o_conv.is_owned = ptr_is_owned(o);
19602 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19603 o_conv = AnnouncementSignatures_clone(&o_conv);
19604 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
19605 *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_ok(o_conv);
19606 return tag_ptr(ret_conv, true);
19609 uint64_t __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_err"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_err(uint64_t e) {
19610 void* e_ptr = untag_ptr(e);
19611 CHECK_ACCESS(e_ptr);
19612 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
19613 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
19614 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
19615 *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_err(e_conv);
19616 return tag_ptr(ret_conv, true);
19619 jboolean __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(uint64_t o) {
19620 LDKCResult_AnnouncementSignaturesDecodeErrorZ* o_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)untag_ptr(o);
19621 jboolean ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o_conv);
19625 void __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_free"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_free(uint64_t _res) {
19626 if (!ptr_is_owned(_res)) return;
19627 void* _res_ptr = untag_ptr(_res);
19628 CHECK_ACCESS(_res_ptr);
19629 LDKCResult_AnnouncementSignaturesDecodeErrorZ _res_conv = *(LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(_res_ptr);
19630 FREE(untag_ptr(_res));
19631 CResult_AnnouncementSignaturesDecodeErrorZ_free(_res_conv);
19634 static inline uint64_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg) {
19635 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
19636 *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_clone(arg);
19637 return tag_ptr(ret_conv, true);
19639 int64_t __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(uint64_t arg) {
19640 LDKCResult_AnnouncementSignaturesDecodeErrorZ* arg_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)untag_ptr(arg);
19641 int64_t ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg_conv);
19645 uint64_t __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone(uint64_t orig) {
19646 LDKCResult_AnnouncementSignaturesDecodeErrorZ* orig_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)untag_ptr(orig);
19647 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
19648 *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig_conv);
19649 return tag_ptr(ret_conv, true);
19652 uint64_t __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_ok"))) TS_CResult_ChannelReestablishDecodeErrorZ_ok(uint64_t o) {
19653 LDKChannelReestablish o_conv;
19654 o_conv.inner = untag_ptr(o);
19655 o_conv.is_owned = ptr_is_owned(o);
19656 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19657 o_conv = ChannelReestablish_clone(&o_conv);
19658 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
19659 *ret_conv = CResult_ChannelReestablishDecodeErrorZ_ok(o_conv);
19660 return tag_ptr(ret_conv, true);
19663 uint64_t __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_err"))) TS_CResult_ChannelReestablishDecodeErrorZ_err(uint64_t e) {
19664 void* e_ptr = untag_ptr(e);
19665 CHECK_ACCESS(e_ptr);
19666 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
19667 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
19668 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
19669 *ret_conv = CResult_ChannelReestablishDecodeErrorZ_err(e_conv);
19670 return tag_ptr(ret_conv, true);
19673 jboolean __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_is_ok"))) TS_CResult_ChannelReestablishDecodeErrorZ_is_ok(uint64_t o) {
19674 LDKCResult_ChannelReestablishDecodeErrorZ* o_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)untag_ptr(o);
19675 jboolean ret_conv = CResult_ChannelReestablishDecodeErrorZ_is_ok(o_conv);
19679 void __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_free"))) TS_CResult_ChannelReestablishDecodeErrorZ_free(uint64_t _res) {
19680 if (!ptr_is_owned(_res)) return;
19681 void* _res_ptr = untag_ptr(_res);
19682 CHECK_ACCESS(_res_ptr);
19683 LDKCResult_ChannelReestablishDecodeErrorZ _res_conv = *(LDKCResult_ChannelReestablishDecodeErrorZ*)(_res_ptr);
19684 FREE(untag_ptr(_res));
19685 CResult_ChannelReestablishDecodeErrorZ_free(_res_conv);
19688 static inline uint64_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg) {
19689 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
19690 *ret_conv = CResult_ChannelReestablishDecodeErrorZ_clone(arg);
19691 return tag_ptr(ret_conv, true);
19693 int64_t __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr(uint64_t arg) {
19694 LDKCResult_ChannelReestablishDecodeErrorZ* arg_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)untag_ptr(arg);
19695 int64_t ret_conv = CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg_conv);
19699 uint64_t __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_clone"))) TS_CResult_ChannelReestablishDecodeErrorZ_clone(uint64_t orig) {
19700 LDKCResult_ChannelReestablishDecodeErrorZ* orig_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)untag_ptr(orig);
19701 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
19702 *ret_conv = CResult_ChannelReestablishDecodeErrorZ_clone(orig_conv);
19703 return tag_ptr(ret_conv, true);
19706 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_ok"))) TS_CResult_ClosingSignedDecodeErrorZ_ok(uint64_t o) {
19707 LDKClosingSigned o_conv;
19708 o_conv.inner = untag_ptr(o);
19709 o_conv.is_owned = ptr_is_owned(o);
19710 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19711 o_conv = ClosingSigned_clone(&o_conv);
19712 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
19713 *ret_conv = CResult_ClosingSignedDecodeErrorZ_ok(o_conv);
19714 return tag_ptr(ret_conv, true);
19717 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_err"))) TS_CResult_ClosingSignedDecodeErrorZ_err(uint64_t e) {
19718 void* e_ptr = untag_ptr(e);
19719 CHECK_ACCESS(e_ptr);
19720 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
19721 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
19722 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
19723 *ret_conv = CResult_ClosingSignedDecodeErrorZ_err(e_conv);
19724 return tag_ptr(ret_conv, true);
19727 jboolean __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_is_ok"))) TS_CResult_ClosingSignedDecodeErrorZ_is_ok(uint64_t o) {
19728 LDKCResult_ClosingSignedDecodeErrorZ* o_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)untag_ptr(o);
19729 jboolean ret_conv = CResult_ClosingSignedDecodeErrorZ_is_ok(o_conv);
19733 void __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_free"))) TS_CResult_ClosingSignedDecodeErrorZ_free(uint64_t _res) {
19734 if (!ptr_is_owned(_res)) return;
19735 void* _res_ptr = untag_ptr(_res);
19736 CHECK_ACCESS(_res_ptr);
19737 LDKCResult_ClosingSignedDecodeErrorZ _res_conv = *(LDKCResult_ClosingSignedDecodeErrorZ*)(_res_ptr);
19738 FREE(untag_ptr(_res));
19739 CResult_ClosingSignedDecodeErrorZ_free(_res_conv);
19742 static inline uint64_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg) {
19743 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
19744 *ret_conv = CResult_ClosingSignedDecodeErrorZ_clone(arg);
19745 return tag_ptr(ret_conv, true);
19747 int64_t __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr"))) TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr(uint64_t arg) {
19748 LDKCResult_ClosingSignedDecodeErrorZ* arg_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)untag_ptr(arg);
19749 int64_t ret_conv = CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg_conv);
19753 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_clone"))) TS_CResult_ClosingSignedDecodeErrorZ_clone(uint64_t orig) {
19754 LDKCResult_ClosingSignedDecodeErrorZ* orig_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)untag_ptr(orig);
19755 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
19756 *ret_conv = CResult_ClosingSignedDecodeErrorZ_clone(orig_conv);
19757 return tag_ptr(ret_conv, true);
19760 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(uint64_t o) {
19761 LDKClosingSignedFeeRange o_conv;
19762 o_conv.inner = untag_ptr(o);
19763 o_conv.is_owned = ptr_is_owned(o);
19764 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19765 o_conv = ClosingSignedFeeRange_clone(&o_conv);
19766 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
19767 *ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o_conv);
19768 return tag_ptr(ret_conv, true);
19771 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err(uint64_t e) {
19772 void* e_ptr = untag_ptr(e);
19773 CHECK_ACCESS(e_ptr);
19774 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
19775 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
19776 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
19777 *ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e_conv);
19778 return tag_ptr(ret_conv, true);
19781 jboolean __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(uint64_t o) {
19782 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* o_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)untag_ptr(o);
19783 jboolean ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o_conv);
19787 void __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free(uint64_t _res) {
19788 if (!ptr_is_owned(_res)) return;
19789 void* _res_ptr = untag_ptr(_res);
19790 CHECK_ACCESS(_res_ptr);
19791 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ _res_conv = *(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)(_res_ptr);
19792 FREE(untag_ptr(_res));
19793 CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res_conv);
19796 static inline uint64_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg) {
19797 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
19798 *ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(arg);
19799 return tag_ptr(ret_conv, true);
19801 int64_t __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(uint64_t arg) {
19802 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* arg_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)untag_ptr(arg);
19803 int64_t ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg_conv);
19807 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(uint64_t orig) {
19808 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* orig_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)untag_ptr(orig);
19809 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
19810 *ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig_conv);
19811 return tag_ptr(ret_conv, true);
19814 uint64_t __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_ok"))) TS_CResult_CommitmentSignedDecodeErrorZ_ok(uint64_t o) {
19815 LDKCommitmentSigned o_conv;
19816 o_conv.inner = untag_ptr(o);
19817 o_conv.is_owned = ptr_is_owned(o);
19818 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19819 o_conv = CommitmentSigned_clone(&o_conv);
19820 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
19821 *ret_conv = CResult_CommitmentSignedDecodeErrorZ_ok(o_conv);
19822 return tag_ptr(ret_conv, true);
19825 uint64_t __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_err"))) TS_CResult_CommitmentSignedDecodeErrorZ_err(uint64_t e) {
19826 void* e_ptr = untag_ptr(e);
19827 CHECK_ACCESS(e_ptr);
19828 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
19829 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
19830 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
19831 *ret_conv = CResult_CommitmentSignedDecodeErrorZ_err(e_conv);
19832 return tag_ptr(ret_conv, true);
19835 jboolean __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_is_ok"))) TS_CResult_CommitmentSignedDecodeErrorZ_is_ok(uint64_t o) {
19836 LDKCResult_CommitmentSignedDecodeErrorZ* o_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)untag_ptr(o);
19837 jboolean ret_conv = CResult_CommitmentSignedDecodeErrorZ_is_ok(o_conv);
19841 void __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_free"))) TS_CResult_CommitmentSignedDecodeErrorZ_free(uint64_t _res) {
19842 if (!ptr_is_owned(_res)) return;
19843 void* _res_ptr = untag_ptr(_res);
19844 CHECK_ACCESS(_res_ptr);
19845 LDKCResult_CommitmentSignedDecodeErrorZ _res_conv = *(LDKCResult_CommitmentSignedDecodeErrorZ*)(_res_ptr);
19846 FREE(untag_ptr(_res));
19847 CResult_CommitmentSignedDecodeErrorZ_free(_res_conv);
19850 static inline uint64_t CResult_CommitmentSignedDecodeErrorZ_clone_ptr(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR arg) {
19851 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
19852 *ret_conv = CResult_CommitmentSignedDecodeErrorZ_clone(arg);
19853 return tag_ptr(ret_conv, true);
19855 int64_t __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr"))) TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr(uint64_t arg) {
19856 LDKCResult_CommitmentSignedDecodeErrorZ* arg_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)untag_ptr(arg);
19857 int64_t ret_conv = CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg_conv);
19861 uint64_t __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_clone"))) TS_CResult_CommitmentSignedDecodeErrorZ_clone(uint64_t orig) {
19862 LDKCResult_CommitmentSignedDecodeErrorZ* orig_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)untag_ptr(orig);
19863 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
19864 *ret_conv = CResult_CommitmentSignedDecodeErrorZ_clone(orig_conv);
19865 return tag_ptr(ret_conv, true);
19868 uint64_t __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_ok"))) TS_CResult_FundingCreatedDecodeErrorZ_ok(uint64_t o) {
19869 LDKFundingCreated o_conv;
19870 o_conv.inner = untag_ptr(o);
19871 o_conv.is_owned = ptr_is_owned(o);
19872 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19873 o_conv = FundingCreated_clone(&o_conv);
19874 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
19875 *ret_conv = CResult_FundingCreatedDecodeErrorZ_ok(o_conv);
19876 return tag_ptr(ret_conv, true);
19879 uint64_t __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_err"))) TS_CResult_FundingCreatedDecodeErrorZ_err(uint64_t e) {
19880 void* e_ptr = untag_ptr(e);
19881 CHECK_ACCESS(e_ptr);
19882 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
19883 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
19884 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
19885 *ret_conv = CResult_FundingCreatedDecodeErrorZ_err(e_conv);
19886 return tag_ptr(ret_conv, true);
19889 jboolean __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_is_ok"))) TS_CResult_FundingCreatedDecodeErrorZ_is_ok(uint64_t o) {
19890 LDKCResult_FundingCreatedDecodeErrorZ* o_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)untag_ptr(o);
19891 jboolean ret_conv = CResult_FundingCreatedDecodeErrorZ_is_ok(o_conv);
19895 void __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_free"))) TS_CResult_FundingCreatedDecodeErrorZ_free(uint64_t _res) {
19896 if (!ptr_is_owned(_res)) return;
19897 void* _res_ptr = untag_ptr(_res);
19898 CHECK_ACCESS(_res_ptr);
19899 LDKCResult_FundingCreatedDecodeErrorZ _res_conv = *(LDKCResult_FundingCreatedDecodeErrorZ*)(_res_ptr);
19900 FREE(untag_ptr(_res));
19901 CResult_FundingCreatedDecodeErrorZ_free(_res_conv);
19904 static inline uint64_t CResult_FundingCreatedDecodeErrorZ_clone_ptr(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR arg) {
19905 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
19906 *ret_conv = CResult_FundingCreatedDecodeErrorZ_clone(arg);
19907 return tag_ptr(ret_conv, true);
19909 int64_t __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr"))) TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr(uint64_t arg) {
19910 LDKCResult_FundingCreatedDecodeErrorZ* arg_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)untag_ptr(arg);
19911 int64_t ret_conv = CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg_conv);
19915 uint64_t __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_clone"))) TS_CResult_FundingCreatedDecodeErrorZ_clone(uint64_t orig) {
19916 LDKCResult_FundingCreatedDecodeErrorZ* orig_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)untag_ptr(orig);
19917 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
19918 *ret_conv = CResult_FundingCreatedDecodeErrorZ_clone(orig_conv);
19919 return tag_ptr(ret_conv, true);
19922 uint64_t __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_ok"))) TS_CResult_FundingSignedDecodeErrorZ_ok(uint64_t o) {
19923 LDKFundingSigned o_conv;
19924 o_conv.inner = untag_ptr(o);
19925 o_conv.is_owned = ptr_is_owned(o);
19926 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19927 o_conv = FundingSigned_clone(&o_conv);
19928 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
19929 *ret_conv = CResult_FundingSignedDecodeErrorZ_ok(o_conv);
19930 return tag_ptr(ret_conv, true);
19933 uint64_t __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_err"))) TS_CResult_FundingSignedDecodeErrorZ_err(uint64_t e) {
19934 void* e_ptr = untag_ptr(e);
19935 CHECK_ACCESS(e_ptr);
19936 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
19937 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
19938 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
19939 *ret_conv = CResult_FundingSignedDecodeErrorZ_err(e_conv);
19940 return tag_ptr(ret_conv, true);
19943 jboolean __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_is_ok"))) TS_CResult_FundingSignedDecodeErrorZ_is_ok(uint64_t o) {
19944 LDKCResult_FundingSignedDecodeErrorZ* o_conv = (LDKCResult_FundingSignedDecodeErrorZ*)untag_ptr(o);
19945 jboolean ret_conv = CResult_FundingSignedDecodeErrorZ_is_ok(o_conv);
19949 void __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_free"))) TS_CResult_FundingSignedDecodeErrorZ_free(uint64_t _res) {
19950 if (!ptr_is_owned(_res)) return;
19951 void* _res_ptr = untag_ptr(_res);
19952 CHECK_ACCESS(_res_ptr);
19953 LDKCResult_FundingSignedDecodeErrorZ _res_conv = *(LDKCResult_FundingSignedDecodeErrorZ*)(_res_ptr);
19954 FREE(untag_ptr(_res));
19955 CResult_FundingSignedDecodeErrorZ_free(_res_conv);
19958 static inline uint64_t CResult_FundingSignedDecodeErrorZ_clone_ptr(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR arg) {
19959 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
19960 *ret_conv = CResult_FundingSignedDecodeErrorZ_clone(arg);
19961 return tag_ptr(ret_conv, true);
19963 int64_t __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_clone_ptr"))) TS_CResult_FundingSignedDecodeErrorZ_clone_ptr(uint64_t arg) {
19964 LDKCResult_FundingSignedDecodeErrorZ* arg_conv = (LDKCResult_FundingSignedDecodeErrorZ*)untag_ptr(arg);
19965 int64_t ret_conv = CResult_FundingSignedDecodeErrorZ_clone_ptr(arg_conv);
19969 uint64_t __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_clone"))) TS_CResult_FundingSignedDecodeErrorZ_clone(uint64_t orig) {
19970 LDKCResult_FundingSignedDecodeErrorZ* orig_conv = (LDKCResult_FundingSignedDecodeErrorZ*)untag_ptr(orig);
19971 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
19972 *ret_conv = CResult_FundingSignedDecodeErrorZ_clone(orig_conv);
19973 return tag_ptr(ret_conv, true);
19976 uint64_t __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_ok"))) TS_CResult_ChannelReadyDecodeErrorZ_ok(uint64_t o) {
19977 LDKChannelReady o_conv;
19978 o_conv.inner = untag_ptr(o);
19979 o_conv.is_owned = ptr_is_owned(o);
19980 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19981 o_conv = ChannelReady_clone(&o_conv);
19982 LDKCResult_ChannelReadyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReadyDecodeErrorZ), "LDKCResult_ChannelReadyDecodeErrorZ");
19983 *ret_conv = CResult_ChannelReadyDecodeErrorZ_ok(o_conv);
19984 return tag_ptr(ret_conv, true);
19987 uint64_t __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_err"))) TS_CResult_ChannelReadyDecodeErrorZ_err(uint64_t e) {
19988 void* e_ptr = untag_ptr(e);
19989 CHECK_ACCESS(e_ptr);
19990 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
19991 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
19992 LDKCResult_ChannelReadyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReadyDecodeErrorZ), "LDKCResult_ChannelReadyDecodeErrorZ");
19993 *ret_conv = CResult_ChannelReadyDecodeErrorZ_err(e_conv);
19994 return tag_ptr(ret_conv, true);
19997 jboolean __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_is_ok"))) TS_CResult_ChannelReadyDecodeErrorZ_is_ok(uint64_t o) {
19998 LDKCResult_ChannelReadyDecodeErrorZ* o_conv = (LDKCResult_ChannelReadyDecodeErrorZ*)untag_ptr(o);
19999 jboolean ret_conv = CResult_ChannelReadyDecodeErrorZ_is_ok(o_conv);
20003 void __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_free"))) TS_CResult_ChannelReadyDecodeErrorZ_free(uint64_t _res) {
20004 if (!ptr_is_owned(_res)) return;
20005 void* _res_ptr = untag_ptr(_res);
20006 CHECK_ACCESS(_res_ptr);
20007 LDKCResult_ChannelReadyDecodeErrorZ _res_conv = *(LDKCResult_ChannelReadyDecodeErrorZ*)(_res_ptr);
20008 FREE(untag_ptr(_res));
20009 CResult_ChannelReadyDecodeErrorZ_free(_res_conv);
20012 static inline uint64_t CResult_ChannelReadyDecodeErrorZ_clone_ptr(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR arg) {
20013 LDKCResult_ChannelReadyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReadyDecodeErrorZ), "LDKCResult_ChannelReadyDecodeErrorZ");
20014 *ret_conv = CResult_ChannelReadyDecodeErrorZ_clone(arg);
20015 return tag_ptr(ret_conv, true);
20017 int64_t __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelReadyDecodeErrorZ_clone_ptr(uint64_t arg) {
20018 LDKCResult_ChannelReadyDecodeErrorZ* arg_conv = (LDKCResult_ChannelReadyDecodeErrorZ*)untag_ptr(arg);
20019 int64_t ret_conv = CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg_conv);
20023 uint64_t __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_clone"))) TS_CResult_ChannelReadyDecodeErrorZ_clone(uint64_t orig) {
20024 LDKCResult_ChannelReadyDecodeErrorZ* orig_conv = (LDKCResult_ChannelReadyDecodeErrorZ*)untag_ptr(orig);
20025 LDKCResult_ChannelReadyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReadyDecodeErrorZ), "LDKCResult_ChannelReadyDecodeErrorZ");
20026 *ret_conv = CResult_ChannelReadyDecodeErrorZ_clone(orig_conv);
20027 return tag_ptr(ret_conv, true);
20030 uint64_t __attribute__((export_name("TS_CResult_InitDecodeErrorZ_ok"))) TS_CResult_InitDecodeErrorZ_ok(uint64_t o) {
20032 o_conv.inner = untag_ptr(o);
20033 o_conv.is_owned = ptr_is_owned(o);
20034 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20035 o_conv = Init_clone(&o_conv);
20036 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
20037 *ret_conv = CResult_InitDecodeErrorZ_ok(o_conv);
20038 return tag_ptr(ret_conv, true);
20041 uint64_t __attribute__((export_name("TS_CResult_InitDecodeErrorZ_err"))) TS_CResult_InitDecodeErrorZ_err(uint64_t e) {
20042 void* e_ptr = untag_ptr(e);
20043 CHECK_ACCESS(e_ptr);
20044 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20045 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20046 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
20047 *ret_conv = CResult_InitDecodeErrorZ_err(e_conv);
20048 return tag_ptr(ret_conv, true);
20051 jboolean __attribute__((export_name("TS_CResult_InitDecodeErrorZ_is_ok"))) TS_CResult_InitDecodeErrorZ_is_ok(uint64_t o) {
20052 LDKCResult_InitDecodeErrorZ* o_conv = (LDKCResult_InitDecodeErrorZ*)untag_ptr(o);
20053 jboolean ret_conv = CResult_InitDecodeErrorZ_is_ok(o_conv);
20057 void __attribute__((export_name("TS_CResult_InitDecodeErrorZ_free"))) TS_CResult_InitDecodeErrorZ_free(uint64_t _res) {
20058 if (!ptr_is_owned(_res)) return;
20059 void* _res_ptr = untag_ptr(_res);
20060 CHECK_ACCESS(_res_ptr);
20061 LDKCResult_InitDecodeErrorZ _res_conv = *(LDKCResult_InitDecodeErrorZ*)(_res_ptr);
20062 FREE(untag_ptr(_res));
20063 CResult_InitDecodeErrorZ_free(_res_conv);
20066 static inline uint64_t CResult_InitDecodeErrorZ_clone_ptr(LDKCResult_InitDecodeErrorZ *NONNULL_PTR arg) {
20067 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
20068 *ret_conv = CResult_InitDecodeErrorZ_clone(arg);
20069 return tag_ptr(ret_conv, true);
20071 int64_t __attribute__((export_name("TS_CResult_InitDecodeErrorZ_clone_ptr"))) TS_CResult_InitDecodeErrorZ_clone_ptr(uint64_t arg) {
20072 LDKCResult_InitDecodeErrorZ* arg_conv = (LDKCResult_InitDecodeErrorZ*)untag_ptr(arg);
20073 int64_t ret_conv = CResult_InitDecodeErrorZ_clone_ptr(arg_conv);
20077 uint64_t __attribute__((export_name("TS_CResult_InitDecodeErrorZ_clone"))) TS_CResult_InitDecodeErrorZ_clone(uint64_t orig) {
20078 LDKCResult_InitDecodeErrorZ* orig_conv = (LDKCResult_InitDecodeErrorZ*)untag_ptr(orig);
20079 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
20080 *ret_conv = CResult_InitDecodeErrorZ_clone(orig_conv);
20081 return tag_ptr(ret_conv, true);
20084 uint64_t __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_ok"))) TS_CResult_OpenChannelDecodeErrorZ_ok(uint64_t o) {
20085 LDKOpenChannel o_conv;
20086 o_conv.inner = untag_ptr(o);
20087 o_conv.is_owned = ptr_is_owned(o);
20088 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20089 o_conv = OpenChannel_clone(&o_conv);
20090 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
20091 *ret_conv = CResult_OpenChannelDecodeErrorZ_ok(o_conv);
20092 return tag_ptr(ret_conv, true);
20095 uint64_t __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_err"))) TS_CResult_OpenChannelDecodeErrorZ_err(uint64_t e) {
20096 void* e_ptr = untag_ptr(e);
20097 CHECK_ACCESS(e_ptr);
20098 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20099 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20100 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
20101 *ret_conv = CResult_OpenChannelDecodeErrorZ_err(e_conv);
20102 return tag_ptr(ret_conv, true);
20105 jboolean __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_is_ok"))) TS_CResult_OpenChannelDecodeErrorZ_is_ok(uint64_t o) {
20106 LDKCResult_OpenChannelDecodeErrorZ* o_conv = (LDKCResult_OpenChannelDecodeErrorZ*)untag_ptr(o);
20107 jboolean ret_conv = CResult_OpenChannelDecodeErrorZ_is_ok(o_conv);
20111 void __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_free"))) TS_CResult_OpenChannelDecodeErrorZ_free(uint64_t _res) {
20112 if (!ptr_is_owned(_res)) return;
20113 void* _res_ptr = untag_ptr(_res);
20114 CHECK_ACCESS(_res_ptr);
20115 LDKCResult_OpenChannelDecodeErrorZ _res_conv = *(LDKCResult_OpenChannelDecodeErrorZ*)(_res_ptr);
20116 FREE(untag_ptr(_res));
20117 CResult_OpenChannelDecodeErrorZ_free(_res_conv);
20120 static inline uint64_t CResult_OpenChannelDecodeErrorZ_clone_ptr(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR arg) {
20121 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
20122 *ret_conv = CResult_OpenChannelDecodeErrorZ_clone(arg);
20123 return tag_ptr(ret_conv, true);
20125 int64_t __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_clone_ptr"))) TS_CResult_OpenChannelDecodeErrorZ_clone_ptr(uint64_t arg) {
20126 LDKCResult_OpenChannelDecodeErrorZ* arg_conv = (LDKCResult_OpenChannelDecodeErrorZ*)untag_ptr(arg);
20127 int64_t ret_conv = CResult_OpenChannelDecodeErrorZ_clone_ptr(arg_conv);
20131 uint64_t __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_clone"))) TS_CResult_OpenChannelDecodeErrorZ_clone(uint64_t orig) {
20132 LDKCResult_OpenChannelDecodeErrorZ* orig_conv = (LDKCResult_OpenChannelDecodeErrorZ*)untag_ptr(orig);
20133 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
20134 *ret_conv = CResult_OpenChannelDecodeErrorZ_clone(orig_conv);
20135 return tag_ptr(ret_conv, true);
20138 uint64_t __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_ok"))) TS_CResult_RevokeAndACKDecodeErrorZ_ok(uint64_t o) {
20139 LDKRevokeAndACK o_conv;
20140 o_conv.inner = untag_ptr(o);
20141 o_conv.is_owned = ptr_is_owned(o);
20142 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20143 o_conv = RevokeAndACK_clone(&o_conv);
20144 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
20145 *ret_conv = CResult_RevokeAndACKDecodeErrorZ_ok(o_conv);
20146 return tag_ptr(ret_conv, true);
20149 uint64_t __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_err"))) TS_CResult_RevokeAndACKDecodeErrorZ_err(uint64_t e) {
20150 void* e_ptr = untag_ptr(e);
20151 CHECK_ACCESS(e_ptr);
20152 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20153 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20154 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
20155 *ret_conv = CResult_RevokeAndACKDecodeErrorZ_err(e_conv);
20156 return tag_ptr(ret_conv, true);
20159 jboolean __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_is_ok"))) TS_CResult_RevokeAndACKDecodeErrorZ_is_ok(uint64_t o) {
20160 LDKCResult_RevokeAndACKDecodeErrorZ* o_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)untag_ptr(o);
20161 jboolean ret_conv = CResult_RevokeAndACKDecodeErrorZ_is_ok(o_conv);
20165 void __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_free"))) TS_CResult_RevokeAndACKDecodeErrorZ_free(uint64_t _res) {
20166 if (!ptr_is_owned(_res)) return;
20167 void* _res_ptr = untag_ptr(_res);
20168 CHECK_ACCESS(_res_ptr);
20169 LDKCResult_RevokeAndACKDecodeErrorZ _res_conv = *(LDKCResult_RevokeAndACKDecodeErrorZ*)(_res_ptr);
20170 FREE(untag_ptr(_res));
20171 CResult_RevokeAndACKDecodeErrorZ_free(_res_conv);
20174 static inline uint64_t CResult_RevokeAndACKDecodeErrorZ_clone_ptr(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR arg) {
20175 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
20176 *ret_conv = CResult_RevokeAndACKDecodeErrorZ_clone(arg);
20177 return tag_ptr(ret_conv, true);
20179 int64_t __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr"))) TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr(uint64_t arg) {
20180 LDKCResult_RevokeAndACKDecodeErrorZ* arg_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)untag_ptr(arg);
20181 int64_t ret_conv = CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg_conv);
20185 uint64_t __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_clone"))) TS_CResult_RevokeAndACKDecodeErrorZ_clone(uint64_t orig) {
20186 LDKCResult_RevokeAndACKDecodeErrorZ* orig_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)untag_ptr(orig);
20187 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
20188 *ret_conv = CResult_RevokeAndACKDecodeErrorZ_clone(orig_conv);
20189 return tag_ptr(ret_conv, true);
20192 uint64_t __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_ok"))) TS_CResult_ShutdownDecodeErrorZ_ok(uint64_t o) {
20193 LDKShutdown o_conv;
20194 o_conv.inner = untag_ptr(o);
20195 o_conv.is_owned = ptr_is_owned(o);
20196 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20197 o_conv = Shutdown_clone(&o_conv);
20198 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
20199 *ret_conv = CResult_ShutdownDecodeErrorZ_ok(o_conv);
20200 return tag_ptr(ret_conv, true);
20203 uint64_t __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_err"))) TS_CResult_ShutdownDecodeErrorZ_err(uint64_t e) {
20204 void* e_ptr = untag_ptr(e);
20205 CHECK_ACCESS(e_ptr);
20206 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20207 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20208 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
20209 *ret_conv = CResult_ShutdownDecodeErrorZ_err(e_conv);
20210 return tag_ptr(ret_conv, true);
20213 jboolean __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_is_ok"))) TS_CResult_ShutdownDecodeErrorZ_is_ok(uint64_t o) {
20214 LDKCResult_ShutdownDecodeErrorZ* o_conv = (LDKCResult_ShutdownDecodeErrorZ*)untag_ptr(o);
20215 jboolean ret_conv = CResult_ShutdownDecodeErrorZ_is_ok(o_conv);
20219 void __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_free"))) TS_CResult_ShutdownDecodeErrorZ_free(uint64_t _res) {
20220 if (!ptr_is_owned(_res)) return;
20221 void* _res_ptr = untag_ptr(_res);
20222 CHECK_ACCESS(_res_ptr);
20223 LDKCResult_ShutdownDecodeErrorZ _res_conv = *(LDKCResult_ShutdownDecodeErrorZ*)(_res_ptr);
20224 FREE(untag_ptr(_res));
20225 CResult_ShutdownDecodeErrorZ_free(_res_conv);
20228 static inline uint64_t CResult_ShutdownDecodeErrorZ_clone_ptr(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR arg) {
20229 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
20230 *ret_conv = CResult_ShutdownDecodeErrorZ_clone(arg);
20231 return tag_ptr(ret_conv, true);
20233 int64_t __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_clone_ptr"))) TS_CResult_ShutdownDecodeErrorZ_clone_ptr(uint64_t arg) {
20234 LDKCResult_ShutdownDecodeErrorZ* arg_conv = (LDKCResult_ShutdownDecodeErrorZ*)untag_ptr(arg);
20235 int64_t ret_conv = CResult_ShutdownDecodeErrorZ_clone_ptr(arg_conv);
20239 uint64_t __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_clone"))) TS_CResult_ShutdownDecodeErrorZ_clone(uint64_t orig) {
20240 LDKCResult_ShutdownDecodeErrorZ* orig_conv = (LDKCResult_ShutdownDecodeErrorZ*)untag_ptr(orig);
20241 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
20242 *ret_conv = CResult_ShutdownDecodeErrorZ_clone(orig_conv);
20243 return tag_ptr(ret_conv, true);
20246 uint64_t __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_ok"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_ok(uint64_t o) {
20247 LDKUpdateFailHTLC o_conv;
20248 o_conv.inner = untag_ptr(o);
20249 o_conv.is_owned = ptr_is_owned(o);
20250 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20251 o_conv = UpdateFailHTLC_clone(&o_conv);
20252 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
20253 *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_ok(o_conv);
20254 return tag_ptr(ret_conv, true);
20257 uint64_t __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_err"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_err(uint64_t e) {
20258 void* e_ptr = untag_ptr(e);
20259 CHECK_ACCESS(e_ptr);
20260 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20261 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20262 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
20263 *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_err(e_conv);
20264 return tag_ptr(ret_conv, true);
20267 jboolean __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok(uint64_t o) {
20268 LDKCResult_UpdateFailHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)untag_ptr(o);
20269 jboolean ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o_conv);
20273 void __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_free"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_free(uint64_t _res) {
20274 if (!ptr_is_owned(_res)) return;
20275 void* _res_ptr = untag_ptr(_res);
20276 CHECK_ACCESS(_res_ptr);
20277 LDKCResult_UpdateFailHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateFailHTLCDecodeErrorZ*)(_res_ptr);
20278 FREE(untag_ptr(_res));
20279 CResult_UpdateFailHTLCDecodeErrorZ_free(_res_conv);
20282 static inline uint64_t CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR arg) {
20283 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
20284 *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_clone(arg);
20285 return tag_ptr(ret_conv, true);
20287 int64_t __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(uint64_t arg) {
20288 LDKCResult_UpdateFailHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)untag_ptr(arg);
20289 int64_t ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg_conv);
20293 uint64_t __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_clone"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_clone(uint64_t orig) {
20294 LDKCResult_UpdateFailHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)untag_ptr(orig);
20295 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
20296 *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_clone(orig_conv);
20297 return tag_ptr(ret_conv, true);
20300 uint64_t __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(uint64_t o) {
20301 LDKUpdateFailMalformedHTLC o_conv;
20302 o_conv.inner = untag_ptr(o);
20303 o_conv.is_owned = ptr_is_owned(o);
20304 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20305 o_conv = UpdateFailMalformedHTLC_clone(&o_conv);
20306 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
20307 *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o_conv);
20308 return tag_ptr(ret_conv, true);
20311 uint64_t __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_err"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(uint64_t e) {
20312 void* e_ptr = untag_ptr(e);
20313 CHECK_ACCESS(e_ptr);
20314 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20315 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20316 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
20317 *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e_conv);
20318 return tag_ptr(ret_conv, true);
20321 jboolean __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(uint64_t o) {
20322 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)untag_ptr(o);
20323 jboolean ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o_conv);
20327 void __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(uint64_t _res) {
20328 if (!ptr_is_owned(_res)) return;
20329 void* _res_ptr = untag_ptr(_res);
20330 CHECK_ACCESS(_res_ptr);
20331 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(_res_ptr);
20332 FREE(untag_ptr(_res));
20333 CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res_conv);
20336 static inline uint64_t CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR arg) {
20337 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
20338 *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(arg);
20339 return tag_ptr(ret_conv, true);
20341 int64_t __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(uint64_t arg) {
20342 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)untag_ptr(arg);
20343 int64_t ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg_conv);
20347 uint64_t __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(uint64_t orig) {
20348 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)untag_ptr(orig);
20349 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
20350 *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig_conv);
20351 return tag_ptr(ret_conv, true);
20354 uint64_t __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_ok"))) TS_CResult_UpdateFeeDecodeErrorZ_ok(uint64_t o) {
20355 LDKUpdateFee o_conv;
20356 o_conv.inner = untag_ptr(o);
20357 o_conv.is_owned = ptr_is_owned(o);
20358 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20359 o_conv = UpdateFee_clone(&o_conv);
20360 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
20361 *ret_conv = CResult_UpdateFeeDecodeErrorZ_ok(o_conv);
20362 return tag_ptr(ret_conv, true);
20365 uint64_t __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_err"))) TS_CResult_UpdateFeeDecodeErrorZ_err(uint64_t e) {
20366 void* e_ptr = untag_ptr(e);
20367 CHECK_ACCESS(e_ptr);
20368 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20369 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20370 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
20371 *ret_conv = CResult_UpdateFeeDecodeErrorZ_err(e_conv);
20372 return tag_ptr(ret_conv, true);
20375 jboolean __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_is_ok"))) TS_CResult_UpdateFeeDecodeErrorZ_is_ok(uint64_t o) {
20376 LDKCResult_UpdateFeeDecodeErrorZ* o_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)untag_ptr(o);
20377 jboolean ret_conv = CResult_UpdateFeeDecodeErrorZ_is_ok(o_conv);
20381 void __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_free"))) TS_CResult_UpdateFeeDecodeErrorZ_free(uint64_t _res) {
20382 if (!ptr_is_owned(_res)) return;
20383 void* _res_ptr = untag_ptr(_res);
20384 CHECK_ACCESS(_res_ptr);
20385 LDKCResult_UpdateFeeDecodeErrorZ _res_conv = *(LDKCResult_UpdateFeeDecodeErrorZ*)(_res_ptr);
20386 FREE(untag_ptr(_res));
20387 CResult_UpdateFeeDecodeErrorZ_free(_res_conv);
20390 static inline uint64_t CResult_UpdateFeeDecodeErrorZ_clone_ptr(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR arg) {
20391 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
20392 *ret_conv = CResult_UpdateFeeDecodeErrorZ_clone(arg);
20393 return tag_ptr(ret_conv, true);
20395 int64_t __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr"))) TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr(uint64_t arg) {
20396 LDKCResult_UpdateFeeDecodeErrorZ* arg_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)untag_ptr(arg);
20397 int64_t ret_conv = CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg_conv);
20401 uint64_t __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_clone"))) TS_CResult_UpdateFeeDecodeErrorZ_clone(uint64_t orig) {
20402 LDKCResult_UpdateFeeDecodeErrorZ* orig_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)untag_ptr(orig);
20403 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
20404 *ret_conv = CResult_UpdateFeeDecodeErrorZ_clone(orig_conv);
20405 return tag_ptr(ret_conv, true);
20408 uint64_t __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_ok"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_ok(uint64_t o) {
20409 LDKUpdateFulfillHTLC o_conv;
20410 o_conv.inner = untag_ptr(o);
20411 o_conv.is_owned = ptr_is_owned(o);
20412 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20413 o_conv = UpdateFulfillHTLC_clone(&o_conv);
20414 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
20415 *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o_conv);
20416 return tag_ptr(ret_conv, true);
20419 uint64_t __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_err"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_err(uint64_t e) {
20420 void* e_ptr = untag_ptr(e);
20421 CHECK_ACCESS(e_ptr);
20422 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20423 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20424 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
20425 *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_err(e_conv);
20426 return tag_ptr(ret_conv, true);
20429 jboolean __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(uint64_t o) {
20430 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)untag_ptr(o);
20431 jboolean ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o_conv);
20435 void __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free(uint64_t _res) {
20436 if (!ptr_is_owned(_res)) return;
20437 void* _res_ptr = untag_ptr(_res);
20438 CHECK_ACCESS(_res_ptr);
20439 LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(_res_ptr);
20440 FREE(untag_ptr(_res));
20441 CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res_conv);
20444 static inline uint64_t CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR arg) {
20445 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
20446 *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_clone(arg);
20447 return tag_ptr(ret_conv, true);
20449 int64_t __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(uint64_t arg) {
20450 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)untag_ptr(arg);
20451 int64_t ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg_conv);
20455 uint64_t __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone(uint64_t orig) {
20456 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)untag_ptr(orig);
20457 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
20458 *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig_conv);
20459 return tag_ptr(ret_conv, true);
20462 uint64_t __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_ok"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_ok(uint64_t o) {
20463 LDKUpdateAddHTLC o_conv;
20464 o_conv.inner = untag_ptr(o);
20465 o_conv.is_owned = ptr_is_owned(o);
20466 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20467 o_conv = UpdateAddHTLC_clone(&o_conv);
20468 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
20469 *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_ok(o_conv);
20470 return tag_ptr(ret_conv, true);
20473 uint64_t __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_err"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_err(uint64_t e) {
20474 void* e_ptr = untag_ptr(e);
20475 CHECK_ACCESS(e_ptr);
20476 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20477 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20478 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
20479 *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_err(e_conv);
20480 return tag_ptr(ret_conv, true);
20483 jboolean __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok(uint64_t o) {
20484 LDKCResult_UpdateAddHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)untag_ptr(o);
20485 jboolean ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o_conv);
20489 void __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_free"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_free(uint64_t _res) {
20490 if (!ptr_is_owned(_res)) return;
20491 void* _res_ptr = untag_ptr(_res);
20492 CHECK_ACCESS(_res_ptr);
20493 LDKCResult_UpdateAddHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateAddHTLCDecodeErrorZ*)(_res_ptr);
20494 FREE(untag_ptr(_res));
20495 CResult_UpdateAddHTLCDecodeErrorZ_free(_res_conv);
20498 static inline uint64_t CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR arg) {
20499 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
20500 *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_clone(arg);
20501 return tag_ptr(ret_conv, true);
20503 int64_t __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(uint64_t arg) {
20504 LDKCResult_UpdateAddHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)untag_ptr(arg);
20505 int64_t ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg_conv);
20509 uint64_t __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_clone"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_clone(uint64_t orig) {
20510 LDKCResult_UpdateAddHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)untag_ptr(orig);
20511 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
20512 *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_clone(orig_conv);
20513 return tag_ptr(ret_conv, true);
20516 uint64_t __attribute__((export_name("TS_CResult_OnionMessageDecodeErrorZ_ok"))) TS_CResult_OnionMessageDecodeErrorZ_ok(uint64_t o) {
20517 LDKOnionMessage o_conv;
20518 o_conv.inner = untag_ptr(o);
20519 o_conv.is_owned = ptr_is_owned(o);
20520 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20521 o_conv = OnionMessage_clone(&o_conv);
20522 LDKCResult_OnionMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OnionMessageDecodeErrorZ), "LDKCResult_OnionMessageDecodeErrorZ");
20523 *ret_conv = CResult_OnionMessageDecodeErrorZ_ok(o_conv);
20524 return tag_ptr(ret_conv, true);
20527 uint64_t __attribute__((export_name("TS_CResult_OnionMessageDecodeErrorZ_err"))) TS_CResult_OnionMessageDecodeErrorZ_err(uint64_t e) {
20528 void* e_ptr = untag_ptr(e);
20529 CHECK_ACCESS(e_ptr);
20530 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20531 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20532 LDKCResult_OnionMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OnionMessageDecodeErrorZ), "LDKCResult_OnionMessageDecodeErrorZ");
20533 *ret_conv = CResult_OnionMessageDecodeErrorZ_err(e_conv);
20534 return tag_ptr(ret_conv, true);
20537 jboolean __attribute__((export_name("TS_CResult_OnionMessageDecodeErrorZ_is_ok"))) TS_CResult_OnionMessageDecodeErrorZ_is_ok(uint64_t o) {
20538 LDKCResult_OnionMessageDecodeErrorZ* o_conv = (LDKCResult_OnionMessageDecodeErrorZ*)untag_ptr(o);
20539 jboolean ret_conv = CResult_OnionMessageDecodeErrorZ_is_ok(o_conv);
20543 void __attribute__((export_name("TS_CResult_OnionMessageDecodeErrorZ_free"))) TS_CResult_OnionMessageDecodeErrorZ_free(uint64_t _res) {
20544 if (!ptr_is_owned(_res)) return;
20545 void* _res_ptr = untag_ptr(_res);
20546 CHECK_ACCESS(_res_ptr);
20547 LDKCResult_OnionMessageDecodeErrorZ _res_conv = *(LDKCResult_OnionMessageDecodeErrorZ*)(_res_ptr);
20548 FREE(untag_ptr(_res));
20549 CResult_OnionMessageDecodeErrorZ_free(_res_conv);
20552 static inline uint64_t CResult_OnionMessageDecodeErrorZ_clone_ptr(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR arg) {
20553 LDKCResult_OnionMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OnionMessageDecodeErrorZ), "LDKCResult_OnionMessageDecodeErrorZ");
20554 *ret_conv = CResult_OnionMessageDecodeErrorZ_clone(arg);
20555 return tag_ptr(ret_conv, true);
20557 int64_t __attribute__((export_name("TS_CResult_OnionMessageDecodeErrorZ_clone_ptr"))) TS_CResult_OnionMessageDecodeErrorZ_clone_ptr(uint64_t arg) {
20558 LDKCResult_OnionMessageDecodeErrorZ* arg_conv = (LDKCResult_OnionMessageDecodeErrorZ*)untag_ptr(arg);
20559 int64_t ret_conv = CResult_OnionMessageDecodeErrorZ_clone_ptr(arg_conv);
20563 uint64_t __attribute__((export_name("TS_CResult_OnionMessageDecodeErrorZ_clone"))) TS_CResult_OnionMessageDecodeErrorZ_clone(uint64_t orig) {
20564 LDKCResult_OnionMessageDecodeErrorZ* orig_conv = (LDKCResult_OnionMessageDecodeErrorZ*)untag_ptr(orig);
20565 LDKCResult_OnionMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OnionMessageDecodeErrorZ), "LDKCResult_OnionMessageDecodeErrorZ");
20566 *ret_conv = CResult_OnionMessageDecodeErrorZ_clone(orig_conv);
20567 return tag_ptr(ret_conv, true);
20570 uint64_t __attribute__((export_name("TS_CResult_PingDecodeErrorZ_ok"))) TS_CResult_PingDecodeErrorZ_ok(uint64_t o) {
20572 o_conv.inner = untag_ptr(o);
20573 o_conv.is_owned = ptr_is_owned(o);
20574 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20575 o_conv = Ping_clone(&o_conv);
20576 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
20577 *ret_conv = CResult_PingDecodeErrorZ_ok(o_conv);
20578 return tag_ptr(ret_conv, true);
20581 uint64_t __attribute__((export_name("TS_CResult_PingDecodeErrorZ_err"))) TS_CResult_PingDecodeErrorZ_err(uint64_t e) {
20582 void* e_ptr = untag_ptr(e);
20583 CHECK_ACCESS(e_ptr);
20584 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20585 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20586 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
20587 *ret_conv = CResult_PingDecodeErrorZ_err(e_conv);
20588 return tag_ptr(ret_conv, true);
20591 jboolean __attribute__((export_name("TS_CResult_PingDecodeErrorZ_is_ok"))) TS_CResult_PingDecodeErrorZ_is_ok(uint64_t o) {
20592 LDKCResult_PingDecodeErrorZ* o_conv = (LDKCResult_PingDecodeErrorZ*)untag_ptr(o);
20593 jboolean ret_conv = CResult_PingDecodeErrorZ_is_ok(o_conv);
20597 void __attribute__((export_name("TS_CResult_PingDecodeErrorZ_free"))) TS_CResult_PingDecodeErrorZ_free(uint64_t _res) {
20598 if (!ptr_is_owned(_res)) return;
20599 void* _res_ptr = untag_ptr(_res);
20600 CHECK_ACCESS(_res_ptr);
20601 LDKCResult_PingDecodeErrorZ _res_conv = *(LDKCResult_PingDecodeErrorZ*)(_res_ptr);
20602 FREE(untag_ptr(_res));
20603 CResult_PingDecodeErrorZ_free(_res_conv);
20606 static inline uint64_t CResult_PingDecodeErrorZ_clone_ptr(LDKCResult_PingDecodeErrorZ *NONNULL_PTR arg) {
20607 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
20608 *ret_conv = CResult_PingDecodeErrorZ_clone(arg);
20609 return tag_ptr(ret_conv, true);
20611 int64_t __attribute__((export_name("TS_CResult_PingDecodeErrorZ_clone_ptr"))) TS_CResult_PingDecodeErrorZ_clone_ptr(uint64_t arg) {
20612 LDKCResult_PingDecodeErrorZ* arg_conv = (LDKCResult_PingDecodeErrorZ*)untag_ptr(arg);
20613 int64_t ret_conv = CResult_PingDecodeErrorZ_clone_ptr(arg_conv);
20617 uint64_t __attribute__((export_name("TS_CResult_PingDecodeErrorZ_clone"))) TS_CResult_PingDecodeErrorZ_clone(uint64_t orig) {
20618 LDKCResult_PingDecodeErrorZ* orig_conv = (LDKCResult_PingDecodeErrorZ*)untag_ptr(orig);
20619 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
20620 *ret_conv = CResult_PingDecodeErrorZ_clone(orig_conv);
20621 return tag_ptr(ret_conv, true);
20624 uint64_t __attribute__((export_name("TS_CResult_PongDecodeErrorZ_ok"))) TS_CResult_PongDecodeErrorZ_ok(uint64_t o) {
20626 o_conv.inner = untag_ptr(o);
20627 o_conv.is_owned = ptr_is_owned(o);
20628 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20629 o_conv = Pong_clone(&o_conv);
20630 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
20631 *ret_conv = CResult_PongDecodeErrorZ_ok(o_conv);
20632 return tag_ptr(ret_conv, true);
20635 uint64_t __attribute__((export_name("TS_CResult_PongDecodeErrorZ_err"))) TS_CResult_PongDecodeErrorZ_err(uint64_t e) {
20636 void* e_ptr = untag_ptr(e);
20637 CHECK_ACCESS(e_ptr);
20638 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20639 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20640 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
20641 *ret_conv = CResult_PongDecodeErrorZ_err(e_conv);
20642 return tag_ptr(ret_conv, true);
20645 jboolean __attribute__((export_name("TS_CResult_PongDecodeErrorZ_is_ok"))) TS_CResult_PongDecodeErrorZ_is_ok(uint64_t o) {
20646 LDKCResult_PongDecodeErrorZ* o_conv = (LDKCResult_PongDecodeErrorZ*)untag_ptr(o);
20647 jboolean ret_conv = CResult_PongDecodeErrorZ_is_ok(o_conv);
20651 void __attribute__((export_name("TS_CResult_PongDecodeErrorZ_free"))) TS_CResult_PongDecodeErrorZ_free(uint64_t _res) {
20652 if (!ptr_is_owned(_res)) return;
20653 void* _res_ptr = untag_ptr(_res);
20654 CHECK_ACCESS(_res_ptr);
20655 LDKCResult_PongDecodeErrorZ _res_conv = *(LDKCResult_PongDecodeErrorZ*)(_res_ptr);
20656 FREE(untag_ptr(_res));
20657 CResult_PongDecodeErrorZ_free(_res_conv);
20660 static inline uint64_t CResult_PongDecodeErrorZ_clone_ptr(LDKCResult_PongDecodeErrorZ *NONNULL_PTR arg) {
20661 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
20662 *ret_conv = CResult_PongDecodeErrorZ_clone(arg);
20663 return tag_ptr(ret_conv, true);
20665 int64_t __attribute__((export_name("TS_CResult_PongDecodeErrorZ_clone_ptr"))) TS_CResult_PongDecodeErrorZ_clone_ptr(uint64_t arg) {
20666 LDKCResult_PongDecodeErrorZ* arg_conv = (LDKCResult_PongDecodeErrorZ*)untag_ptr(arg);
20667 int64_t ret_conv = CResult_PongDecodeErrorZ_clone_ptr(arg_conv);
20671 uint64_t __attribute__((export_name("TS_CResult_PongDecodeErrorZ_clone"))) TS_CResult_PongDecodeErrorZ_clone(uint64_t orig) {
20672 LDKCResult_PongDecodeErrorZ* orig_conv = (LDKCResult_PongDecodeErrorZ*)untag_ptr(orig);
20673 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
20674 *ret_conv = CResult_PongDecodeErrorZ_clone(orig_conv);
20675 return tag_ptr(ret_conv, true);
20678 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(uint64_t o) {
20679 LDKUnsignedChannelAnnouncement o_conv;
20680 o_conv.inner = untag_ptr(o);
20681 o_conv.is_owned = ptr_is_owned(o);
20682 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20683 o_conv = UnsignedChannelAnnouncement_clone(&o_conv);
20684 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
20685 *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o_conv);
20686 return tag_ptr(ret_conv, true);
20689 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_err"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(uint64_t e) {
20690 void* e_ptr = untag_ptr(e);
20691 CHECK_ACCESS(e_ptr);
20692 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20693 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20694 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
20695 *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e_conv);
20696 return tag_ptr(ret_conv, true);
20699 jboolean __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(uint64_t o) {
20700 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* o_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)untag_ptr(o);
20701 jboolean ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o_conv);
20705 void __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(uint64_t _res) {
20706 if (!ptr_is_owned(_res)) return;
20707 void* _res_ptr = untag_ptr(_res);
20708 CHECK_ACCESS(_res_ptr);
20709 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(_res_ptr);
20710 FREE(untag_ptr(_res));
20711 CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res_conv);
20714 static inline uint64_t CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
20715 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
20716 *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(arg);
20717 return tag_ptr(ret_conv, true);
20719 int64_t __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(uint64_t arg) {
20720 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)untag_ptr(arg);
20721 int64_t ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
20725 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(uint64_t orig) {
20726 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)untag_ptr(orig);
20727 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
20728 *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig_conv);
20729 return tag_ptr(ret_conv, true);
20732 uint64_t __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_ok"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_ok(uint64_t o) {
20733 LDKChannelAnnouncement o_conv;
20734 o_conv.inner = untag_ptr(o);
20735 o_conv.is_owned = ptr_is_owned(o);
20736 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20737 o_conv = ChannelAnnouncement_clone(&o_conv);
20738 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
20739 *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_ok(o_conv);
20740 return tag_ptr(ret_conv, true);
20743 uint64_t __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_err"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_err(uint64_t e) {
20744 void* e_ptr = untag_ptr(e);
20745 CHECK_ACCESS(e_ptr);
20746 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20747 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20748 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
20749 *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_err(e_conv);
20750 return tag_ptr(ret_conv, true);
20753 jboolean __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok(uint64_t o) {
20754 LDKCResult_ChannelAnnouncementDecodeErrorZ* o_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)untag_ptr(o);
20755 jboolean ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o_conv);
20759 void __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_free"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_free(uint64_t _res) {
20760 if (!ptr_is_owned(_res)) return;
20761 void* _res_ptr = untag_ptr(_res);
20762 CHECK_ACCESS(_res_ptr);
20763 LDKCResult_ChannelAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_ChannelAnnouncementDecodeErrorZ*)(_res_ptr);
20764 FREE(untag_ptr(_res));
20765 CResult_ChannelAnnouncementDecodeErrorZ_free(_res_conv);
20768 static inline uint64_t CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
20769 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
20770 *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_clone(arg);
20771 return tag_ptr(ret_conv, true);
20773 int64_t __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(uint64_t arg) {
20774 LDKCResult_ChannelAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)untag_ptr(arg);
20775 int64_t ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
20779 uint64_t __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_clone"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_clone(uint64_t orig) {
20780 LDKCResult_ChannelAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)untag_ptr(orig);
20781 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
20782 *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_clone(orig_conv);
20783 return tag_ptr(ret_conv, true);
20786 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_ok"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_ok(uint64_t o) {
20787 LDKUnsignedChannelUpdate o_conv;
20788 o_conv.inner = untag_ptr(o);
20789 o_conv.is_owned = ptr_is_owned(o);
20790 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20791 o_conv = UnsignedChannelUpdate_clone(&o_conv);
20792 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
20793 *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o_conv);
20794 return tag_ptr(ret_conv, true);
20797 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_err"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_err(uint64_t e) {
20798 void* e_ptr = untag_ptr(e);
20799 CHECK_ACCESS(e_ptr);
20800 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20801 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20802 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
20803 *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_err(e_conv);
20804 return tag_ptr(ret_conv, true);
20807 jboolean __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(uint64_t o) {
20808 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* o_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)untag_ptr(o);
20809 jboolean ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o_conv);
20813 void __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free(uint64_t _res) {
20814 if (!ptr_is_owned(_res)) return;
20815 void* _res_ptr = untag_ptr(_res);
20816 CHECK_ACCESS(_res_ptr);
20817 LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res_conv = *(LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(_res_ptr);
20818 FREE(untag_ptr(_res));
20819 CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res_conv);
20822 static inline uint64_t CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR arg) {
20823 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
20824 *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_clone(arg);
20825 return tag_ptr(ret_conv, true);
20827 int64_t __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(uint64_t arg) {
20828 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* arg_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)untag_ptr(arg);
20829 int64_t ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg_conv);
20833 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone(uint64_t orig) {
20834 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* orig_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)untag_ptr(orig);
20835 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
20836 *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig_conv);
20837 return tag_ptr(ret_conv, true);
20840 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_ok"))) TS_CResult_ChannelUpdateDecodeErrorZ_ok(uint64_t o) {
20841 LDKChannelUpdate o_conv;
20842 o_conv.inner = untag_ptr(o);
20843 o_conv.is_owned = ptr_is_owned(o);
20844 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20845 o_conv = ChannelUpdate_clone(&o_conv);
20846 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
20847 *ret_conv = CResult_ChannelUpdateDecodeErrorZ_ok(o_conv);
20848 return tag_ptr(ret_conv, true);
20851 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_err"))) TS_CResult_ChannelUpdateDecodeErrorZ_err(uint64_t e) {
20852 void* e_ptr = untag_ptr(e);
20853 CHECK_ACCESS(e_ptr);
20854 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20855 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20856 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
20857 *ret_conv = CResult_ChannelUpdateDecodeErrorZ_err(e_conv);
20858 return tag_ptr(ret_conv, true);
20861 jboolean __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_is_ok"))) TS_CResult_ChannelUpdateDecodeErrorZ_is_ok(uint64_t o) {
20862 LDKCResult_ChannelUpdateDecodeErrorZ* o_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)untag_ptr(o);
20863 jboolean ret_conv = CResult_ChannelUpdateDecodeErrorZ_is_ok(o_conv);
20867 void __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_free"))) TS_CResult_ChannelUpdateDecodeErrorZ_free(uint64_t _res) {
20868 if (!ptr_is_owned(_res)) return;
20869 void* _res_ptr = untag_ptr(_res);
20870 CHECK_ACCESS(_res_ptr);
20871 LDKCResult_ChannelUpdateDecodeErrorZ _res_conv = *(LDKCResult_ChannelUpdateDecodeErrorZ*)(_res_ptr);
20872 FREE(untag_ptr(_res));
20873 CResult_ChannelUpdateDecodeErrorZ_free(_res_conv);
20876 static inline uint64_t CResult_ChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR arg) {
20877 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
20878 *ret_conv = CResult_ChannelUpdateDecodeErrorZ_clone(arg);
20879 return tag_ptr(ret_conv, true);
20881 int64_t __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr(uint64_t arg) {
20882 LDKCResult_ChannelUpdateDecodeErrorZ* arg_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)untag_ptr(arg);
20883 int64_t ret_conv = CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg_conv);
20887 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_clone"))) TS_CResult_ChannelUpdateDecodeErrorZ_clone(uint64_t orig) {
20888 LDKCResult_ChannelUpdateDecodeErrorZ* orig_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)untag_ptr(orig);
20889 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
20890 *ret_conv = CResult_ChannelUpdateDecodeErrorZ_clone(orig_conv);
20891 return tag_ptr(ret_conv, true);
20894 uint64_t __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_ok"))) TS_CResult_ErrorMessageDecodeErrorZ_ok(uint64_t o) {
20895 LDKErrorMessage o_conv;
20896 o_conv.inner = untag_ptr(o);
20897 o_conv.is_owned = ptr_is_owned(o);
20898 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20899 o_conv = ErrorMessage_clone(&o_conv);
20900 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
20901 *ret_conv = CResult_ErrorMessageDecodeErrorZ_ok(o_conv);
20902 return tag_ptr(ret_conv, true);
20905 uint64_t __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_err"))) TS_CResult_ErrorMessageDecodeErrorZ_err(uint64_t e) {
20906 void* e_ptr = untag_ptr(e);
20907 CHECK_ACCESS(e_ptr);
20908 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20909 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20910 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
20911 *ret_conv = CResult_ErrorMessageDecodeErrorZ_err(e_conv);
20912 return tag_ptr(ret_conv, true);
20915 jboolean __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_is_ok"))) TS_CResult_ErrorMessageDecodeErrorZ_is_ok(uint64_t o) {
20916 LDKCResult_ErrorMessageDecodeErrorZ* o_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)untag_ptr(o);
20917 jboolean ret_conv = CResult_ErrorMessageDecodeErrorZ_is_ok(o_conv);
20921 void __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_free"))) TS_CResult_ErrorMessageDecodeErrorZ_free(uint64_t _res) {
20922 if (!ptr_is_owned(_res)) return;
20923 void* _res_ptr = untag_ptr(_res);
20924 CHECK_ACCESS(_res_ptr);
20925 LDKCResult_ErrorMessageDecodeErrorZ _res_conv = *(LDKCResult_ErrorMessageDecodeErrorZ*)(_res_ptr);
20926 FREE(untag_ptr(_res));
20927 CResult_ErrorMessageDecodeErrorZ_free(_res_conv);
20930 static inline uint64_t CResult_ErrorMessageDecodeErrorZ_clone_ptr(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR arg) {
20931 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
20932 *ret_conv = CResult_ErrorMessageDecodeErrorZ_clone(arg);
20933 return tag_ptr(ret_conv, true);
20935 int64_t __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr"))) TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr(uint64_t arg) {
20936 LDKCResult_ErrorMessageDecodeErrorZ* arg_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)untag_ptr(arg);
20937 int64_t ret_conv = CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg_conv);
20941 uint64_t __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_clone"))) TS_CResult_ErrorMessageDecodeErrorZ_clone(uint64_t orig) {
20942 LDKCResult_ErrorMessageDecodeErrorZ* orig_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)untag_ptr(orig);
20943 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
20944 *ret_conv = CResult_ErrorMessageDecodeErrorZ_clone(orig_conv);
20945 return tag_ptr(ret_conv, true);
20948 uint64_t __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_ok"))) TS_CResult_WarningMessageDecodeErrorZ_ok(uint64_t o) {
20949 LDKWarningMessage o_conv;
20950 o_conv.inner = untag_ptr(o);
20951 o_conv.is_owned = ptr_is_owned(o);
20952 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20953 o_conv = WarningMessage_clone(&o_conv);
20954 LDKCResult_WarningMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WarningMessageDecodeErrorZ), "LDKCResult_WarningMessageDecodeErrorZ");
20955 *ret_conv = CResult_WarningMessageDecodeErrorZ_ok(o_conv);
20956 return tag_ptr(ret_conv, true);
20959 uint64_t __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_err"))) TS_CResult_WarningMessageDecodeErrorZ_err(uint64_t e) {
20960 void* e_ptr = untag_ptr(e);
20961 CHECK_ACCESS(e_ptr);
20962 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20963 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20964 LDKCResult_WarningMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WarningMessageDecodeErrorZ), "LDKCResult_WarningMessageDecodeErrorZ");
20965 *ret_conv = CResult_WarningMessageDecodeErrorZ_err(e_conv);
20966 return tag_ptr(ret_conv, true);
20969 jboolean __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_is_ok"))) TS_CResult_WarningMessageDecodeErrorZ_is_ok(uint64_t o) {
20970 LDKCResult_WarningMessageDecodeErrorZ* o_conv = (LDKCResult_WarningMessageDecodeErrorZ*)untag_ptr(o);
20971 jboolean ret_conv = CResult_WarningMessageDecodeErrorZ_is_ok(o_conv);
20975 void __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_free"))) TS_CResult_WarningMessageDecodeErrorZ_free(uint64_t _res) {
20976 if (!ptr_is_owned(_res)) return;
20977 void* _res_ptr = untag_ptr(_res);
20978 CHECK_ACCESS(_res_ptr);
20979 LDKCResult_WarningMessageDecodeErrorZ _res_conv = *(LDKCResult_WarningMessageDecodeErrorZ*)(_res_ptr);
20980 FREE(untag_ptr(_res));
20981 CResult_WarningMessageDecodeErrorZ_free(_res_conv);
20984 static inline uint64_t CResult_WarningMessageDecodeErrorZ_clone_ptr(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR arg) {
20985 LDKCResult_WarningMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WarningMessageDecodeErrorZ), "LDKCResult_WarningMessageDecodeErrorZ");
20986 *ret_conv = CResult_WarningMessageDecodeErrorZ_clone(arg);
20987 return tag_ptr(ret_conv, true);
20989 int64_t __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_clone_ptr"))) TS_CResult_WarningMessageDecodeErrorZ_clone_ptr(uint64_t arg) {
20990 LDKCResult_WarningMessageDecodeErrorZ* arg_conv = (LDKCResult_WarningMessageDecodeErrorZ*)untag_ptr(arg);
20991 int64_t ret_conv = CResult_WarningMessageDecodeErrorZ_clone_ptr(arg_conv);
20995 uint64_t __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_clone"))) TS_CResult_WarningMessageDecodeErrorZ_clone(uint64_t orig) {
20996 LDKCResult_WarningMessageDecodeErrorZ* orig_conv = (LDKCResult_WarningMessageDecodeErrorZ*)untag_ptr(orig);
20997 LDKCResult_WarningMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WarningMessageDecodeErrorZ), "LDKCResult_WarningMessageDecodeErrorZ");
20998 *ret_conv = CResult_WarningMessageDecodeErrorZ_clone(orig_conv);
20999 return tag_ptr(ret_conv, true);
21002 uint64_t __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(uint64_t o) {
21003 LDKUnsignedNodeAnnouncement o_conv;
21004 o_conv.inner = untag_ptr(o);
21005 o_conv.is_owned = ptr_is_owned(o);
21006 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21007 o_conv = UnsignedNodeAnnouncement_clone(&o_conv);
21008 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
21009 *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o_conv);
21010 return tag_ptr(ret_conv, true);
21013 uint64_t __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_err"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(uint64_t e) {
21014 void* e_ptr = untag_ptr(e);
21015 CHECK_ACCESS(e_ptr);
21016 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21017 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21018 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
21019 *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e_conv);
21020 return tag_ptr(ret_conv, true);
21023 jboolean __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(uint64_t o) {
21024 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* o_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)untag_ptr(o);
21025 jboolean ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o_conv);
21029 void __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(uint64_t _res) {
21030 if (!ptr_is_owned(_res)) return;
21031 void* _res_ptr = untag_ptr(_res);
21032 CHECK_ACCESS(_res_ptr);
21033 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(_res_ptr);
21034 FREE(untag_ptr(_res));
21035 CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res_conv);
21038 static inline uint64_t CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
21039 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
21040 *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(arg);
21041 return tag_ptr(ret_conv, true);
21043 int64_t __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(uint64_t arg) {
21044 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)untag_ptr(arg);
21045 int64_t ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
21049 uint64_t __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(uint64_t orig) {
21050 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)untag_ptr(orig);
21051 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
21052 *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig_conv);
21053 return tag_ptr(ret_conv, true);
21056 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_ok"))) TS_CResult_NodeAnnouncementDecodeErrorZ_ok(uint64_t o) {
21057 LDKNodeAnnouncement o_conv;
21058 o_conv.inner = untag_ptr(o);
21059 o_conv.is_owned = ptr_is_owned(o);
21060 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21061 o_conv = NodeAnnouncement_clone(&o_conv);
21062 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
21063 *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_ok(o_conv);
21064 return tag_ptr(ret_conv, true);
21067 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_err"))) TS_CResult_NodeAnnouncementDecodeErrorZ_err(uint64_t e) {
21068 void* e_ptr = untag_ptr(e);
21069 CHECK_ACCESS(e_ptr);
21070 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21071 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21072 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
21073 *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_err(e_conv);
21074 return tag_ptr(ret_conv, true);
21077 jboolean __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok"))) TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok(uint64_t o) {
21078 LDKCResult_NodeAnnouncementDecodeErrorZ* o_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)untag_ptr(o);
21079 jboolean ret_conv = CResult_NodeAnnouncementDecodeErrorZ_is_ok(o_conv);
21083 void __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_free"))) TS_CResult_NodeAnnouncementDecodeErrorZ_free(uint64_t _res) {
21084 if (!ptr_is_owned(_res)) return;
21085 void* _res_ptr = untag_ptr(_res);
21086 CHECK_ACCESS(_res_ptr);
21087 LDKCResult_NodeAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_NodeAnnouncementDecodeErrorZ*)(_res_ptr);
21088 FREE(untag_ptr(_res));
21089 CResult_NodeAnnouncementDecodeErrorZ_free(_res_conv);
21092 static inline uint64_t CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
21093 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
21094 *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_clone(arg);
21095 return tag_ptr(ret_conv, true);
21097 int64_t __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr"))) TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(uint64_t arg) {
21098 LDKCResult_NodeAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)untag_ptr(arg);
21099 int64_t ret_conv = CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
21103 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_clone"))) TS_CResult_NodeAnnouncementDecodeErrorZ_clone(uint64_t orig) {
21104 LDKCResult_NodeAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)untag_ptr(orig);
21105 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
21106 *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_clone(orig_conv);
21107 return tag_ptr(ret_conv, true);
21110 uint64_t __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_ok"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_ok(uint64_t o) {
21111 LDKQueryShortChannelIds o_conv;
21112 o_conv.inner = untag_ptr(o);
21113 o_conv.is_owned = ptr_is_owned(o);
21114 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21115 o_conv = QueryShortChannelIds_clone(&o_conv);
21116 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
21117 *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_ok(o_conv);
21118 return tag_ptr(ret_conv, true);
21121 uint64_t __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_err"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_err(uint64_t e) {
21122 void* e_ptr = untag_ptr(e);
21123 CHECK_ACCESS(e_ptr);
21124 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21125 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21126 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
21127 *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_err(e_conv);
21128 return tag_ptr(ret_conv, true);
21131 jboolean __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(uint64_t o) {
21132 LDKCResult_QueryShortChannelIdsDecodeErrorZ* o_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)untag_ptr(o);
21133 jboolean ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o_conv);
21137 void __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_free"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_free(uint64_t _res) {
21138 if (!ptr_is_owned(_res)) return;
21139 void* _res_ptr = untag_ptr(_res);
21140 CHECK_ACCESS(_res_ptr);
21141 LDKCResult_QueryShortChannelIdsDecodeErrorZ _res_conv = *(LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(_res_ptr);
21142 FREE(untag_ptr(_res));
21143 CResult_QueryShortChannelIdsDecodeErrorZ_free(_res_conv);
21146 static inline uint64_t CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR arg) {
21147 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
21148 *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_clone(arg);
21149 return tag_ptr(ret_conv, true);
21151 int64_t __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(uint64_t arg) {
21152 LDKCResult_QueryShortChannelIdsDecodeErrorZ* arg_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)untag_ptr(arg);
21153 int64_t ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg_conv);
21157 uint64_t __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone(uint64_t orig) {
21158 LDKCResult_QueryShortChannelIdsDecodeErrorZ* orig_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)untag_ptr(orig);
21159 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
21160 *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig_conv);
21161 return tag_ptr(ret_conv, true);
21164 uint64_t __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(uint64_t o) {
21165 LDKReplyShortChannelIdsEnd o_conv;
21166 o_conv.inner = untag_ptr(o);
21167 o_conv.is_owned = ptr_is_owned(o);
21168 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21169 o_conv = ReplyShortChannelIdsEnd_clone(&o_conv);
21170 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
21171 *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o_conv);
21172 return tag_ptr(ret_conv, true);
21175 uint64_t __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_err"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(uint64_t e) {
21176 void* e_ptr = untag_ptr(e);
21177 CHECK_ACCESS(e_ptr);
21178 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21179 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21180 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
21181 *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e_conv);
21182 return tag_ptr(ret_conv, true);
21185 jboolean __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(uint64_t o) {
21186 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* o_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)untag_ptr(o);
21187 jboolean ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o_conv);
21191 void __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(uint64_t _res) {
21192 if (!ptr_is_owned(_res)) return;
21193 void* _res_ptr = untag_ptr(_res);
21194 CHECK_ACCESS(_res_ptr);
21195 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res_conv = *(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(_res_ptr);
21196 FREE(untag_ptr(_res));
21197 CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res_conv);
21200 static inline uint64_t CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR arg) {
21201 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
21202 *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(arg);
21203 return tag_ptr(ret_conv, true);
21205 int64_t __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(uint64_t arg) {
21206 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* arg_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)untag_ptr(arg);
21207 int64_t ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg_conv);
21211 uint64_t __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(uint64_t orig) {
21212 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* orig_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)untag_ptr(orig);
21213 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
21214 *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig_conv);
21215 return tag_ptr(ret_conv, true);
21218 uint64_t __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_ok"))) TS_CResult_QueryChannelRangeDecodeErrorZ_ok(uint64_t o) {
21219 LDKQueryChannelRange o_conv;
21220 o_conv.inner = untag_ptr(o);
21221 o_conv.is_owned = ptr_is_owned(o);
21222 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21223 o_conv = QueryChannelRange_clone(&o_conv);
21224 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
21225 *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_ok(o_conv);
21226 return tag_ptr(ret_conv, true);
21229 uint64_t __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_err"))) TS_CResult_QueryChannelRangeDecodeErrorZ_err(uint64_t e) {
21230 void* e_ptr = untag_ptr(e);
21231 CHECK_ACCESS(e_ptr);
21232 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21233 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21234 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
21235 *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_err(e_conv);
21236 return tag_ptr(ret_conv, true);
21239 jboolean __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok"))) TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok(uint64_t o) {
21240 LDKCResult_QueryChannelRangeDecodeErrorZ* o_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)untag_ptr(o);
21241 jboolean ret_conv = CResult_QueryChannelRangeDecodeErrorZ_is_ok(o_conv);
21245 void __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_free"))) TS_CResult_QueryChannelRangeDecodeErrorZ_free(uint64_t _res) {
21246 if (!ptr_is_owned(_res)) return;
21247 void* _res_ptr = untag_ptr(_res);
21248 CHECK_ACCESS(_res_ptr);
21249 LDKCResult_QueryChannelRangeDecodeErrorZ _res_conv = *(LDKCResult_QueryChannelRangeDecodeErrorZ*)(_res_ptr);
21250 FREE(untag_ptr(_res));
21251 CResult_QueryChannelRangeDecodeErrorZ_free(_res_conv);
21254 static inline uint64_t CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR arg) {
21255 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
21256 *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_clone(arg);
21257 return tag_ptr(ret_conv, true);
21259 int64_t __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr"))) TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(uint64_t arg) {
21260 LDKCResult_QueryChannelRangeDecodeErrorZ* arg_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)untag_ptr(arg);
21261 int64_t ret_conv = CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg_conv);
21265 uint64_t __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_clone"))) TS_CResult_QueryChannelRangeDecodeErrorZ_clone(uint64_t orig) {
21266 LDKCResult_QueryChannelRangeDecodeErrorZ* orig_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)untag_ptr(orig);
21267 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
21268 *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_clone(orig_conv);
21269 return tag_ptr(ret_conv, true);
21272 uint64_t __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_ok"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_ok(uint64_t o) {
21273 LDKReplyChannelRange o_conv;
21274 o_conv.inner = untag_ptr(o);
21275 o_conv.is_owned = ptr_is_owned(o);
21276 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21277 o_conv = ReplyChannelRange_clone(&o_conv);
21278 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
21279 *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_ok(o_conv);
21280 return tag_ptr(ret_conv, true);
21283 uint64_t __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_err"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_err(uint64_t e) {
21284 void* e_ptr = untag_ptr(e);
21285 CHECK_ACCESS(e_ptr);
21286 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21287 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21288 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
21289 *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_err(e_conv);
21290 return tag_ptr(ret_conv, true);
21293 jboolean __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok(uint64_t o) {
21294 LDKCResult_ReplyChannelRangeDecodeErrorZ* o_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)untag_ptr(o);
21295 jboolean ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o_conv);
21299 void __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_free"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_free(uint64_t _res) {
21300 if (!ptr_is_owned(_res)) return;
21301 void* _res_ptr = untag_ptr(_res);
21302 CHECK_ACCESS(_res_ptr);
21303 LDKCResult_ReplyChannelRangeDecodeErrorZ _res_conv = *(LDKCResult_ReplyChannelRangeDecodeErrorZ*)(_res_ptr);
21304 FREE(untag_ptr(_res));
21305 CResult_ReplyChannelRangeDecodeErrorZ_free(_res_conv);
21308 static inline uint64_t CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR arg) {
21309 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
21310 *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_clone(arg);
21311 return tag_ptr(ret_conv, true);
21313 int64_t __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(uint64_t arg) {
21314 LDKCResult_ReplyChannelRangeDecodeErrorZ* arg_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)untag_ptr(arg);
21315 int64_t ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg_conv);
21319 uint64_t __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_clone"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_clone(uint64_t orig) {
21320 LDKCResult_ReplyChannelRangeDecodeErrorZ* orig_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)untag_ptr(orig);
21321 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
21322 *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_clone(orig_conv);
21323 return tag_ptr(ret_conv, true);
21326 uint64_t __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_ok"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_ok(uint64_t o) {
21327 LDKGossipTimestampFilter o_conv;
21328 o_conv.inner = untag_ptr(o);
21329 o_conv.is_owned = ptr_is_owned(o);
21330 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21331 o_conv = GossipTimestampFilter_clone(&o_conv);
21332 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
21333 *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_ok(o_conv);
21334 return tag_ptr(ret_conv, true);
21337 uint64_t __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_err"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_err(uint64_t e) {
21338 void* e_ptr = untag_ptr(e);
21339 CHECK_ACCESS(e_ptr);
21340 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21341 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21342 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
21343 *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_err(e_conv);
21344 return tag_ptr(ret_conv, true);
21347 jboolean __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok(uint64_t o) {
21348 LDKCResult_GossipTimestampFilterDecodeErrorZ* o_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)untag_ptr(o);
21349 jboolean ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o_conv);
21353 void __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_free"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_free(uint64_t _res) {
21354 if (!ptr_is_owned(_res)) return;
21355 void* _res_ptr = untag_ptr(_res);
21356 CHECK_ACCESS(_res_ptr);
21357 LDKCResult_GossipTimestampFilterDecodeErrorZ _res_conv = *(LDKCResult_GossipTimestampFilterDecodeErrorZ*)(_res_ptr);
21358 FREE(untag_ptr(_res));
21359 CResult_GossipTimestampFilterDecodeErrorZ_free(_res_conv);
21362 static inline uint64_t CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR arg) {
21363 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
21364 *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_clone(arg);
21365 return tag_ptr(ret_conv, true);
21367 int64_t __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(uint64_t arg) {
21368 LDKCResult_GossipTimestampFilterDecodeErrorZ* arg_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)untag_ptr(arg);
21369 int64_t ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg_conv);
21373 uint64_t __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_clone"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_clone(uint64_t orig) {
21374 LDKCResult_GossipTimestampFilterDecodeErrorZ* orig_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)untag_ptr(orig);
21375 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
21376 *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_clone(orig_conv);
21377 return tag_ptr(ret_conv, true);
21380 uint64_t __attribute__((export_name("TS_CResult_InvoiceSignOrCreationErrorZ_ok"))) TS_CResult_InvoiceSignOrCreationErrorZ_ok(uint64_t o) {
21382 o_conv.inner = untag_ptr(o);
21383 o_conv.is_owned = ptr_is_owned(o);
21384 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21385 o_conv = Invoice_clone(&o_conv);
21386 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
21387 *ret_conv = CResult_InvoiceSignOrCreationErrorZ_ok(o_conv);
21388 return tag_ptr(ret_conv, true);
21391 uint64_t __attribute__((export_name("TS_CResult_InvoiceSignOrCreationErrorZ_err"))) TS_CResult_InvoiceSignOrCreationErrorZ_err(uint64_t e) {
21392 void* e_ptr = untag_ptr(e);
21393 CHECK_ACCESS(e_ptr);
21394 LDKSignOrCreationError e_conv = *(LDKSignOrCreationError*)(e_ptr);
21395 e_conv = SignOrCreationError_clone((LDKSignOrCreationError*)untag_ptr(e));
21396 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
21397 *ret_conv = CResult_InvoiceSignOrCreationErrorZ_err(e_conv);
21398 return tag_ptr(ret_conv, true);
21401 jboolean __attribute__((export_name("TS_CResult_InvoiceSignOrCreationErrorZ_is_ok"))) TS_CResult_InvoiceSignOrCreationErrorZ_is_ok(uint64_t o) {
21402 LDKCResult_InvoiceSignOrCreationErrorZ* o_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)untag_ptr(o);
21403 jboolean ret_conv = CResult_InvoiceSignOrCreationErrorZ_is_ok(o_conv);
21407 void __attribute__((export_name("TS_CResult_InvoiceSignOrCreationErrorZ_free"))) TS_CResult_InvoiceSignOrCreationErrorZ_free(uint64_t _res) {
21408 if (!ptr_is_owned(_res)) return;
21409 void* _res_ptr = untag_ptr(_res);
21410 CHECK_ACCESS(_res_ptr);
21411 LDKCResult_InvoiceSignOrCreationErrorZ _res_conv = *(LDKCResult_InvoiceSignOrCreationErrorZ*)(_res_ptr);
21412 FREE(untag_ptr(_res));
21413 CResult_InvoiceSignOrCreationErrorZ_free(_res_conv);
21416 static inline uint64_t CResult_InvoiceSignOrCreationErrorZ_clone_ptr(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR arg) {
21417 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
21418 *ret_conv = CResult_InvoiceSignOrCreationErrorZ_clone(arg);
21419 return tag_ptr(ret_conv, true);
21421 int64_t __attribute__((export_name("TS_CResult_InvoiceSignOrCreationErrorZ_clone_ptr"))) TS_CResult_InvoiceSignOrCreationErrorZ_clone_ptr(uint64_t arg) {
21422 LDKCResult_InvoiceSignOrCreationErrorZ* arg_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)untag_ptr(arg);
21423 int64_t ret_conv = CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg_conv);
21427 uint64_t __attribute__((export_name("TS_CResult_InvoiceSignOrCreationErrorZ_clone"))) TS_CResult_InvoiceSignOrCreationErrorZ_clone(uint64_t orig) {
21428 LDKCResult_InvoiceSignOrCreationErrorZ* orig_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)untag_ptr(orig);
21429 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
21430 *ret_conv = CResult_InvoiceSignOrCreationErrorZ_clone(orig_conv);
21431 return tag_ptr(ret_conv, true);
21434 uint64_t __attribute__((export_name("TS_COption_FilterZ_some"))) TS_COption_FilterZ_some(uint64_t o) {
21435 void* o_ptr = untag_ptr(o);
21436 CHECK_ACCESS(o_ptr);
21437 LDKFilter o_conv = *(LDKFilter*)(o_ptr);
21438 if (o_conv.free == LDKFilter_JCalls_free) {
21439 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
21440 LDKFilter_JCalls_cloned(&o_conv);
21442 LDKCOption_FilterZ *ret_copy = MALLOC(sizeof(LDKCOption_FilterZ), "LDKCOption_FilterZ");
21443 *ret_copy = COption_FilterZ_some(o_conv);
21444 uint64_t ret_ref = tag_ptr(ret_copy, true);
21448 uint64_t __attribute__((export_name("TS_COption_FilterZ_none"))) TS_COption_FilterZ_none() {
21449 LDKCOption_FilterZ *ret_copy = MALLOC(sizeof(LDKCOption_FilterZ), "LDKCOption_FilterZ");
21450 *ret_copy = COption_FilterZ_none();
21451 uint64_t ret_ref = tag_ptr(ret_copy, true);
21455 void __attribute__((export_name("TS_COption_FilterZ_free"))) TS_COption_FilterZ_free(uint64_t _res) {
21456 if (!ptr_is_owned(_res)) return;
21457 void* _res_ptr = untag_ptr(_res);
21458 CHECK_ACCESS(_res_ptr);
21459 LDKCOption_FilterZ _res_conv = *(LDKCOption_FilterZ*)(_res_ptr);
21460 FREE(untag_ptr(_res));
21461 COption_FilterZ_free(_res_conv);
21464 uint64_t __attribute__((export_name("TS_CResult_LockedChannelMonitorNoneZ_ok"))) TS_CResult_LockedChannelMonitorNoneZ_ok(uint64_t o) {
21465 LDKLockedChannelMonitor o_conv;
21466 o_conv.inner = untag_ptr(o);
21467 o_conv.is_owned = ptr_is_owned(o);
21468 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21469 // WARNING: we need a move here but no clone is available for LDKLockedChannelMonitor
21471 LDKCResult_LockedChannelMonitorNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_LockedChannelMonitorNoneZ), "LDKCResult_LockedChannelMonitorNoneZ");
21472 *ret_conv = CResult_LockedChannelMonitorNoneZ_ok(o_conv);
21473 return tag_ptr(ret_conv, true);
21476 uint64_t __attribute__((export_name("TS_CResult_LockedChannelMonitorNoneZ_err"))) TS_CResult_LockedChannelMonitorNoneZ_err() {
21477 LDKCResult_LockedChannelMonitorNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_LockedChannelMonitorNoneZ), "LDKCResult_LockedChannelMonitorNoneZ");
21478 *ret_conv = CResult_LockedChannelMonitorNoneZ_err();
21479 return tag_ptr(ret_conv, true);
21482 jboolean __attribute__((export_name("TS_CResult_LockedChannelMonitorNoneZ_is_ok"))) TS_CResult_LockedChannelMonitorNoneZ_is_ok(uint64_t o) {
21483 LDKCResult_LockedChannelMonitorNoneZ* o_conv = (LDKCResult_LockedChannelMonitorNoneZ*)untag_ptr(o);
21484 jboolean ret_conv = CResult_LockedChannelMonitorNoneZ_is_ok(o_conv);
21488 void __attribute__((export_name("TS_CResult_LockedChannelMonitorNoneZ_free"))) TS_CResult_LockedChannelMonitorNoneZ_free(uint64_t _res) {
21489 if (!ptr_is_owned(_res)) return;
21490 void* _res_ptr = untag_ptr(_res);
21491 CHECK_ACCESS(_res_ptr);
21492 LDKCResult_LockedChannelMonitorNoneZ _res_conv = *(LDKCResult_LockedChannelMonitorNoneZ*)(_res_ptr);
21493 FREE(untag_ptr(_res));
21494 CResult_LockedChannelMonitorNoneZ_free(_res_conv);
21497 void __attribute__((export_name("TS_CVec_OutPointZ_free"))) TS_CVec_OutPointZ_free(uint64_tArray _res) {
21498 LDKCVec_OutPointZ _res_constr;
21499 _res_constr.datalen = _res->arr_len;
21500 if (_res_constr.datalen > 0)
21501 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKOutPoint), "LDKCVec_OutPointZ Elements");
21503 _res_constr.data = NULL;
21504 uint64_t* _res_vals = _res->elems;
21505 for (size_t k = 0; k < _res_constr.datalen; k++) {
21506 uint64_t _res_conv_10 = _res_vals[k];
21507 LDKOutPoint _res_conv_10_conv;
21508 _res_conv_10_conv.inner = untag_ptr(_res_conv_10);
21509 _res_conv_10_conv.is_owned = ptr_is_owned(_res_conv_10);
21510 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_10_conv);
21511 _res_constr.data[k] = _res_conv_10_conv;
21514 CVec_OutPointZ_free(_res_constr);
21517 void __attribute__((export_name("TS_CVec_MonitorUpdateIdZ_free"))) TS_CVec_MonitorUpdateIdZ_free(uint64_tArray _res) {
21518 LDKCVec_MonitorUpdateIdZ _res_constr;
21519 _res_constr.datalen = _res->arr_len;
21520 if (_res_constr.datalen > 0)
21521 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKMonitorUpdateId), "LDKCVec_MonitorUpdateIdZ Elements");
21523 _res_constr.data = NULL;
21524 uint64_t* _res_vals = _res->elems;
21525 for (size_t r = 0; r < _res_constr.datalen; r++) {
21526 uint64_t _res_conv_17 = _res_vals[r];
21527 LDKMonitorUpdateId _res_conv_17_conv;
21528 _res_conv_17_conv.inner = untag_ptr(_res_conv_17);
21529 _res_conv_17_conv.is_owned = ptr_is_owned(_res_conv_17);
21530 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_17_conv);
21531 _res_constr.data[r] = _res_conv_17_conv;
21534 CVec_MonitorUpdateIdZ_free(_res_constr);
21537 static inline uint64_t C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR arg) {
21538 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ), "LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ");
21539 *ret_conv = C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(arg);
21540 return tag_ptr(ret_conv, true);
21542 int64_t __attribute__((export_name("TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr"))) TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(uint64_t arg) {
21543 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* arg_conv = (LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ*)untag_ptr(arg);
21544 int64_t ret_conv = C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(arg_conv);
21548 uint64_t __attribute__((export_name("TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone"))) TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(uint64_t orig) {
21549 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* orig_conv = (LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ*)untag_ptr(orig);
21550 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ), "LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ");
21551 *ret_conv = C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(orig_conv);
21552 return tag_ptr(ret_conv, true);
21555 uint64_t __attribute__((export_name("TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new"))) TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new(uint64_t a, uint64_tArray b) {
21556 LDKOutPoint a_conv;
21557 a_conv.inner = untag_ptr(a);
21558 a_conv.is_owned = ptr_is_owned(a);
21559 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
21560 a_conv = OutPoint_clone(&a_conv);
21561 LDKCVec_MonitorUpdateIdZ b_constr;
21562 b_constr.datalen = b->arr_len;
21563 if (b_constr.datalen > 0)
21564 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKMonitorUpdateId), "LDKCVec_MonitorUpdateIdZ Elements");
21566 b_constr.data = NULL;
21567 uint64_t* b_vals = b->elems;
21568 for (size_t r = 0; r < b_constr.datalen; r++) {
21569 uint64_t b_conv_17 = b_vals[r];
21570 LDKMonitorUpdateId b_conv_17_conv;
21571 b_conv_17_conv.inner = untag_ptr(b_conv_17);
21572 b_conv_17_conv.is_owned = ptr_is_owned(b_conv_17);
21573 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv_17_conv);
21574 b_conv_17_conv = MonitorUpdateId_clone(&b_conv_17_conv);
21575 b_constr.data[r] = b_conv_17_conv;
21578 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ), "LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ");
21579 *ret_conv = C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new(a_conv, b_constr);
21580 return tag_ptr(ret_conv, true);
21583 void __attribute__((export_name("TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free"))) TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(uint64_t _res) {
21584 if (!ptr_is_owned(_res)) return;
21585 void* _res_ptr = untag_ptr(_res);
21586 CHECK_ACCESS(_res_ptr);
21587 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ _res_conv = *(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ*)(_res_ptr);
21588 FREE(untag_ptr(_res));
21589 C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(_res_conv);
21592 void __attribute__((export_name("TS_CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free"))) TS_CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(uint64_tArray _res) {
21593 LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ _res_constr;
21594 _res_constr.datalen = _res->arr_len;
21595 if (_res_constr.datalen > 0)
21596 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ), "LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ Elements");
21598 _res_constr.data = NULL;
21599 uint64_t* _res_vals = _res->elems;
21600 for (size_t p = 0; p < _res_constr.datalen; p++) {
21601 uint64_t _res_conv_41 = _res_vals[p];
21602 void* _res_conv_41_ptr = untag_ptr(_res_conv_41);
21603 CHECK_ACCESS(_res_conv_41_ptr);
21604 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ _res_conv_41_conv = *(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ*)(_res_conv_41_ptr);
21605 FREE(untag_ptr(_res_conv_41));
21606 _res_constr.data[p] = _res_conv_41_conv;
21609 CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(_res_constr);
21612 void __attribute__((export_name("TS_PaymentPurpose_free"))) TS_PaymentPurpose_free(uint64_t this_ptr) {
21613 if (!ptr_is_owned(this_ptr)) return;
21614 void* this_ptr_ptr = untag_ptr(this_ptr);
21615 CHECK_ACCESS(this_ptr_ptr);
21616 LDKPaymentPurpose this_ptr_conv = *(LDKPaymentPurpose*)(this_ptr_ptr);
21617 FREE(untag_ptr(this_ptr));
21618 PaymentPurpose_free(this_ptr_conv);
21621 static inline uint64_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg) {
21622 LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
21623 *ret_copy = PaymentPurpose_clone(arg);
21624 uint64_t ret_ref = tag_ptr(ret_copy, true);
21627 int64_t __attribute__((export_name("TS_PaymentPurpose_clone_ptr"))) TS_PaymentPurpose_clone_ptr(uint64_t arg) {
21628 LDKPaymentPurpose* arg_conv = (LDKPaymentPurpose*)untag_ptr(arg);
21629 int64_t ret_conv = PaymentPurpose_clone_ptr(arg_conv);
21633 uint64_t __attribute__((export_name("TS_PaymentPurpose_clone"))) TS_PaymentPurpose_clone(uint64_t orig) {
21634 LDKPaymentPurpose* orig_conv = (LDKPaymentPurpose*)untag_ptr(orig);
21635 LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
21636 *ret_copy = PaymentPurpose_clone(orig_conv);
21637 uint64_t ret_ref = tag_ptr(ret_copy, true);
21641 uint64_t __attribute__((export_name("TS_PaymentPurpose_invoice_payment"))) TS_PaymentPurpose_invoice_payment(int8_tArray payment_preimage, int8_tArray payment_secret) {
21642 LDKThirtyTwoBytes payment_preimage_ref;
21643 CHECK(payment_preimage->arr_len == 32);
21644 memcpy(payment_preimage_ref.data, payment_preimage->elems, 32); FREE(payment_preimage);
21645 LDKThirtyTwoBytes payment_secret_ref;
21646 CHECK(payment_secret->arr_len == 32);
21647 memcpy(payment_secret_ref.data, payment_secret->elems, 32); FREE(payment_secret);
21648 LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
21649 *ret_copy = PaymentPurpose_invoice_payment(payment_preimage_ref, payment_secret_ref);
21650 uint64_t ret_ref = tag_ptr(ret_copy, true);
21654 uint64_t __attribute__((export_name("TS_PaymentPurpose_spontaneous_payment"))) TS_PaymentPurpose_spontaneous_payment(int8_tArray a) {
21655 LDKThirtyTwoBytes a_ref;
21656 CHECK(a->arr_len == 32);
21657 memcpy(a_ref.data, a->elems, 32); FREE(a);
21658 LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
21659 *ret_copy = PaymentPurpose_spontaneous_payment(a_ref);
21660 uint64_t ret_ref = tag_ptr(ret_copy, true);
21664 int8_tArray __attribute__((export_name("TS_PaymentPurpose_write"))) TS_PaymentPurpose_write(uint64_t obj) {
21665 LDKPaymentPurpose* obj_conv = (LDKPaymentPurpose*)untag_ptr(obj);
21666 LDKCVec_u8Z ret_var = PaymentPurpose_write(obj_conv);
21667 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
21668 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
21669 CVec_u8Z_free(ret_var);
21673 uint64_t __attribute__((export_name("TS_PaymentPurpose_read"))) TS_PaymentPurpose_read(int8_tArray ser) {
21674 LDKu8slice ser_ref;
21675 ser_ref.datalen = ser->arr_len;
21676 ser_ref.data = ser->elems;
21677 LDKCResult_PaymentPurposeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPurposeDecodeErrorZ), "LDKCResult_PaymentPurposeDecodeErrorZ");
21678 *ret_conv = PaymentPurpose_read(ser_ref);
21680 return tag_ptr(ret_conv, true);
21683 void __attribute__((export_name("TS_ClosureReason_free"))) TS_ClosureReason_free(uint64_t this_ptr) {
21684 if (!ptr_is_owned(this_ptr)) return;
21685 void* this_ptr_ptr = untag_ptr(this_ptr);
21686 CHECK_ACCESS(this_ptr_ptr);
21687 LDKClosureReason this_ptr_conv = *(LDKClosureReason*)(this_ptr_ptr);
21688 FREE(untag_ptr(this_ptr));
21689 ClosureReason_free(this_ptr_conv);
21692 static inline uint64_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg) {
21693 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
21694 *ret_copy = ClosureReason_clone(arg);
21695 uint64_t ret_ref = tag_ptr(ret_copy, true);
21698 int64_t __attribute__((export_name("TS_ClosureReason_clone_ptr"))) TS_ClosureReason_clone_ptr(uint64_t arg) {
21699 LDKClosureReason* arg_conv = (LDKClosureReason*)untag_ptr(arg);
21700 int64_t ret_conv = ClosureReason_clone_ptr(arg_conv);
21704 uint64_t __attribute__((export_name("TS_ClosureReason_clone"))) TS_ClosureReason_clone(uint64_t orig) {
21705 LDKClosureReason* orig_conv = (LDKClosureReason*)untag_ptr(orig);
21706 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
21707 *ret_copy = ClosureReason_clone(orig_conv);
21708 uint64_t ret_ref = tag_ptr(ret_copy, true);
21712 uint64_t __attribute__((export_name("TS_ClosureReason_counterparty_force_closed"))) TS_ClosureReason_counterparty_force_closed(jstring peer_msg) {
21713 LDKStr peer_msg_conv = str_ref_to_owned_c(peer_msg);
21714 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
21715 *ret_copy = ClosureReason_counterparty_force_closed(peer_msg_conv);
21716 uint64_t ret_ref = tag_ptr(ret_copy, true);
21720 uint64_t __attribute__((export_name("TS_ClosureReason_holder_force_closed"))) TS_ClosureReason_holder_force_closed() {
21721 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
21722 *ret_copy = ClosureReason_holder_force_closed();
21723 uint64_t ret_ref = tag_ptr(ret_copy, true);
21727 uint64_t __attribute__((export_name("TS_ClosureReason_cooperative_closure"))) TS_ClosureReason_cooperative_closure() {
21728 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
21729 *ret_copy = ClosureReason_cooperative_closure();
21730 uint64_t ret_ref = tag_ptr(ret_copy, true);
21734 uint64_t __attribute__((export_name("TS_ClosureReason_commitment_tx_confirmed"))) TS_ClosureReason_commitment_tx_confirmed() {
21735 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
21736 *ret_copy = ClosureReason_commitment_tx_confirmed();
21737 uint64_t ret_ref = tag_ptr(ret_copy, true);
21741 uint64_t __attribute__((export_name("TS_ClosureReason_funding_timed_out"))) TS_ClosureReason_funding_timed_out() {
21742 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
21743 *ret_copy = ClosureReason_funding_timed_out();
21744 uint64_t ret_ref = tag_ptr(ret_copy, true);
21748 uint64_t __attribute__((export_name("TS_ClosureReason_processing_error"))) TS_ClosureReason_processing_error(jstring err) {
21749 LDKStr err_conv = str_ref_to_owned_c(err);
21750 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
21751 *ret_copy = ClosureReason_processing_error(err_conv);
21752 uint64_t ret_ref = tag_ptr(ret_copy, true);
21756 uint64_t __attribute__((export_name("TS_ClosureReason_disconnected_peer"))) TS_ClosureReason_disconnected_peer() {
21757 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
21758 *ret_copy = ClosureReason_disconnected_peer();
21759 uint64_t ret_ref = tag_ptr(ret_copy, true);
21763 uint64_t __attribute__((export_name("TS_ClosureReason_outdated_channel_manager"))) TS_ClosureReason_outdated_channel_manager() {
21764 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
21765 *ret_copy = ClosureReason_outdated_channel_manager();
21766 uint64_t ret_ref = tag_ptr(ret_copy, true);
21770 jboolean __attribute__((export_name("TS_ClosureReason_eq"))) TS_ClosureReason_eq(uint64_t a, uint64_t b) {
21771 LDKClosureReason* a_conv = (LDKClosureReason*)untag_ptr(a);
21772 LDKClosureReason* b_conv = (LDKClosureReason*)untag_ptr(b);
21773 jboolean ret_conv = ClosureReason_eq(a_conv, b_conv);
21777 int8_tArray __attribute__((export_name("TS_ClosureReason_write"))) TS_ClosureReason_write(uint64_t obj) {
21778 LDKClosureReason* obj_conv = (LDKClosureReason*)untag_ptr(obj);
21779 LDKCVec_u8Z ret_var = ClosureReason_write(obj_conv);
21780 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
21781 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
21782 CVec_u8Z_free(ret_var);
21786 uint64_t __attribute__((export_name("TS_ClosureReason_read"))) TS_ClosureReason_read(int8_tArray ser) {
21787 LDKu8slice ser_ref;
21788 ser_ref.datalen = ser->arr_len;
21789 ser_ref.data = ser->elems;
21790 LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
21791 *ret_conv = ClosureReason_read(ser_ref);
21793 return tag_ptr(ret_conv, true);
21796 void __attribute__((export_name("TS_HTLCDestination_free"))) TS_HTLCDestination_free(uint64_t this_ptr) {
21797 if (!ptr_is_owned(this_ptr)) return;
21798 void* this_ptr_ptr = untag_ptr(this_ptr);
21799 CHECK_ACCESS(this_ptr_ptr);
21800 LDKHTLCDestination this_ptr_conv = *(LDKHTLCDestination*)(this_ptr_ptr);
21801 FREE(untag_ptr(this_ptr));
21802 HTLCDestination_free(this_ptr_conv);
21805 static inline uint64_t HTLCDestination_clone_ptr(LDKHTLCDestination *NONNULL_PTR arg) {
21806 LDKHTLCDestination *ret_copy = MALLOC(sizeof(LDKHTLCDestination), "LDKHTLCDestination");
21807 *ret_copy = HTLCDestination_clone(arg);
21808 uint64_t ret_ref = tag_ptr(ret_copy, true);
21811 int64_t __attribute__((export_name("TS_HTLCDestination_clone_ptr"))) TS_HTLCDestination_clone_ptr(uint64_t arg) {
21812 LDKHTLCDestination* arg_conv = (LDKHTLCDestination*)untag_ptr(arg);
21813 int64_t ret_conv = HTLCDestination_clone_ptr(arg_conv);
21817 uint64_t __attribute__((export_name("TS_HTLCDestination_clone"))) TS_HTLCDestination_clone(uint64_t orig) {
21818 LDKHTLCDestination* orig_conv = (LDKHTLCDestination*)untag_ptr(orig);
21819 LDKHTLCDestination *ret_copy = MALLOC(sizeof(LDKHTLCDestination), "LDKHTLCDestination");
21820 *ret_copy = HTLCDestination_clone(orig_conv);
21821 uint64_t ret_ref = tag_ptr(ret_copy, true);
21825 uint64_t __attribute__((export_name("TS_HTLCDestination_next_hop_channel"))) TS_HTLCDestination_next_hop_channel(int8_tArray node_id, int8_tArray channel_id) {
21826 LDKPublicKey node_id_ref;
21827 CHECK(node_id->arr_len == 33);
21828 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
21829 LDKThirtyTwoBytes channel_id_ref;
21830 CHECK(channel_id->arr_len == 32);
21831 memcpy(channel_id_ref.data, channel_id->elems, 32); FREE(channel_id);
21832 LDKHTLCDestination *ret_copy = MALLOC(sizeof(LDKHTLCDestination), "LDKHTLCDestination");
21833 *ret_copy = HTLCDestination_next_hop_channel(node_id_ref, channel_id_ref);
21834 uint64_t ret_ref = tag_ptr(ret_copy, true);
21838 uint64_t __attribute__((export_name("TS_HTLCDestination_unknown_next_hop"))) TS_HTLCDestination_unknown_next_hop(int64_t requested_forward_scid) {
21839 LDKHTLCDestination *ret_copy = MALLOC(sizeof(LDKHTLCDestination), "LDKHTLCDestination");
21840 *ret_copy = HTLCDestination_unknown_next_hop(requested_forward_scid);
21841 uint64_t ret_ref = tag_ptr(ret_copy, true);
21845 uint64_t __attribute__((export_name("TS_HTLCDestination_invalid_forward"))) TS_HTLCDestination_invalid_forward(int64_t requested_forward_scid) {
21846 LDKHTLCDestination *ret_copy = MALLOC(sizeof(LDKHTLCDestination), "LDKHTLCDestination");
21847 *ret_copy = HTLCDestination_invalid_forward(requested_forward_scid);
21848 uint64_t ret_ref = tag_ptr(ret_copy, true);
21852 uint64_t __attribute__((export_name("TS_HTLCDestination_failed_payment"))) TS_HTLCDestination_failed_payment(int8_tArray payment_hash) {
21853 LDKThirtyTwoBytes payment_hash_ref;
21854 CHECK(payment_hash->arr_len == 32);
21855 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
21856 LDKHTLCDestination *ret_copy = MALLOC(sizeof(LDKHTLCDestination), "LDKHTLCDestination");
21857 *ret_copy = HTLCDestination_failed_payment(payment_hash_ref);
21858 uint64_t ret_ref = tag_ptr(ret_copy, true);
21862 jboolean __attribute__((export_name("TS_HTLCDestination_eq"))) TS_HTLCDestination_eq(uint64_t a, uint64_t b) {
21863 LDKHTLCDestination* a_conv = (LDKHTLCDestination*)untag_ptr(a);
21864 LDKHTLCDestination* b_conv = (LDKHTLCDestination*)untag_ptr(b);
21865 jboolean ret_conv = HTLCDestination_eq(a_conv, b_conv);
21869 int8_tArray __attribute__((export_name("TS_HTLCDestination_write"))) TS_HTLCDestination_write(uint64_t obj) {
21870 LDKHTLCDestination* obj_conv = (LDKHTLCDestination*)untag_ptr(obj);
21871 LDKCVec_u8Z ret_var = HTLCDestination_write(obj_conv);
21872 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
21873 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
21874 CVec_u8Z_free(ret_var);
21878 uint64_t __attribute__((export_name("TS_HTLCDestination_read"))) TS_HTLCDestination_read(int8_tArray ser) {
21879 LDKu8slice ser_ref;
21880 ser_ref.datalen = ser->arr_len;
21881 ser_ref.data = ser->elems;
21882 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ), "LDKCResult_COption_HTLCDestinationZDecodeErrorZ");
21883 *ret_conv = HTLCDestination_read(ser_ref);
21885 return tag_ptr(ret_conv, true);
21888 void __attribute__((export_name("TS_Event_free"))) TS_Event_free(uint64_t this_ptr) {
21889 if (!ptr_is_owned(this_ptr)) return;
21890 void* this_ptr_ptr = untag_ptr(this_ptr);
21891 CHECK_ACCESS(this_ptr_ptr);
21892 LDKEvent this_ptr_conv = *(LDKEvent*)(this_ptr_ptr);
21893 FREE(untag_ptr(this_ptr));
21894 Event_free(this_ptr_conv);
21897 static inline uint64_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg) {
21898 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
21899 *ret_copy = Event_clone(arg);
21900 uint64_t ret_ref = tag_ptr(ret_copy, true);
21903 int64_t __attribute__((export_name("TS_Event_clone_ptr"))) TS_Event_clone_ptr(uint64_t arg) {
21904 LDKEvent* arg_conv = (LDKEvent*)untag_ptr(arg);
21905 int64_t ret_conv = Event_clone_ptr(arg_conv);
21909 uint64_t __attribute__((export_name("TS_Event_clone"))) TS_Event_clone(uint64_t orig) {
21910 LDKEvent* orig_conv = (LDKEvent*)untag_ptr(orig);
21911 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
21912 *ret_copy = Event_clone(orig_conv);
21913 uint64_t ret_ref = tag_ptr(ret_copy, true);
21917 uint64_t __attribute__((export_name("TS_Event_funding_generation_ready"))) TS_Event_funding_generation_ready(int8_tArray temporary_channel_id, int8_tArray counterparty_node_id, int64_t channel_value_satoshis, int8_tArray output_script, int8_tArray user_channel_id) {
21918 LDKThirtyTwoBytes temporary_channel_id_ref;
21919 CHECK(temporary_channel_id->arr_len == 32);
21920 memcpy(temporary_channel_id_ref.data, temporary_channel_id->elems, 32); FREE(temporary_channel_id);
21921 LDKPublicKey counterparty_node_id_ref;
21922 CHECK(counterparty_node_id->arr_len == 33);
21923 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
21924 LDKCVec_u8Z output_script_ref;
21925 output_script_ref.datalen = output_script->arr_len;
21926 output_script_ref.data = MALLOC(output_script_ref.datalen, "LDKCVec_u8Z Bytes");
21927 memcpy(output_script_ref.data, output_script->elems, output_script_ref.datalen); FREE(output_script);
21928 LDKU128 user_channel_id_ref;
21929 CHECK(user_channel_id->arr_len == 16);
21930 memcpy(user_channel_id_ref.le_bytes, user_channel_id->elems, 16); FREE(user_channel_id);
21931 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
21932 *ret_copy = Event_funding_generation_ready(temporary_channel_id_ref, counterparty_node_id_ref, channel_value_satoshis, output_script_ref, user_channel_id_ref);
21933 uint64_t ret_ref = tag_ptr(ret_copy, true);
21937 uint64_t __attribute__((export_name("TS_Event_payment_claimable"))) TS_Event_payment_claimable(int8_tArray receiver_node_id, int8_tArray payment_hash, int64_t amount_msat, uint64_t purpose, int8_tArray via_channel_id, uint64_t via_user_channel_id) {
21938 LDKPublicKey receiver_node_id_ref;
21939 CHECK(receiver_node_id->arr_len == 33);
21940 memcpy(receiver_node_id_ref.compressed_form, receiver_node_id->elems, 33); FREE(receiver_node_id);
21941 LDKThirtyTwoBytes payment_hash_ref;
21942 CHECK(payment_hash->arr_len == 32);
21943 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
21944 void* purpose_ptr = untag_ptr(purpose);
21945 CHECK_ACCESS(purpose_ptr);
21946 LDKPaymentPurpose purpose_conv = *(LDKPaymentPurpose*)(purpose_ptr);
21947 purpose_conv = PaymentPurpose_clone((LDKPaymentPurpose*)untag_ptr(purpose));
21948 LDKThirtyTwoBytes via_channel_id_ref;
21949 CHECK(via_channel_id->arr_len == 32);
21950 memcpy(via_channel_id_ref.data, via_channel_id->elems, 32); FREE(via_channel_id);
21951 void* via_user_channel_id_ptr = untag_ptr(via_user_channel_id);
21952 CHECK_ACCESS(via_user_channel_id_ptr);
21953 LDKCOption_u128Z via_user_channel_id_conv = *(LDKCOption_u128Z*)(via_user_channel_id_ptr);
21954 via_user_channel_id_conv = COption_u128Z_clone((LDKCOption_u128Z*)untag_ptr(via_user_channel_id));
21955 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
21956 *ret_copy = Event_payment_claimable(receiver_node_id_ref, payment_hash_ref, amount_msat, purpose_conv, via_channel_id_ref, via_user_channel_id_conv);
21957 uint64_t ret_ref = tag_ptr(ret_copy, true);
21961 uint64_t __attribute__((export_name("TS_Event_payment_claimed"))) TS_Event_payment_claimed(int8_tArray receiver_node_id, int8_tArray payment_hash, int64_t amount_msat, uint64_t purpose) {
21962 LDKPublicKey receiver_node_id_ref;
21963 CHECK(receiver_node_id->arr_len == 33);
21964 memcpy(receiver_node_id_ref.compressed_form, receiver_node_id->elems, 33); FREE(receiver_node_id);
21965 LDKThirtyTwoBytes payment_hash_ref;
21966 CHECK(payment_hash->arr_len == 32);
21967 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
21968 void* purpose_ptr = untag_ptr(purpose);
21969 CHECK_ACCESS(purpose_ptr);
21970 LDKPaymentPurpose purpose_conv = *(LDKPaymentPurpose*)(purpose_ptr);
21971 purpose_conv = PaymentPurpose_clone((LDKPaymentPurpose*)untag_ptr(purpose));
21972 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
21973 *ret_copy = Event_payment_claimed(receiver_node_id_ref, payment_hash_ref, amount_msat, purpose_conv);
21974 uint64_t ret_ref = tag_ptr(ret_copy, true);
21978 uint64_t __attribute__((export_name("TS_Event_payment_sent"))) TS_Event_payment_sent(int8_tArray payment_id, int8_tArray payment_preimage, int8_tArray payment_hash, uint64_t fee_paid_msat) {
21979 LDKThirtyTwoBytes payment_id_ref;
21980 CHECK(payment_id->arr_len == 32);
21981 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
21982 LDKThirtyTwoBytes payment_preimage_ref;
21983 CHECK(payment_preimage->arr_len == 32);
21984 memcpy(payment_preimage_ref.data, payment_preimage->elems, 32); FREE(payment_preimage);
21985 LDKThirtyTwoBytes payment_hash_ref;
21986 CHECK(payment_hash->arr_len == 32);
21987 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
21988 void* fee_paid_msat_ptr = untag_ptr(fee_paid_msat);
21989 CHECK_ACCESS(fee_paid_msat_ptr);
21990 LDKCOption_u64Z fee_paid_msat_conv = *(LDKCOption_u64Z*)(fee_paid_msat_ptr);
21991 fee_paid_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(fee_paid_msat));
21992 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
21993 *ret_copy = Event_payment_sent(payment_id_ref, payment_preimage_ref, payment_hash_ref, fee_paid_msat_conv);
21994 uint64_t ret_ref = tag_ptr(ret_copy, true);
21998 uint64_t __attribute__((export_name("TS_Event_payment_failed"))) TS_Event_payment_failed(int8_tArray payment_id, int8_tArray payment_hash) {
21999 LDKThirtyTwoBytes payment_id_ref;
22000 CHECK(payment_id->arr_len == 32);
22001 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
22002 LDKThirtyTwoBytes payment_hash_ref;
22003 CHECK(payment_hash->arr_len == 32);
22004 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
22005 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
22006 *ret_copy = Event_payment_failed(payment_id_ref, payment_hash_ref);
22007 uint64_t ret_ref = tag_ptr(ret_copy, true);
22011 uint64_t __attribute__((export_name("TS_Event_payment_path_successful"))) TS_Event_payment_path_successful(int8_tArray payment_id, int8_tArray payment_hash, uint64_tArray path) {
22012 LDKThirtyTwoBytes payment_id_ref;
22013 CHECK(payment_id->arr_len == 32);
22014 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
22015 LDKThirtyTwoBytes payment_hash_ref;
22016 CHECK(payment_hash->arr_len == 32);
22017 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
22018 LDKCVec_RouteHopZ path_constr;
22019 path_constr.datalen = path->arr_len;
22020 if (path_constr.datalen > 0)
22021 path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
22023 path_constr.data = NULL;
22024 uint64_t* path_vals = path->elems;
22025 for (size_t k = 0; k < path_constr.datalen; k++) {
22026 uint64_t path_conv_10 = path_vals[k];
22027 LDKRouteHop path_conv_10_conv;
22028 path_conv_10_conv.inner = untag_ptr(path_conv_10);
22029 path_conv_10_conv.is_owned = ptr_is_owned(path_conv_10);
22030 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
22031 path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
22032 path_constr.data[k] = path_conv_10_conv;
22035 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
22036 *ret_copy = Event_payment_path_successful(payment_id_ref, payment_hash_ref, path_constr);
22037 uint64_t ret_ref = tag_ptr(ret_copy, true);
22041 uint64_t __attribute__((export_name("TS_Event_payment_path_failed"))) TS_Event_payment_path_failed(int8_tArray payment_id, int8_tArray payment_hash, jboolean payment_failed_permanently, uint64_t network_update, jboolean all_paths_failed, uint64_tArray path, uint64_t short_channel_id, uint64_t retry) {
22042 LDKThirtyTwoBytes payment_id_ref;
22043 CHECK(payment_id->arr_len == 32);
22044 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
22045 LDKThirtyTwoBytes payment_hash_ref;
22046 CHECK(payment_hash->arr_len == 32);
22047 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
22048 void* network_update_ptr = untag_ptr(network_update);
22049 CHECK_ACCESS(network_update_ptr);
22050 LDKCOption_NetworkUpdateZ network_update_conv = *(LDKCOption_NetworkUpdateZ*)(network_update_ptr);
22051 network_update_conv = COption_NetworkUpdateZ_clone((LDKCOption_NetworkUpdateZ*)untag_ptr(network_update));
22052 LDKCVec_RouteHopZ path_constr;
22053 path_constr.datalen = path->arr_len;
22054 if (path_constr.datalen > 0)
22055 path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
22057 path_constr.data = NULL;
22058 uint64_t* path_vals = path->elems;
22059 for (size_t k = 0; k < path_constr.datalen; k++) {
22060 uint64_t path_conv_10 = path_vals[k];
22061 LDKRouteHop path_conv_10_conv;
22062 path_conv_10_conv.inner = untag_ptr(path_conv_10);
22063 path_conv_10_conv.is_owned = ptr_is_owned(path_conv_10);
22064 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
22065 path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
22066 path_constr.data[k] = path_conv_10_conv;
22069 void* short_channel_id_ptr = untag_ptr(short_channel_id);
22070 CHECK_ACCESS(short_channel_id_ptr);
22071 LDKCOption_u64Z short_channel_id_conv = *(LDKCOption_u64Z*)(short_channel_id_ptr);
22072 short_channel_id_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(short_channel_id));
22073 LDKRouteParameters retry_conv;
22074 retry_conv.inner = untag_ptr(retry);
22075 retry_conv.is_owned = ptr_is_owned(retry);
22076 CHECK_INNER_FIELD_ACCESS_OR_NULL(retry_conv);
22077 retry_conv = RouteParameters_clone(&retry_conv);
22078 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
22079 *ret_copy = Event_payment_path_failed(payment_id_ref, payment_hash_ref, payment_failed_permanently, network_update_conv, all_paths_failed, path_constr, short_channel_id_conv, retry_conv);
22080 uint64_t ret_ref = tag_ptr(ret_copy, true);
22084 uint64_t __attribute__((export_name("TS_Event_probe_successful"))) TS_Event_probe_successful(int8_tArray payment_id, int8_tArray payment_hash, uint64_tArray path) {
22085 LDKThirtyTwoBytes payment_id_ref;
22086 CHECK(payment_id->arr_len == 32);
22087 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
22088 LDKThirtyTwoBytes payment_hash_ref;
22089 CHECK(payment_hash->arr_len == 32);
22090 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
22091 LDKCVec_RouteHopZ path_constr;
22092 path_constr.datalen = path->arr_len;
22093 if (path_constr.datalen > 0)
22094 path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
22096 path_constr.data = NULL;
22097 uint64_t* path_vals = path->elems;
22098 for (size_t k = 0; k < path_constr.datalen; k++) {
22099 uint64_t path_conv_10 = path_vals[k];
22100 LDKRouteHop path_conv_10_conv;
22101 path_conv_10_conv.inner = untag_ptr(path_conv_10);
22102 path_conv_10_conv.is_owned = ptr_is_owned(path_conv_10);
22103 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
22104 path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
22105 path_constr.data[k] = path_conv_10_conv;
22108 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
22109 *ret_copy = Event_probe_successful(payment_id_ref, payment_hash_ref, path_constr);
22110 uint64_t ret_ref = tag_ptr(ret_copy, true);
22114 uint64_t __attribute__((export_name("TS_Event_probe_failed"))) TS_Event_probe_failed(int8_tArray payment_id, int8_tArray payment_hash, uint64_tArray path, uint64_t short_channel_id) {
22115 LDKThirtyTwoBytes payment_id_ref;
22116 CHECK(payment_id->arr_len == 32);
22117 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
22118 LDKThirtyTwoBytes payment_hash_ref;
22119 CHECK(payment_hash->arr_len == 32);
22120 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
22121 LDKCVec_RouteHopZ path_constr;
22122 path_constr.datalen = path->arr_len;
22123 if (path_constr.datalen > 0)
22124 path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
22126 path_constr.data = NULL;
22127 uint64_t* path_vals = path->elems;
22128 for (size_t k = 0; k < path_constr.datalen; k++) {
22129 uint64_t path_conv_10 = path_vals[k];
22130 LDKRouteHop path_conv_10_conv;
22131 path_conv_10_conv.inner = untag_ptr(path_conv_10);
22132 path_conv_10_conv.is_owned = ptr_is_owned(path_conv_10);
22133 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
22134 path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
22135 path_constr.data[k] = path_conv_10_conv;
22138 void* short_channel_id_ptr = untag_ptr(short_channel_id);
22139 CHECK_ACCESS(short_channel_id_ptr);
22140 LDKCOption_u64Z short_channel_id_conv = *(LDKCOption_u64Z*)(short_channel_id_ptr);
22141 short_channel_id_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(short_channel_id));
22142 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
22143 *ret_copy = Event_probe_failed(payment_id_ref, payment_hash_ref, path_constr, short_channel_id_conv);
22144 uint64_t ret_ref = tag_ptr(ret_copy, true);
22148 uint64_t __attribute__((export_name("TS_Event_pending_htlcs_forwardable"))) TS_Event_pending_htlcs_forwardable(int64_t time_forwardable) {
22149 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
22150 *ret_copy = Event_pending_htlcs_forwardable(time_forwardable);
22151 uint64_t ret_ref = tag_ptr(ret_copy, true);
22155 uint64_t __attribute__((export_name("TS_Event_htlcintercepted"))) TS_Event_htlcintercepted(int8_tArray intercept_id, int64_t requested_next_hop_scid, int8_tArray payment_hash, int64_t inbound_amount_msat, int64_t expected_outbound_amount_msat) {
22156 LDKThirtyTwoBytes intercept_id_ref;
22157 CHECK(intercept_id->arr_len == 32);
22158 memcpy(intercept_id_ref.data, intercept_id->elems, 32); FREE(intercept_id);
22159 LDKThirtyTwoBytes payment_hash_ref;
22160 CHECK(payment_hash->arr_len == 32);
22161 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
22162 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
22163 *ret_copy = Event_htlcintercepted(intercept_id_ref, requested_next_hop_scid, payment_hash_ref, inbound_amount_msat, expected_outbound_amount_msat);
22164 uint64_t ret_ref = tag_ptr(ret_copy, true);
22168 uint64_t __attribute__((export_name("TS_Event_spendable_outputs"))) TS_Event_spendable_outputs(uint64_tArray outputs) {
22169 LDKCVec_SpendableOutputDescriptorZ outputs_constr;
22170 outputs_constr.datalen = outputs->arr_len;
22171 if (outputs_constr.datalen > 0)
22172 outputs_constr.data = MALLOC(outputs_constr.datalen * sizeof(LDKSpendableOutputDescriptor), "LDKCVec_SpendableOutputDescriptorZ Elements");
22174 outputs_constr.data = NULL;
22175 uint64_t* outputs_vals = outputs->elems;
22176 for (size_t b = 0; b < outputs_constr.datalen; b++) {
22177 uint64_t outputs_conv_27 = outputs_vals[b];
22178 void* outputs_conv_27_ptr = untag_ptr(outputs_conv_27);
22179 CHECK_ACCESS(outputs_conv_27_ptr);
22180 LDKSpendableOutputDescriptor outputs_conv_27_conv = *(LDKSpendableOutputDescriptor*)(outputs_conv_27_ptr);
22181 outputs_conv_27_conv = SpendableOutputDescriptor_clone((LDKSpendableOutputDescriptor*)untag_ptr(outputs_conv_27));
22182 outputs_constr.data[b] = outputs_conv_27_conv;
22185 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
22186 *ret_copy = Event_spendable_outputs(outputs_constr);
22187 uint64_t ret_ref = tag_ptr(ret_copy, true);
22191 uint64_t __attribute__((export_name("TS_Event_payment_forwarded"))) TS_Event_payment_forwarded(int8_tArray prev_channel_id, int8_tArray next_channel_id, uint64_t fee_earned_msat, jboolean claim_from_onchain_tx) {
22192 LDKThirtyTwoBytes prev_channel_id_ref;
22193 CHECK(prev_channel_id->arr_len == 32);
22194 memcpy(prev_channel_id_ref.data, prev_channel_id->elems, 32); FREE(prev_channel_id);
22195 LDKThirtyTwoBytes next_channel_id_ref;
22196 CHECK(next_channel_id->arr_len == 32);
22197 memcpy(next_channel_id_ref.data, next_channel_id->elems, 32); FREE(next_channel_id);
22198 void* fee_earned_msat_ptr = untag_ptr(fee_earned_msat);
22199 CHECK_ACCESS(fee_earned_msat_ptr);
22200 LDKCOption_u64Z fee_earned_msat_conv = *(LDKCOption_u64Z*)(fee_earned_msat_ptr);
22201 fee_earned_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(fee_earned_msat));
22202 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
22203 *ret_copy = Event_payment_forwarded(prev_channel_id_ref, next_channel_id_ref, fee_earned_msat_conv, claim_from_onchain_tx);
22204 uint64_t ret_ref = tag_ptr(ret_copy, true);
22208 uint64_t __attribute__((export_name("TS_Event_channel_ready"))) TS_Event_channel_ready(int8_tArray channel_id, int8_tArray user_channel_id, int8_tArray counterparty_node_id, uint64_t channel_type) {
22209 LDKThirtyTwoBytes channel_id_ref;
22210 CHECK(channel_id->arr_len == 32);
22211 memcpy(channel_id_ref.data, channel_id->elems, 32); FREE(channel_id);
22212 LDKU128 user_channel_id_ref;
22213 CHECK(user_channel_id->arr_len == 16);
22214 memcpy(user_channel_id_ref.le_bytes, user_channel_id->elems, 16); FREE(user_channel_id);
22215 LDKPublicKey counterparty_node_id_ref;
22216 CHECK(counterparty_node_id->arr_len == 33);
22217 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
22218 LDKChannelTypeFeatures channel_type_conv;
22219 channel_type_conv.inner = untag_ptr(channel_type);
22220 channel_type_conv.is_owned = ptr_is_owned(channel_type);
22221 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_conv);
22222 channel_type_conv = ChannelTypeFeatures_clone(&channel_type_conv);
22223 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
22224 *ret_copy = Event_channel_ready(channel_id_ref, user_channel_id_ref, counterparty_node_id_ref, channel_type_conv);
22225 uint64_t ret_ref = tag_ptr(ret_copy, true);
22229 uint64_t __attribute__((export_name("TS_Event_channel_closed"))) TS_Event_channel_closed(int8_tArray channel_id, int8_tArray user_channel_id, uint64_t reason) {
22230 LDKThirtyTwoBytes channel_id_ref;
22231 CHECK(channel_id->arr_len == 32);
22232 memcpy(channel_id_ref.data, channel_id->elems, 32); FREE(channel_id);
22233 LDKU128 user_channel_id_ref;
22234 CHECK(user_channel_id->arr_len == 16);
22235 memcpy(user_channel_id_ref.le_bytes, user_channel_id->elems, 16); FREE(user_channel_id);
22236 void* reason_ptr = untag_ptr(reason);
22237 CHECK_ACCESS(reason_ptr);
22238 LDKClosureReason reason_conv = *(LDKClosureReason*)(reason_ptr);
22239 reason_conv = ClosureReason_clone((LDKClosureReason*)untag_ptr(reason));
22240 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
22241 *ret_copy = Event_channel_closed(channel_id_ref, user_channel_id_ref, reason_conv);
22242 uint64_t ret_ref = tag_ptr(ret_copy, true);
22246 uint64_t __attribute__((export_name("TS_Event_discard_funding"))) TS_Event_discard_funding(int8_tArray channel_id, int8_tArray transaction) {
22247 LDKThirtyTwoBytes channel_id_ref;
22248 CHECK(channel_id->arr_len == 32);
22249 memcpy(channel_id_ref.data, channel_id->elems, 32); FREE(channel_id);
22250 LDKTransaction transaction_ref;
22251 transaction_ref.datalen = transaction->arr_len;
22252 transaction_ref.data = MALLOC(transaction_ref.datalen, "LDKTransaction Bytes");
22253 memcpy(transaction_ref.data, transaction->elems, transaction_ref.datalen); FREE(transaction);
22254 transaction_ref.data_is_owned = true;
22255 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
22256 *ret_copy = Event_discard_funding(channel_id_ref, transaction_ref);
22257 uint64_t ret_ref = tag_ptr(ret_copy, true);
22261 uint64_t __attribute__((export_name("TS_Event_open_channel_request"))) TS_Event_open_channel_request(int8_tArray temporary_channel_id, int8_tArray counterparty_node_id, int64_t funding_satoshis, int64_t push_msat, uint64_t channel_type) {
22262 LDKThirtyTwoBytes temporary_channel_id_ref;
22263 CHECK(temporary_channel_id->arr_len == 32);
22264 memcpy(temporary_channel_id_ref.data, temporary_channel_id->elems, 32); FREE(temporary_channel_id);
22265 LDKPublicKey counterparty_node_id_ref;
22266 CHECK(counterparty_node_id->arr_len == 33);
22267 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
22268 LDKChannelTypeFeatures channel_type_conv;
22269 channel_type_conv.inner = untag_ptr(channel_type);
22270 channel_type_conv.is_owned = ptr_is_owned(channel_type);
22271 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_conv);
22272 channel_type_conv = ChannelTypeFeatures_clone(&channel_type_conv);
22273 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
22274 *ret_copy = Event_open_channel_request(temporary_channel_id_ref, counterparty_node_id_ref, funding_satoshis, push_msat, channel_type_conv);
22275 uint64_t ret_ref = tag_ptr(ret_copy, true);
22279 uint64_t __attribute__((export_name("TS_Event_htlchandling_failed"))) TS_Event_htlchandling_failed(int8_tArray prev_channel_id, uint64_t failed_next_destination) {
22280 LDKThirtyTwoBytes prev_channel_id_ref;
22281 CHECK(prev_channel_id->arr_len == 32);
22282 memcpy(prev_channel_id_ref.data, prev_channel_id->elems, 32); FREE(prev_channel_id);
22283 void* failed_next_destination_ptr = untag_ptr(failed_next_destination);
22284 CHECK_ACCESS(failed_next_destination_ptr);
22285 LDKHTLCDestination failed_next_destination_conv = *(LDKHTLCDestination*)(failed_next_destination_ptr);
22286 failed_next_destination_conv = HTLCDestination_clone((LDKHTLCDestination*)untag_ptr(failed_next_destination));
22287 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
22288 *ret_copy = Event_htlchandling_failed(prev_channel_id_ref, failed_next_destination_conv);
22289 uint64_t ret_ref = tag_ptr(ret_copy, true);
22293 int8_tArray __attribute__((export_name("TS_Event_write"))) TS_Event_write(uint64_t obj) {
22294 LDKEvent* obj_conv = (LDKEvent*)untag_ptr(obj);
22295 LDKCVec_u8Z ret_var = Event_write(obj_conv);
22296 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
22297 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
22298 CVec_u8Z_free(ret_var);
22302 uint64_t __attribute__((export_name("TS_Event_read"))) TS_Event_read(int8_tArray ser) {
22303 LDKu8slice ser_ref;
22304 ser_ref.datalen = ser->arr_len;
22305 ser_ref.data = ser->elems;
22306 LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
22307 *ret_conv = Event_read(ser_ref);
22309 return tag_ptr(ret_conv, true);
22312 void __attribute__((export_name("TS_MessageSendEvent_free"))) TS_MessageSendEvent_free(uint64_t this_ptr) {
22313 if (!ptr_is_owned(this_ptr)) return;
22314 void* this_ptr_ptr = untag_ptr(this_ptr);
22315 CHECK_ACCESS(this_ptr_ptr);
22316 LDKMessageSendEvent this_ptr_conv = *(LDKMessageSendEvent*)(this_ptr_ptr);
22317 FREE(untag_ptr(this_ptr));
22318 MessageSendEvent_free(this_ptr_conv);
22321 static inline uint64_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg) {
22322 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
22323 *ret_copy = MessageSendEvent_clone(arg);
22324 uint64_t ret_ref = tag_ptr(ret_copy, true);
22327 int64_t __attribute__((export_name("TS_MessageSendEvent_clone_ptr"))) TS_MessageSendEvent_clone_ptr(uint64_t arg) {
22328 LDKMessageSendEvent* arg_conv = (LDKMessageSendEvent*)untag_ptr(arg);
22329 int64_t ret_conv = MessageSendEvent_clone_ptr(arg_conv);
22333 uint64_t __attribute__((export_name("TS_MessageSendEvent_clone"))) TS_MessageSendEvent_clone(uint64_t orig) {
22334 LDKMessageSendEvent* orig_conv = (LDKMessageSendEvent*)untag_ptr(orig);
22335 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
22336 *ret_copy = MessageSendEvent_clone(orig_conv);
22337 uint64_t ret_ref = tag_ptr(ret_copy, true);
22341 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_accept_channel"))) TS_MessageSendEvent_send_accept_channel(int8_tArray node_id, uint64_t msg) {
22342 LDKPublicKey node_id_ref;
22343 CHECK(node_id->arr_len == 33);
22344 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
22345 LDKAcceptChannel msg_conv;
22346 msg_conv.inner = untag_ptr(msg);
22347 msg_conv.is_owned = ptr_is_owned(msg);
22348 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
22349 msg_conv = AcceptChannel_clone(&msg_conv);
22350 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
22351 *ret_copy = MessageSendEvent_send_accept_channel(node_id_ref, msg_conv);
22352 uint64_t ret_ref = tag_ptr(ret_copy, true);
22356 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_open_channel"))) TS_MessageSendEvent_send_open_channel(int8_tArray node_id, uint64_t msg) {
22357 LDKPublicKey node_id_ref;
22358 CHECK(node_id->arr_len == 33);
22359 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
22360 LDKOpenChannel msg_conv;
22361 msg_conv.inner = untag_ptr(msg);
22362 msg_conv.is_owned = ptr_is_owned(msg);
22363 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
22364 msg_conv = OpenChannel_clone(&msg_conv);
22365 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
22366 *ret_copy = MessageSendEvent_send_open_channel(node_id_ref, msg_conv);
22367 uint64_t ret_ref = tag_ptr(ret_copy, true);
22371 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_funding_created"))) TS_MessageSendEvent_send_funding_created(int8_tArray node_id, uint64_t msg) {
22372 LDKPublicKey node_id_ref;
22373 CHECK(node_id->arr_len == 33);
22374 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
22375 LDKFundingCreated msg_conv;
22376 msg_conv.inner = untag_ptr(msg);
22377 msg_conv.is_owned = ptr_is_owned(msg);
22378 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
22379 msg_conv = FundingCreated_clone(&msg_conv);
22380 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
22381 *ret_copy = MessageSendEvent_send_funding_created(node_id_ref, msg_conv);
22382 uint64_t ret_ref = tag_ptr(ret_copy, true);
22386 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_funding_signed"))) TS_MessageSendEvent_send_funding_signed(int8_tArray node_id, uint64_t msg) {
22387 LDKPublicKey node_id_ref;
22388 CHECK(node_id->arr_len == 33);
22389 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
22390 LDKFundingSigned msg_conv;
22391 msg_conv.inner = untag_ptr(msg);
22392 msg_conv.is_owned = ptr_is_owned(msg);
22393 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
22394 msg_conv = FundingSigned_clone(&msg_conv);
22395 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
22396 *ret_copy = MessageSendEvent_send_funding_signed(node_id_ref, msg_conv);
22397 uint64_t ret_ref = tag_ptr(ret_copy, true);
22401 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_channel_ready"))) TS_MessageSendEvent_send_channel_ready(int8_tArray node_id, uint64_t msg) {
22402 LDKPublicKey node_id_ref;
22403 CHECK(node_id->arr_len == 33);
22404 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
22405 LDKChannelReady msg_conv;
22406 msg_conv.inner = untag_ptr(msg);
22407 msg_conv.is_owned = ptr_is_owned(msg);
22408 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
22409 msg_conv = ChannelReady_clone(&msg_conv);
22410 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
22411 *ret_copy = MessageSendEvent_send_channel_ready(node_id_ref, msg_conv);
22412 uint64_t ret_ref = tag_ptr(ret_copy, true);
22416 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_announcement_signatures"))) TS_MessageSendEvent_send_announcement_signatures(int8_tArray node_id, uint64_t msg) {
22417 LDKPublicKey node_id_ref;
22418 CHECK(node_id->arr_len == 33);
22419 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
22420 LDKAnnouncementSignatures msg_conv;
22421 msg_conv.inner = untag_ptr(msg);
22422 msg_conv.is_owned = ptr_is_owned(msg);
22423 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
22424 msg_conv = AnnouncementSignatures_clone(&msg_conv);
22425 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
22426 *ret_copy = MessageSendEvent_send_announcement_signatures(node_id_ref, msg_conv);
22427 uint64_t ret_ref = tag_ptr(ret_copy, true);
22431 uint64_t __attribute__((export_name("TS_MessageSendEvent_update_htlcs"))) TS_MessageSendEvent_update_htlcs(int8_tArray node_id, uint64_t updates) {
22432 LDKPublicKey node_id_ref;
22433 CHECK(node_id->arr_len == 33);
22434 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
22435 LDKCommitmentUpdate updates_conv;
22436 updates_conv.inner = untag_ptr(updates);
22437 updates_conv.is_owned = ptr_is_owned(updates);
22438 CHECK_INNER_FIELD_ACCESS_OR_NULL(updates_conv);
22439 updates_conv = CommitmentUpdate_clone(&updates_conv);
22440 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
22441 *ret_copy = MessageSendEvent_update_htlcs(node_id_ref, updates_conv);
22442 uint64_t ret_ref = tag_ptr(ret_copy, true);
22446 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_revoke_and_ack"))) TS_MessageSendEvent_send_revoke_and_ack(int8_tArray node_id, uint64_t msg) {
22447 LDKPublicKey node_id_ref;
22448 CHECK(node_id->arr_len == 33);
22449 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
22450 LDKRevokeAndACK msg_conv;
22451 msg_conv.inner = untag_ptr(msg);
22452 msg_conv.is_owned = ptr_is_owned(msg);
22453 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
22454 msg_conv = RevokeAndACK_clone(&msg_conv);
22455 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
22456 *ret_copy = MessageSendEvent_send_revoke_and_ack(node_id_ref, msg_conv);
22457 uint64_t ret_ref = tag_ptr(ret_copy, true);
22461 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_closing_signed"))) TS_MessageSendEvent_send_closing_signed(int8_tArray node_id, uint64_t msg) {
22462 LDKPublicKey node_id_ref;
22463 CHECK(node_id->arr_len == 33);
22464 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
22465 LDKClosingSigned msg_conv;
22466 msg_conv.inner = untag_ptr(msg);
22467 msg_conv.is_owned = ptr_is_owned(msg);
22468 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
22469 msg_conv = ClosingSigned_clone(&msg_conv);
22470 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
22471 *ret_copy = MessageSendEvent_send_closing_signed(node_id_ref, msg_conv);
22472 uint64_t ret_ref = tag_ptr(ret_copy, true);
22476 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_shutdown"))) TS_MessageSendEvent_send_shutdown(int8_tArray node_id, uint64_t msg) {
22477 LDKPublicKey node_id_ref;
22478 CHECK(node_id->arr_len == 33);
22479 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
22480 LDKShutdown msg_conv;
22481 msg_conv.inner = untag_ptr(msg);
22482 msg_conv.is_owned = ptr_is_owned(msg);
22483 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
22484 msg_conv = Shutdown_clone(&msg_conv);
22485 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
22486 *ret_copy = MessageSendEvent_send_shutdown(node_id_ref, msg_conv);
22487 uint64_t ret_ref = tag_ptr(ret_copy, true);
22491 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_channel_reestablish"))) TS_MessageSendEvent_send_channel_reestablish(int8_tArray node_id, uint64_t msg) {
22492 LDKPublicKey node_id_ref;
22493 CHECK(node_id->arr_len == 33);
22494 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
22495 LDKChannelReestablish msg_conv;
22496 msg_conv.inner = untag_ptr(msg);
22497 msg_conv.is_owned = ptr_is_owned(msg);
22498 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
22499 msg_conv = ChannelReestablish_clone(&msg_conv);
22500 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
22501 *ret_copy = MessageSendEvent_send_channel_reestablish(node_id_ref, msg_conv);
22502 uint64_t ret_ref = tag_ptr(ret_copy, true);
22506 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_channel_announcement"))) TS_MessageSendEvent_send_channel_announcement(int8_tArray node_id, uint64_t msg, uint64_t update_msg) {
22507 LDKPublicKey node_id_ref;
22508 CHECK(node_id->arr_len == 33);
22509 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
22510 LDKChannelAnnouncement msg_conv;
22511 msg_conv.inner = untag_ptr(msg);
22512 msg_conv.is_owned = ptr_is_owned(msg);
22513 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
22514 msg_conv = ChannelAnnouncement_clone(&msg_conv);
22515 LDKChannelUpdate update_msg_conv;
22516 update_msg_conv.inner = untag_ptr(update_msg);
22517 update_msg_conv.is_owned = ptr_is_owned(update_msg);
22518 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_msg_conv);
22519 update_msg_conv = ChannelUpdate_clone(&update_msg_conv);
22520 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
22521 *ret_copy = MessageSendEvent_send_channel_announcement(node_id_ref, msg_conv, update_msg_conv);
22522 uint64_t ret_ref = tag_ptr(ret_copy, true);
22526 uint64_t __attribute__((export_name("TS_MessageSendEvent_broadcast_channel_announcement"))) TS_MessageSendEvent_broadcast_channel_announcement(uint64_t msg, uint64_t update_msg) {
22527 LDKChannelAnnouncement msg_conv;
22528 msg_conv.inner = untag_ptr(msg);
22529 msg_conv.is_owned = ptr_is_owned(msg);
22530 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
22531 msg_conv = ChannelAnnouncement_clone(&msg_conv);
22532 LDKChannelUpdate update_msg_conv;
22533 update_msg_conv.inner = untag_ptr(update_msg);
22534 update_msg_conv.is_owned = ptr_is_owned(update_msg);
22535 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_msg_conv);
22536 update_msg_conv = ChannelUpdate_clone(&update_msg_conv);
22537 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
22538 *ret_copy = MessageSendEvent_broadcast_channel_announcement(msg_conv, update_msg_conv);
22539 uint64_t ret_ref = tag_ptr(ret_copy, true);
22543 uint64_t __attribute__((export_name("TS_MessageSendEvent_broadcast_channel_update"))) TS_MessageSendEvent_broadcast_channel_update(uint64_t msg) {
22544 LDKChannelUpdate msg_conv;
22545 msg_conv.inner = untag_ptr(msg);
22546 msg_conv.is_owned = ptr_is_owned(msg);
22547 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
22548 msg_conv = ChannelUpdate_clone(&msg_conv);
22549 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
22550 *ret_copy = MessageSendEvent_broadcast_channel_update(msg_conv);
22551 uint64_t ret_ref = tag_ptr(ret_copy, true);
22555 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_channel_update"))) TS_MessageSendEvent_send_channel_update(int8_tArray node_id, uint64_t msg) {
22556 LDKPublicKey node_id_ref;
22557 CHECK(node_id->arr_len == 33);
22558 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
22559 LDKChannelUpdate msg_conv;
22560 msg_conv.inner = untag_ptr(msg);
22561 msg_conv.is_owned = ptr_is_owned(msg);
22562 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
22563 msg_conv = ChannelUpdate_clone(&msg_conv);
22564 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
22565 *ret_copy = MessageSendEvent_send_channel_update(node_id_ref, msg_conv);
22566 uint64_t ret_ref = tag_ptr(ret_copy, true);
22570 uint64_t __attribute__((export_name("TS_MessageSendEvent_handle_error"))) TS_MessageSendEvent_handle_error(int8_tArray node_id, uint64_t action) {
22571 LDKPublicKey node_id_ref;
22572 CHECK(node_id->arr_len == 33);
22573 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
22574 void* action_ptr = untag_ptr(action);
22575 CHECK_ACCESS(action_ptr);
22576 LDKErrorAction action_conv = *(LDKErrorAction*)(action_ptr);
22577 action_conv = ErrorAction_clone((LDKErrorAction*)untag_ptr(action));
22578 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
22579 *ret_copy = MessageSendEvent_handle_error(node_id_ref, action_conv);
22580 uint64_t ret_ref = tag_ptr(ret_copy, true);
22584 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_channel_range_query"))) TS_MessageSendEvent_send_channel_range_query(int8_tArray node_id, uint64_t msg) {
22585 LDKPublicKey node_id_ref;
22586 CHECK(node_id->arr_len == 33);
22587 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
22588 LDKQueryChannelRange msg_conv;
22589 msg_conv.inner = untag_ptr(msg);
22590 msg_conv.is_owned = ptr_is_owned(msg);
22591 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
22592 msg_conv = QueryChannelRange_clone(&msg_conv);
22593 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
22594 *ret_copy = MessageSendEvent_send_channel_range_query(node_id_ref, msg_conv);
22595 uint64_t ret_ref = tag_ptr(ret_copy, true);
22599 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_short_ids_query"))) TS_MessageSendEvent_send_short_ids_query(int8_tArray node_id, uint64_t msg) {
22600 LDKPublicKey node_id_ref;
22601 CHECK(node_id->arr_len == 33);
22602 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
22603 LDKQueryShortChannelIds msg_conv;
22604 msg_conv.inner = untag_ptr(msg);
22605 msg_conv.is_owned = ptr_is_owned(msg);
22606 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
22607 msg_conv = QueryShortChannelIds_clone(&msg_conv);
22608 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
22609 *ret_copy = MessageSendEvent_send_short_ids_query(node_id_ref, msg_conv);
22610 uint64_t ret_ref = tag_ptr(ret_copy, true);
22614 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_reply_channel_range"))) TS_MessageSendEvent_send_reply_channel_range(int8_tArray node_id, uint64_t msg) {
22615 LDKPublicKey node_id_ref;
22616 CHECK(node_id->arr_len == 33);
22617 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
22618 LDKReplyChannelRange msg_conv;
22619 msg_conv.inner = untag_ptr(msg);
22620 msg_conv.is_owned = ptr_is_owned(msg);
22621 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
22622 msg_conv = ReplyChannelRange_clone(&msg_conv);
22623 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
22624 *ret_copy = MessageSendEvent_send_reply_channel_range(node_id_ref, msg_conv);
22625 uint64_t ret_ref = tag_ptr(ret_copy, true);
22629 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_gossip_timestamp_filter"))) TS_MessageSendEvent_send_gossip_timestamp_filter(int8_tArray node_id, uint64_t msg) {
22630 LDKPublicKey node_id_ref;
22631 CHECK(node_id->arr_len == 33);
22632 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
22633 LDKGossipTimestampFilter msg_conv;
22634 msg_conv.inner = untag_ptr(msg);
22635 msg_conv.is_owned = ptr_is_owned(msg);
22636 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
22637 msg_conv = GossipTimestampFilter_clone(&msg_conv);
22638 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
22639 *ret_copy = MessageSendEvent_send_gossip_timestamp_filter(node_id_ref, msg_conv);
22640 uint64_t ret_ref = tag_ptr(ret_copy, true);
22644 void __attribute__((export_name("TS_MessageSendEventsProvider_free"))) TS_MessageSendEventsProvider_free(uint64_t this_ptr) {
22645 if (!ptr_is_owned(this_ptr)) return;
22646 void* this_ptr_ptr = untag_ptr(this_ptr);
22647 CHECK_ACCESS(this_ptr_ptr);
22648 LDKMessageSendEventsProvider this_ptr_conv = *(LDKMessageSendEventsProvider*)(this_ptr_ptr);
22649 FREE(untag_ptr(this_ptr));
22650 MessageSendEventsProvider_free(this_ptr_conv);
22653 void __attribute__((export_name("TS_OnionMessageProvider_free"))) TS_OnionMessageProvider_free(uint64_t this_ptr) {
22654 if (!ptr_is_owned(this_ptr)) return;
22655 void* this_ptr_ptr = untag_ptr(this_ptr);
22656 CHECK_ACCESS(this_ptr_ptr);
22657 LDKOnionMessageProvider this_ptr_conv = *(LDKOnionMessageProvider*)(this_ptr_ptr);
22658 FREE(untag_ptr(this_ptr));
22659 OnionMessageProvider_free(this_ptr_conv);
22662 void __attribute__((export_name("TS_EventsProvider_free"))) TS_EventsProvider_free(uint64_t this_ptr) {
22663 if (!ptr_is_owned(this_ptr)) return;
22664 void* this_ptr_ptr = untag_ptr(this_ptr);
22665 CHECK_ACCESS(this_ptr_ptr);
22666 LDKEventsProvider this_ptr_conv = *(LDKEventsProvider*)(this_ptr_ptr);
22667 FREE(untag_ptr(this_ptr));
22668 EventsProvider_free(this_ptr_conv);
22671 void __attribute__((export_name("TS_EventHandler_free"))) TS_EventHandler_free(uint64_t this_ptr) {
22672 if (!ptr_is_owned(this_ptr)) return;
22673 void* this_ptr_ptr = untag_ptr(this_ptr);
22674 CHECK_ACCESS(this_ptr_ptr);
22675 LDKEventHandler this_ptr_conv = *(LDKEventHandler*)(this_ptr_ptr);
22676 FREE(untag_ptr(this_ptr));
22677 EventHandler_free(this_ptr_conv);
22680 void __attribute__((export_name("TS_APIError_free"))) TS_APIError_free(uint64_t this_ptr) {
22681 if (!ptr_is_owned(this_ptr)) return;
22682 void* this_ptr_ptr = untag_ptr(this_ptr);
22683 CHECK_ACCESS(this_ptr_ptr);
22684 LDKAPIError this_ptr_conv = *(LDKAPIError*)(this_ptr_ptr);
22685 FREE(untag_ptr(this_ptr));
22686 APIError_free(this_ptr_conv);
22689 static inline uint64_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg) {
22690 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
22691 *ret_copy = APIError_clone(arg);
22692 uint64_t ret_ref = tag_ptr(ret_copy, true);
22695 int64_t __attribute__((export_name("TS_APIError_clone_ptr"))) TS_APIError_clone_ptr(uint64_t arg) {
22696 LDKAPIError* arg_conv = (LDKAPIError*)untag_ptr(arg);
22697 int64_t ret_conv = APIError_clone_ptr(arg_conv);
22701 uint64_t __attribute__((export_name("TS_APIError_clone"))) TS_APIError_clone(uint64_t orig) {
22702 LDKAPIError* orig_conv = (LDKAPIError*)untag_ptr(orig);
22703 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
22704 *ret_copy = APIError_clone(orig_conv);
22705 uint64_t ret_ref = tag_ptr(ret_copy, true);
22709 uint64_t __attribute__((export_name("TS_APIError_apimisuse_error"))) TS_APIError_apimisuse_error(jstring err) {
22710 LDKStr err_conv = str_ref_to_owned_c(err);
22711 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
22712 *ret_copy = APIError_apimisuse_error(err_conv);
22713 uint64_t ret_ref = tag_ptr(ret_copy, true);
22717 uint64_t __attribute__((export_name("TS_APIError_fee_rate_too_high"))) TS_APIError_fee_rate_too_high(jstring err, int32_t feerate) {
22718 LDKStr err_conv = str_ref_to_owned_c(err);
22719 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
22720 *ret_copy = APIError_fee_rate_too_high(err_conv, feerate);
22721 uint64_t ret_ref = tag_ptr(ret_copy, true);
22725 uint64_t __attribute__((export_name("TS_APIError_invalid_route"))) TS_APIError_invalid_route(jstring err) {
22726 LDKStr err_conv = str_ref_to_owned_c(err);
22727 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
22728 *ret_copy = APIError_invalid_route(err_conv);
22729 uint64_t ret_ref = tag_ptr(ret_copy, true);
22733 uint64_t __attribute__((export_name("TS_APIError_channel_unavailable"))) TS_APIError_channel_unavailable(jstring err) {
22734 LDKStr err_conv = str_ref_to_owned_c(err);
22735 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
22736 *ret_copy = APIError_channel_unavailable(err_conv);
22737 uint64_t ret_ref = tag_ptr(ret_copy, true);
22741 uint64_t __attribute__((export_name("TS_APIError_monitor_update_in_progress"))) TS_APIError_monitor_update_in_progress() {
22742 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
22743 *ret_copy = APIError_monitor_update_in_progress();
22744 uint64_t ret_ref = tag_ptr(ret_copy, true);
22748 uint64_t __attribute__((export_name("TS_APIError_incompatible_shutdown_script"))) TS_APIError_incompatible_shutdown_script(uint64_t script) {
22749 LDKShutdownScript script_conv;
22750 script_conv.inner = untag_ptr(script);
22751 script_conv.is_owned = ptr_is_owned(script);
22752 CHECK_INNER_FIELD_ACCESS_OR_NULL(script_conv);
22753 script_conv = ShutdownScript_clone(&script_conv);
22754 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
22755 *ret_copy = APIError_incompatible_shutdown_script(script_conv);
22756 uint64_t ret_ref = tag_ptr(ret_copy, true);
22760 jboolean __attribute__((export_name("TS_APIError_eq"))) TS_APIError_eq(uint64_t a, uint64_t b) {
22761 LDKAPIError* a_conv = (LDKAPIError*)untag_ptr(a);
22762 LDKAPIError* b_conv = (LDKAPIError*)untag_ptr(b);
22763 jboolean ret_conv = APIError_eq(a_conv, b_conv);
22767 void __attribute__((export_name("TS_BigSize_free"))) TS_BigSize_free(uint64_t this_obj) {
22768 LDKBigSize this_obj_conv;
22769 this_obj_conv.inner = untag_ptr(this_obj);
22770 this_obj_conv.is_owned = ptr_is_owned(this_obj);
22771 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
22772 BigSize_free(this_obj_conv);
22775 int64_t __attribute__((export_name("TS_BigSize_get_a"))) TS_BigSize_get_a(uint64_t this_ptr) {
22776 LDKBigSize this_ptr_conv;
22777 this_ptr_conv.inner = untag_ptr(this_ptr);
22778 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
22779 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22780 this_ptr_conv.is_owned = false;
22781 int64_t ret_conv = BigSize_get_a(&this_ptr_conv);
22785 void __attribute__((export_name("TS_BigSize_set_a"))) TS_BigSize_set_a(uint64_t this_ptr, int64_t val) {
22786 LDKBigSize this_ptr_conv;
22787 this_ptr_conv.inner = untag_ptr(this_ptr);
22788 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
22789 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22790 this_ptr_conv.is_owned = false;
22791 BigSize_set_a(&this_ptr_conv, val);
22794 uint64_t __attribute__((export_name("TS_BigSize_new"))) TS_BigSize_new(int64_t a_arg) {
22795 LDKBigSize ret_var = BigSize_new(a_arg);
22796 uint64_t ret_ref = 0;
22797 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22798 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
22802 void __attribute__((export_name("TS_Hostname_free"))) TS_Hostname_free(uint64_t this_obj) {
22803 LDKHostname this_obj_conv;
22804 this_obj_conv.inner = untag_ptr(this_obj);
22805 this_obj_conv.is_owned = ptr_is_owned(this_obj);
22806 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
22807 Hostname_free(this_obj_conv);
22810 static inline uint64_t Hostname_clone_ptr(LDKHostname *NONNULL_PTR arg) {
22811 LDKHostname ret_var = Hostname_clone(arg);
22812 uint64_t ret_ref = 0;
22813 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22814 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
22817 int64_t __attribute__((export_name("TS_Hostname_clone_ptr"))) TS_Hostname_clone_ptr(uint64_t arg) {
22818 LDKHostname arg_conv;
22819 arg_conv.inner = untag_ptr(arg);
22820 arg_conv.is_owned = ptr_is_owned(arg);
22821 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
22822 arg_conv.is_owned = false;
22823 int64_t ret_conv = Hostname_clone_ptr(&arg_conv);
22827 uint64_t __attribute__((export_name("TS_Hostname_clone"))) TS_Hostname_clone(uint64_t orig) {
22828 LDKHostname orig_conv;
22829 orig_conv.inner = untag_ptr(orig);
22830 orig_conv.is_owned = ptr_is_owned(orig);
22831 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
22832 orig_conv.is_owned = false;
22833 LDKHostname ret_var = Hostname_clone(&orig_conv);
22834 uint64_t ret_ref = 0;
22835 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22836 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
22840 jboolean __attribute__((export_name("TS_Hostname_eq"))) TS_Hostname_eq(uint64_t a, uint64_t b) {
22841 LDKHostname a_conv;
22842 a_conv.inner = untag_ptr(a);
22843 a_conv.is_owned = ptr_is_owned(a);
22844 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
22845 a_conv.is_owned = false;
22846 LDKHostname b_conv;
22847 b_conv.inner = untag_ptr(b);
22848 b_conv.is_owned = ptr_is_owned(b);
22849 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
22850 b_conv.is_owned = false;
22851 jboolean ret_conv = Hostname_eq(&a_conv, &b_conv);
22855 int8_t __attribute__((export_name("TS_Hostname_len"))) TS_Hostname_len(uint64_t this_arg) {
22856 LDKHostname this_arg_conv;
22857 this_arg_conv.inner = untag_ptr(this_arg);
22858 this_arg_conv.is_owned = ptr_is_owned(this_arg);
22859 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
22860 this_arg_conv.is_owned = false;
22861 int8_t ret_conv = Hostname_len(&this_arg_conv);
22865 uint64_t __attribute__((export_name("TS_sign"))) TS_sign(int8_tArray msg, int8_tArray sk) {
22866 LDKu8slice msg_ref;
22867 msg_ref.datalen = msg->arr_len;
22868 msg_ref.data = msg->elems;
22869 unsigned char sk_arr[32];
22870 CHECK(sk->arr_len == 32);
22871 memcpy(sk_arr, sk->elems, 32); FREE(sk);
22872 unsigned char (*sk_ref)[32] = &sk_arr;
22873 LDKCResult_StringErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StringErrorZ), "LDKCResult_StringErrorZ");
22874 *ret_conv = sign(msg_ref, sk_ref);
22876 return tag_ptr(ret_conv, true);
22879 uint64_t __attribute__((export_name("TS_recover_pk"))) TS_recover_pk(int8_tArray msg, jstring sig) {
22880 LDKu8slice msg_ref;
22881 msg_ref.datalen = msg->arr_len;
22882 msg_ref.data = msg->elems;
22883 LDKStr sig_conv = str_ref_to_owned_c(sig);
22884 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
22885 *ret_conv = recover_pk(msg_ref, sig_conv);
22887 return tag_ptr(ret_conv, true);
22890 jboolean __attribute__((export_name("TS_verify"))) TS_verify(int8_tArray msg, jstring sig, int8_tArray pk) {
22891 LDKu8slice msg_ref;
22892 msg_ref.datalen = msg->arr_len;
22893 msg_ref.data = msg->elems;
22894 LDKStr sig_conv = str_ref_to_owned_c(sig);
22895 LDKPublicKey pk_ref;
22896 CHECK(pk->arr_len == 33);
22897 memcpy(pk_ref.compressed_form, pk->elems, 33); FREE(pk);
22898 jboolean ret_conv = verify(msg_ref, sig_conv, pk_ref);
22903 int8_tArray __attribute__((export_name("TS_construct_invoice_preimage"))) TS_construct_invoice_preimage(int8_tArray hrp_bytes, ptrArray data_without_signature) {
22904 LDKu8slice hrp_bytes_ref;
22905 hrp_bytes_ref.datalen = hrp_bytes->arr_len;
22906 hrp_bytes_ref.data = hrp_bytes->elems;
22907 LDKCVec_U5Z data_without_signature_constr;
22908 data_without_signature_constr.datalen = data_without_signature->arr_len;
22909 if (data_without_signature_constr.datalen > 0)
22910 data_without_signature_constr.data = MALLOC(data_without_signature_constr.datalen * sizeof(LDKU5), "LDKCVec_U5Z Elements");
22912 data_without_signature_constr.data = NULL;
22913 int8_t* data_without_signature_vals = (void*) data_without_signature->elems;
22914 for (size_t h = 0; h < data_without_signature_constr.datalen; h++) {
22915 int8_t data_without_signature_conv_7 = data_without_signature_vals[h];
22917 data_without_signature_constr.data[h] = (LDKU5){ ._0 = data_without_signature_conv_7 };
22919 FREE(data_without_signature);
22920 LDKCVec_u8Z ret_var = construct_invoice_preimage(hrp_bytes_ref, data_without_signature_constr);
22921 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
22922 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
22923 CVec_u8Z_free(ret_var);
22928 void __attribute__((export_name("TS_Persister_free"))) TS_Persister_free(uint64_t this_ptr) {
22929 if (!ptr_is_owned(this_ptr)) return;
22930 void* this_ptr_ptr = untag_ptr(this_ptr);
22931 CHECK_ACCESS(this_ptr_ptr);
22932 LDKPersister this_ptr_conv = *(LDKPersister*)(this_ptr_ptr);
22933 FREE(untag_ptr(this_ptr));
22934 Persister_free(this_ptr_conv);
22937 void __attribute__((export_name("TS_PrintableString_free"))) TS_PrintableString_free(uint64_t this_obj) {
22938 LDKPrintableString this_obj_conv;
22939 this_obj_conv.inner = untag_ptr(this_obj);
22940 this_obj_conv.is_owned = ptr_is_owned(this_obj);
22941 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
22942 PrintableString_free(this_obj_conv);
22945 jstring __attribute__((export_name("TS_PrintableString_get_a"))) TS_PrintableString_get_a(uint64_t this_ptr) {
22946 LDKPrintableString this_ptr_conv;
22947 this_ptr_conv.inner = untag_ptr(this_ptr);
22948 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
22949 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22950 this_ptr_conv.is_owned = false;
22951 LDKStr ret_str = PrintableString_get_a(&this_ptr_conv);
22952 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
22957 void __attribute__((export_name("TS_PrintableString_set_a"))) TS_PrintableString_set_a(uint64_t this_ptr, jstring val) {
22958 LDKPrintableString this_ptr_conv;
22959 this_ptr_conv.inner = untag_ptr(this_ptr);
22960 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
22961 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22962 this_ptr_conv.is_owned = false;
22963 LDKStr val_conv = str_ref_to_owned_c(val);
22964 PrintableString_set_a(&this_ptr_conv, val_conv);
22967 uint64_t __attribute__((export_name("TS_PrintableString_new"))) TS_PrintableString_new(jstring a_arg) {
22968 LDKStr a_arg_conv = str_ref_to_owned_c(a_arg);
22969 LDKPrintableString ret_var = PrintableString_new(a_arg_conv);
22970 uint64_t ret_ref = 0;
22971 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22972 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
22976 void __attribute__((export_name("TS_FutureCallback_free"))) TS_FutureCallback_free(uint64_t this_ptr) {
22977 if (!ptr_is_owned(this_ptr)) return;
22978 void* this_ptr_ptr = untag_ptr(this_ptr);
22979 CHECK_ACCESS(this_ptr_ptr);
22980 LDKFutureCallback this_ptr_conv = *(LDKFutureCallback*)(this_ptr_ptr);
22981 FREE(untag_ptr(this_ptr));
22982 FutureCallback_free(this_ptr_conv);
22985 void __attribute__((export_name("TS_Future_free"))) TS_Future_free(uint64_t this_obj) {
22986 LDKFuture this_obj_conv;
22987 this_obj_conv.inner = untag_ptr(this_obj);
22988 this_obj_conv.is_owned = ptr_is_owned(this_obj);
22989 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
22990 Future_free(this_obj_conv);
22993 void __attribute__((export_name("TS_Future_register_callback_fn"))) TS_Future_register_callback_fn(uint64_t this_arg, uint64_t callback) {
22994 LDKFuture this_arg_conv;
22995 this_arg_conv.inner = untag_ptr(this_arg);
22996 this_arg_conv.is_owned = ptr_is_owned(this_arg);
22997 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
22998 this_arg_conv.is_owned = false;
22999 void* callback_ptr = untag_ptr(callback);
23000 CHECK_ACCESS(callback_ptr);
23001 LDKFutureCallback callback_conv = *(LDKFutureCallback*)(callback_ptr);
23002 if (callback_conv.free == LDKFutureCallback_JCalls_free) {
23003 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
23004 LDKFutureCallback_JCalls_cloned(&callback_conv);
23006 Future_register_callback_fn(&this_arg_conv, callback_conv);
23009 uint32_t __attribute__((export_name("TS_Level_clone"))) TS_Level_clone(uint64_t orig) {
23010 LDKLevel* orig_conv = (LDKLevel*)untag_ptr(orig);
23011 uint32_t ret_conv = LDKLevel_to_js(Level_clone(orig_conv));
23015 uint32_t __attribute__((export_name("TS_Level_gossip"))) TS_Level_gossip() {
23016 uint32_t ret_conv = LDKLevel_to_js(Level_gossip());
23020 uint32_t __attribute__((export_name("TS_Level_trace"))) TS_Level_trace() {
23021 uint32_t ret_conv = LDKLevel_to_js(Level_trace());
23025 uint32_t __attribute__((export_name("TS_Level_debug"))) TS_Level_debug() {
23026 uint32_t ret_conv = LDKLevel_to_js(Level_debug());
23030 uint32_t __attribute__((export_name("TS_Level_info"))) TS_Level_info() {
23031 uint32_t ret_conv = LDKLevel_to_js(Level_info());
23035 uint32_t __attribute__((export_name("TS_Level_warn"))) TS_Level_warn() {
23036 uint32_t ret_conv = LDKLevel_to_js(Level_warn());
23040 uint32_t __attribute__((export_name("TS_Level_error"))) TS_Level_error() {
23041 uint32_t ret_conv = LDKLevel_to_js(Level_error());
23045 jboolean __attribute__((export_name("TS_Level_eq"))) TS_Level_eq(uint64_t a, uint64_t b) {
23046 LDKLevel* a_conv = (LDKLevel*)untag_ptr(a);
23047 LDKLevel* b_conv = (LDKLevel*)untag_ptr(b);
23048 jboolean ret_conv = Level_eq(a_conv, b_conv);
23052 int64_t __attribute__((export_name("TS_Level_hash"))) TS_Level_hash(uint64_t o) {
23053 LDKLevel* o_conv = (LDKLevel*)untag_ptr(o);
23054 int64_t ret_conv = Level_hash(o_conv);
23058 uint32_t __attribute__((export_name("TS_Level_max"))) TS_Level_max() {
23059 uint32_t ret_conv = LDKLevel_to_js(Level_max());
23063 void __attribute__((export_name("TS_Record_free"))) TS_Record_free(uint64_t this_obj) {
23064 LDKRecord this_obj_conv;
23065 this_obj_conv.inner = untag_ptr(this_obj);
23066 this_obj_conv.is_owned = ptr_is_owned(this_obj);
23067 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
23068 Record_free(this_obj_conv);
23071 uint32_t __attribute__((export_name("TS_Record_get_level"))) TS_Record_get_level(uint64_t this_ptr) {
23072 LDKRecord this_ptr_conv;
23073 this_ptr_conv.inner = untag_ptr(this_ptr);
23074 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23075 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23076 this_ptr_conv.is_owned = false;
23077 uint32_t ret_conv = LDKLevel_to_js(Record_get_level(&this_ptr_conv));
23081 void __attribute__((export_name("TS_Record_set_level"))) TS_Record_set_level(uint64_t this_ptr, uint32_t val) {
23082 LDKRecord this_ptr_conv;
23083 this_ptr_conv.inner = untag_ptr(this_ptr);
23084 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23085 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23086 this_ptr_conv.is_owned = false;
23087 LDKLevel val_conv = LDKLevel_from_js(val);
23088 Record_set_level(&this_ptr_conv, val_conv);
23091 jstring __attribute__((export_name("TS_Record_get_args"))) TS_Record_get_args(uint64_t this_ptr) {
23092 LDKRecord this_ptr_conv;
23093 this_ptr_conv.inner = untag_ptr(this_ptr);
23094 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23095 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23096 this_ptr_conv.is_owned = false;
23097 LDKStr ret_str = Record_get_args(&this_ptr_conv);
23098 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
23103 void __attribute__((export_name("TS_Record_set_args"))) TS_Record_set_args(uint64_t this_ptr, jstring val) {
23104 LDKRecord this_ptr_conv;
23105 this_ptr_conv.inner = untag_ptr(this_ptr);
23106 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23107 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23108 this_ptr_conv.is_owned = false;
23109 LDKStr val_conv = str_ref_to_owned_c(val);
23110 Record_set_args(&this_ptr_conv, val_conv);
23113 jstring __attribute__((export_name("TS_Record_get_module_path"))) TS_Record_get_module_path(uint64_t this_ptr) {
23114 LDKRecord this_ptr_conv;
23115 this_ptr_conv.inner = untag_ptr(this_ptr);
23116 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23117 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23118 this_ptr_conv.is_owned = false;
23119 LDKStr ret_str = Record_get_module_path(&this_ptr_conv);
23120 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
23125 void __attribute__((export_name("TS_Record_set_module_path"))) TS_Record_set_module_path(uint64_t this_ptr, jstring val) {
23126 LDKRecord this_ptr_conv;
23127 this_ptr_conv.inner = untag_ptr(this_ptr);
23128 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23129 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23130 this_ptr_conv.is_owned = false;
23131 LDKStr val_conv = str_ref_to_owned_c(val);
23132 Record_set_module_path(&this_ptr_conv, val_conv);
23135 jstring __attribute__((export_name("TS_Record_get_file"))) TS_Record_get_file(uint64_t this_ptr) {
23136 LDKRecord this_ptr_conv;
23137 this_ptr_conv.inner = untag_ptr(this_ptr);
23138 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23139 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23140 this_ptr_conv.is_owned = false;
23141 LDKStr ret_str = Record_get_file(&this_ptr_conv);
23142 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
23147 void __attribute__((export_name("TS_Record_set_file"))) TS_Record_set_file(uint64_t this_ptr, jstring val) {
23148 LDKRecord this_ptr_conv;
23149 this_ptr_conv.inner = untag_ptr(this_ptr);
23150 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23151 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23152 this_ptr_conv.is_owned = false;
23153 LDKStr val_conv = str_ref_to_owned_c(val);
23154 Record_set_file(&this_ptr_conv, val_conv);
23157 int32_t __attribute__((export_name("TS_Record_get_line"))) TS_Record_get_line(uint64_t this_ptr) {
23158 LDKRecord this_ptr_conv;
23159 this_ptr_conv.inner = untag_ptr(this_ptr);
23160 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23161 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23162 this_ptr_conv.is_owned = false;
23163 int32_t ret_conv = Record_get_line(&this_ptr_conv);
23167 void __attribute__((export_name("TS_Record_set_line"))) TS_Record_set_line(uint64_t this_ptr, int32_t val) {
23168 LDKRecord this_ptr_conv;
23169 this_ptr_conv.inner = untag_ptr(this_ptr);
23170 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23171 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23172 this_ptr_conv.is_owned = false;
23173 Record_set_line(&this_ptr_conv, val);
23176 static inline uint64_t Record_clone_ptr(LDKRecord *NONNULL_PTR arg) {
23177 LDKRecord ret_var = Record_clone(arg);
23178 uint64_t ret_ref = 0;
23179 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23180 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23183 int64_t __attribute__((export_name("TS_Record_clone_ptr"))) TS_Record_clone_ptr(uint64_t arg) {
23184 LDKRecord arg_conv;
23185 arg_conv.inner = untag_ptr(arg);
23186 arg_conv.is_owned = ptr_is_owned(arg);
23187 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
23188 arg_conv.is_owned = false;
23189 int64_t ret_conv = Record_clone_ptr(&arg_conv);
23193 uint64_t __attribute__((export_name("TS_Record_clone"))) TS_Record_clone(uint64_t orig) {
23194 LDKRecord orig_conv;
23195 orig_conv.inner = untag_ptr(orig);
23196 orig_conv.is_owned = ptr_is_owned(orig);
23197 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
23198 orig_conv.is_owned = false;
23199 LDKRecord ret_var = Record_clone(&orig_conv);
23200 uint64_t ret_ref = 0;
23201 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23202 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23206 void __attribute__((export_name("TS_Logger_free"))) TS_Logger_free(uint64_t this_ptr) {
23207 if (!ptr_is_owned(this_ptr)) return;
23208 void* this_ptr_ptr = untag_ptr(this_ptr);
23209 CHECK_ACCESS(this_ptr_ptr);
23210 LDKLogger this_ptr_conv = *(LDKLogger*)(this_ptr_ptr);
23211 FREE(untag_ptr(this_ptr));
23212 Logger_free(this_ptr_conv);
23215 void __attribute__((export_name("TS_ChannelHandshakeConfig_free"))) TS_ChannelHandshakeConfig_free(uint64_t this_obj) {
23216 LDKChannelHandshakeConfig this_obj_conv;
23217 this_obj_conv.inner = untag_ptr(this_obj);
23218 this_obj_conv.is_owned = ptr_is_owned(this_obj);
23219 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
23220 ChannelHandshakeConfig_free(this_obj_conv);
23223 int32_t __attribute__((export_name("TS_ChannelHandshakeConfig_get_minimum_depth"))) TS_ChannelHandshakeConfig_get_minimum_depth(uint64_t this_ptr) {
23224 LDKChannelHandshakeConfig this_ptr_conv;
23225 this_ptr_conv.inner = untag_ptr(this_ptr);
23226 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23227 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23228 this_ptr_conv.is_owned = false;
23229 int32_t ret_conv = ChannelHandshakeConfig_get_minimum_depth(&this_ptr_conv);
23233 void __attribute__((export_name("TS_ChannelHandshakeConfig_set_minimum_depth"))) TS_ChannelHandshakeConfig_set_minimum_depth(uint64_t this_ptr, int32_t val) {
23234 LDKChannelHandshakeConfig this_ptr_conv;
23235 this_ptr_conv.inner = untag_ptr(this_ptr);
23236 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23237 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23238 this_ptr_conv.is_owned = false;
23239 ChannelHandshakeConfig_set_minimum_depth(&this_ptr_conv, val);
23242 int16_t __attribute__((export_name("TS_ChannelHandshakeConfig_get_our_to_self_delay"))) TS_ChannelHandshakeConfig_get_our_to_self_delay(uint64_t this_ptr) {
23243 LDKChannelHandshakeConfig this_ptr_conv;
23244 this_ptr_conv.inner = untag_ptr(this_ptr);
23245 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23246 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23247 this_ptr_conv.is_owned = false;
23248 int16_t ret_conv = ChannelHandshakeConfig_get_our_to_self_delay(&this_ptr_conv);
23252 void __attribute__((export_name("TS_ChannelHandshakeConfig_set_our_to_self_delay"))) TS_ChannelHandshakeConfig_set_our_to_self_delay(uint64_t this_ptr, int16_t val) {
23253 LDKChannelHandshakeConfig this_ptr_conv;
23254 this_ptr_conv.inner = untag_ptr(this_ptr);
23255 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23256 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23257 this_ptr_conv.is_owned = false;
23258 ChannelHandshakeConfig_set_our_to_self_delay(&this_ptr_conv, val);
23261 int64_t __attribute__((export_name("TS_ChannelHandshakeConfig_get_our_htlc_minimum_msat"))) TS_ChannelHandshakeConfig_get_our_htlc_minimum_msat(uint64_t this_ptr) {
23262 LDKChannelHandshakeConfig this_ptr_conv;
23263 this_ptr_conv.inner = untag_ptr(this_ptr);
23264 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23265 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23266 this_ptr_conv.is_owned = false;
23267 int64_t ret_conv = ChannelHandshakeConfig_get_our_htlc_minimum_msat(&this_ptr_conv);
23271 void __attribute__((export_name("TS_ChannelHandshakeConfig_set_our_htlc_minimum_msat"))) TS_ChannelHandshakeConfig_set_our_htlc_minimum_msat(uint64_t this_ptr, int64_t val) {
23272 LDKChannelHandshakeConfig this_ptr_conv;
23273 this_ptr_conv.inner = untag_ptr(this_ptr);
23274 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23275 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23276 this_ptr_conv.is_owned = false;
23277 ChannelHandshakeConfig_set_our_htlc_minimum_msat(&this_ptr_conv, val);
23280 int8_t __attribute__((export_name("TS_ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel"))) TS_ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(uint64_t this_ptr) {
23281 LDKChannelHandshakeConfig this_ptr_conv;
23282 this_ptr_conv.inner = untag_ptr(this_ptr);
23283 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23284 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23285 this_ptr_conv.is_owned = false;
23286 int8_t ret_conv = ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(&this_ptr_conv);
23290 void __attribute__((export_name("TS_ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel"))) TS_ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(uint64_t this_ptr, int8_t val) {
23291 LDKChannelHandshakeConfig this_ptr_conv;
23292 this_ptr_conv.inner = untag_ptr(this_ptr);
23293 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23294 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23295 this_ptr_conv.is_owned = false;
23296 ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(&this_ptr_conv, val);
23299 jboolean __attribute__((export_name("TS_ChannelHandshakeConfig_get_negotiate_scid_privacy"))) TS_ChannelHandshakeConfig_get_negotiate_scid_privacy(uint64_t this_ptr) {
23300 LDKChannelHandshakeConfig this_ptr_conv;
23301 this_ptr_conv.inner = untag_ptr(this_ptr);
23302 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23303 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23304 this_ptr_conv.is_owned = false;
23305 jboolean ret_conv = ChannelHandshakeConfig_get_negotiate_scid_privacy(&this_ptr_conv);
23309 void __attribute__((export_name("TS_ChannelHandshakeConfig_set_negotiate_scid_privacy"))) TS_ChannelHandshakeConfig_set_negotiate_scid_privacy(uint64_t this_ptr, jboolean val) {
23310 LDKChannelHandshakeConfig this_ptr_conv;
23311 this_ptr_conv.inner = untag_ptr(this_ptr);
23312 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23313 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23314 this_ptr_conv.is_owned = false;
23315 ChannelHandshakeConfig_set_negotiate_scid_privacy(&this_ptr_conv, val);
23318 jboolean __attribute__((export_name("TS_ChannelHandshakeConfig_get_announced_channel"))) TS_ChannelHandshakeConfig_get_announced_channel(uint64_t this_ptr) {
23319 LDKChannelHandshakeConfig this_ptr_conv;
23320 this_ptr_conv.inner = untag_ptr(this_ptr);
23321 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23322 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23323 this_ptr_conv.is_owned = false;
23324 jboolean ret_conv = ChannelHandshakeConfig_get_announced_channel(&this_ptr_conv);
23328 void __attribute__((export_name("TS_ChannelHandshakeConfig_set_announced_channel"))) TS_ChannelHandshakeConfig_set_announced_channel(uint64_t this_ptr, jboolean val) {
23329 LDKChannelHandshakeConfig this_ptr_conv;
23330 this_ptr_conv.inner = untag_ptr(this_ptr);
23331 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23332 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23333 this_ptr_conv.is_owned = false;
23334 ChannelHandshakeConfig_set_announced_channel(&this_ptr_conv, val);
23337 jboolean __attribute__((export_name("TS_ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey"))) TS_ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(uint64_t this_ptr) {
23338 LDKChannelHandshakeConfig this_ptr_conv;
23339 this_ptr_conv.inner = untag_ptr(this_ptr);
23340 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23341 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23342 this_ptr_conv.is_owned = false;
23343 jboolean ret_conv = ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(&this_ptr_conv);
23347 void __attribute__((export_name("TS_ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey"))) TS_ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(uint64_t this_ptr, jboolean val) {
23348 LDKChannelHandshakeConfig this_ptr_conv;
23349 this_ptr_conv.inner = untag_ptr(this_ptr);
23350 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23351 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23352 this_ptr_conv.is_owned = false;
23353 ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(&this_ptr_conv, val);
23356 int32_t __attribute__((export_name("TS_ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths"))) TS_ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(uint64_t this_ptr) {
23357 LDKChannelHandshakeConfig this_ptr_conv;
23358 this_ptr_conv.inner = untag_ptr(this_ptr);
23359 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23360 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23361 this_ptr_conv.is_owned = false;
23362 int32_t ret_conv = ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(&this_ptr_conv);
23366 void __attribute__((export_name("TS_ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths"))) TS_ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(uint64_t this_ptr, int32_t val) {
23367 LDKChannelHandshakeConfig this_ptr_conv;
23368 this_ptr_conv.inner = untag_ptr(this_ptr);
23369 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23370 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23371 this_ptr_conv.is_owned = false;
23372 ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(&this_ptr_conv, val);
23375 uint64_t __attribute__((export_name("TS_ChannelHandshakeConfig_new"))) TS_ChannelHandshakeConfig_new(int32_t minimum_depth_arg, int16_t our_to_self_delay_arg, int64_t our_htlc_minimum_msat_arg, int8_t max_inbound_htlc_value_in_flight_percent_of_channel_arg, jboolean negotiate_scid_privacy_arg, jboolean announced_channel_arg, jboolean commit_upfront_shutdown_pubkey_arg, int32_t their_channel_reserve_proportional_millionths_arg) {
23376 LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_new(minimum_depth_arg, our_to_self_delay_arg, our_htlc_minimum_msat_arg, max_inbound_htlc_value_in_flight_percent_of_channel_arg, negotiate_scid_privacy_arg, announced_channel_arg, commit_upfront_shutdown_pubkey_arg, their_channel_reserve_proportional_millionths_arg);
23377 uint64_t ret_ref = 0;
23378 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23379 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23383 static inline uint64_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg) {
23384 LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_clone(arg);
23385 uint64_t ret_ref = 0;
23386 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23387 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23390 int64_t __attribute__((export_name("TS_ChannelHandshakeConfig_clone_ptr"))) TS_ChannelHandshakeConfig_clone_ptr(uint64_t arg) {
23391 LDKChannelHandshakeConfig arg_conv;
23392 arg_conv.inner = untag_ptr(arg);
23393 arg_conv.is_owned = ptr_is_owned(arg);
23394 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
23395 arg_conv.is_owned = false;
23396 int64_t ret_conv = ChannelHandshakeConfig_clone_ptr(&arg_conv);
23400 uint64_t __attribute__((export_name("TS_ChannelHandshakeConfig_clone"))) TS_ChannelHandshakeConfig_clone(uint64_t orig) {
23401 LDKChannelHandshakeConfig orig_conv;
23402 orig_conv.inner = untag_ptr(orig);
23403 orig_conv.is_owned = ptr_is_owned(orig);
23404 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
23405 orig_conv.is_owned = false;
23406 LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_clone(&orig_conv);
23407 uint64_t ret_ref = 0;
23408 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23409 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23413 uint64_t __attribute__((export_name("TS_ChannelHandshakeConfig_default"))) TS_ChannelHandshakeConfig_default() {
23414 LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_default();
23415 uint64_t ret_ref = 0;
23416 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23417 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23421 void __attribute__((export_name("TS_ChannelHandshakeLimits_free"))) TS_ChannelHandshakeLimits_free(uint64_t this_obj) {
23422 LDKChannelHandshakeLimits this_obj_conv;
23423 this_obj_conv.inner = untag_ptr(this_obj);
23424 this_obj_conv.is_owned = ptr_is_owned(this_obj);
23425 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
23426 ChannelHandshakeLimits_free(this_obj_conv);
23429 int64_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_min_funding_satoshis"))) TS_ChannelHandshakeLimits_get_min_funding_satoshis(uint64_t this_ptr) {
23430 LDKChannelHandshakeLimits this_ptr_conv;
23431 this_ptr_conv.inner = untag_ptr(this_ptr);
23432 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23433 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23434 this_ptr_conv.is_owned = false;
23435 int64_t ret_conv = ChannelHandshakeLimits_get_min_funding_satoshis(&this_ptr_conv);
23439 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_min_funding_satoshis"))) TS_ChannelHandshakeLimits_set_min_funding_satoshis(uint64_t this_ptr, int64_t val) {
23440 LDKChannelHandshakeLimits this_ptr_conv;
23441 this_ptr_conv.inner = untag_ptr(this_ptr);
23442 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23443 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23444 this_ptr_conv.is_owned = false;
23445 ChannelHandshakeLimits_set_min_funding_satoshis(&this_ptr_conv, val);
23448 int64_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_max_funding_satoshis"))) TS_ChannelHandshakeLimits_get_max_funding_satoshis(uint64_t this_ptr) {
23449 LDKChannelHandshakeLimits this_ptr_conv;
23450 this_ptr_conv.inner = untag_ptr(this_ptr);
23451 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23452 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23453 this_ptr_conv.is_owned = false;
23454 int64_t ret_conv = ChannelHandshakeLimits_get_max_funding_satoshis(&this_ptr_conv);
23458 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_max_funding_satoshis"))) TS_ChannelHandshakeLimits_set_max_funding_satoshis(uint64_t this_ptr, int64_t val) {
23459 LDKChannelHandshakeLimits this_ptr_conv;
23460 this_ptr_conv.inner = untag_ptr(this_ptr);
23461 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23462 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23463 this_ptr_conv.is_owned = false;
23464 ChannelHandshakeLimits_set_max_funding_satoshis(&this_ptr_conv, val);
23467 int64_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_max_htlc_minimum_msat"))) TS_ChannelHandshakeLimits_get_max_htlc_minimum_msat(uint64_t this_ptr) {
23468 LDKChannelHandshakeLimits this_ptr_conv;
23469 this_ptr_conv.inner = untag_ptr(this_ptr);
23470 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23471 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23472 this_ptr_conv.is_owned = false;
23473 int64_t ret_conv = ChannelHandshakeLimits_get_max_htlc_minimum_msat(&this_ptr_conv);
23477 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_max_htlc_minimum_msat"))) TS_ChannelHandshakeLimits_set_max_htlc_minimum_msat(uint64_t this_ptr, int64_t val) {
23478 LDKChannelHandshakeLimits this_ptr_conv;
23479 this_ptr_conv.inner = untag_ptr(this_ptr);
23480 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23481 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23482 this_ptr_conv.is_owned = false;
23483 ChannelHandshakeLimits_set_max_htlc_minimum_msat(&this_ptr_conv, val);
23486 int64_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat"))) TS_ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(uint64_t this_ptr) {
23487 LDKChannelHandshakeLimits this_ptr_conv;
23488 this_ptr_conv.inner = untag_ptr(this_ptr);
23489 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23490 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23491 this_ptr_conv.is_owned = false;
23492 int64_t ret_conv = ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(&this_ptr_conv);
23496 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat"))) TS_ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(uint64_t this_ptr, int64_t val) {
23497 LDKChannelHandshakeLimits this_ptr_conv;
23498 this_ptr_conv.inner = untag_ptr(this_ptr);
23499 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23500 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23501 this_ptr_conv.is_owned = false;
23502 ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
23505 int64_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_max_channel_reserve_satoshis"))) TS_ChannelHandshakeLimits_get_max_channel_reserve_satoshis(uint64_t this_ptr) {
23506 LDKChannelHandshakeLimits this_ptr_conv;
23507 this_ptr_conv.inner = untag_ptr(this_ptr);
23508 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23509 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23510 this_ptr_conv.is_owned = false;
23511 int64_t ret_conv = ChannelHandshakeLimits_get_max_channel_reserve_satoshis(&this_ptr_conv);
23515 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_max_channel_reserve_satoshis"))) TS_ChannelHandshakeLimits_set_max_channel_reserve_satoshis(uint64_t this_ptr, int64_t val) {
23516 LDKChannelHandshakeLimits this_ptr_conv;
23517 this_ptr_conv.inner = untag_ptr(this_ptr);
23518 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23519 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23520 this_ptr_conv.is_owned = false;
23521 ChannelHandshakeLimits_set_max_channel_reserve_satoshis(&this_ptr_conv, val);
23524 int16_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_min_max_accepted_htlcs"))) TS_ChannelHandshakeLimits_get_min_max_accepted_htlcs(uint64_t this_ptr) {
23525 LDKChannelHandshakeLimits this_ptr_conv;
23526 this_ptr_conv.inner = untag_ptr(this_ptr);
23527 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23528 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23529 this_ptr_conv.is_owned = false;
23530 int16_t ret_conv = ChannelHandshakeLimits_get_min_max_accepted_htlcs(&this_ptr_conv);
23534 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_min_max_accepted_htlcs"))) TS_ChannelHandshakeLimits_set_min_max_accepted_htlcs(uint64_t this_ptr, int16_t val) {
23535 LDKChannelHandshakeLimits this_ptr_conv;
23536 this_ptr_conv.inner = untag_ptr(this_ptr);
23537 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23538 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23539 this_ptr_conv.is_owned = false;
23540 ChannelHandshakeLimits_set_min_max_accepted_htlcs(&this_ptr_conv, val);
23543 int32_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_max_minimum_depth"))) TS_ChannelHandshakeLimits_get_max_minimum_depth(uint64_t this_ptr) {
23544 LDKChannelHandshakeLimits this_ptr_conv;
23545 this_ptr_conv.inner = untag_ptr(this_ptr);
23546 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23547 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23548 this_ptr_conv.is_owned = false;
23549 int32_t ret_conv = ChannelHandshakeLimits_get_max_minimum_depth(&this_ptr_conv);
23553 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_max_minimum_depth"))) TS_ChannelHandshakeLimits_set_max_minimum_depth(uint64_t this_ptr, int32_t val) {
23554 LDKChannelHandshakeLimits this_ptr_conv;
23555 this_ptr_conv.inner = untag_ptr(this_ptr);
23556 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23557 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23558 this_ptr_conv.is_owned = false;
23559 ChannelHandshakeLimits_set_max_minimum_depth(&this_ptr_conv, val);
23562 jboolean __attribute__((export_name("TS_ChannelHandshakeLimits_get_trust_own_funding_0conf"))) TS_ChannelHandshakeLimits_get_trust_own_funding_0conf(uint64_t this_ptr) {
23563 LDKChannelHandshakeLimits this_ptr_conv;
23564 this_ptr_conv.inner = untag_ptr(this_ptr);
23565 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23566 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23567 this_ptr_conv.is_owned = false;
23568 jboolean ret_conv = ChannelHandshakeLimits_get_trust_own_funding_0conf(&this_ptr_conv);
23572 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_trust_own_funding_0conf"))) TS_ChannelHandshakeLimits_set_trust_own_funding_0conf(uint64_t this_ptr, jboolean val) {
23573 LDKChannelHandshakeLimits this_ptr_conv;
23574 this_ptr_conv.inner = untag_ptr(this_ptr);
23575 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23576 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23577 this_ptr_conv.is_owned = false;
23578 ChannelHandshakeLimits_set_trust_own_funding_0conf(&this_ptr_conv, val);
23581 jboolean __attribute__((export_name("TS_ChannelHandshakeLimits_get_force_announced_channel_preference"))) TS_ChannelHandshakeLimits_get_force_announced_channel_preference(uint64_t this_ptr) {
23582 LDKChannelHandshakeLimits this_ptr_conv;
23583 this_ptr_conv.inner = untag_ptr(this_ptr);
23584 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23585 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23586 this_ptr_conv.is_owned = false;
23587 jboolean ret_conv = ChannelHandshakeLimits_get_force_announced_channel_preference(&this_ptr_conv);
23591 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_force_announced_channel_preference"))) TS_ChannelHandshakeLimits_set_force_announced_channel_preference(uint64_t this_ptr, jboolean val) {
23592 LDKChannelHandshakeLimits this_ptr_conv;
23593 this_ptr_conv.inner = untag_ptr(this_ptr);
23594 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23595 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23596 this_ptr_conv.is_owned = false;
23597 ChannelHandshakeLimits_set_force_announced_channel_preference(&this_ptr_conv, val);
23600 int16_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_their_to_self_delay"))) TS_ChannelHandshakeLimits_get_their_to_self_delay(uint64_t this_ptr) {
23601 LDKChannelHandshakeLimits this_ptr_conv;
23602 this_ptr_conv.inner = untag_ptr(this_ptr);
23603 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23604 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23605 this_ptr_conv.is_owned = false;
23606 int16_t ret_conv = ChannelHandshakeLimits_get_their_to_self_delay(&this_ptr_conv);
23610 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_their_to_self_delay"))) TS_ChannelHandshakeLimits_set_their_to_self_delay(uint64_t this_ptr, int16_t val) {
23611 LDKChannelHandshakeLimits this_ptr_conv;
23612 this_ptr_conv.inner = untag_ptr(this_ptr);
23613 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23614 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23615 this_ptr_conv.is_owned = false;
23616 ChannelHandshakeLimits_set_their_to_self_delay(&this_ptr_conv, val);
23619 uint64_t __attribute__((export_name("TS_ChannelHandshakeLimits_new"))) TS_ChannelHandshakeLimits_new(int64_t min_funding_satoshis_arg, int64_t max_funding_satoshis_arg, int64_t max_htlc_minimum_msat_arg, int64_t min_max_htlc_value_in_flight_msat_arg, int64_t max_channel_reserve_satoshis_arg, int16_t min_max_accepted_htlcs_arg, int32_t max_minimum_depth_arg, jboolean trust_own_funding_0conf_arg, jboolean force_announced_channel_preference_arg, int16_t their_to_self_delay_arg) {
23620 LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_new(min_funding_satoshis_arg, max_funding_satoshis_arg, max_htlc_minimum_msat_arg, min_max_htlc_value_in_flight_msat_arg, max_channel_reserve_satoshis_arg, min_max_accepted_htlcs_arg, max_minimum_depth_arg, trust_own_funding_0conf_arg, force_announced_channel_preference_arg, their_to_self_delay_arg);
23621 uint64_t ret_ref = 0;
23622 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23623 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23627 static inline uint64_t ChannelHandshakeLimits_clone_ptr(LDKChannelHandshakeLimits *NONNULL_PTR arg) {
23628 LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_clone(arg);
23629 uint64_t ret_ref = 0;
23630 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23631 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23634 int64_t __attribute__((export_name("TS_ChannelHandshakeLimits_clone_ptr"))) TS_ChannelHandshakeLimits_clone_ptr(uint64_t arg) {
23635 LDKChannelHandshakeLimits arg_conv;
23636 arg_conv.inner = untag_ptr(arg);
23637 arg_conv.is_owned = ptr_is_owned(arg);
23638 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
23639 arg_conv.is_owned = false;
23640 int64_t ret_conv = ChannelHandshakeLimits_clone_ptr(&arg_conv);
23644 uint64_t __attribute__((export_name("TS_ChannelHandshakeLimits_clone"))) TS_ChannelHandshakeLimits_clone(uint64_t orig) {
23645 LDKChannelHandshakeLimits orig_conv;
23646 orig_conv.inner = untag_ptr(orig);
23647 orig_conv.is_owned = ptr_is_owned(orig);
23648 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
23649 orig_conv.is_owned = false;
23650 LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_clone(&orig_conv);
23651 uint64_t ret_ref = 0;
23652 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23653 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23657 uint64_t __attribute__((export_name("TS_ChannelHandshakeLimits_default"))) TS_ChannelHandshakeLimits_default() {
23658 LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_default();
23659 uint64_t ret_ref = 0;
23660 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23661 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23665 void __attribute__((export_name("TS_ChannelConfig_free"))) TS_ChannelConfig_free(uint64_t this_obj) {
23666 LDKChannelConfig this_obj_conv;
23667 this_obj_conv.inner = untag_ptr(this_obj);
23668 this_obj_conv.is_owned = ptr_is_owned(this_obj);
23669 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
23670 ChannelConfig_free(this_obj_conv);
23673 int32_t __attribute__((export_name("TS_ChannelConfig_get_forwarding_fee_proportional_millionths"))) TS_ChannelConfig_get_forwarding_fee_proportional_millionths(uint64_t this_ptr) {
23674 LDKChannelConfig this_ptr_conv;
23675 this_ptr_conv.inner = untag_ptr(this_ptr);
23676 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23677 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23678 this_ptr_conv.is_owned = false;
23679 int32_t ret_conv = ChannelConfig_get_forwarding_fee_proportional_millionths(&this_ptr_conv);
23683 void __attribute__((export_name("TS_ChannelConfig_set_forwarding_fee_proportional_millionths"))) TS_ChannelConfig_set_forwarding_fee_proportional_millionths(uint64_t this_ptr, int32_t val) {
23684 LDKChannelConfig this_ptr_conv;
23685 this_ptr_conv.inner = untag_ptr(this_ptr);
23686 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23687 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23688 this_ptr_conv.is_owned = false;
23689 ChannelConfig_set_forwarding_fee_proportional_millionths(&this_ptr_conv, val);
23692 int32_t __attribute__((export_name("TS_ChannelConfig_get_forwarding_fee_base_msat"))) TS_ChannelConfig_get_forwarding_fee_base_msat(uint64_t this_ptr) {
23693 LDKChannelConfig this_ptr_conv;
23694 this_ptr_conv.inner = untag_ptr(this_ptr);
23695 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23696 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23697 this_ptr_conv.is_owned = false;
23698 int32_t ret_conv = ChannelConfig_get_forwarding_fee_base_msat(&this_ptr_conv);
23702 void __attribute__((export_name("TS_ChannelConfig_set_forwarding_fee_base_msat"))) TS_ChannelConfig_set_forwarding_fee_base_msat(uint64_t this_ptr, int32_t val) {
23703 LDKChannelConfig this_ptr_conv;
23704 this_ptr_conv.inner = untag_ptr(this_ptr);
23705 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23706 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23707 this_ptr_conv.is_owned = false;
23708 ChannelConfig_set_forwarding_fee_base_msat(&this_ptr_conv, val);
23711 int16_t __attribute__((export_name("TS_ChannelConfig_get_cltv_expiry_delta"))) TS_ChannelConfig_get_cltv_expiry_delta(uint64_t this_ptr) {
23712 LDKChannelConfig this_ptr_conv;
23713 this_ptr_conv.inner = untag_ptr(this_ptr);
23714 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23715 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23716 this_ptr_conv.is_owned = false;
23717 int16_t ret_conv = ChannelConfig_get_cltv_expiry_delta(&this_ptr_conv);
23721 void __attribute__((export_name("TS_ChannelConfig_set_cltv_expiry_delta"))) TS_ChannelConfig_set_cltv_expiry_delta(uint64_t this_ptr, int16_t val) {
23722 LDKChannelConfig this_ptr_conv;
23723 this_ptr_conv.inner = untag_ptr(this_ptr);
23724 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23725 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23726 this_ptr_conv.is_owned = false;
23727 ChannelConfig_set_cltv_expiry_delta(&this_ptr_conv, val);
23730 int64_t __attribute__((export_name("TS_ChannelConfig_get_max_dust_htlc_exposure_msat"))) TS_ChannelConfig_get_max_dust_htlc_exposure_msat(uint64_t this_ptr) {
23731 LDKChannelConfig this_ptr_conv;
23732 this_ptr_conv.inner = untag_ptr(this_ptr);
23733 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23734 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23735 this_ptr_conv.is_owned = false;
23736 int64_t ret_conv = ChannelConfig_get_max_dust_htlc_exposure_msat(&this_ptr_conv);
23740 void __attribute__((export_name("TS_ChannelConfig_set_max_dust_htlc_exposure_msat"))) TS_ChannelConfig_set_max_dust_htlc_exposure_msat(uint64_t this_ptr, int64_t val) {
23741 LDKChannelConfig this_ptr_conv;
23742 this_ptr_conv.inner = untag_ptr(this_ptr);
23743 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23744 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23745 this_ptr_conv.is_owned = false;
23746 ChannelConfig_set_max_dust_htlc_exposure_msat(&this_ptr_conv, val);
23749 int64_t __attribute__((export_name("TS_ChannelConfig_get_force_close_avoidance_max_fee_satoshis"))) TS_ChannelConfig_get_force_close_avoidance_max_fee_satoshis(uint64_t this_ptr) {
23750 LDKChannelConfig this_ptr_conv;
23751 this_ptr_conv.inner = untag_ptr(this_ptr);
23752 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23753 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23754 this_ptr_conv.is_owned = false;
23755 int64_t ret_conv = ChannelConfig_get_force_close_avoidance_max_fee_satoshis(&this_ptr_conv);
23759 void __attribute__((export_name("TS_ChannelConfig_set_force_close_avoidance_max_fee_satoshis"))) TS_ChannelConfig_set_force_close_avoidance_max_fee_satoshis(uint64_t this_ptr, int64_t val) {
23760 LDKChannelConfig this_ptr_conv;
23761 this_ptr_conv.inner = untag_ptr(this_ptr);
23762 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23763 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23764 this_ptr_conv.is_owned = false;
23765 ChannelConfig_set_force_close_avoidance_max_fee_satoshis(&this_ptr_conv, val);
23768 uint64_t __attribute__((export_name("TS_ChannelConfig_new"))) TS_ChannelConfig_new(int32_t forwarding_fee_proportional_millionths_arg, int32_t forwarding_fee_base_msat_arg, int16_t cltv_expiry_delta_arg, int64_t max_dust_htlc_exposure_msat_arg, int64_t force_close_avoidance_max_fee_satoshis_arg) {
23769 LDKChannelConfig ret_var = ChannelConfig_new(forwarding_fee_proportional_millionths_arg, forwarding_fee_base_msat_arg, cltv_expiry_delta_arg, max_dust_htlc_exposure_msat_arg, force_close_avoidance_max_fee_satoshis_arg);
23770 uint64_t ret_ref = 0;
23771 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23772 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23776 static inline uint64_t ChannelConfig_clone_ptr(LDKChannelConfig *NONNULL_PTR arg) {
23777 LDKChannelConfig ret_var = ChannelConfig_clone(arg);
23778 uint64_t ret_ref = 0;
23779 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23780 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23783 int64_t __attribute__((export_name("TS_ChannelConfig_clone_ptr"))) TS_ChannelConfig_clone_ptr(uint64_t arg) {
23784 LDKChannelConfig arg_conv;
23785 arg_conv.inner = untag_ptr(arg);
23786 arg_conv.is_owned = ptr_is_owned(arg);
23787 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
23788 arg_conv.is_owned = false;
23789 int64_t ret_conv = ChannelConfig_clone_ptr(&arg_conv);
23793 uint64_t __attribute__((export_name("TS_ChannelConfig_clone"))) TS_ChannelConfig_clone(uint64_t orig) {
23794 LDKChannelConfig orig_conv;
23795 orig_conv.inner = untag_ptr(orig);
23796 orig_conv.is_owned = ptr_is_owned(orig);
23797 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
23798 orig_conv.is_owned = false;
23799 LDKChannelConfig ret_var = ChannelConfig_clone(&orig_conv);
23800 uint64_t ret_ref = 0;
23801 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23802 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23806 jboolean __attribute__((export_name("TS_ChannelConfig_eq"))) TS_ChannelConfig_eq(uint64_t a, uint64_t b) {
23807 LDKChannelConfig a_conv;
23808 a_conv.inner = untag_ptr(a);
23809 a_conv.is_owned = ptr_is_owned(a);
23810 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
23811 a_conv.is_owned = false;
23812 LDKChannelConfig b_conv;
23813 b_conv.inner = untag_ptr(b);
23814 b_conv.is_owned = ptr_is_owned(b);
23815 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
23816 b_conv.is_owned = false;
23817 jboolean ret_conv = ChannelConfig_eq(&a_conv, &b_conv);
23821 uint64_t __attribute__((export_name("TS_ChannelConfig_default"))) TS_ChannelConfig_default() {
23822 LDKChannelConfig ret_var = ChannelConfig_default();
23823 uint64_t ret_ref = 0;
23824 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23825 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23829 int8_tArray __attribute__((export_name("TS_ChannelConfig_write"))) TS_ChannelConfig_write(uint64_t obj) {
23830 LDKChannelConfig obj_conv;
23831 obj_conv.inner = untag_ptr(obj);
23832 obj_conv.is_owned = ptr_is_owned(obj);
23833 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
23834 obj_conv.is_owned = false;
23835 LDKCVec_u8Z ret_var = ChannelConfig_write(&obj_conv);
23836 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
23837 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
23838 CVec_u8Z_free(ret_var);
23842 uint64_t __attribute__((export_name("TS_ChannelConfig_read"))) TS_ChannelConfig_read(int8_tArray ser) {
23843 LDKu8slice ser_ref;
23844 ser_ref.datalen = ser->arr_len;
23845 ser_ref.data = ser->elems;
23846 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
23847 *ret_conv = ChannelConfig_read(ser_ref);
23849 return tag_ptr(ret_conv, true);
23852 void __attribute__((export_name("TS_UserConfig_free"))) TS_UserConfig_free(uint64_t this_obj) {
23853 LDKUserConfig this_obj_conv;
23854 this_obj_conv.inner = untag_ptr(this_obj);
23855 this_obj_conv.is_owned = ptr_is_owned(this_obj);
23856 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
23857 UserConfig_free(this_obj_conv);
23860 uint64_t __attribute__((export_name("TS_UserConfig_get_channel_handshake_config"))) TS_UserConfig_get_channel_handshake_config(uint64_t this_ptr) {
23861 LDKUserConfig this_ptr_conv;
23862 this_ptr_conv.inner = untag_ptr(this_ptr);
23863 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23864 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23865 this_ptr_conv.is_owned = false;
23866 LDKChannelHandshakeConfig ret_var = UserConfig_get_channel_handshake_config(&this_ptr_conv);
23867 uint64_t ret_ref = 0;
23868 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23869 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23873 void __attribute__((export_name("TS_UserConfig_set_channel_handshake_config"))) TS_UserConfig_set_channel_handshake_config(uint64_t this_ptr, uint64_t val) {
23874 LDKUserConfig this_ptr_conv;
23875 this_ptr_conv.inner = untag_ptr(this_ptr);
23876 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23877 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23878 this_ptr_conv.is_owned = false;
23879 LDKChannelHandshakeConfig val_conv;
23880 val_conv.inner = untag_ptr(val);
23881 val_conv.is_owned = ptr_is_owned(val);
23882 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
23883 val_conv = ChannelHandshakeConfig_clone(&val_conv);
23884 UserConfig_set_channel_handshake_config(&this_ptr_conv, val_conv);
23887 uint64_t __attribute__((export_name("TS_UserConfig_get_channel_handshake_limits"))) TS_UserConfig_get_channel_handshake_limits(uint64_t this_ptr) {
23888 LDKUserConfig this_ptr_conv;
23889 this_ptr_conv.inner = untag_ptr(this_ptr);
23890 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23891 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23892 this_ptr_conv.is_owned = false;
23893 LDKChannelHandshakeLimits ret_var = UserConfig_get_channel_handshake_limits(&this_ptr_conv);
23894 uint64_t ret_ref = 0;
23895 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23896 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23900 void __attribute__((export_name("TS_UserConfig_set_channel_handshake_limits"))) TS_UserConfig_set_channel_handshake_limits(uint64_t this_ptr, uint64_t val) {
23901 LDKUserConfig this_ptr_conv;
23902 this_ptr_conv.inner = untag_ptr(this_ptr);
23903 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23904 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23905 this_ptr_conv.is_owned = false;
23906 LDKChannelHandshakeLimits val_conv;
23907 val_conv.inner = untag_ptr(val);
23908 val_conv.is_owned = ptr_is_owned(val);
23909 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
23910 val_conv = ChannelHandshakeLimits_clone(&val_conv);
23911 UserConfig_set_channel_handshake_limits(&this_ptr_conv, val_conv);
23914 uint64_t __attribute__((export_name("TS_UserConfig_get_channel_config"))) TS_UserConfig_get_channel_config(uint64_t this_ptr) {
23915 LDKUserConfig this_ptr_conv;
23916 this_ptr_conv.inner = untag_ptr(this_ptr);
23917 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23918 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23919 this_ptr_conv.is_owned = false;
23920 LDKChannelConfig ret_var = UserConfig_get_channel_config(&this_ptr_conv);
23921 uint64_t ret_ref = 0;
23922 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23923 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23927 void __attribute__((export_name("TS_UserConfig_set_channel_config"))) TS_UserConfig_set_channel_config(uint64_t this_ptr, uint64_t val) {
23928 LDKUserConfig this_ptr_conv;
23929 this_ptr_conv.inner = untag_ptr(this_ptr);
23930 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23931 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23932 this_ptr_conv.is_owned = false;
23933 LDKChannelConfig val_conv;
23934 val_conv.inner = untag_ptr(val);
23935 val_conv.is_owned = ptr_is_owned(val);
23936 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
23937 val_conv = ChannelConfig_clone(&val_conv);
23938 UserConfig_set_channel_config(&this_ptr_conv, val_conv);
23941 jboolean __attribute__((export_name("TS_UserConfig_get_accept_forwards_to_priv_channels"))) TS_UserConfig_get_accept_forwards_to_priv_channels(uint64_t this_ptr) {
23942 LDKUserConfig this_ptr_conv;
23943 this_ptr_conv.inner = untag_ptr(this_ptr);
23944 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23945 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23946 this_ptr_conv.is_owned = false;
23947 jboolean ret_conv = UserConfig_get_accept_forwards_to_priv_channels(&this_ptr_conv);
23951 void __attribute__((export_name("TS_UserConfig_set_accept_forwards_to_priv_channels"))) TS_UserConfig_set_accept_forwards_to_priv_channels(uint64_t this_ptr, jboolean val) {
23952 LDKUserConfig this_ptr_conv;
23953 this_ptr_conv.inner = untag_ptr(this_ptr);
23954 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23955 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23956 this_ptr_conv.is_owned = false;
23957 UserConfig_set_accept_forwards_to_priv_channels(&this_ptr_conv, val);
23960 jboolean __attribute__((export_name("TS_UserConfig_get_accept_inbound_channels"))) TS_UserConfig_get_accept_inbound_channels(uint64_t this_ptr) {
23961 LDKUserConfig this_ptr_conv;
23962 this_ptr_conv.inner = untag_ptr(this_ptr);
23963 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23964 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23965 this_ptr_conv.is_owned = false;
23966 jboolean ret_conv = UserConfig_get_accept_inbound_channels(&this_ptr_conv);
23970 void __attribute__((export_name("TS_UserConfig_set_accept_inbound_channels"))) TS_UserConfig_set_accept_inbound_channels(uint64_t this_ptr, jboolean val) {
23971 LDKUserConfig this_ptr_conv;
23972 this_ptr_conv.inner = untag_ptr(this_ptr);
23973 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23974 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23975 this_ptr_conv.is_owned = false;
23976 UserConfig_set_accept_inbound_channels(&this_ptr_conv, val);
23979 jboolean __attribute__((export_name("TS_UserConfig_get_manually_accept_inbound_channels"))) TS_UserConfig_get_manually_accept_inbound_channels(uint64_t this_ptr) {
23980 LDKUserConfig this_ptr_conv;
23981 this_ptr_conv.inner = untag_ptr(this_ptr);
23982 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23983 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23984 this_ptr_conv.is_owned = false;
23985 jboolean ret_conv = UserConfig_get_manually_accept_inbound_channels(&this_ptr_conv);
23989 void __attribute__((export_name("TS_UserConfig_set_manually_accept_inbound_channels"))) TS_UserConfig_set_manually_accept_inbound_channels(uint64_t this_ptr, jboolean val) {
23990 LDKUserConfig this_ptr_conv;
23991 this_ptr_conv.inner = untag_ptr(this_ptr);
23992 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23993 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23994 this_ptr_conv.is_owned = false;
23995 UserConfig_set_manually_accept_inbound_channels(&this_ptr_conv, val);
23998 jboolean __attribute__((export_name("TS_UserConfig_get_accept_intercept_htlcs"))) TS_UserConfig_get_accept_intercept_htlcs(uint64_t this_ptr) {
23999 LDKUserConfig this_ptr_conv;
24000 this_ptr_conv.inner = untag_ptr(this_ptr);
24001 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24002 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24003 this_ptr_conv.is_owned = false;
24004 jboolean ret_conv = UserConfig_get_accept_intercept_htlcs(&this_ptr_conv);
24008 void __attribute__((export_name("TS_UserConfig_set_accept_intercept_htlcs"))) TS_UserConfig_set_accept_intercept_htlcs(uint64_t this_ptr, jboolean val) {
24009 LDKUserConfig this_ptr_conv;
24010 this_ptr_conv.inner = untag_ptr(this_ptr);
24011 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24012 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24013 this_ptr_conv.is_owned = false;
24014 UserConfig_set_accept_intercept_htlcs(&this_ptr_conv, val);
24017 uint64_t __attribute__((export_name("TS_UserConfig_new"))) TS_UserConfig_new(uint64_t channel_handshake_config_arg, uint64_t channel_handshake_limits_arg, uint64_t channel_config_arg, jboolean accept_forwards_to_priv_channels_arg, jboolean accept_inbound_channels_arg, jboolean manually_accept_inbound_channels_arg, jboolean accept_intercept_htlcs_arg) {
24018 LDKChannelHandshakeConfig channel_handshake_config_arg_conv;
24019 channel_handshake_config_arg_conv.inner = untag_ptr(channel_handshake_config_arg);
24020 channel_handshake_config_arg_conv.is_owned = ptr_is_owned(channel_handshake_config_arg);
24021 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_handshake_config_arg_conv);
24022 channel_handshake_config_arg_conv = ChannelHandshakeConfig_clone(&channel_handshake_config_arg_conv);
24023 LDKChannelHandshakeLimits channel_handshake_limits_arg_conv;
24024 channel_handshake_limits_arg_conv.inner = untag_ptr(channel_handshake_limits_arg);
24025 channel_handshake_limits_arg_conv.is_owned = ptr_is_owned(channel_handshake_limits_arg);
24026 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_handshake_limits_arg_conv);
24027 channel_handshake_limits_arg_conv = ChannelHandshakeLimits_clone(&channel_handshake_limits_arg_conv);
24028 LDKChannelConfig channel_config_arg_conv;
24029 channel_config_arg_conv.inner = untag_ptr(channel_config_arg);
24030 channel_config_arg_conv.is_owned = ptr_is_owned(channel_config_arg);
24031 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_config_arg_conv);
24032 channel_config_arg_conv = ChannelConfig_clone(&channel_config_arg_conv);
24033 LDKUserConfig ret_var = UserConfig_new(channel_handshake_config_arg_conv, channel_handshake_limits_arg_conv, channel_config_arg_conv, accept_forwards_to_priv_channels_arg, accept_inbound_channels_arg, manually_accept_inbound_channels_arg, accept_intercept_htlcs_arg);
24034 uint64_t ret_ref = 0;
24035 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24036 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24040 static inline uint64_t UserConfig_clone_ptr(LDKUserConfig *NONNULL_PTR arg) {
24041 LDKUserConfig ret_var = UserConfig_clone(arg);
24042 uint64_t ret_ref = 0;
24043 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24044 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24047 int64_t __attribute__((export_name("TS_UserConfig_clone_ptr"))) TS_UserConfig_clone_ptr(uint64_t arg) {
24048 LDKUserConfig arg_conv;
24049 arg_conv.inner = untag_ptr(arg);
24050 arg_conv.is_owned = ptr_is_owned(arg);
24051 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
24052 arg_conv.is_owned = false;
24053 int64_t ret_conv = UserConfig_clone_ptr(&arg_conv);
24057 uint64_t __attribute__((export_name("TS_UserConfig_clone"))) TS_UserConfig_clone(uint64_t orig) {
24058 LDKUserConfig orig_conv;
24059 orig_conv.inner = untag_ptr(orig);
24060 orig_conv.is_owned = ptr_is_owned(orig);
24061 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
24062 orig_conv.is_owned = false;
24063 LDKUserConfig ret_var = UserConfig_clone(&orig_conv);
24064 uint64_t ret_ref = 0;
24065 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24066 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24070 uint64_t __attribute__((export_name("TS_UserConfig_default"))) TS_UserConfig_default() {
24071 LDKUserConfig ret_var = UserConfig_default();
24072 uint64_t ret_ref = 0;
24073 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24074 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24078 void __attribute__((export_name("TS_BestBlock_free"))) TS_BestBlock_free(uint64_t this_obj) {
24079 LDKBestBlock this_obj_conv;
24080 this_obj_conv.inner = untag_ptr(this_obj);
24081 this_obj_conv.is_owned = ptr_is_owned(this_obj);
24082 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
24083 BestBlock_free(this_obj_conv);
24086 static inline uint64_t BestBlock_clone_ptr(LDKBestBlock *NONNULL_PTR arg) {
24087 LDKBestBlock ret_var = BestBlock_clone(arg);
24088 uint64_t ret_ref = 0;
24089 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24090 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24093 int64_t __attribute__((export_name("TS_BestBlock_clone_ptr"))) TS_BestBlock_clone_ptr(uint64_t arg) {
24094 LDKBestBlock arg_conv;
24095 arg_conv.inner = untag_ptr(arg);
24096 arg_conv.is_owned = ptr_is_owned(arg);
24097 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
24098 arg_conv.is_owned = false;
24099 int64_t ret_conv = BestBlock_clone_ptr(&arg_conv);
24103 uint64_t __attribute__((export_name("TS_BestBlock_clone"))) TS_BestBlock_clone(uint64_t orig) {
24104 LDKBestBlock orig_conv;
24105 orig_conv.inner = untag_ptr(orig);
24106 orig_conv.is_owned = ptr_is_owned(orig);
24107 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
24108 orig_conv.is_owned = false;
24109 LDKBestBlock ret_var = BestBlock_clone(&orig_conv);
24110 uint64_t ret_ref = 0;
24111 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24112 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24116 jboolean __attribute__((export_name("TS_BestBlock_eq"))) TS_BestBlock_eq(uint64_t a, uint64_t b) {
24117 LDKBestBlock a_conv;
24118 a_conv.inner = untag_ptr(a);
24119 a_conv.is_owned = ptr_is_owned(a);
24120 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
24121 a_conv.is_owned = false;
24122 LDKBestBlock b_conv;
24123 b_conv.inner = untag_ptr(b);
24124 b_conv.is_owned = ptr_is_owned(b);
24125 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
24126 b_conv.is_owned = false;
24127 jboolean ret_conv = BestBlock_eq(&a_conv, &b_conv);
24131 uint64_t __attribute__((export_name("TS_BestBlock_from_genesis"))) TS_BestBlock_from_genesis(uint32_t network) {
24132 LDKNetwork network_conv = LDKNetwork_from_js(network);
24133 LDKBestBlock ret_var = BestBlock_from_genesis(network_conv);
24134 uint64_t ret_ref = 0;
24135 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24136 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24140 uint64_t __attribute__((export_name("TS_BestBlock_new"))) TS_BestBlock_new(int8_tArray block_hash, int32_t height) {
24141 LDKThirtyTwoBytes block_hash_ref;
24142 CHECK(block_hash->arr_len == 32);
24143 memcpy(block_hash_ref.data, block_hash->elems, 32); FREE(block_hash);
24144 LDKBestBlock ret_var = BestBlock_new(block_hash_ref, height);
24145 uint64_t ret_ref = 0;
24146 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24147 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24151 int8_tArray __attribute__((export_name("TS_BestBlock_block_hash"))) TS_BestBlock_block_hash(uint64_t this_arg) {
24152 LDKBestBlock this_arg_conv;
24153 this_arg_conv.inner = untag_ptr(this_arg);
24154 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24155 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24156 this_arg_conv.is_owned = false;
24157 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
24158 memcpy(ret_arr->elems, BestBlock_block_hash(&this_arg_conv).data, 32);
24162 int32_t __attribute__((export_name("TS_BestBlock_height"))) TS_BestBlock_height(uint64_t this_arg) {
24163 LDKBestBlock this_arg_conv;
24164 this_arg_conv.inner = untag_ptr(this_arg);
24165 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24166 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24167 this_arg_conv.is_owned = false;
24168 int32_t ret_conv = BestBlock_height(&this_arg_conv);
24172 uint32_t __attribute__((export_name("TS_AccessError_clone"))) TS_AccessError_clone(uint64_t orig) {
24173 LDKAccessError* orig_conv = (LDKAccessError*)untag_ptr(orig);
24174 uint32_t ret_conv = LDKAccessError_to_js(AccessError_clone(orig_conv));
24178 uint32_t __attribute__((export_name("TS_AccessError_unknown_chain"))) TS_AccessError_unknown_chain() {
24179 uint32_t ret_conv = LDKAccessError_to_js(AccessError_unknown_chain());
24183 uint32_t __attribute__((export_name("TS_AccessError_unknown_tx"))) TS_AccessError_unknown_tx() {
24184 uint32_t ret_conv = LDKAccessError_to_js(AccessError_unknown_tx());
24188 void __attribute__((export_name("TS_Access_free"))) TS_Access_free(uint64_t this_ptr) {
24189 if (!ptr_is_owned(this_ptr)) return;
24190 void* this_ptr_ptr = untag_ptr(this_ptr);
24191 CHECK_ACCESS(this_ptr_ptr);
24192 LDKAccess this_ptr_conv = *(LDKAccess*)(this_ptr_ptr);
24193 FREE(untag_ptr(this_ptr));
24194 Access_free(this_ptr_conv);
24197 void __attribute__((export_name("TS_Listen_free"))) TS_Listen_free(uint64_t this_ptr) {
24198 if (!ptr_is_owned(this_ptr)) return;
24199 void* this_ptr_ptr = untag_ptr(this_ptr);
24200 CHECK_ACCESS(this_ptr_ptr);
24201 LDKListen this_ptr_conv = *(LDKListen*)(this_ptr_ptr);
24202 FREE(untag_ptr(this_ptr));
24203 Listen_free(this_ptr_conv);
24206 void __attribute__((export_name("TS_Confirm_free"))) TS_Confirm_free(uint64_t this_ptr) {
24207 if (!ptr_is_owned(this_ptr)) return;
24208 void* this_ptr_ptr = untag_ptr(this_ptr);
24209 CHECK_ACCESS(this_ptr_ptr);
24210 LDKConfirm this_ptr_conv = *(LDKConfirm*)(this_ptr_ptr);
24211 FREE(untag_ptr(this_ptr));
24212 Confirm_free(this_ptr_conv);
24215 uint32_t __attribute__((export_name("TS_ChannelMonitorUpdateStatus_clone"))) TS_ChannelMonitorUpdateStatus_clone(uint64_t orig) {
24216 LDKChannelMonitorUpdateStatus* orig_conv = (LDKChannelMonitorUpdateStatus*)untag_ptr(orig);
24217 uint32_t ret_conv = LDKChannelMonitorUpdateStatus_to_js(ChannelMonitorUpdateStatus_clone(orig_conv));
24221 uint32_t __attribute__((export_name("TS_ChannelMonitorUpdateStatus_completed"))) TS_ChannelMonitorUpdateStatus_completed() {
24222 uint32_t ret_conv = LDKChannelMonitorUpdateStatus_to_js(ChannelMonitorUpdateStatus_completed());
24226 uint32_t __attribute__((export_name("TS_ChannelMonitorUpdateStatus_in_progress"))) TS_ChannelMonitorUpdateStatus_in_progress() {
24227 uint32_t ret_conv = LDKChannelMonitorUpdateStatus_to_js(ChannelMonitorUpdateStatus_in_progress());
24231 uint32_t __attribute__((export_name("TS_ChannelMonitorUpdateStatus_permanent_failure"))) TS_ChannelMonitorUpdateStatus_permanent_failure() {
24232 uint32_t ret_conv = LDKChannelMonitorUpdateStatus_to_js(ChannelMonitorUpdateStatus_permanent_failure());
24236 jboolean __attribute__((export_name("TS_ChannelMonitorUpdateStatus_eq"))) TS_ChannelMonitorUpdateStatus_eq(uint64_t a, uint64_t b) {
24237 LDKChannelMonitorUpdateStatus* a_conv = (LDKChannelMonitorUpdateStatus*)untag_ptr(a);
24238 LDKChannelMonitorUpdateStatus* b_conv = (LDKChannelMonitorUpdateStatus*)untag_ptr(b);
24239 jboolean ret_conv = ChannelMonitorUpdateStatus_eq(a_conv, b_conv);
24243 void __attribute__((export_name("TS_Watch_free"))) TS_Watch_free(uint64_t this_ptr) {
24244 if (!ptr_is_owned(this_ptr)) return;
24245 void* this_ptr_ptr = untag_ptr(this_ptr);
24246 CHECK_ACCESS(this_ptr_ptr);
24247 LDKWatch this_ptr_conv = *(LDKWatch*)(this_ptr_ptr);
24248 FREE(untag_ptr(this_ptr));
24249 Watch_free(this_ptr_conv);
24252 void __attribute__((export_name("TS_Filter_free"))) TS_Filter_free(uint64_t this_ptr) {
24253 if (!ptr_is_owned(this_ptr)) return;
24254 void* this_ptr_ptr = untag_ptr(this_ptr);
24255 CHECK_ACCESS(this_ptr_ptr);
24256 LDKFilter this_ptr_conv = *(LDKFilter*)(this_ptr_ptr);
24257 FREE(untag_ptr(this_ptr));
24258 Filter_free(this_ptr_conv);
24261 void __attribute__((export_name("TS_WatchedOutput_free"))) TS_WatchedOutput_free(uint64_t this_obj) {
24262 LDKWatchedOutput this_obj_conv;
24263 this_obj_conv.inner = untag_ptr(this_obj);
24264 this_obj_conv.is_owned = ptr_is_owned(this_obj);
24265 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
24266 WatchedOutput_free(this_obj_conv);
24269 int8_tArray __attribute__((export_name("TS_WatchedOutput_get_block_hash"))) TS_WatchedOutput_get_block_hash(uint64_t this_ptr) {
24270 LDKWatchedOutput this_ptr_conv;
24271 this_ptr_conv.inner = untag_ptr(this_ptr);
24272 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24273 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24274 this_ptr_conv.is_owned = false;
24275 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
24276 memcpy(ret_arr->elems, WatchedOutput_get_block_hash(&this_ptr_conv).data, 32);
24280 void __attribute__((export_name("TS_WatchedOutput_set_block_hash"))) TS_WatchedOutput_set_block_hash(uint64_t this_ptr, int8_tArray val) {
24281 LDKWatchedOutput this_ptr_conv;
24282 this_ptr_conv.inner = untag_ptr(this_ptr);
24283 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24284 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24285 this_ptr_conv.is_owned = false;
24286 LDKThirtyTwoBytes val_ref;
24287 CHECK(val->arr_len == 32);
24288 memcpy(val_ref.data, val->elems, 32); FREE(val);
24289 WatchedOutput_set_block_hash(&this_ptr_conv, val_ref);
24292 uint64_t __attribute__((export_name("TS_WatchedOutput_get_outpoint"))) TS_WatchedOutput_get_outpoint(uint64_t this_ptr) {
24293 LDKWatchedOutput this_ptr_conv;
24294 this_ptr_conv.inner = untag_ptr(this_ptr);
24295 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24296 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24297 this_ptr_conv.is_owned = false;
24298 LDKOutPoint ret_var = WatchedOutput_get_outpoint(&this_ptr_conv);
24299 uint64_t ret_ref = 0;
24300 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24301 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24305 void __attribute__((export_name("TS_WatchedOutput_set_outpoint"))) TS_WatchedOutput_set_outpoint(uint64_t this_ptr, uint64_t val) {
24306 LDKWatchedOutput this_ptr_conv;
24307 this_ptr_conv.inner = untag_ptr(this_ptr);
24308 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24309 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24310 this_ptr_conv.is_owned = false;
24311 LDKOutPoint val_conv;
24312 val_conv.inner = untag_ptr(val);
24313 val_conv.is_owned = ptr_is_owned(val);
24314 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
24315 val_conv = OutPoint_clone(&val_conv);
24316 WatchedOutput_set_outpoint(&this_ptr_conv, val_conv);
24319 int8_tArray __attribute__((export_name("TS_WatchedOutput_get_script_pubkey"))) TS_WatchedOutput_get_script_pubkey(uint64_t this_ptr) {
24320 LDKWatchedOutput this_ptr_conv;
24321 this_ptr_conv.inner = untag_ptr(this_ptr);
24322 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24323 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24324 this_ptr_conv.is_owned = false;
24325 LDKu8slice ret_var = WatchedOutput_get_script_pubkey(&this_ptr_conv);
24326 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
24327 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
24331 void __attribute__((export_name("TS_WatchedOutput_set_script_pubkey"))) TS_WatchedOutput_set_script_pubkey(uint64_t this_ptr, int8_tArray val) {
24332 LDKWatchedOutput this_ptr_conv;
24333 this_ptr_conv.inner = untag_ptr(this_ptr);
24334 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24335 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24336 this_ptr_conv.is_owned = false;
24337 LDKCVec_u8Z val_ref;
24338 val_ref.datalen = val->arr_len;
24339 val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
24340 memcpy(val_ref.data, val->elems, val_ref.datalen); FREE(val);
24341 WatchedOutput_set_script_pubkey(&this_ptr_conv, val_ref);
24344 uint64_t __attribute__((export_name("TS_WatchedOutput_new"))) TS_WatchedOutput_new(int8_tArray block_hash_arg, uint64_t outpoint_arg, int8_tArray script_pubkey_arg) {
24345 LDKThirtyTwoBytes block_hash_arg_ref;
24346 CHECK(block_hash_arg->arr_len == 32);
24347 memcpy(block_hash_arg_ref.data, block_hash_arg->elems, 32); FREE(block_hash_arg);
24348 LDKOutPoint outpoint_arg_conv;
24349 outpoint_arg_conv.inner = untag_ptr(outpoint_arg);
24350 outpoint_arg_conv.is_owned = ptr_is_owned(outpoint_arg);
24351 CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_arg_conv);
24352 outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
24353 LDKCVec_u8Z script_pubkey_arg_ref;
24354 script_pubkey_arg_ref.datalen = script_pubkey_arg->arr_len;
24355 script_pubkey_arg_ref.data = MALLOC(script_pubkey_arg_ref.datalen, "LDKCVec_u8Z Bytes");
24356 memcpy(script_pubkey_arg_ref.data, script_pubkey_arg->elems, script_pubkey_arg_ref.datalen); FREE(script_pubkey_arg);
24357 LDKWatchedOutput ret_var = WatchedOutput_new(block_hash_arg_ref, outpoint_arg_conv, script_pubkey_arg_ref);
24358 uint64_t ret_ref = 0;
24359 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24360 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24364 static inline uint64_t WatchedOutput_clone_ptr(LDKWatchedOutput *NONNULL_PTR arg) {
24365 LDKWatchedOutput ret_var = WatchedOutput_clone(arg);
24366 uint64_t ret_ref = 0;
24367 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24368 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24371 int64_t __attribute__((export_name("TS_WatchedOutput_clone_ptr"))) TS_WatchedOutput_clone_ptr(uint64_t arg) {
24372 LDKWatchedOutput arg_conv;
24373 arg_conv.inner = untag_ptr(arg);
24374 arg_conv.is_owned = ptr_is_owned(arg);
24375 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
24376 arg_conv.is_owned = false;
24377 int64_t ret_conv = WatchedOutput_clone_ptr(&arg_conv);
24381 uint64_t __attribute__((export_name("TS_WatchedOutput_clone"))) TS_WatchedOutput_clone(uint64_t orig) {
24382 LDKWatchedOutput orig_conv;
24383 orig_conv.inner = untag_ptr(orig);
24384 orig_conv.is_owned = ptr_is_owned(orig);
24385 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
24386 orig_conv.is_owned = false;
24387 LDKWatchedOutput ret_var = WatchedOutput_clone(&orig_conv);
24388 uint64_t ret_ref = 0;
24389 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24390 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24394 jboolean __attribute__((export_name("TS_WatchedOutput_eq"))) TS_WatchedOutput_eq(uint64_t a, uint64_t b) {
24395 LDKWatchedOutput a_conv;
24396 a_conv.inner = untag_ptr(a);
24397 a_conv.is_owned = ptr_is_owned(a);
24398 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
24399 a_conv.is_owned = false;
24400 LDKWatchedOutput b_conv;
24401 b_conv.inner = untag_ptr(b);
24402 b_conv.is_owned = ptr_is_owned(b);
24403 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
24404 b_conv.is_owned = false;
24405 jboolean ret_conv = WatchedOutput_eq(&a_conv, &b_conv);
24409 int64_t __attribute__((export_name("TS_WatchedOutput_hash"))) TS_WatchedOutput_hash(uint64_t o) {
24410 LDKWatchedOutput o_conv;
24411 o_conv.inner = untag_ptr(o);
24412 o_conv.is_owned = ptr_is_owned(o);
24413 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
24414 o_conv.is_owned = false;
24415 int64_t ret_conv = WatchedOutput_hash(&o_conv);
24419 void __attribute__((export_name("TS_BroadcasterInterface_free"))) TS_BroadcasterInterface_free(uint64_t this_ptr) {
24420 if (!ptr_is_owned(this_ptr)) return;
24421 void* this_ptr_ptr = untag_ptr(this_ptr);
24422 CHECK_ACCESS(this_ptr_ptr);
24423 LDKBroadcasterInterface this_ptr_conv = *(LDKBroadcasterInterface*)(this_ptr_ptr);
24424 FREE(untag_ptr(this_ptr));
24425 BroadcasterInterface_free(this_ptr_conv);
24428 uint32_t __attribute__((export_name("TS_ConfirmationTarget_clone"))) TS_ConfirmationTarget_clone(uint64_t orig) {
24429 LDKConfirmationTarget* orig_conv = (LDKConfirmationTarget*)untag_ptr(orig);
24430 uint32_t ret_conv = LDKConfirmationTarget_to_js(ConfirmationTarget_clone(orig_conv));
24434 uint32_t __attribute__((export_name("TS_ConfirmationTarget_background"))) TS_ConfirmationTarget_background() {
24435 uint32_t ret_conv = LDKConfirmationTarget_to_js(ConfirmationTarget_background());
24439 uint32_t __attribute__((export_name("TS_ConfirmationTarget_normal"))) TS_ConfirmationTarget_normal() {
24440 uint32_t ret_conv = LDKConfirmationTarget_to_js(ConfirmationTarget_normal());
24444 uint32_t __attribute__((export_name("TS_ConfirmationTarget_high_priority"))) TS_ConfirmationTarget_high_priority() {
24445 uint32_t ret_conv = LDKConfirmationTarget_to_js(ConfirmationTarget_high_priority());
24449 int64_t __attribute__((export_name("TS_ConfirmationTarget_hash"))) TS_ConfirmationTarget_hash(uint64_t o) {
24450 LDKConfirmationTarget* o_conv = (LDKConfirmationTarget*)untag_ptr(o);
24451 int64_t ret_conv = ConfirmationTarget_hash(o_conv);
24455 jboolean __attribute__((export_name("TS_ConfirmationTarget_eq"))) TS_ConfirmationTarget_eq(uint64_t a, uint64_t b) {
24456 LDKConfirmationTarget* a_conv = (LDKConfirmationTarget*)untag_ptr(a);
24457 LDKConfirmationTarget* b_conv = (LDKConfirmationTarget*)untag_ptr(b);
24458 jboolean ret_conv = ConfirmationTarget_eq(a_conv, b_conv);
24462 void __attribute__((export_name("TS_FeeEstimator_free"))) TS_FeeEstimator_free(uint64_t this_ptr) {
24463 if (!ptr_is_owned(this_ptr)) return;
24464 void* this_ptr_ptr = untag_ptr(this_ptr);
24465 CHECK_ACCESS(this_ptr_ptr);
24466 LDKFeeEstimator this_ptr_conv = *(LDKFeeEstimator*)(this_ptr_ptr);
24467 FREE(untag_ptr(this_ptr));
24468 FeeEstimator_free(this_ptr_conv);
24471 void __attribute__((export_name("TS_MonitorUpdateId_free"))) TS_MonitorUpdateId_free(uint64_t this_obj) {
24472 LDKMonitorUpdateId this_obj_conv;
24473 this_obj_conv.inner = untag_ptr(this_obj);
24474 this_obj_conv.is_owned = ptr_is_owned(this_obj);
24475 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
24476 MonitorUpdateId_free(this_obj_conv);
24479 static inline uint64_t MonitorUpdateId_clone_ptr(LDKMonitorUpdateId *NONNULL_PTR arg) {
24480 LDKMonitorUpdateId ret_var = MonitorUpdateId_clone(arg);
24481 uint64_t ret_ref = 0;
24482 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24483 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24486 int64_t __attribute__((export_name("TS_MonitorUpdateId_clone_ptr"))) TS_MonitorUpdateId_clone_ptr(uint64_t arg) {
24487 LDKMonitorUpdateId arg_conv;
24488 arg_conv.inner = untag_ptr(arg);
24489 arg_conv.is_owned = ptr_is_owned(arg);
24490 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
24491 arg_conv.is_owned = false;
24492 int64_t ret_conv = MonitorUpdateId_clone_ptr(&arg_conv);
24496 uint64_t __attribute__((export_name("TS_MonitorUpdateId_clone"))) TS_MonitorUpdateId_clone(uint64_t orig) {
24497 LDKMonitorUpdateId orig_conv;
24498 orig_conv.inner = untag_ptr(orig);
24499 orig_conv.is_owned = ptr_is_owned(orig);
24500 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
24501 orig_conv.is_owned = false;
24502 LDKMonitorUpdateId ret_var = MonitorUpdateId_clone(&orig_conv);
24503 uint64_t ret_ref = 0;
24504 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24505 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24509 int64_t __attribute__((export_name("TS_MonitorUpdateId_hash"))) TS_MonitorUpdateId_hash(uint64_t o) {
24510 LDKMonitorUpdateId o_conv;
24511 o_conv.inner = untag_ptr(o);
24512 o_conv.is_owned = ptr_is_owned(o);
24513 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
24514 o_conv.is_owned = false;
24515 int64_t ret_conv = MonitorUpdateId_hash(&o_conv);
24519 jboolean __attribute__((export_name("TS_MonitorUpdateId_eq"))) TS_MonitorUpdateId_eq(uint64_t a, uint64_t b) {
24520 LDKMonitorUpdateId a_conv;
24521 a_conv.inner = untag_ptr(a);
24522 a_conv.is_owned = ptr_is_owned(a);
24523 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
24524 a_conv.is_owned = false;
24525 LDKMonitorUpdateId b_conv;
24526 b_conv.inner = untag_ptr(b);
24527 b_conv.is_owned = ptr_is_owned(b);
24528 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
24529 b_conv.is_owned = false;
24530 jboolean ret_conv = MonitorUpdateId_eq(&a_conv, &b_conv);
24534 void __attribute__((export_name("TS_Persist_free"))) TS_Persist_free(uint64_t this_ptr) {
24535 if (!ptr_is_owned(this_ptr)) return;
24536 void* this_ptr_ptr = untag_ptr(this_ptr);
24537 CHECK_ACCESS(this_ptr_ptr);
24538 LDKPersist this_ptr_conv = *(LDKPersist*)(this_ptr_ptr);
24539 FREE(untag_ptr(this_ptr));
24540 Persist_free(this_ptr_conv);
24543 void __attribute__((export_name("TS_LockedChannelMonitor_free"))) TS_LockedChannelMonitor_free(uint64_t this_obj) {
24544 LDKLockedChannelMonitor this_obj_conv;
24545 this_obj_conv.inner = untag_ptr(this_obj);
24546 this_obj_conv.is_owned = ptr_is_owned(this_obj);
24547 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
24548 LockedChannelMonitor_free(this_obj_conv);
24551 void __attribute__((export_name("TS_ChainMonitor_free"))) TS_ChainMonitor_free(uint64_t this_obj) {
24552 LDKChainMonitor this_obj_conv;
24553 this_obj_conv.inner = untag_ptr(this_obj);
24554 this_obj_conv.is_owned = ptr_is_owned(this_obj);
24555 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
24556 ChainMonitor_free(this_obj_conv);
24559 uint64_t __attribute__((export_name("TS_ChainMonitor_new"))) TS_ChainMonitor_new(uint64_t chain_source, uint64_t broadcaster, uint64_t logger, uint64_t feeest, uint64_t persister) {
24560 void* chain_source_ptr = untag_ptr(chain_source);
24561 CHECK_ACCESS(chain_source_ptr);
24562 LDKCOption_FilterZ chain_source_conv = *(LDKCOption_FilterZ*)(chain_source_ptr);
24563 // WARNING: we may need a move here but no clone is available for LDKCOption_FilterZ
24564 if (chain_source_conv.tag == LDKCOption_FilterZ_Some) {
24565 // Manually implement clone for Java trait instances
24566 if (chain_source_conv.some.free == LDKFilter_JCalls_free) {
24567 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
24568 LDKFilter_JCalls_cloned(&chain_source_conv.some);
24571 void* broadcaster_ptr = untag_ptr(broadcaster);
24572 CHECK_ACCESS(broadcaster_ptr);
24573 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
24574 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
24575 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
24576 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
24578 void* logger_ptr = untag_ptr(logger);
24579 CHECK_ACCESS(logger_ptr);
24580 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
24581 if (logger_conv.free == LDKLogger_JCalls_free) {
24582 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
24583 LDKLogger_JCalls_cloned(&logger_conv);
24585 void* feeest_ptr = untag_ptr(feeest);
24586 CHECK_ACCESS(feeest_ptr);
24587 LDKFeeEstimator feeest_conv = *(LDKFeeEstimator*)(feeest_ptr);
24588 if (feeest_conv.free == LDKFeeEstimator_JCalls_free) {
24589 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
24590 LDKFeeEstimator_JCalls_cloned(&feeest_conv);
24592 void* persister_ptr = untag_ptr(persister);
24593 CHECK_ACCESS(persister_ptr);
24594 LDKPersist persister_conv = *(LDKPersist*)(persister_ptr);
24595 if (persister_conv.free == LDKPersist_JCalls_free) {
24596 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
24597 LDKPersist_JCalls_cloned(&persister_conv);
24599 LDKChainMonitor ret_var = ChainMonitor_new(chain_source_conv, broadcaster_conv, logger_conv, feeest_conv, persister_conv);
24600 uint64_t ret_ref = 0;
24601 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24602 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24606 uint64_tArray __attribute__((export_name("TS_ChainMonitor_get_claimable_balances"))) TS_ChainMonitor_get_claimable_balances(uint64_t this_arg, uint64_tArray ignored_channels) {
24607 LDKChainMonitor this_arg_conv;
24608 this_arg_conv.inner = untag_ptr(this_arg);
24609 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24610 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24611 this_arg_conv.is_owned = false;
24612 LDKCVec_ChannelDetailsZ ignored_channels_constr;
24613 ignored_channels_constr.datalen = ignored_channels->arr_len;
24614 if (ignored_channels_constr.datalen > 0)
24615 ignored_channels_constr.data = MALLOC(ignored_channels_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
24617 ignored_channels_constr.data = NULL;
24618 uint64_t* ignored_channels_vals = ignored_channels->elems;
24619 for (size_t q = 0; q < ignored_channels_constr.datalen; q++) {
24620 uint64_t ignored_channels_conv_16 = ignored_channels_vals[q];
24621 LDKChannelDetails ignored_channels_conv_16_conv;
24622 ignored_channels_conv_16_conv.inner = untag_ptr(ignored_channels_conv_16);
24623 ignored_channels_conv_16_conv.is_owned = ptr_is_owned(ignored_channels_conv_16);
24624 CHECK_INNER_FIELD_ACCESS_OR_NULL(ignored_channels_conv_16_conv);
24625 ignored_channels_conv_16_conv = ChannelDetails_clone(&ignored_channels_conv_16_conv);
24626 ignored_channels_constr.data[q] = ignored_channels_conv_16_conv;
24628 FREE(ignored_channels);
24629 LDKCVec_BalanceZ ret_var = ChainMonitor_get_claimable_balances(&this_arg_conv, ignored_channels_constr);
24630 uint64_tArray ret_arr = NULL;
24631 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
24632 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
24633 for (size_t j = 0; j < ret_var.datalen; j++) {
24634 LDKBalance *ret_conv_9_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
24635 *ret_conv_9_copy = ret_var.data[j];
24636 uint64_t ret_conv_9_ref = tag_ptr(ret_conv_9_copy, true);
24637 ret_arr_ptr[j] = ret_conv_9_ref;
24640 FREE(ret_var.data);
24644 uint64_t __attribute__((export_name("TS_ChainMonitor_get_monitor"))) TS_ChainMonitor_get_monitor(uint64_t this_arg, uint64_t funding_txo) {
24645 LDKChainMonitor this_arg_conv;
24646 this_arg_conv.inner = untag_ptr(this_arg);
24647 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24648 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24649 this_arg_conv.is_owned = false;
24650 LDKOutPoint funding_txo_conv;
24651 funding_txo_conv.inner = untag_ptr(funding_txo);
24652 funding_txo_conv.is_owned = ptr_is_owned(funding_txo);
24653 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
24654 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
24655 LDKCResult_LockedChannelMonitorNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_LockedChannelMonitorNoneZ), "LDKCResult_LockedChannelMonitorNoneZ");
24656 *ret_conv = ChainMonitor_get_monitor(&this_arg_conv, funding_txo_conv);
24657 return tag_ptr(ret_conv, true);
24660 uint64_tArray __attribute__((export_name("TS_ChainMonitor_list_monitors"))) TS_ChainMonitor_list_monitors(uint64_t this_arg) {
24661 LDKChainMonitor this_arg_conv;
24662 this_arg_conv.inner = untag_ptr(this_arg);
24663 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24664 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24665 this_arg_conv.is_owned = false;
24666 LDKCVec_OutPointZ ret_var = ChainMonitor_list_monitors(&this_arg_conv);
24667 uint64_tArray ret_arr = NULL;
24668 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
24669 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
24670 for (size_t k = 0; k < ret_var.datalen; k++) {
24671 LDKOutPoint ret_conv_10_var = ret_var.data[k];
24672 uint64_t ret_conv_10_ref = 0;
24673 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_10_var);
24674 ret_conv_10_ref = tag_ptr(ret_conv_10_var.inner, ret_conv_10_var.is_owned);
24675 ret_arr_ptr[k] = ret_conv_10_ref;
24678 FREE(ret_var.data);
24682 uint64_tArray __attribute__((export_name("TS_ChainMonitor_list_pending_monitor_updates"))) TS_ChainMonitor_list_pending_monitor_updates(uint64_t this_arg) {
24683 LDKChainMonitor this_arg_conv;
24684 this_arg_conv.inner = untag_ptr(this_arg);
24685 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24686 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24687 this_arg_conv.is_owned = false;
24688 LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ ret_var = ChainMonitor_list_pending_monitor_updates(&this_arg_conv);
24689 uint64_tArray ret_arr = NULL;
24690 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
24691 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
24692 for (size_t p = 0; p < ret_var.datalen; p++) {
24693 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* ret_conv_41_conv = MALLOC(sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ), "LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ");
24694 *ret_conv_41_conv = ret_var.data[p];
24695 ret_arr_ptr[p] = tag_ptr(ret_conv_41_conv, true);
24698 FREE(ret_var.data);
24702 uint64_t __attribute__((export_name("TS_ChainMonitor_channel_monitor_updated"))) TS_ChainMonitor_channel_monitor_updated(uint64_t this_arg, uint64_t funding_txo, uint64_t completed_update_id) {
24703 LDKChainMonitor this_arg_conv;
24704 this_arg_conv.inner = untag_ptr(this_arg);
24705 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24706 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24707 this_arg_conv.is_owned = false;
24708 LDKOutPoint funding_txo_conv;
24709 funding_txo_conv.inner = untag_ptr(funding_txo);
24710 funding_txo_conv.is_owned = ptr_is_owned(funding_txo);
24711 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
24712 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
24713 LDKMonitorUpdateId completed_update_id_conv;
24714 completed_update_id_conv.inner = untag_ptr(completed_update_id);
24715 completed_update_id_conv.is_owned = ptr_is_owned(completed_update_id);
24716 CHECK_INNER_FIELD_ACCESS_OR_NULL(completed_update_id_conv);
24717 completed_update_id_conv = MonitorUpdateId_clone(&completed_update_id_conv);
24718 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
24719 *ret_conv = ChainMonitor_channel_monitor_updated(&this_arg_conv, funding_txo_conv, completed_update_id_conv);
24720 return tag_ptr(ret_conv, true);
24723 uint64_t __attribute__((export_name("TS_ChainMonitor_as_Listen"))) TS_ChainMonitor_as_Listen(uint64_t this_arg) {
24724 LDKChainMonitor this_arg_conv;
24725 this_arg_conv.inner = untag_ptr(this_arg);
24726 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24727 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24728 this_arg_conv.is_owned = false;
24729 LDKListen* ret_ret = MALLOC(sizeof(LDKListen), "LDKListen");
24730 *ret_ret = ChainMonitor_as_Listen(&this_arg_conv);
24731 return tag_ptr(ret_ret, true);
24734 uint64_t __attribute__((export_name("TS_ChainMonitor_as_Confirm"))) TS_ChainMonitor_as_Confirm(uint64_t this_arg) {
24735 LDKChainMonitor this_arg_conv;
24736 this_arg_conv.inner = untag_ptr(this_arg);
24737 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24738 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24739 this_arg_conv.is_owned = false;
24740 LDKConfirm* ret_ret = MALLOC(sizeof(LDKConfirm), "LDKConfirm");
24741 *ret_ret = ChainMonitor_as_Confirm(&this_arg_conv);
24742 return tag_ptr(ret_ret, true);
24745 uint64_t __attribute__((export_name("TS_ChainMonitor_as_Watch"))) TS_ChainMonitor_as_Watch(uint64_t this_arg) {
24746 LDKChainMonitor this_arg_conv;
24747 this_arg_conv.inner = untag_ptr(this_arg);
24748 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24749 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24750 this_arg_conv.is_owned = false;
24751 LDKWatch* ret_ret = MALLOC(sizeof(LDKWatch), "LDKWatch");
24752 *ret_ret = ChainMonitor_as_Watch(&this_arg_conv);
24753 return tag_ptr(ret_ret, true);
24756 uint64_t __attribute__((export_name("TS_ChainMonitor_as_EventsProvider"))) TS_ChainMonitor_as_EventsProvider(uint64_t this_arg) {
24757 LDKChainMonitor this_arg_conv;
24758 this_arg_conv.inner = untag_ptr(this_arg);
24759 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24760 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24761 this_arg_conv.is_owned = false;
24762 LDKEventsProvider* ret_ret = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider");
24763 *ret_ret = ChainMonitor_as_EventsProvider(&this_arg_conv);
24764 return tag_ptr(ret_ret, true);
24767 void __attribute__((export_name("TS_ChannelMonitorUpdate_free"))) TS_ChannelMonitorUpdate_free(uint64_t this_obj) {
24768 LDKChannelMonitorUpdate this_obj_conv;
24769 this_obj_conv.inner = untag_ptr(this_obj);
24770 this_obj_conv.is_owned = ptr_is_owned(this_obj);
24771 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
24772 ChannelMonitorUpdate_free(this_obj_conv);
24775 int64_t __attribute__((export_name("TS_ChannelMonitorUpdate_get_update_id"))) TS_ChannelMonitorUpdate_get_update_id(uint64_t this_ptr) {
24776 LDKChannelMonitorUpdate this_ptr_conv;
24777 this_ptr_conv.inner = untag_ptr(this_ptr);
24778 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24779 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24780 this_ptr_conv.is_owned = false;
24781 int64_t ret_conv = ChannelMonitorUpdate_get_update_id(&this_ptr_conv);
24785 void __attribute__((export_name("TS_ChannelMonitorUpdate_set_update_id"))) TS_ChannelMonitorUpdate_set_update_id(uint64_t this_ptr, int64_t val) {
24786 LDKChannelMonitorUpdate this_ptr_conv;
24787 this_ptr_conv.inner = untag_ptr(this_ptr);
24788 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24789 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24790 this_ptr_conv.is_owned = false;
24791 ChannelMonitorUpdate_set_update_id(&this_ptr_conv, val);
24794 static inline uint64_t ChannelMonitorUpdate_clone_ptr(LDKChannelMonitorUpdate *NONNULL_PTR arg) {
24795 LDKChannelMonitorUpdate ret_var = ChannelMonitorUpdate_clone(arg);
24796 uint64_t ret_ref = 0;
24797 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24798 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24801 int64_t __attribute__((export_name("TS_ChannelMonitorUpdate_clone_ptr"))) TS_ChannelMonitorUpdate_clone_ptr(uint64_t arg) {
24802 LDKChannelMonitorUpdate arg_conv;
24803 arg_conv.inner = untag_ptr(arg);
24804 arg_conv.is_owned = ptr_is_owned(arg);
24805 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
24806 arg_conv.is_owned = false;
24807 int64_t ret_conv = ChannelMonitorUpdate_clone_ptr(&arg_conv);
24811 uint64_t __attribute__((export_name("TS_ChannelMonitorUpdate_clone"))) TS_ChannelMonitorUpdate_clone(uint64_t orig) {
24812 LDKChannelMonitorUpdate orig_conv;
24813 orig_conv.inner = untag_ptr(orig);
24814 orig_conv.is_owned = ptr_is_owned(orig);
24815 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
24816 orig_conv.is_owned = false;
24817 LDKChannelMonitorUpdate ret_var = ChannelMonitorUpdate_clone(&orig_conv);
24818 uint64_t ret_ref = 0;
24819 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24820 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24824 int8_tArray __attribute__((export_name("TS_ChannelMonitorUpdate_write"))) TS_ChannelMonitorUpdate_write(uint64_t obj) {
24825 LDKChannelMonitorUpdate obj_conv;
24826 obj_conv.inner = untag_ptr(obj);
24827 obj_conv.is_owned = ptr_is_owned(obj);
24828 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
24829 obj_conv.is_owned = false;
24830 LDKCVec_u8Z ret_var = ChannelMonitorUpdate_write(&obj_conv);
24831 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
24832 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
24833 CVec_u8Z_free(ret_var);
24837 uint64_t __attribute__((export_name("TS_ChannelMonitorUpdate_read"))) TS_ChannelMonitorUpdate_read(int8_tArray ser) {
24838 LDKu8slice ser_ref;
24839 ser_ref.datalen = ser->arr_len;
24840 ser_ref.data = ser->elems;
24841 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
24842 *ret_conv = ChannelMonitorUpdate_read(ser_ref);
24844 return tag_ptr(ret_conv, true);
24847 void __attribute__((export_name("TS_MonitorEvent_free"))) TS_MonitorEvent_free(uint64_t this_ptr) {
24848 if (!ptr_is_owned(this_ptr)) return;
24849 void* this_ptr_ptr = untag_ptr(this_ptr);
24850 CHECK_ACCESS(this_ptr_ptr);
24851 LDKMonitorEvent this_ptr_conv = *(LDKMonitorEvent*)(this_ptr_ptr);
24852 FREE(untag_ptr(this_ptr));
24853 MonitorEvent_free(this_ptr_conv);
24856 static inline uint64_t MonitorEvent_clone_ptr(LDKMonitorEvent *NONNULL_PTR arg) {
24857 LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
24858 *ret_copy = MonitorEvent_clone(arg);
24859 uint64_t ret_ref = tag_ptr(ret_copy, true);
24862 int64_t __attribute__((export_name("TS_MonitorEvent_clone_ptr"))) TS_MonitorEvent_clone_ptr(uint64_t arg) {
24863 LDKMonitorEvent* arg_conv = (LDKMonitorEvent*)untag_ptr(arg);
24864 int64_t ret_conv = MonitorEvent_clone_ptr(arg_conv);
24868 uint64_t __attribute__((export_name("TS_MonitorEvent_clone"))) TS_MonitorEvent_clone(uint64_t orig) {
24869 LDKMonitorEvent* orig_conv = (LDKMonitorEvent*)untag_ptr(orig);
24870 LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
24871 *ret_copy = MonitorEvent_clone(orig_conv);
24872 uint64_t ret_ref = tag_ptr(ret_copy, true);
24876 uint64_t __attribute__((export_name("TS_MonitorEvent_htlcevent"))) TS_MonitorEvent_htlcevent(uint64_t a) {
24877 LDKHTLCUpdate a_conv;
24878 a_conv.inner = untag_ptr(a);
24879 a_conv.is_owned = ptr_is_owned(a);
24880 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
24881 a_conv = HTLCUpdate_clone(&a_conv);
24882 LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
24883 *ret_copy = MonitorEvent_htlcevent(a_conv);
24884 uint64_t ret_ref = tag_ptr(ret_copy, true);
24888 uint64_t __attribute__((export_name("TS_MonitorEvent_commitment_tx_confirmed"))) TS_MonitorEvent_commitment_tx_confirmed(uint64_t a) {
24889 LDKOutPoint a_conv;
24890 a_conv.inner = untag_ptr(a);
24891 a_conv.is_owned = ptr_is_owned(a);
24892 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
24893 a_conv = OutPoint_clone(&a_conv);
24894 LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
24895 *ret_copy = MonitorEvent_commitment_tx_confirmed(a_conv);
24896 uint64_t ret_ref = tag_ptr(ret_copy, true);
24900 uint64_t __attribute__((export_name("TS_MonitorEvent_completed"))) TS_MonitorEvent_completed(uint64_t funding_txo, int64_t monitor_update_id) {
24901 LDKOutPoint funding_txo_conv;
24902 funding_txo_conv.inner = untag_ptr(funding_txo);
24903 funding_txo_conv.is_owned = ptr_is_owned(funding_txo);
24904 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
24905 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
24906 LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
24907 *ret_copy = MonitorEvent_completed(funding_txo_conv, monitor_update_id);
24908 uint64_t ret_ref = tag_ptr(ret_copy, true);
24912 uint64_t __attribute__((export_name("TS_MonitorEvent_update_failed"))) TS_MonitorEvent_update_failed(uint64_t a) {
24913 LDKOutPoint a_conv;
24914 a_conv.inner = untag_ptr(a);
24915 a_conv.is_owned = ptr_is_owned(a);
24916 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
24917 a_conv = OutPoint_clone(&a_conv);
24918 LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
24919 *ret_copy = MonitorEvent_update_failed(a_conv);
24920 uint64_t ret_ref = tag_ptr(ret_copy, true);
24924 jboolean __attribute__((export_name("TS_MonitorEvent_eq"))) TS_MonitorEvent_eq(uint64_t a, uint64_t b) {
24925 LDKMonitorEvent* a_conv = (LDKMonitorEvent*)untag_ptr(a);
24926 LDKMonitorEvent* b_conv = (LDKMonitorEvent*)untag_ptr(b);
24927 jboolean ret_conv = MonitorEvent_eq(a_conv, b_conv);
24931 int8_tArray __attribute__((export_name("TS_MonitorEvent_write"))) TS_MonitorEvent_write(uint64_t obj) {
24932 LDKMonitorEvent* obj_conv = (LDKMonitorEvent*)untag_ptr(obj);
24933 LDKCVec_u8Z ret_var = MonitorEvent_write(obj_conv);
24934 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
24935 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
24936 CVec_u8Z_free(ret_var);
24940 uint64_t __attribute__((export_name("TS_MonitorEvent_read"))) TS_MonitorEvent_read(int8_tArray ser) {
24941 LDKu8slice ser_ref;
24942 ser_ref.datalen = ser->arr_len;
24943 ser_ref.data = ser->elems;
24944 LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
24945 *ret_conv = MonitorEvent_read(ser_ref);
24947 return tag_ptr(ret_conv, true);
24950 void __attribute__((export_name("TS_HTLCUpdate_free"))) TS_HTLCUpdate_free(uint64_t this_obj) {
24951 LDKHTLCUpdate this_obj_conv;
24952 this_obj_conv.inner = untag_ptr(this_obj);
24953 this_obj_conv.is_owned = ptr_is_owned(this_obj);
24954 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
24955 HTLCUpdate_free(this_obj_conv);
24958 static inline uint64_t HTLCUpdate_clone_ptr(LDKHTLCUpdate *NONNULL_PTR arg) {
24959 LDKHTLCUpdate ret_var = HTLCUpdate_clone(arg);
24960 uint64_t ret_ref = 0;
24961 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24962 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24965 int64_t __attribute__((export_name("TS_HTLCUpdate_clone_ptr"))) TS_HTLCUpdate_clone_ptr(uint64_t arg) {
24966 LDKHTLCUpdate arg_conv;
24967 arg_conv.inner = untag_ptr(arg);
24968 arg_conv.is_owned = ptr_is_owned(arg);
24969 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
24970 arg_conv.is_owned = false;
24971 int64_t ret_conv = HTLCUpdate_clone_ptr(&arg_conv);
24975 uint64_t __attribute__((export_name("TS_HTLCUpdate_clone"))) TS_HTLCUpdate_clone(uint64_t orig) {
24976 LDKHTLCUpdate orig_conv;
24977 orig_conv.inner = untag_ptr(orig);
24978 orig_conv.is_owned = ptr_is_owned(orig);
24979 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
24980 orig_conv.is_owned = false;
24981 LDKHTLCUpdate ret_var = HTLCUpdate_clone(&orig_conv);
24982 uint64_t ret_ref = 0;
24983 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24984 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24988 jboolean __attribute__((export_name("TS_HTLCUpdate_eq"))) TS_HTLCUpdate_eq(uint64_t a, uint64_t b) {
24989 LDKHTLCUpdate a_conv;
24990 a_conv.inner = untag_ptr(a);
24991 a_conv.is_owned = ptr_is_owned(a);
24992 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
24993 a_conv.is_owned = false;
24994 LDKHTLCUpdate b_conv;
24995 b_conv.inner = untag_ptr(b);
24996 b_conv.is_owned = ptr_is_owned(b);
24997 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
24998 b_conv.is_owned = false;
24999 jboolean ret_conv = HTLCUpdate_eq(&a_conv, &b_conv);
25003 int8_tArray __attribute__((export_name("TS_HTLCUpdate_write"))) TS_HTLCUpdate_write(uint64_t obj) {
25004 LDKHTLCUpdate obj_conv;
25005 obj_conv.inner = untag_ptr(obj);
25006 obj_conv.is_owned = ptr_is_owned(obj);
25007 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
25008 obj_conv.is_owned = false;
25009 LDKCVec_u8Z ret_var = HTLCUpdate_write(&obj_conv);
25010 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
25011 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
25012 CVec_u8Z_free(ret_var);
25016 uint64_t __attribute__((export_name("TS_HTLCUpdate_read"))) TS_HTLCUpdate_read(int8_tArray ser) {
25017 LDKu8slice ser_ref;
25018 ser_ref.datalen = ser->arr_len;
25019 ser_ref.data = ser->elems;
25020 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
25021 *ret_conv = HTLCUpdate_read(ser_ref);
25023 return tag_ptr(ret_conv, true);
25026 void __attribute__((export_name("TS_Balance_free"))) TS_Balance_free(uint64_t this_ptr) {
25027 if (!ptr_is_owned(this_ptr)) return;
25028 void* this_ptr_ptr = untag_ptr(this_ptr);
25029 CHECK_ACCESS(this_ptr_ptr);
25030 LDKBalance this_ptr_conv = *(LDKBalance*)(this_ptr_ptr);
25031 FREE(untag_ptr(this_ptr));
25032 Balance_free(this_ptr_conv);
25035 static inline uint64_t Balance_clone_ptr(LDKBalance *NONNULL_PTR arg) {
25036 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
25037 *ret_copy = Balance_clone(arg);
25038 uint64_t ret_ref = tag_ptr(ret_copy, true);
25041 int64_t __attribute__((export_name("TS_Balance_clone_ptr"))) TS_Balance_clone_ptr(uint64_t arg) {
25042 LDKBalance* arg_conv = (LDKBalance*)untag_ptr(arg);
25043 int64_t ret_conv = Balance_clone_ptr(arg_conv);
25047 uint64_t __attribute__((export_name("TS_Balance_clone"))) TS_Balance_clone(uint64_t orig) {
25048 LDKBalance* orig_conv = (LDKBalance*)untag_ptr(orig);
25049 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
25050 *ret_copy = Balance_clone(orig_conv);
25051 uint64_t ret_ref = tag_ptr(ret_copy, true);
25055 uint64_t __attribute__((export_name("TS_Balance_claimable_on_channel_close"))) TS_Balance_claimable_on_channel_close(int64_t claimable_amount_satoshis) {
25056 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
25057 *ret_copy = Balance_claimable_on_channel_close(claimable_amount_satoshis);
25058 uint64_t ret_ref = tag_ptr(ret_copy, true);
25062 uint64_t __attribute__((export_name("TS_Balance_claimable_awaiting_confirmations"))) TS_Balance_claimable_awaiting_confirmations(int64_t claimable_amount_satoshis, int32_t confirmation_height) {
25063 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
25064 *ret_copy = Balance_claimable_awaiting_confirmations(claimable_amount_satoshis, confirmation_height);
25065 uint64_t ret_ref = tag_ptr(ret_copy, true);
25069 uint64_t __attribute__((export_name("TS_Balance_contentious_claimable"))) TS_Balance_contentious_claimable(int64_t claimable_amount_satoshis, int32_t timeout_height) {
25070 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
25071 *ret_copy = Balance_contentious_claimable(claimable_amount_satoshis, timeout_height);
25072 uint64_t ret_ref = tag_ptr(ret_copy, true);
25076 uint64_t __attribute__((export_name("TS_Balance_maybe_timeout_claimable_htlc"))) TS_Balance_maybe_timeout_claimable_htlc(int64_t claimable_amount_satoshis, int32_t claimable_height) {
25077 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
25078 *ret_copy = Balance_maybe_timeout_claimable_htlc(claimable_amount_satoshis, claimable_height);
25079 uint64_t ret_ref = tag_ptr(ret_copy, true);
25083 uint64_t __attribute__((export_name("TS_Balance_maybe_preimage_claimable_htlc"))) TS_Balance_maybe_preimage_claimable_htlc(int64_t claimable_amount_satoshis, int32_t expiry_height) {
25084 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
25085 *ret_copy = Balance_maybe_preimage_claimable_htlc(claimable_amount_satoshis, expiry_height);
25086 uint64_t ret_ref = tag_ptr(ret_copy, true);
25090 uint64_t __attribute__((export_name("TS_Balance_counterparty_revoked_output_claimable"))) TS_Balance_counterparty_revoked_output_claimable(int64_t claimable_amount_satoshis) {
25091 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
25092 *ret_copy = Balance_counterparty_revoked_output_claimable(claimable_amount_satoshis);
25093 uint64_t ret_ref = tag_ptr(ret_copy, true);
25097 jboolean __attribute__((export_name("TS_Balance_eq"))) TS_Balance_eq(uint64_t a, uint64_t b) {
25098 LDKBalance* a_conv = (LDKBalance*)untag_ptr(a);
25099 LDKBalance* b_conv = (LDKBalance*)untag_ptr(b);
25100 jboolean ret_conv = Balance_eq(a_conv, b_conv);
25104 void __attribute__((export_name("TS_ChannelMonitor_free"))) TS_ChannelMonitor_free(uint64_t this_obj) {
25105 LDKChannelMonitor this_obj_conv;
25106 this_obj_conv.inner = untag_ptr(this_obj);
25107 this_obj_conv.is_owned = ptr_is_owned(this_obj);
25108 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
25109 ChannelMonitor_free(this_obj_conv);
25112 static inline uint64_t ChannelMonitor_clone_ptr(LDKChannelMonitor *NONNULL_PTR arg) {
25113 LDKChannelMonitor ret_var = ChannelMonitor_clone(arg);
25114 uint64_t ret_ref = 0;
25115 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25116 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
25119 int64_t __attribute__((export_name("TS_ChannelMonitor_clone_ptr"))) TS_ChannelMonitor_clone_ptr(uint64_t arg) {
25120 LDKChannelMonitor arg_conv;
25121 arg_conv.inner = untag_ptr(arg);
25122 arg_conv.is_owned = ptr_is_owned(arg);
25123 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
25124 arg_conv.is_owned = false;
25125 int64_t ret_conv = ChannelMonitor_clone_ptr(&arg_conv);
25129 uint64_t __attribute__((export_name("TS_ChannelMonitor_clone"))) TS_ChannelMonitor_clone(uint64_t orig) {
25130 LDKChannelMonitor orig_conv;
25131 orig_conv.inner = untag_ptr(orig);
25132 orig_conv.is_owned = ptr_is_owned(orig);
25133 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
25134 orig_conv.is_owned = false;
25135 LDKChannelMonitor ret_var = ChannelMonitor_clone(&orig_conv);
25136 uint64_t ret_ref = 0;
25137 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25138 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
25142 int8_tArray __attribute__((export_name("TS_ChannelMonitor_write"))) TS_ChannelMonitor_write(uint64_t obj) {
25143 LDKChannelMonitor obj_conv;
25144 obj_conv.inner = untag_ptr(obj);
25145 obj_conv.is_owned = ptr_is_owned(obj);
25146 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
25147 obj_conv.is_owned = false;
25148 LDKCVec_u8Z ret_var = ChannelMonitor_write(&obj_conv);
25149 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
25150 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
25151 CVec_u8Z_free(ret_var);
25155 uint64_t __attribute__((export_name("TS_ChannelMonitor_update_monitor"))) TS_ChannelMonitor_update_monitor(uint64_t this_arg, uint64_t updates, uint64_t broadcaster, uint64_t fee_estimator, uint64_t logger) {
25156 LDKChannelMonitor this_arg_conv;
25157 this_arg_conv.inner = untag_ptr(this_arg);
25158 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25159 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25160 this_arg_conv.is_owned = false;
25161 LDKChannelMonitorUpdate updates_conv;
25162 updates_conv.inner = untag_ptr(updates);
25163 updates_conv.is_owned = ptr_is_owned(updates);
25164 CHECK_INNER_FIELD_ACCESS_OR_NULL(updates_conv);
25165 updates_conv.is_owned = false;
25166 void* broadcaster_ptr = untag_ptr(broadcaster);
25167 if (ptr_is_owned(broadcaster)) { CHECK_ACCESS(broadcaster_ptr); }
25168 LDKBroadcasterInterface* broadcaster_conv = (LDKBroadcasterInterface*)broadcaster_ptr;
25169 void* fee_estimator_ptr = untag_ptr(fee_estimator);
25170 CHECK_ACCESS(fee_estimator_ptr);
25171 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
25172 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
25173 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25174 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
25176 void* logger_ptr = untag_ptr(logger);
25177 if (ptr_is_owned(logger)) { CHECK_ACCESS(logger_ptr); }
25178 LDKLogger* logger_conv = (LDKLogger*)logger_ptr;
25179 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
25180 *ret_conv = ChannelMonitor_update_monitor(&this_arg_conv, &updates_conv, broadcaster_conv, fee_estimator_conv, logger_conv);
25181 return tag_ptr(ret_conv, true);
25184 int64_t __attribute__((export_name("TS_ChannelMonitor_get_latest_update_id"))) TS_ChannelMonitor_get_latest_update_id(uint64_t this_arg) {
25185 LDKChannelMonitor this_arg_conv;
25186 this_arg_conv.inner = untag_ptr(this_arg);
25187 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25188 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25189 this_arg_conv.is_owned = false;
25190 int64_t ret_conv = ChannelMonitor_get_latest_update_id(&this_arg_conv);
25194 uint64_t __attribute__((export_name("TS_ChannelMonitor_get_funding_txo"))) TS_ChannelMonitor_get_funding_txo(uint64_t this_arg) {
25195 LDKChannelMonitor this_arg_conv;
25196 this_arg_conv.inner = untag_ptr(this_arg);
25197 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25198 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25199 this_arg_conv.is_owned = false;
25200 LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
25201 *ret_conv = ChannelMonitor_get_funding_txo(&this_arg_conv);
25202 return tag_ptr(ret_conv, true);
25205 uint64_tArray __attribute__((export_name("TS_ChannelMonitor_get_outputs_to_watch"))) TS_ChannelMonitor_get_outputs_to_watch(uint64_t this_arg) {
25206 LDKChannelMonitor this_arg_conv;
25207 this_arg_conv.inner = untag_ptr(this_arg);
25208 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25209 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25210 this_arg_conv.is_owned = false;
25211 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ret_var = ChannelMonitor_get_outputs_to_watch(&this_arg_conv);
25212 uint64_tArray ret_arr = NULL;
25213 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
25214 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
25215 for (size_t o = 0; o < ret_var.datalen; o++) {
25216 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv_40_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
25217 *ret_conv_40_conv = ret_var.data[o];
25218 ret_arr_ptr[o] = tag_ptr(ret_conv_40_conv, true);
25221 FREE(ret_var.data);
25225 void __attribute__((export_name("TS_ChannelMonitor_load_outputs_to_watch"))) TS_ChannelMonitor_load_outputs_to_watch(uint64_t this_arg, uint64_t filter) {
25226 LDKChannelMonitor this_arg_conv;
25227 this_arg_conv.inner = untag_ptr(this_arg);
25228 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25229 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25230 this_arg_conv.is_owned = false;
25231 void* filter_ptr = untag_ptr(filter);
25232 if (ptr_is_owned(filter)) { CHECK_ACCESS(filter_ptr); }
25233 LDKFilter* filter_conv = (LDKFilter*)filter_ptr;
25234 ChannelMonitor_load_outputs_to_watch(&this_arg_conv, filter_conv);
25237 uint64_tArray __attribute__((export_name("TS_ChannelMonitor_get_and_clear_pending_monitor_events"))) TS_ChannelMonitor_get_and_clear_pending_monitor_events(uint64_t this_arg) {
25238 LDKChannelMonitor this_arg_conv;
25239 this_arg_conv.inner = untag_ptr(this_arg);
25240 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25241 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25242 this_arg_conv.is_owned = false;
25243 LDKCVec_MonitorEventZ ret_var = ChannelMonitor_get_and_clear_pending_monitor_events(&this_arg_conv);
25244 uint64_tArray ret_arr = NULL;
25245 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
25246 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
25247 for (size_t o = 0; o < ret_var.datalen; o++) {
25248 LDKMonitorEvent *ret_conv_14_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
25249 *ret_conv_14_copy = ret_var.data[o];
25250 uint64_t ret_conv_14_ref = tag_ptr(ret_conv_14_copy, true);
25251 ret_arr_ptr[o] = ret_conv_14_ref;
25254 FREE(ret_var.data);
25258 uint64_tArray __attribute__((export_name("TS_ChannelMonitor_get_and_clear_pending_events"))) TS_ChannelMonitor_get_and_clear_pending_events(uint64_t this_arg) {
25259 LDKChannelMonitor this_arg_conv;
25260 this_arg_conv.inner = untag_ptr(this_arg);
25261 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25262 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25263 this_arg_conv.is_owned = false;
25264 LDKCVec_EventZ ret_var = ChannelMonitor_get_and_clear_pending_events(&this_arg_conv);
25265 uint64_tArray ret_arr = NULL;
25266 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
25267 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
25268 for (size_t h = 0; h < ret_var.datalen; h++) {
25269 LDKEvent *ret_conv_7_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
25270 *ret_conv_7_copy = ret_var.data[h];
25271 uint64_t ret_conv_7_ref = tag_ptr(ret_conv_7_copy, true);
25272 ret_arr_ptr[h] = ret_conv_7_ref;
25275 FREE(ret_var.data);
25279 int8_tArray __attribute__((export_name("TS_ChannelMonitor_get_counterparty_node_id"))) TS_ChannelMonitor_get_counterparty_node_id(uint64_t this_arg) {
25280 LDKChannelMonitor this_arg_conv;
25281 this_arg_conv.inner = untag_ptr(this_arg);
25282 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25283 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25284 this_arg_conv.is_owned = false;
25285 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
25286 memcpy(ret_arr->elems, ChannelMonitor_get_counterparty_node_id(&this_arg_conv).compressed_form, 33);
25290 ptrArray __attribute__((export_name("TS_ChannelMonitor_get_latest_holder_commitment_txn"))) TS_ChannelMonitor_get_latest_holder_commitment_txn(uint64_t this_arg, uint64_t logger) {
25291 LDKChannelMonitor this_arg_conv;
25292 this_arg_conv.inner = untag_ptr(this_arg);
25293 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25294 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25295 this_arg_conv.is_owned = false;
25296 void* logger_ptr = untag_ptr(logger);
25297 if (ptr_is_owned(logger)) { CHECK_ACCESS(logger_ptr); }
25298 LDKLogger* logger_conv = (LDKLogger*)logger_ptr;
25299 LDKCVec_TransactionZ ret_var = ChannelMonitor_get_latest_holder_commitment_txn(&this_arg_conv, logger_conv);
25300 ptrArray ret_arr = NULL;
25301 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
25302 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 8);
25303 for (size_t m = 0; m < ret_var.datalen; m++) {
25304 LDKTransaction ret_conv_12_var = ret_var.data[m];
25305 int8_tArray ret_conv_12_arr = init_int8_tArray(ret_conv_12_var.datalen, __LINE__);
25306 memcpy(ret_conv_12_arr->elems, ret_conv_12_var.data, ret_conv_12_var.datalen);
25307 Transaction_free(ret_conv_12_var);
25308 ret_arr_ptr[m] = ret_conv_12_arr;
25311 FREE(ret_var.data);
25315 uint64_tArray __attribute__((export_name("TS_ChannelMonitor_block_connected"))) TS_ChannelMonitor_block_connected(uint64_t this_arg, int8_tArray header, uint64_tArray txdata, int32_t height, uint64_t broadcaster, uint64_t fee_estimator, uint64_t logger) {
25316 LDKChannelMonitor this_arg_conv;
25317 this_arg_conv.inner = untag_ptr(this_arg);
25318 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25319 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25320 this_arg_conv.is_owned = false;
25321 unsigned char header_arr[80];
25322 CHECK(header->arr_len == 80);
25323 memcpy(header_arr, header->elems, 80); FREE(header);
25324 unsigned char (*header_ref)[80] = &header_arr;
25325 LDKCVec_C2Tuple_usizeTransactionZZ txdata_constr;
25326 txdata_constr.datalen = txdata->arr_len;
25327 if (txdata_constr.datalen > 0)
25328 txdata_constr.data = MALLOC(txdata_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
25330 txdata_constr.data = NULL;
25331 uint64_t* txdata_vals = txdata->elems;
25332 for (size_t c = 0; c < txdata_constr.datalen; c++) {
25333 uint64_t txdata_conv_28 = txdata_vals[c];
25334 void* txdata_conv_28_ptr = untag_ptr(txdata_conv_28);
25335 CHECK_ACCESS(txdata_conv_28_ptr);
25336 LDKC2Tuple_usizeTransactionZ txdata_conv_28_conv = *(LDKC2Tuple_usizeTransactionZ*)(txdata_conv_28_ptr);
25337 txdata_conv_28_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)untag_ptr(txdata_conv_28));
25338 txdata_constr.data[c] = txdata_conv_28_conv;
25341 void* broadcaster_ptr = untag_ptr(broadcaster);
25342 CHECK_ACCESS(broadcaster_ptr);
25343 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
25344 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
25345 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25346 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
25348 void* fee_estimator_ptr = untag_ptr(fee_estimator);
25349 CHECK_ACCESS(fee_estimator_ptr);
25350 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
25351 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
25352 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25353 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
25355 void* logger_ptr = untag_ptr(logger);
25356 CHECK_ACCESS(logger_ptr);
25357 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
25358 if (logger_conv.free == LDKLogger_JCalls_free) {
25359 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25360 LDKLogger_JCalls_cloned(&logger_conv);
25362 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);
25363 uint64_tArray ret_arr = NULL;
25364 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
25365 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
25366 for (size_t n = 0; n < ret_var.datalen; n++) {
25367 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv_39_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
25368 *ret_conv_39_conv = ret_var.data[n];
25369 ret_arr_ptr[n] = tag_ptr(ret_conv_39_conv, true);
25372 FREE(ret_var.data);
25376 void __attribute__((export_name("TS_ChannelMonitor_block_disconnected"))) TS_ChannelMonitor_block_disconnected(uint64_t this_arg, int8_tArray header, int32_t height, uint64_t broadcaster, uint64_t fee_estimator, uint64_t logger) {
25377 LDKChannelMonitor this_arg_conv;
25378 this_arg_conv.inner = untag_ptr(this_arg);
25379 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25380 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25381 this_arg_conv.is_owned = false;
25382 unsigned char header_arr[80];
25383 CHECK(header->arr_len == 80);
25384 memcpy(header_arr, header->elems, 80); FREE(header);
25385 unsigned char (*header_ref)[80] = &header_arr;
25386 void* broadcaster_ptr = untag_ptr(broadcaster);
25387 CHECK_ACCESS(broadcaster_ptr);
25388 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
25389 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
25390 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25391 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
25393 void* fee_estimator_ptr = untag_ptr(fee_estimator);
25394 CHECK_ACCESS(fee_estimator_ptr);
25395 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
25396 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
25397 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25398 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
25400 void* logger_ptr = untag_ptr(logger);
25401 CHECK_ACCESS(logger_ptr);
25402 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
25403 if (logger_conv.free == LDKLogger_JCalls_free) {
25404 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25405 LDKLogger_JCalls_cloned(&logger_conv);
25407 ChannelMonitor_block_disconnected(&this_arg_conv, header_ref, height, broadcaster_conv, fee_estimator_conv, logger_conv);
25410 uint64_tArray __attribute__((export_name("TS_ChannelMonitor_transactions_confirmed"))) TS_ChannelMonitor_transactions_confirmed(uint64_t this_arg, int8_tArray header, uint64_tArray txdata, int32_t height, uint64_t broadcaster, uint64_t fee_estimator, uint64_t logger) {
25411 LDKChannelMonitor this_arg_conv;
25412 this_arg_conv.inner = untag_ptr(this_arg);
25413 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25414 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25415 this_arg_conv.is_owned = false;
25416 unsigned char header_arr[80];
25417 CHECK(header->arr_len == 80);
25418 memcpy(header_arr, header->elems, 80); FREE(header);
25419 unsigned char (*header_ref)[80] = &header_arr;
25420 LDKCVec_C2Tuple_usizeTransactionZZ txdata_constr;
25421 txdata_constr.datalen = txdata->arr_len;
25422 if (txdata_constr.datalen > 0)
25423 txdata_constr.data = MALLOC(txdata_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
25425 txdata_constr.data = NULL;
25426 uint64_t* txdata_vals = txdata->elems;
25427 for (size_t c = 0; c < txdata_constr.datalen; c++) {
25428 uint64_t txdata_conv_28 = txdata_vals[c];
25429 void* txdata_conv_28_ptr = untag_ptr(txdata_conv_28);
25430 CHECK_ACCESS(txdata_conv_28_ptr);
25431 LDKC2Tuple_usizeTransactionZ txdata_conv_28_conv = *(LDKC2Tuple_usizeTransactionZ*)(txdata_conv_28_ptr);
25432 txdata_conv_28_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)untag_ptr(txdata_conv_28));
25433 txdata_constr.data[c] = txdata_conv_28_conv;
25436 void* broadcaster_ptr = untag_ptr(broadcaster);
25437 CHECK_ACCESS(broadcaster_ptr);
25438 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
25439 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
25440 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25441 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
25443 void* fee_estimator_ptr = untag_ptr(fee_estimator);
25444 CHECK_ACCESS(fee_estimator_ptr);
25445 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
25446 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
25447 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25448 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
25450 void* logger_ptr = untag_ptr(logger);
25451 CHECK_ACCESS(logger_ptr);
25452 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
25453 if (logger_conv.free == LDKLogger_JCalls_free) {
25454 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25455 LDKLogger_JCalls_cloned(&logger_conv);
25457 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ret_var = ChannelMonitor_transactions_confirmed(&this_arg_conv, header_ref, txdata_constr, height, broadcaster_conv, fee_estimator_conv, logger_conv);
25458 uint64_tArray ret_arr = NULL;
25459 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
25460 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
25461 for (size_t n = 0; n < ret_var.datalen; n++) {
25462 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv_39_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
25463 *ret_conv_39_conv = ret_var.data[n];
25464 ret_arr_ptr[n] = tag_ptr(ret_conv_39_conv, true);
25467 FREE(ret_var.data);
25471 void __attribute__((export_name("TS_ChannelMonitor_transaction_unconfirmed"))) TS_ChannelMonitor_transaction_unconfirmed(uint64_t this_arg, int8_tArray txid, uint64_t broadcaster, uint64_t fee_estimator, uint64_t logger) {
25472 LDKChannelMonitor this_arg_conv;
25473 this_arg_conv.inner = untag_ptr(this_arg);
25474 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25475 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25476 this_arg_conv.is_owned = false;
25477 unsigned char txid_arr[32];
25478 CHECK(txid->arr_len == 32);
25479 memcpy(txid_arr, txid->elems, 32); FREE(txid);
25480 unsigned char (*txid_ref)[32] = &txid_arr;
25481 void* broadcaster_ptr = untag_ptr(broadcaster);
25482 CHECK_ACCESS(broadcaster_ptr);
25483 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
25484 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
25485 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25486 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
25488 void* fee_estimator_ptr = untag_ptr(fee_estimator);
25489 CHECK_ACCESS(fee_estimator_ptr);
25490 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
25491 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
25492 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25493 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
25495 void* logger_ptr = untag_ptr(logger);
25496 CHECK_ACCESS(logger_ptr);
25497 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
25498 if (logger_conv.free == LDKLogger_JCalls_free) {
25499 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25500 LDKLogger_JCalls_cloned(&logger_conv);
25502 ChannelMonitor_transaction_unconfirmed(&this_arg_conv, txid_ref, broadcaster_conv, fee_estimator_conv, logger_conv);
25505 uint64_tArray __attribute__((export_name("TS_ChannelMonitor_best_block_updated"))) TS_ChannelMonitor_best_block_updated(uint64_t this_arg, int8_tArray header, int32_t height, uint64_t broadcaster, uint64_t fee_estimator, uint64_t logger) {
25506 LDKChannelMonitor this_arg_conv;
25507 this_arg_conv.inner = untag_ptr(this_arg);
25508 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25509 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25510 this_arg_conv.is_owned = false;
25511 unsigned char header_arr[80];
25512 CHECK(header->arr_len == 80);
25513 memcpy(header_arr, header->elems, 80); FREE(header);
25514 unsigned char (*header_ref)[80] = &header_arr;
25515 void* broadcaster_ptr = untag_ptr(broadcaster);
25516 CHECK_ACCESS(broadcaster_ptr);
25517 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
25518 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
25519 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25520 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
25522 void* fee_estimator_ptr = untag_ptr(fee_estimator);
25523 CHECK_ACCESS(fee_estimator_ptr);
25524 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
25525 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
25526 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25527 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
25529 void* logger_ptr = untag_ptr(logger);
25530 CHECK_ACCESS(logger_ptr);
25531 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
25532 if (logger_conv.free == LDKLogger_JCalls_free) {
25533 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25534 LDKLogger_JCalls_cloned(&logger_conv);
25536 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ret_var = ChannelMonitor_best_block_updated(&this_arg_conv, header_ref, height, broadcaster_conv, fee_estimator_conv, logger_conv);
25537 uint64_tArray ret_arr = NULL;
25538 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
25539 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
25540 for (size_t n = 0; n < ret_var.datalen; n++) {
25541 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv_39_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
25542 *ret_conv_39_conv = ret_var.data[n];
25543 ret_arr_ptr[n] = tag_ptr(ret_conv_39_conv, true);
25546 FREE(ret_var.data);
25550 uint64_tArray __attribute__((export_name("TS_ChannelMonitor_get_relevant_txids"))) TS_ChannelMonitor_get_relevant_txids(uint64_t this_arg) {
25551 LDKChannelMonitor this_arg_conv;
25552 this_arg_conv.inner = untag_ptr(this_arg);
25553 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25554 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25555 this_arg_conv.is_owned = false;
25556 LDKCVec_C2Tuple_TxidBlockHashZZ ret_var = ChannelMonitor_get_relevant_txids(&this_arg_conv);
25557 uint64_tArray ret_arr = NULL;
25558 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
25559 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
25560 for (size_t z = 0; z < ret_var.datalen; z++) {
25561 LDKC2Tuple_TxidBlockHashZ* ret_conv_25_conv = MALLOC(sizeof(LDKC2Tuple_TxidBlockHashZ), "LDKC2Tuple_TxidBlockHashZ");
25562 *ret_conv_25_conv = ret_var.data[z];
25563 ret_arr_ptr[z] = tag_ptr(ret_conv_25_conv, true);
25566 FREE(ret_var.data);
25570 uint64_t __attribute__((export_name("TS_ChannelMonitor_current_best_block"))) TS_ChannelMonitor_current_best_block(uint64_t this_arg) {
25571 LDKChannelMonitor this_arg_conv;
25572 this_arg_conv.inner = untag_ptr(this_arg);
25573 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25574 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25575 this_arg_conv.is_owned = false;
25576 LDKBestBlock ret_var = ChannelMonitor_current_best_block(&this_arg_conv);
25577 uint64_t ret_ref = 0;
25578 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25579 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
25583 uint64_tArray __attribute__((export_name("TS_ChannelMonitor_get_claimable_balances"))) TS_ChannelMonitor_get_claimable_balances(uint64_t this_arg) {
25584 LDKChannelMonitor this_arg_conv;
25585 this_arg_conv.inner = untag_ptr(this_arg);
25586 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25587 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25588 this_arg_conv.is_owned = false;
25589 LDKCVec_BalanceZ ret_var = ChannelMonitor_get_claimable_balances(&this_arg_conv);
25590 uint64_tArray ret_arr = NULL;
25591 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
25592 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
25593 for (size_t j = 0; j < ret_var.datalen; j++) {
25594 LDKBalance *ret_conv_9_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
25595 *ret_conv_9_copy = ret_var.data[j];
25596 uint64_t ret_conv_9_ref = tag_ptr(ret_conv_9_copy, true);
25597 ret_arr_ptr[j] = ret_conv_9_ref;
25600 FREE(ret_var.data);
25604 uint64_t __attribute__((export_name("TS_C2Tuple_BlockHashChannelMonitorZ_read"))) TS_C2Tuple_BlockHashChannelMonitorZ_read(int8_tArray ser, uint64_t arg) {
25605 LDKu8slice ser_ref;
25606 ser_ref.datalen = ser->arr_len;
25607 ser_ref.data = ser->elems;
25608 void* arg_ptr = untag_ptr(arg);
25609 if (ptr_is_owned(arg)) { CHECK_ACCESS(arg_ptr); }
25610 LDKKeysInterface* arg_conv = (LDKKeysInterface*)arg_ptr;
25611 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
25612 *ret_conv = C2Tuple_BlockHashChannelMonitorZ_read(ser_ref, arg_conv);
25614 return tag_ptr(ret_conv, true);
25617 void __attribute__((export_name("TS_OutPoint_free"))) TS_OutPoint_free(uint64_t this_obj) {
25618 LDKOutPoint this_obj_conv;
25619 this_obj_conv.inner = untag_ptr(this_obj);
25620 this_obj_conv.is_owned = ptr_is_owned(this_obj);
25621 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
25622 OutPoint_free(this_obj_conv);
25625 int8_tArray __attribute__((export_name("TS_OutPoint_get_txid"))) TS_OutPoint_get_txid(uint64_t this_ptr) {
25626 LDKOutPoint this_ptr_conv;
25627 this_ptr_conv.inner = untag_ptr(this_ptr);
25628 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
25629 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25630 this_ptr_conv.is_owned = false;
25631 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
25632 memcpy(ret_arr->elems, *OutPoint_get_txid(&this_ptr_conv), 32);
25636 void __attribute__((export_name("TS_OutPoint_set_txid"))) TS_OutPoint_set_txid(uint64_t this_ptr, int8_tArray val) {
25637 LDKOutPoint this_ptr_conv;
25638 this_ptr_conv.inner = untag_ptr(this_ptr);
25639 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
25640 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25641 this_ptr_conv.is_owned = false;
25642 LDKThirtyTwoBytes val_ref;
25643 CHECK(val->arr_len == 32);
25644 memcpy(val_ref.data, val->elems, 32); FREE(val);
25645 OutPoint_set_txid(&this_ptr_conv, val_ref);
25648 int16_t __attribute__((export_name("TS_OutPoint_get_index"))) TS_OutPoint_get_index(uint64_t this_ptr) {
25649 LDKOutPoint this_ptr_conv;
25650 this_ptr_conv.inner = untag_ptr(this_ptr);
25651 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
25652 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25653 this_ptr_conv.is_owned = false;
25654 int16_t ret_conv = OutPoint_get_index(&this_ptr_conv);
25658 void __attribute__((export_name("TS_OutPoint_set_index"))) TS_OutPoint_set_index(uint64_t this_ptr, int16_t val) {
25659 LDKOutPoint this_ptr_conv;
25660 this_ptr_conv.inner = untag_ptr(this_ptr);
25661 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
25662 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25663 this_ptr_conv.is_owned = false;
25664 OutPoint_set_index(&this_ptr_conv, val);
25667 uint64_t __attribute__((export_name("TS_OutPoint_new"))) TS_OutPoint_new(int8_tArray txid_arg, int16_t index_arg) {
25668 LDKThirtyTwoBytes txid_arg_ref;
25669 CHECK(txid_arg->arr_len == 32);
25670 memcpy(txid_arg_ref.data, txid_arg->elems, 32); FREE(txid_arg);
25671 LDKOutPoint ret_var = OutPoint_new(txid_arg_ref, index_arg);
25672 uint64_t ret_ref = 0;
25673 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25674 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
25678 static inline uint64_t OutPoint_clone_ptr(LDKOutPoint *NONNULL_PTR arg) {
25679 LDKOutPoint ret_var = OutPoint_clone(arg);
25680 uint64_t ret_ref = 0;
25681 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25682 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
25685 int64_t __attribute__((export_name("TS_OutPoint_clone_ptr"))) TS_OutPoint_clone_ptr(uint64_t arg) {
25686 LDKOutPoint arg_conv;
25687 arg_conv.inner = untag_ptr(arg);
25688 arg_conv.is_owned = ptr_is_owned(arg);
25689 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
25690 arg_conv.is_owned = false;
25691 int64_t ret_conv = OutPoint_clone_ptr(&arg_conv);
25695 uint64_t __attribute__((export_name("TS_OutPoint_clone"))) TS_OutPoint_clone(uint64_t orig) {
25696 LDKOutPoint orig_conv;
25697 orig_conv.inner = untag_ptr(orig);
25698 orig_conv.is_owned = ptr_is_owned(orig);
25699 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
25700 orig_conv.is_owned = false;
25701 LDKOutPoint ret_var = OutPoint_clone(&orig_conv);
25702 uint64_t ret_ref = 0;
25703 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25704 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
25708 jboolean __attribute__((export_name("TS_OutPoint_eq"))) TS_OutPoint_eq(uint64_t a, uint64_t b) {
25709 LDKOutPoint a_conv;
25710 a_conv.inner = untag_ptr(a);
25711 a_conv.is_owned = ptr_is_owned(a);
25712 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
25713 a_conv.is_owned = false;
25714 LDKOutPoint b_conv;
25715 b_conv.inner = untag_ptr(b);
25716 b_conv.is_owned = ptr_is_owned(b);
25717 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
25718 b_conv.is_owned = false;
25719 jboolean ret_conv = OutPoint_eq(&a_conv, &b_conv);
25723 int64_t __attribute__((export_name("TS_OutPoint_hash"))) TS_OutPoint_hash(uint64_t o) {
25724 LDKOutPoint o_conv;
25725 o_conv.inner = untag_ptr(o);
25726 o_conv.is_owned = ptr_is_owned(o);
25727 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
25728 o_conv.is_owned = false;
25729 int64_t ret_conv = OutPoint_hash(&o_conv);
25733 int8_tArray __attribute__((export_name("TS_OutPoint_to_channel_id"))) TS_OutPoint_to_channel_id(uint64_t this_arg) {
25734 LDKOutPoint this_arg_conv;
25735 this_arg_conv.inner = untag_ptr(this_arg);
25736 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25737 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25738 this_arg_conv.is_owned = false;
25739 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
25740 memcpy(ret_arr->elems, OutPoint_to_channel_id(&this_arg_conv).data, 32);
25744 int8_tArray __attribute__((export_name("TS_OutPoint_write"))) TS_OutPoint_write(uint64_t obj) {
25745 LDKOutPoint obj_conv;
25746 obj_conv.inner = untag_ptr(obj);
25747 obj_conv.is_owned = ptr_is_owned(obj);
25748 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
25749 obj_conv.is_owned = false;
25750 LDKCVec_u8Z ret_var = OutPoint_write(&obj_conv);
25751 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
25752 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
25753 CVec_u8Z_free(ret_var);
25757 uint64_t __attribute__((export_name("TS_OutPoint_read"))) TS_OutPoint_read(int8_tArray ser) {
25758 LDKu8slice ser_ref;
25759 ser_ref.datalen = ser->arr_len;
25760 ser_ref.data = ser->elems;
25761 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
25762 *ret_conv = OutPoint_read(ser_ref);
25764 return tag_ptr(ret_conv, true);
25767 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_free"))) TS_DelayedPaymentOutputDescriptor_free(uint64_t this_obj) {
25768 LDKDelayedPaymentOutputDescriptor this_obj_conv;
25769 this_obj_conv.inner = untag_ptr(this_obj);
25770 this_obj_conv.is_owned = ptr_is_owned(this_obj);
25771 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
25772 DelayedPaymentOutputDescriptor_free(this_obj_conv);
25775 uint64_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_outpoint"))) TS_DelayedPaymentOutputDescriptor_get_outpoint(uint64_t this_ptr) {
25776 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
25777 this_ptr_conv.inner = untag_ptr(this_ptr);
25778 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
25779 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25780 this_ptr_conv.is_owned = false;
25781 LDKOutPoint ret_var = DelayedPaymentOutputDescriptor_get_outpoint(&this_ptr_conv);
25782 uint64_t ret_ref = 0;
25783 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25784 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
25788 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_outpoint"))) TS_DelayedPaymentOutputDescriptor_set_outpoint(uint64_t this_ptr, uint64_t val) {
25789 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
25790 this_ptr_conv.inner = untag_ptr(this_ptr);
25791 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
25792 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25793 this_ptr_conv.is_owned = false;
25794 LDKOutPoint val_conv;
25795 val_conv.inner = untag_ptr(val);
25796 val_conv.is_owned = ptr_is_owned(val);
25797 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
25798 val_conv = OutPoint_clone(&val_conv);
25799 DelayedPaymentOutputDescriptor_set_outpoint(&this_ptr_conv, val_conv);
25802 int8_tArray __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_per_commitment_point"))) TS_DelayedPaymentOutputDescriptor_get_per_commitment_point(uint64_t this_ptr) {
25803 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
25804 this_ptr_conv.inner = untag_ptr(this_ptr);
25805 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
25806 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25807 this_ptr_conv.is_owned = false;
25808 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
25809 memcpy(ret_arr->elems, DelayedPaymentOutputDescriptor_get_per_commitment_point(&this_ptr_conv).compressed_form, 33);
25813 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_per_commitment_point"))) TS_DelayedPaymentOutputDescriptor_set_per_commitment_point(uint64_t this_ptr, int8_tArray val) {
25814 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
25815 this_ptr_conv.inner = untag_ptr(this_ptr);
25816 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
25817 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25818 this_ptr_conv.is_owned = false;
25819 LDKPublicKey val_ref;
25820 CHECK(val->arr_len == 33);
25821 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
25822 DelayedPaymentOutputDescriptor_set_per_commitment_point(&this_ptr_conv, val_ref);
25825 int16_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_to_self_delay"))) TS_DelayedPaymentOutputDescriptor_get_to_self_delay(uint64_t this_ptr) {
25826 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
25827 this_ptr_conv.inner = untag_ptr(this_ptr);
25828 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
25829 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25830 this_ptr_conv.is_owned = false;
25831 int16_t ret_conv = DelayedPaymentOutputDescriptor_get_to_self_delay(&this_ptr_conv);
25835 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_to_self_delay"))) TS_DelayedPaymentOutputDescriptor_set_to_self_delay(uint64_t this_ptr, int16_t val) {
25836 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
25837 this_ptr_conv.inner = untag_ptr(this_ptr);
25838 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
25839 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25840 this_ptr_conv.is_owned = false;
25841 DelayedPaymentOutputDescriptor_set_to_self_delay(&this_ptr_conv, val);
25844 uint64_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_output"))) TS_DelayedPaymentOutputDescriptor_get_output(uint64_t this_ptr) {
25845 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
25846 this_ptr_conv.inner = untag_ptr(this_ptr);
25847 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
25848 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25849 this_ptr_conv.is_owned = false;
25850 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
25851 *ret_ref = DelayedPaymentOutputDescriptor_get_output(&this_ptr_conv);
25852 return tag_ptr(ret_ref, true);
25855 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_output"))) TS_DelayedPaymentOutputDescriptor_set_output(uint64_t this_ptr, uint64_t val) {
25856 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
25857 this_ptr_conv.inner = untag_ptr(this_ptr);
25858 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
25859 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25860 this_ptr_conv.is_owned = false;
25861 void* val_ptr = untag_ptr(val);
25862 CHECK_ACCESS(val_ptr);
25863 LDKTxOut val_conv = *(LDKTxOut*)(val_ptr);
25864 val_conv = TxOut_clone((LDKTxOut*)untag_ptr(val));
25865 DelayedPaymentOutputDescriptor_set_output(&this_ptr_conv, val_conv);
25868 int8_tArray __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_revocation_pubkey"))) TS_DelayedPaymentOutputDescriptor_get_revocation_pubkey(uint64_t this_ptr) {
25869 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
25870 this_ptr_conv.inner = untag_ptr(this_ptr);
25871 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
25872 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25873 this_ptr_conv.is_owned = false;
25874 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
25875 memcpy(ret_arr->elems, DelayedPaymentOutputDescriptor_get_revocation_pubkey(&this_ptr_conv).compressed_form, 33);
25879 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_revocation_pubkey"))) TS_DelayedPaymentOutputDescriptor_set_revocation_pubkey(uint64_t this_ptr, int8_tArray val) {
25880 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
25881 this_ptr_conv.inner = untag_ptr(this_ptr);
25882 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
25883 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25884 this_ptr_conv.is_owned = false;
25885 LDKPublicKey val_ref;
25886 CHECK(val->arr_len == 33);
25887 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
25888 DelayedPaymentOutputDescriptor_set_revocation_pubkey(&this_ptr_conv, val_ref);
25891 int8_tArray __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_channel_keys_id"))) TS_DelayedPaymentOutputDescriptor_get_channel_keys_id(uint64_t this_ptr) {
25892 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
25893 this_ptr_conv.inner = untag_ptr(this_ptr);
25894 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
25895 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25896 this_ptr_conv.is_owned = false;
25897 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
25898 memcpy(ret_arr->elems, *DelayedPaymentOutputDescriptor_get_channel_keys_id(&this_ptr_conv), 32);
25902 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_channel_keys_id"))) TS_DelayedPaymentOutputDescriptor_set_channel_keys_id(uint64_t this_ptr, int8_tArray val) {
25903 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
25904 this_ptr_conv.inner = untag_ptr(this_ptr);
25905 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
25906 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25907 this_ptr_conv.is_owned = false;
25908 LDKThirtyTwoBytes val_ref;
25909 CHECK(val->arr_len == 32);
25910 memcpy(val_ref.data, val->elems, 32); FREE(val);
25911 DelayedPaymentOutputDescriptor_set_channel_keys_id(&this_ptr_conv, val_ref);
25914 int64_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_channel_value_satoshis"))) TS_DelayedPaymentOutputDescriptor_get_channel_value_satoshis(uint64_t this_ptr) {
25915 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
25916 this_ptr_conv.inner = untag_ptr(this_ptr);
25917 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
25918 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25919 this_ptr_conv.is_owned = false;
25920 int64_t ret_conv = DelayedPaymentOutputDescriptor_get_channel_value_satoshis(&this_ptr_conv);
25924 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_channel_value_satoshis"))) TS_DelayedPaymentOutputDescriptor_set_channel_value_satoshis(uint64_t this_ptr, int64_t val) {
25925 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
25926 this_ptr_conv.inner = untag_ptr(this_ptr);
25927 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
25928 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25929 this_ptr_conv.is_owned = false;
25930 DelayedPaymentOutputDescriptor_set_channel_value_satoshis(&this_ptr_conv, val);
25933 uint64_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_new"))) TS_DelayedPaymentOutputDescriptor_new(uint64_t outpoint_arg, int8_tArray per_commitment_point_arg, int16_t to_self_delay_arg, uint64_t output_arg, int8_tArray revocation_pubkey_arg, int8_tArray channel_keys_id_arg, int64_t channel_value_satoshis_arg) {
25934 LDKOutPoint outpoint_arg_conv;
25935 outpoint_arg_conv.inner = untag_ptr(outpoint_arg);
25936 outpoint_arg_conv.is_owned = ptr_is_owned(outpoint_arg);
25937 CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_arg_conv);
25938 outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
25939 LDKPublicKey per_commitment_point_arg_ref;
25940 CHECK(per_commitment_point_arg->arr_len == 33);
25941 memcpy(per_commitment_point_arg_ref.compressed_form, per_commitment_point_arg->elems, 33); FREE(per_commitment_point_arg);
25942 void* output_arg_ptr = untag_ptr(output_arg);
25943 CHECK_ACCESS(output_arg_ptr);
25944 LDKTxOut output_arg_conv = *(LDKTxOut*)(output_arg_ptr);
25945 output_arg_conv = TxOut_clone((LDKTxOut*)untag_ptr(output_arg));
25946 LDKPublicKey revocation_pubkey_arg_ref;
25947 CHECK(revocation_pubkey_arg->arr_len == 33);
25948 memcpy(revocation_pubkey_arg_ref.compressed_form, revocation_pubkey_arg->elems, 33); FREE(revocation_pubkey_arg);
25949 LDKThirtyTwoBytes channel_keys_id_arg_ref;
25950 CHECK(channel_keys_id_arg->arr_len == 32);
25951 memcpy(channel_keys_id_arg_ref.data, channel_keys_id_arg->elems, 32); FREE(channel_keys_id_arg);
25952 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);
25953 uint64_t ret_ref = 0;
25954 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25955 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
25959 static inline uint64_t DelayedPaymentOutputDescriptor_clone_ptr(LDKDelayedPaymentOutputDescriptor *NONNULL_PTR arg) {
25960 LDKDelayedPaymentOutputDescriptor ret_var = DelayedPaymentOutputDescriptor_clone(arg);
25961 uint64_t ret_ref = 0;
25962 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25963 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
25966 int64_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_clone_ptr"))) TS_DelayedPaymentOutputDescriptor_clone_ptr(uint64_t arg) {
25967 LDKDelayedPaymentOutputDescriptor arg_conv;
25968 arg_conv.inner = untag_ptr(arg);
25969 arg_conv.is_owned = ptr_is_owned(arg);
25970 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
25971 arg_conv.is_owned = false;
25972 int64_t ret_conv = DelayedPaymentOutputDescriptor_clone_ptr(&arg_conv);
25976 uint64_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_clone"))) TS_DelayedPaymentOutputDescriptor_clone(uint64_t orig) {
25977 LDKDelayedPaymentOutputDescriptor orig_conv;
25978 orig_conv.inner = untag_ptr(orig);
25979 orig_conv.is_owned = ptr_is_owned(orig);
25980 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
25981 orig_conv.is_owned = false;
25982 LDKDelayedPaymentOutputDescriptor ret_var = DelayedPaymentOutputDescriptor_clone(&orig_conv);
25983 uint64_t ret_ref = 0;
25984 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25985 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
25989 jboolean __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_eq"))) TS_DelayedPaymentOutputDescriptor_eq(uint64_t a, uint64_t b) {
25990 LDKDelayedPaymentOutputDescriptor a_conv;
25991 a_conv.inner = untag_ptr(a);
25992 a_conv.is_owned = ptr_is_owned(a);
25993 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
25994 a_conv.is_owned = false;
25995 LDKDelayedPaymentOutputDescriptor b_conv;
25996 b_conv.inner = untag_ptr(b);
25997 b_conv.is_owned = ptr_is_owned(b);
25998 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
25999 b_conv.is_owned = false;
26000 jboolean ret_conv = DelayedPaymentOutputDescriptor_eq(&a_conv, &b_conv);
26004 int8_tArray __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_write"))) TS_DelayedPaymentOutputDescriptor_write(uint64_t obj) {
26005 LDKDelayedPaymentOutputDescriptor obj_conv;
26006 obj_conv.inner = untag_ptr(obj);
26007 obj_conv.is_owned = ptr_is_owned(obj);
26008 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
26009 obj_conv.is_owned = false;
26010 LDKCVec_u8Z ret_var = DelayedPaymentOutputDescriptor_write(&obj_conv);
26011 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
26012 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
26013 CVec_u8Z_free(ret_var);
26017 uint64_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_read"))) TS_DelayedPaymentOutputDescriptor_read(int8_tArray ser) {
26018 LDKu8slice ser_ref;
26019 ser_ref.datalen = ser->arr_len;
26020 ser_ref.data = ser->elems;
26021 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
26022 *ret_conv = DelayedPaymentOutputDescriptor_read(ser_ref);
26024 return tag_ptr(ret_conv, true);
26027 void __attribute__((export_name("TS_StaticPaymentOutputDescriptor_free"))) TS_StaticPaymentOutputDescriptor_free(uint64_t this_obj) {
26028 LDKStaticPaymentOutputDescriptor this_obj_conv;
26029 this_obj_conv.inner = untag_ptr(this_obj);
26030 this_obj_conv.is_owned = ptr_is_owned(this_obj);
26031 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
26032 StaticPaymentOutputDescriptor_free(this_obj_conv);
26035 uint64_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_get_outpoint"))) TS_StaticPaymentOutputDescriptor_get_outpoint(uint64_t this_ptr) {
26036 LDKStaticPaymentOutputDescriptor this_ptr_conv;
26037 this_ptr_conv.inner = untag_ptr(this_ptr);
26038 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26039 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26040 this_ptr_conv.is_owned = false;
26041 LDKOutPoint ret_var = StaticPaymentOutputDescriptor_get_outpoint(&this_ptr_conv);
26042 uint64_t ret_ref = 0;
26043 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26044 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26048 void __attribute__((export_name("TS_StaticPaymentOutputDescriptor_set_outpoint"))) TS_StaticPaymentOutputDescriptor_set_outpoint(uint64_t this_ptr, uint64_t val) {
26049 LDKStaticPaymentOutputDescriptor this_ptr_conv;
26050 this_ptr_conv.inner = untag_ptr(this_ptr);
26051 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26052 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26053 this_ptr_conv.is_owned = false;
26054 LDKOutPoint val_conv;
26055 val_conv.inner = untag_ptr(val);
26056 val_conv.is_owned = ptr_is_owned(val);
26057 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
26058 val_conv = OutPoint_clone(&val_conv);
26059 StaticPaymentOutputDescriptor_set_outpoint(&this_ptr_conv, val_conv);
26062 uint64_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_get_output"))) TS_StaticPaymentOutputDescriptor_get_output(uint64_t this_ptr) {
26063 LDKStaticPaymentOutputDescriptor this_ptr_conv;
26064 this_ptr_conv.inner = untag_ptr(this_ptr);
26065 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26066 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26067 this_ptr_conv.is_owned = false;
26068 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
26069 *ret_ref = StaticPaymentOutputDescriptor_get_output(&this_ptr_conv);
26070 return tag_ptr(ret_ref, true);
26073 void __attribute__((export_name("TS_StaticPaymentOutputDescriptor_set_output"))) TS_StaticPaymentOutputDescriptor_set_output(uint64_t this_ptr, uint64_t val) {
26074 LDKStaticPaymentOutputDescriptor this_ptr_conv;
26075 this_ptr_conv.inner = untag_ptr(this_ptr);
26076 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26077 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26078 this_ptr_conv.is_owned = false;
26079 void* val_ptr = untag_ptr(val);
26080 CHECK_ACCESS(val_ptr);
26081 LDKTxOut val_conv = *(LDKTxOut*)(val_ptr);
26082 val_conv = TxOut_clone((LDKTxOut*)untag_ptr(val));
26083 StaticPaymentOutputDescriptor_set_output(&this_ptr_conv, val_conv);
26086 int8_tArray __attribute__((export_name("TS_StaticPaymentOutputDescriptor_get_channel_keys_id"))) TS_StaticPaymentOutputDescriptor_get_channel_keys_id(uint64_t this_ptr) {
26087 LDKStaticPaymentOutputDescriptor this_ptr_conv;
26088 this_ptr_conv.inner = untag_ptr(this_ptr);
26089 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26090 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26091 this_ptr_conv.is_owned = false;
26092 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
26093 memcpy(ret_arr->elems, *StaticPaymentOutputDescriptor_get_channel_keys_id(&this_ptr_conv), 32);
26097 void __attribute__((export_name("TS_StaticPaymentOutputDescriptor_set_channel_keys_id"))) TS_StaticPaymentOutputDescriptor_set_channel_keys_id(uint64_t this_ptr, int8_tArray val) {
26098 LDKStaticPaymentOutputDescriptor this_ptr_conv;
26099 this_ptr_conv.inner = untag_ptr(this_ptr);
26100 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26101 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26102 this_ptr_conv.is_owned = false;
26103 LDKThirtyTwoBytes val_ref;
26104 CHECK(val->arr_len == 32);
26105 memcpy(val_ref.data, val->elems, 32); FREE(val);
26106 StaticPaymentOutputDescriptor_set_channel_keys_id(&this_ptr_conv, val_ref);
26109 int64_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_get_channel_value_satoshis"))) TS_StaticPaymentOutputDescriptor_get_channel_value_satoshis(uint64_t this_ptr) {
26110 LDKStaticPaymentOutputDescriptor this_ptr_conv;
26111 this_ptr_conv.inner = untag_ptr(this_ptr);
26112 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26113 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26114 this_ptr_conv.is_owned = false;
26115 int64_t ret_conv = StaticPaymentOutputDescriptor_get_channel_value_satoshis(&this_ptr_conv);
26119 void __attribute__((export_name("TS_StaticPaymentOutputDescriptor_set_channel_value_satoshis"))) TS_StaticPaymentOutputDescriptor_set_channel_value_satoshis(uint64_t this_ptr, int64_t val) {
26120 LDKStaticPaymentOutputDescriptor this_ptr_conv;
26121 this_ptr_conv.inner = untag_ptr(this_ptr);
26122 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26123 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26124 this_ptr_conv.is_owned = false;
26125 StaticPaymentOutputDescriptor_set_channel_value_satoshis(&this_ptr_conv, val);
26128 uint64_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_new"))) TS_StaticPaymentOutputDescriptor_new(uint64_t outpoint_arg, uint64_t output_arg, int8_tArray channel_keys_id_arg, int64_t channel_value_satoshis_arg) {
26129 LDKOutPoint outpoint_arg_conv;
26130 outpoint_arg_conv.inner = untag_ptr(outpoint_arg);
26131 outpoint_arg_conv.is_owned = ptr_is_owned(outpoint_arg);
26132 CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_arg_conv);
26133 outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
26134 void* output_arg_ptr = untag_ptr(output_arg);
26135 CHECK_ACCESS(output_arg_ptr);
26136 LDKTxOut output_arg_conv = *(LDKTxOut*)(output_arg_ptr);
26137 output_arg_conv = TxOut_clone((LDKTxOut*)untag_ptr(output_arg));
26138 LDKThirtyTwoBytes channel_keys_id_arg_ref;
26139 CHECK(channel_keys_id_arg->arr_len == 32);
26140 memcpy(channel_keys_id_arg_ref.data, channel_keys_id_arg->elems, 32); FREE(channel_keys_id_arg);
26141 LDKStaticPaymentOutputDescriptor ret_var = StaticPaymentOutputDescriptor_new(outpoint_arg_conv, output_arg_conv, channel_keys_id_arg_ref, channel_value_satoshis_arg);
26142 uint64_t ret_ref = 0;
26143 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26144 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26148 static inline uint64_t StaticPaymentOutputDescriptor_clone_ptr(LDKStaticPaymentOutputDescriptor *NONNULL_PTR arg) {
26149 LDKStaticPaymentOutputDescriptor ret_var = StaticPaymentOutputDescriptor_clone(arg);
26150 uint64_t ret_ref = 0;
26151 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26152 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26155 int64_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_clone_ptr"))) TS_StaticPaymentOutputDescriptor_clone_ptr(uint64_t arg) {
26156 LDKStaticPaymentOutputDescriptor arg_conv;
26157 arg_conv.inner = untag_ptr(arg);
26158 arg_conv.is_owned = ptr_is_owned(arg);
26159 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
26160 arg_conv.is_owned = false;
26161 int64_t ret_conv = StaticPaymentOutputDescriptor_clone_ptr(&arg_conv);
26165 uint64_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_clone"))) TS_StaticPaymentOutputDescriptor_clone(uint64_t orig) {
26166 LDKStaticPaymentOutputDescriptor orig_conv;
26167 orig_conv.inner = untag_ptr(orig);
26168 orig_conv.is_owned = ptr_is_owned(orig);
26169 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
26170 orig_conv.is_owned = false;
26171 LDKStaticPaymentOutputDescriptor ret_var = StaticPaymentOutputDescriptor_clone(&orig_conv);
26172 uint64_t ret_ref = 0;
26173 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26174 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26178 jboolean __attribute__((export_name("TS_StaticPaymentOutputDescriptor_eq"))) TS_StaticPaymentOutputDescriptor_eq(uint64_t a, uint64_t b) {
26179 LDKStaticPaymentOutputDescriptor a_conv;
26180 a_conv.inner = untag_ptr(a);
26181 a_conv.is_owned = ptr_is_owned(a);
26182 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
26183 a_conv.is_owned = false;
26184 LDKStaticPaymentOutputDescriptor b_conv;
26185 b_conv.inner = untag_ptr(b);
26186 b_conv.is_owned = ptr_is_owned(b);
26187 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
26188 b_conv.is_owned = false;
26189 jboolean ret_conv = StaticPaymentOutputDescriptor_eq(&a_conv, &b_conv);
26193 int8_tArray __attribute__((export_name("TS_StaticPaymentOutputDescriptor_write"))) TS_StaticPaymentOutputDescriptor_write(uint64_t obj) {
26194 LDKStaticPaymentOutputDescriptor obj_conv;
26195 obj_conv.inner = untag_ptr(obj);
26196 obj_conv.is_owned = ptr_is_owned(obj);
26197 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
26198 obj_conv.is_owned = false;
26199 LDKCVec_u8Z ret_var = StaticPaymentOutputDescriptor_write(&obj_conv);
26200 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
26201 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
26202 CVec_u8Z_free(ret_var);
26206 uint64_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_read"))) TS_StaticPaymentOutputDescriptor_read(int8_tArray ser) {
26207 LDKu8slice ser_ref;
26208 ser_ref.datalen = ser->arr_len;
26209 ser_ref.data = ser->elems;
26210 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
26211 *ret_conv = StaticPaymentOutputDescriptor_read(ser_ref);
26213 return tag_ptr(ret_conv, true);
26216 void __attribute__((export_name("TS_SpendableOutputDescriptor_free"))) TS_SpendableOutputDescriptor_free(uint64_t this_ptr) {
26217 if (!ptr_is_owned(this_ptr)) return;
26218 void* this_ptr_ptr = untag_ptr(this_ptr);
26219 CHECK_ACCESS(this_ptr_ptr);
26220 LDKSpendableOutputDescriptor this_ptr_conv = *(LDKSpendableOutputDescriptor*)(this_ptr_ptr);
26221 FREE(untag_ptr(this_ptr));
26222 SpendableOutputDescriptor_free(this_ptr_conv);
26225 static inline uint64_t SpendableOutputDescriptor_clone_ptr(LDKSpendableOutputDescriptor *NONNULL_PTR arg) {
26226 LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
26227 *ret_copy = SpendableOutputDescriptor_clone(arg);
26228 uint64_t ret_ref = tag_ptr(ret_copy, true);
26231 int64_t __attribute__((export_name("TS_SpendableOutputDescriptor_clone_ptr"))) TS_SpendableOutputDescriptor_clone_ptr(uint64_t arg) {
26232 LDKSpendableOutputDescriptor* arg_conv = (LDKSpendableOutputDescriptor*)untag_ptr(arg);
26233 int64_t ret_conv = SpendableOutputDescriptor_clone_ptr(arg_conv);
26237 uint64_t __attribute__((export_name("TS_SpendableOutputDescriptor_clone"))) TS_SpendableOutputDescriptor_clone(uint64_t orig) {
26238 LDKSpendableOutputDescriptor* orig_conv = (LDKSpendableOutputDescriptor*)untag_ptr(orig);
26239 LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
26240 *ret_copy = SpendableOutputDescriptor_clone(orig_conv);
26241 uint64_t ret_ref = tag_ptr(ret_copy, true);
26245 uint64_t __attribute__((export_name("TS_SpendableOutputDescriptor_static_output"))) TS_SpendableOutputDescriptor_static_output(uint64_t outpoint, uint64_t output) {
26246 LDKOutPoint outpoint_conv;
26247 outpoint_conv.inner = untag_ptr(outpoint);
26248 outpoint_conv.is_owned = ptr_is_owned(outpoint);
26249 CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_conv);
26250 outpoint_conv = OutPoint_clone(&outpoint_conv);
26251 void* output_ptr = untag_ptr(output);
26252 CHECK_ACCESS(output_ptr);
26253 LDKTxOut output_conv = *(LDKTxOut*)(output_ptr);
26254 output_conv = TxOut_clone((LDKTxOut*)untag_ptr(output));
26255 LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
26256 *ret_copy = SpendableOutputDescriptor_static_output(outpoint_conv, output_conv);
26257 uint64_t ret_ref = tag_ptr(ret_copy, true);
26261 uint64_t __attribute__((export_name("TS_SpendableOutputDescriptor_delayed_payment_output"))) TS_SpendableOutputDescriptor_delayed_payment_output(uint64_t a) {
26262 LDKDelayedPaymentOutputDescriptor a_conv;
26263 a_conv.inner = untag_ptr(a);
26264 a_conv.is_owned = ptr_is_owned(a);
26265 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
26266 a_conv = DelayedPaymentOutputDescriptor_clone(&a_conv);
26267 LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
26268 *ret_copy = SpendableOutputDescriptor_delayed_payment_output(a_conv);
26269 uint64_t ret_ref = tag_ptr(ret_copy, true);
26273 uint64_t __attribute__((export_name("TS_SpendableOutputDescriptor_static_payment_output"))) TS_SpendableOutputDescriptor_static_payment_output(uint64_t a) {
26274 LDKStaticPaymentOutputDescriptor a_conv;
26275 a_conv.inner = untag_ptr(a);
26276 a_conv.is_owned = ptr_is_owned(a);
26277 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
26278 a_conv = StaticPaymentOutputDescriptor_clone(&a_conv);
26279 LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
26280 *ret_copy = SpendableOutputDescriptor_static_payment_output(a_conv);
26281 uint64_t ret_ref = tag_ptr(ret_copy, true);
26285 jboolean __attribute__((export_name("TS_SpendableOutputDescriptor_eq"))) TS_SpendableOutputDescriptor_eq(uint64_t a, uint64_t b) {
26286 LDKSpendableOutputDescriptor* a_conv = (LDKSpendableOutputDescriptor*)untag_ptr(a);
26287 LDKSpendableOutputDescriptor* b_conv = (LDKSpendableOutputDescriptor*)untag_ptr(b);
26288 jboolean ret_conv = SpendableOutputDescriptor_eq(a_conv, b_conv);
26292 int8_tArray __attribute__((export_name("TS_SpendableOutputDescriptor_write"))) TS_SpendableOutputDescriptor_write(uint64_t obj) {
26293 LDKSpendableOutputDescriptor* obj_conv = (LDKSpendableOutputDescriptor*)untag_ptr(obj);
26294 LDKCVec_u8Z ret_var = SpendableOutputDescriptor_write(obj_conv);
26295 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
26296 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
26297 CVec_u8Z_free(ret_var);
26301 uint64_t __attribute__((export_name("TS_SpendableOutputDescriptor_read"))) TS_SpendableOutputDescriptor_read(int8_tArray ser) {
26302 LDKu8slice ser_ref;
26303 ser_ref.datalen = ser->arr_len;
26304 ser_ref.data = ser->elems;
26305 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
26306 *ret_conv = SpendableOutputDescriptor_read(ser_ref);
26308 return tag_ptr(ret_conv, true);
26311 void __attribute__((export_name("TS_BaseSign_free"))) TS_BaseSign_free(uint64_t this_ptr) {
26312 if (!ptr_is_owned(this_ptr)) return;
26313 void* this_ptr_ptr = untag_ptr(this_ptr);
26314 CHECK_ACCESS(this_ptr_ptr);
26315 LDKBaseSign this_ptr_conv = *(LDKBaseSign*)(this_ptr_ptr);
26316 FREE(untag_ptr(this_ptr));
26317 BaseSign_free(this_ptr_conv);
26320 static inline uint64_t Sign_clone_ptr(LDKSign *NONNULL_PTR arg) {
26321 LDKSign* ret_ret = MALLOC(sizeof(LDKSign), "LDKSign");
26322 *ret_ret = Sign_clone(arg);
26323 return tag_ptr(ret_ret, true);
26325 int64_t __attribute__((export_name("TS_Sign_clone_ptr"))) TS_Sign_clone_ptr(uint64_t arg) {
26326 void* arg_ptr = untag_ptr(arg);
26327 if (ptr_is_owned(arg)) { CHECK_ACCESS(arg_ptr); }
26328 LDKSign* arg_conv = (LDKSign*)arg_ptr;
26329 int64_t ret_conv = Sign_clone_ptr(arg_conv);
26333 uint64_t __attribute__((export_name("TS_Sign_clone"))) TS_Sign_clone(uint64_t orig) {
26334 void* orig_ptr = untag_ptr(orig);
26335 if (ptr_is_owned(orig)) { CHECK_ACCESS(orig_ptr); }
26336 LDKSign* orig_conv = (LDKSign*)orig_ptr;
26337 LDKSign* ret_ret = MALLOC(sizeof(LDKSign), "LDKSign");
26338 *ret_ret = Sign_clone(orig_conv);
26339 return tag_ptr(ret_ret, true);
26342 void __attribute__((export_name("TS_Sign_free"))) TS_Sign_free(uint64_t this_ptr) {
26343 if (!ptr_is_owned(this_ptr)) return;
26344 void* this_ptr_ptr = untag_ptr(this_ptr);
26345 CHECK_ACCESS(this_ptr_ptr);
26346 LDKSign this_ptr_conv = *(LDKSign*)(this_ptr_ptr);
26347 FREE(untag_ptr(this_ptr));
26348 Sign_free(this_ptr_conv);
26351 uint32_t __attribute__((export_name("TS_Recipient_clone"))) TS_Recipient_clone(uint64_t orig) {
26352 LDKRecipient* orig_conv = (LDKRecipient*)untag_ptr(orig);
26353 uint32_t ret_conv = LDKRecipient_to_js(Recipient_clone(orig_conv));
26357 uint32_t __attribute__((export_name("TS_Recipient_node"))) TS_Recipient_node() {
26358 uint32_t ret_conv = LDKRecipient_to_js(Recipient_node());
26362 uint32_t __attribute__((export_name("TS_Recipient_phantom_node"))) TS_Recipient_phantom_node() {
26363 uint32_t ret_conv = LDKRecipient_to_js(Recipient_phantom_node());
26367 void __attribute__((export_name("TS_KeysInterface_free"))) TS_KeysInterface_free(uint64_t this_ptr) {
26368 if (!ptr_is_owned(this_ptr)) return;
26369 void* this_ptr_ptr = untag_ptr(this_ptr);
26370 CHECK_ACCESS(this_ptr_ptr);
26371 LDKKeysInterface this_ptr_conv = *(LDKKeysInterface*)(this_ptr_ptr);
26372 FREE(untag_ptr(this_ptr));
26373 KeysInterface_free(this_ptr_conv);
26376 void __attribute__((export_name("TS_InMemorySigner_free"))) TS_InMemorySigner_free(uint64_t this_obj) {
26377 LDKInMemorySigner this_obj_conv;
26378 this_obj_conv.inner = untag_ptr(this_obj);
26379 this_obj_conv.is_owned = ptr_is_owned(this_obj);
26380 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
26381 InMemorySigner_free(this_obj_conv);
26384 int8_tArray __attribute__((export_name("TS_InMemorySigner_get_funding_key"))) TS_InMemorySigner_get_funding_key(uint64_t this_ptr) {
26385 LDKInMemorySigner this_ptr_conv;
26386 this_ptr_conv.inner = untag_ptr(this_ptr);
26387 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26388 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26389 this_ptr_conv.is_owned = false;
26390 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
26391 memcpy(ret_arr->elems, *InMemorySigner_get_funding_key(&this_ptr_conv), 32);
26395 void __attribute__((export_name("TS_InMemorySigner_set_funding_key"))) TS_InMemorySigner_set_funding_key(uint64_t this_ptr, int8_tArray val) {
26396 LDKInMemorySigner this_ptr_conv;
26397 this_ptr_conv.inner = untag_ptr(this_ptr);
26398 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26399 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26400 this_ptr_conv.is_owned = false;
26401 LDKSecretKey val_ref;
26402 CHECK(val->arr_len == 32);
26403 memcpy(val_ref.bytes, val->elems, 32); FREE(val);
26404 InMemorySigner_set_funding_key(&this_ptr_conv, val_ref);
26407 int8_tArray __attribute__((export_name("TS_InMemorySigner_get_revocation_base_key"))) TS_InMemorySigner_get_revocation_base_key(uint64_t this_ptr) {
26408 LDKInMemorySigner this_ptr_conv;
26409 this_ptr_conv.inner = untag_ptr(this_ptr);
26410 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26411 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26412 this_ptr_conv.is_owned = false;
26413 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
26414 memcpy(ret_arr->elems, *InMemorySigner_get_revocation_base_key(&this_ptr_conv), 32);
26418 void __attribute__((export_name("TS_InMemorySigner_set_revocation_base_key"))) TS_InMemorySigner_set_revocation_base_key(uint64_t this_ptr, int8_tArray val) {
26419 LDKInMemorySigner this_ptr_conv;
26420 this_ptr_conv.inner = untag_ptr(this_ptr);
26421 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26422 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26423 this_ptr_conv.is_owned = false;
26424 LDKSecretKey val_ref;
26425 CHECK(val->arr_len == 32);
26426 memcpy(val_ref.bytes, val->elems, 32); FREE(val);
26427 InMemorySigner_set_revocation_base_key(&this_ptr_conv, val_ref);
26430 int8_tArray __attribute__((export_name("TS_InMemorySigner_get_payment_key"))) TS_InMemorySigner_get_payment_key(uint64_t this_ptr) {
26431 LDKInMemorySigner this_ptr_conv;
26432 this_ptr_conv.inner = untag_ptr(this_ptr);
26433 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26434 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26435 this_ptr_conv.is_owned = false;
26436 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
26437 memcpy(ret_arr->elems, *InMemorySigner_get_payment_key(&this_ptr_conv), 32);
26441 void __attribute__((export_name("TS_InMemorySigner_set_payment_key"))) TS_InMemorySigner_set_payment_key(uint64_t this_ptr, int8_tArray val) {
26442 LDKInMemorySigner this_ptr_conv;
26443 this_ptr_conv.inner = untag_ptr(this_ptr);
26444 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26445 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26446 this_ptr_conv.is_owned = false;
26447 LDKSecretKey val_ref;
26448 CHECK(val->arr_len == 32);
26449 memcpy(val_ref.bytes, val->elems, 32); FREE(val);
26450 InMemorySigner_set_payment_key(&this_ptr_conv, val_ref);
26453 int8_tArray __attribute__((export_name("TS_InMemorySigner_get_delayed_payment_base_key"))) TS_InMemorySigner_get_delayed_payment_base_key(uint64_t this_ptr) {
26454 LDKInMemorySigner this_ptr_conv;
26455 this_ptr_conv.inner = untag_ptr(this_ptr);
26456 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26457 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26458 this_ptr_conv.is_owned = false;
26459 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
26460 memcpy(ret_arr->elems, *InMemorySigner_get_delayed_payment_base_key(&this_ptr_conv), 32);
26464 void __attribute__((export_name("TS_InMemorySigner_set_delayed_payment_base_key"))) TS_InMemorySigner_set_delayed_payment_base_key(uint64_t this_ptr, int8_tArray val) {
26465 LDKInMemorySigner this_ptr_conv;
26466 this_ptr_conv.inner = untag_ptr(this_ptr);
26467 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26468 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26469 this_ptr_conv.is_owned = false;
26470 LDKSecretKey val_ref;
26471 CHECK(val->arr_len == 32);
26472 memcpy(val_ref.bytes, val->elems, 32); FREE(val);
26473 InMemorySigner_set_delayed_payment_base_key(&this_ptr_conv, val_ref);
26476 int8_tArray __attribute__((export_name("TS_InMemorySigner_get_htlc_base_key"))) TS_InMemorySigner_get_htlc_base_key(uint64_t this_ptr) {
26477 LDKInMemorySigner this_ptr_conv;
26478 this_ptr_conv.inner = untag_ptr(this_ptr);
26479 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26480 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26481 this_ptr_conv.is_owned = false;
26482 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
26483 memcpy(ret_arr->elems, *InMemorySigner_get_htlc_base_key(&this_ptr_conv), 32);
26487 void __attribute__((export_name("TS_InMemorySigner_set_htlc_base_key"))) TS_InMemorySigner_set_htlc_base_key(uint64_t this_ptr, int8_tArray val) {
26488 LDKInMemorySigner this_ptr_conv;
26489 this_ptr_conv.inner = untag_ptr(this_ptr);
26490 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26491 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26492 this_ptr_conv.is_owned = false;
26493 LDKSecretKey val_ref;
26494 CHECK(val->arr_len == 32);
26495 memcpy(val_ref.bytes, val->elems, 32); FREE(val);
26496 InMemorySigner_set_htlc_base_key(&this_ptr_conv, val_ref);
26499 int8_tArray __attribute__((export_name("TS_InMemorySigner_get_commitment_seed"))) TS_InMemorySigner_get_commitment_seed(uint64_t this_ptr) {
26500 LDKInMemorySigner this_ptr_conv;
26501 this_ptr_conv.inner = untag_ptr(this_ptr);
26502 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26503 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26504 this_ptr_conv.is_owned = false;
26505 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
26506 memcpy(ret_arr->elems, *InMemorySigner_get_commitment_seed(&this_ptr_conv), 32);
26510 void __attribute__((export_name("TS_InMemorySigner_set_commitment_seed"))) TS_InMemorySigner_set_commitment_seed(uint64_t this_ptr, int8_tArray val) {
26511 LDKInMemorySigner this_ptr_conv;
26512 this_ptr_conv.inner = untag_ptr(this_ptr);
26513 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26514 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26515 this_ptr_conv.is_owned = false;
26516 LDKThirtyTwoBytes val_ref;
26517 CHECK(val->arr_len == 32);
26518 memcpy(val_ref.data, val->elems, 32); FREE(val);
26519 InMemorySigner_set_commitment_seed(&this_ptr_conv, val_ref);
26522 static inline uint64_t InMemorySigner_clone_ptr(LDKInMemorySigner *NONNULL_PTR arg) {
26523 LDKInMemorySigner ret_var = InMemorySigner_clone(arg);
26524 uint64_t ret_ref = 0;
26525 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26526 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26529 int64_t __attribute__((export_name("TS_InMemorySigner_clone_ptr"))) TS_InMemorySigner_clone_ptr(uint64_t arg) {
26530 LDKInMemorySigner arg_conv;
26531 arg_conv.inner = untag_ptr(arg);
26532 arg_conv.is_owned = ptr_is_owned(arg);
26533 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
26534 arg_conv.is_owned = false;
26535 int64_t ret_conv = InMemorySigner_clone_ptr(&arg_conv);
26539 uint64_t __attribute__((export_name("TS_InMemorySigner_clone"))) TS_InMemorySigner_clone(uint64_t orig) {
26540 LDKInMemorySigner orig_conv;
26541 orig_conv.inner = untag_ptr(orig);
26542 orig_conv.is_owned = ptr_is_owned(orig);
26543 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
26544 orig_conv.is_owned = false;
26545 LDKInMemorySigner ret_var = InMemorySigner_clone(&orig_conv);
26546 uint64_t ret_ref = 0;
26547 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26548 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26552 uint64_t __attribute__((export_name("TS_InMemorySigner_new"))) TS_InMemorySigner_new(int8_tArray node_secret, 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) {
26553 LDKSecretKey node_secret_ref;
26554 CHECK(node_secret->arr_len == 32);
26555 memcpy(node_secret_ref.bytes, node_secret->elems, 32); FREE(node_secret);
26556 LDKSecretKey funding_key_ref;
26557 CHECK(funding_key->arr_len == 32);
26558 memcpy(funding_key_ref.bytes, funding_key->elems, 32); FREE(funding_key);
26559 LDKSecretKey revocation_base_key_ref;
26560 CHECK(revocation_base_key->arr_len == 32);
26561 memcpy(revocation_base_key_ref.bytes, revocation_base_key->elems, 32); FREE(revocation_base_key);
26562 LDKSecretKey payment_key_ref;
26563 CHECK(payment_key->arr_len == 32);
26564 memcpy(payment_key_ref.bytes, payment_key->elems, 32); FREE(payment_key);
26565 LDKSecretKey delayed_payment_base_key_ref;
26566 CHECK(delayed_payment_base_key->arr_len == 32);
26567 memcpy(delayed_payment_base_key_ref.bytes, delayed_payment_base_key->elems, 32); FREE(delayed_payment_base_key);
26568 LDKSecretKey htlc_base_key_ref;
26569 CHECK(htlc_base_key->arr_len == 32);
26570 memcpy(htlc_base_key_ref.bytes, htlc_base_key->elems, 32); FREE(htlc_base_key);
26571 LDKThirtyTwoBytes commitment_seed_ref;
26572 CHECK(commitment_seed->arr_len == 32);
26573 memcpy(commitment_seed_ref.data, commitment_seed->elems, 32); FREE(commitment_seed);
26574 LDKThirtyTwoBytes channel_keys_id_ref;
26575 CHECK(channel_keys_id->arr_len == 32);
26576 memcpy(channel_keys_id_ref.data, channel_keys_id->elems, 32); FREE(channel_keys_id);
26577 LDKInMemorySigner ret_var = InMemorySigner_new(node_secret_ref, 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);
26578 uint64_t ret_ref = 0;
26579 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26580 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26584 uint64_t __attribute__((export_name("TS_InMemorySigner_counterparty_pubkeys"))) TS_InMemorySigner_counterparty_pubkeys(uint64_t this_arg) {
26585 LDKInMemorySigner this_arg_conv;
26586 this_arg_conv.inner = untag_ptr(this_arg);
26587 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26588 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26589 this_arg_conv.is_owned = false;
26590 LDKChannelPublicKeys ret_var = InMemorySigner_counterparty_pubkeys(&this_arg_conv);
26591 uint64_t ret_ref = 0;
26592 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26593 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26597 int16_t __attribute__((export_name("TS_InMemorySigner_counterparty_selected_contest_delay"))) TS_InMemorySigner_counterparty_selected_contest_delay(uint64_t this_arg) {
26598 LDKInMemorySigner this_arg_conv;
26599 this_arg_conv.inner = untag_ptr(this_arg);
26600 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26601 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26602 this_arg_conv.is_owned = false;
26603 int16_t ret_conv = InMemorySigner_counterparty_selected_contest_delay(&this_arg_conv);
26607 int16_t __attribute__((export_name("TS_InMemorySigner_holder_selected_contest_delay"))) TS_InMemorySigner_holder_selected_contest_delay(uint64_t this_arg) {
26608 LDKInMemorySigner this_arg_conv;
26609 this_arg_conv.inner = untag_ptr(this_arg);
26610 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26611 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26612 this_arg_conv.is_owned = false;
26613 int16_t ret_conv = InMemorySigner_holder_selected_contest_delay(&this_arg_conv);
26617 jboolean __attribute__((export_name("TS_InMemorySigner_is_outbound"))) TS_InMemorySigner_is_outbound(uint64_t this_arg) {
26618 LDKInMemorySigner this_arg_conv;
26619 this_arg_conv.inner = untag_ptr(this_arg);
26620 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26621 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26622 this_arg_conv.is_owned = false;
26623 jboolean ret_conv = InMemorySigner_is_outbound(&this_arg_conv);
26627 uint64_t __attribute__((export_name("TS_InMemorySigner_funding_outpoint"))) TS_InMemorySigner_funding_outpoint(uint64_t this_arg) {
26628 LDKInMemorySigner this_arg_conv;
26629 this_arg_conv.inner = untag_ptr(this_arg);
26630 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26631 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26632 this_arg_conv.is_owned = false;
26633 LDKOutPoint ret_var = InMemorySigner_funding_outpoint(&this_arg_conv);
26634 uint64_t ret_ref = 0;
26635 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26636 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26640 uint64_t __attribute__((export_name("TS_InMemorySigner_get_channel_parameters"))) TS_InMemorySigner_get_channel_parameters(uint64_t this_arg) {
26641 LDKInMemorySigner this_arg_conv;
26642 this_arg_conv.inner = untag_ptr(this_arg);
26643 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26644 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26645 this_arg_conv.is_owned = false;
26646 LDKChannelTransactionParameters ret_var = InMemorySigner_get_channel_parameters(&this_arg_conv);
26647 uint64_t ret_ref = 0;
26648 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26649 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26653 jboolean __attribute__((export_name("TS_InMemorySigner_opt_anchors"))) TS_InMemorySigner_opt_anchors(uint64_t this_arg) {
26654 LDKInMemorySigner this_arg_conv;
26655 this_arg_conv.inner = untag_ptr(this_arg);
26656 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26657 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26658 this_arg_conv.is_owned = false;
26659 jboolean ret_conv = InMemorySigner_opt_anchors(&this_arg_conv);
26663 uint64_t __attribute__((export_name("TS_InMemorySigner_sign_counterparty_payment_input"))) TS_InMemorySigner_sign_counterparty_payment_input(uint64_t this_arg, int8_tArray spend_tx, uint32_t input_idx, uint64_t descriptor) {
26664 LDKInMemorySigner this_arg_conv;
26665 this_arg_conv.inner = untag_ptr(this_arg);
26666 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26667 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26668 this_arg_conv.is_owned = false;
26669 LDKTransaction spend_tx_ref;
26670 spend_tx_ref.datalen = spend_tx->arr_len;
26671 spend_tx_ref.data = MALLOC(spend_tx_ref.datalen, "LDKTransaction Bytes");
26672 memcpy(spend_tx_ref.data, spend_tx->elems, spend_tx_ref.datalen); FREE(spend_tx);
26673 spend_tx_ref.data_is_owned = true;
26674 LDKStaticPaymentOutputDescriptor descriptor_conv;
26675 descriptor_conv.inner = untag_ptr(descriptor);
26676 descriptor_conv.is_owned = ptr_is_owned(descriptor);
26677 CHECK_INNER_FIELD_ACCESS_OR_NULL(descriptor_conv);
26678 descriptor_conv.is_owned = false;
26679 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
26680 *ret_conv = InMemorySigner_sign_counterparty_payment_input(&this_arg_conv, spend_tx_ref, input_idx, &descriptor_conv);
26681 return tag_ptr(ret_conv, true);
26684 uint64_t __attribute__((export_name("TS_InMemorySigner_sign_dynamic_p2wsh_input"))) TS_InMemorySigner_sign_dynamic_p2wsh_input(uint64_t this_arg, int8_tArray spend_tx, uint32_t input_idx, uint64_t descriptor) {
26685 LDKInMemorySigner this_arg_conv;
26686 this_arg_conv.inner = untag_ptr(this_arg);
26687 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26688 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26689 this_arg_conv.is_owned = false;
26690 LDKTransaction spend_tx_ref;
26691 spend_tx_ref.datalen = spend_tx->arr_len;
26692 spend_tx_ref.data = MALLOC(spend_tx_ref.datalen, "LDKTransaction Bytes");
26693 memcpy(spend_tx_ref.data, spend_tx->elems, spend_tx_ref.datalen); FREE(spend_tx);
26694 spend_tx_ref.data_is_owned = true;
26695 LDKDelayedPaymentOutputDescriptor descriptor_conv;
26696 descriptor_conv.inner = untag_ptr(descriptor);
26697 descriptor_conv.is_owned = ptr_is_owned(descriptor);
26698 CHECK_INNER_FIELD_ACCESS_OR_NULL(descriptor_conv);
26699 descriptor_conv.is_owned = false;
26700 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
26701 *ret_conv = InMemorySigner_sign_dynamic_p2wsh_input(&this_arg_conv, spend_tx_ref, input_idx, &descriptor_conv);
26702 return tag_ptr(ret_conv, true);
26705 uint64_t __attribute__((export_name("TS_InMemorySigner_as_BaseSign"))) TS_InMemorySigner_as_BaseSign(uint64_t this_arg) {
26706 LDKInMemorySigner this_arg_conv;
26707 this_arg_conv.inner = untag_ptr(this_arg);
26708 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26709 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26710 this_arg_conv.is_owned = false;
26711 LDKBaseSign* ret_ret = MALLOC(sizeof(LDKBaseSign), "LDKBaseSign");
26712 *ret_ret = InMemorySigner_as_BaseSign(&this_arg_conv);
26713 return tag_ptr(ret_ret, true);
26716 uint64_t __attribute__((export_name("TS_InMemorySigner_as_Sign"))) TS_InMemorySigner_as_Sign(uint64_t this_arg) {
26717 LDKInMemorySigner this_arg_conv;
26718 this_arg_conv.inner = untag_ptr(this_arg);
26719 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26720 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26721 this_arg_conv.is_owned = false;
26722 LDKSign* ret_ret = MALLOC(sizeof(LDKSign), "LDKSign");
26723 *ret_ret = InMemorySigner_as_Sign(&this_arg_conv);
26724 return tag_ptr(ret_ret, true);
26727 int8_tArray __attribute__((export_name("TS_InMemorySigner_write"))) TS_InMemorySigner_write(uint64_t obj) {
26728 LDKInMemorySigner obj_conv;
26729 obj_conv.inner = untag_ptr(obj);
26730 obj_conv.is_owned = ptr_is_owned(obj);
26731 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
26732 obj_conv.is_owned = false;
26733 LDKCVec_u8Z ret_var = InMemorySigner_write(&obj_conv);
26734 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
26735 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
26736 CVec_u8Z_free(ret_var);
26740 uint64_t __attribute__((export_name("TS_InMemorySigner_read"))) TS_InMemorySigner_read(int8_tArray ser, int8_tArray arg) {
26741 LDKu8slice ser_ref;
26742 ser_ref.datalen = ser->arr_len;
26743 ser_ref.data = ser->elems;
26744 LDKSecretKey arg_ref;
26745 CHECK(arg->arr_len == 32);
26746 memcpy(arg_ref.bytes, arg->elems, 32); FREE(arg);
26747 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
26748 *ret_conv = InMemorySigner_read(ser_ref, arg_ref);
26750 return tag_ptr(ret_conv, true);
26753 void __attribute__((export_name("TS_KeysManager_free"))) TS_KeysManager_free(uint64_t this_obj) {
26754 LDKKeysManager this_obj_conv;
26755 this_obj_conv.inner = untag_ptr(this_obj);
26756 this_obj_conv.is_owned = ptr_is_owned(this_obj);
26757 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
26758 KeysManager_free(this_obj_conv);
26761 uint64_t __attribute__((export_name("TS_KeysManager_new"))) TS_KeysManager_new(int8_tArray seed, int64_t starting_time_secs, int32_t starting_time_nanos) {
26762 unsigned char seed_arr[32];
26763 CHECK(seed->arr_len == 32);
26764 memcpy(seed_arr, seed->elems, 32); FREE(seed);
26765 unsigned char (*seed_ref)[32] = &seed_arr;
26766 LDKKeysManager ret_var = KeysManager_new(seed_ref, starting_time_secs, starting_time_nanos);
26767 uint64_t ret_ref = 0;
26768 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26769 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26773 uint64_t __attribute__((export_name("TS_KeysManager_derive_channel_keys"))) TS_KeysManager_derive_channel_keys(uint64_t this_arg, int64_t channel_value_satoshis, int8_tArray params) {
26774 LDKKeysManager this_arg_conv;
26775 this_arg_conv.inner = untag_ptr(this_arg);
26776 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26777 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26778 this_arg_conv.is_owned = false;
26779 unsigned char params_arr[32];
26780 CHECK(params->arr_len == 32);
26781 memcpy(params_arr, params->elems, 32); FREE(params);
26782 unsigned char (*params_ref)[32] = ¶ms_arr;
26783 LDKInMemorySigner ret_var = KeysManager_derive_channel_keys(&this_arg_conv, channel_value_satoshis, params_ref);
26784 uint64_t ret_ref = 0;
26785 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26786 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26790 uint64_t __attribute__((export_name("TS_KeysManager_spend_spendable_outputs"))) TS_KeysManager_spend_spendable_outputs(uint64_t this_arg, uint64_tArray descriptors, uint64_tArray outputs, int8_tArray change_destination_script, int32_t feerate_sat_per_1000_weight) {
26791 LDKKeysManager this_arg_conv;
26792 this_arg_conv.inner = untag_ptr(this_arg);
26793 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26794 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26795 this_arg_conv.is_owned = false;
26796 LDKCVec_SpendableOutputDescriptorZ descriptors_constr;
26797 descriptors_constr.datalen = descriptors->arr_len;
26798 if (descriptors_constr.datalen > 0)
26799 descriptors_constr.data = MALLOC(descriptors_constr.datalen * sizeof(LDKSpendableOutputDescriptor), "LDKCVec_SpendableOutputDescriptorZ Elements");
26801 descriptors_constr.data = NULL;
26802 uint64_t* descriptors_vals = descriptors->elems;
26803 for (size_t b = 0; b < descriptors_constr.datalen; b++) {
26804 uint64_t descriptors_conv_27 = descriptors_vals[b];
26805 void* descriptors_conv_27_ptr = untag_ptr(descriptors_conv_27);
26806 CHECK_ACCESS(descriptors_conv_27_ptr);
26807 LDKSpendableOutputDescriptor descriptors_conv_27_conv = *(LDKSpendableOutputDescriptor*)(descriptors_conv_27_ptr);
26808 descriptors_conv_27_conv = SpendableOutputDescriptor_clone((LDKSpendableOutputDescriptor*)untag_ptr(descriptors_conv_27));
26809 descriptors_constr.data[b] = descriptors_conv_27_conv;
26812 LDKCVec_TxOutZ outputs_constr;
26813 outputs_constr.datalen = outputs->arr_len;
26814 if (outputs_constr.datalen > 0)
26815 outputs_constr.data = MALLOC(outputs_constr.datalen * sizeof(LDKTxOut), "LDKCVec_TxOutZ Elements");
26817 outputs_constr.data = NULL;
26818 uint64_t* outputs_vals = outputs->elems;
26819 for (size_t h = 0; h < outputs_constr.datalen; h++) {
26820 uint64_t outputs_conv_7 = outputs_vals[h];
26821 void* outputs_conv_7_ptr = untag_ptr(outputs_conv_7);
26822 CHECK_ACCESS(outputs_conv_7_ptr);
26823 LDKTxOut outputs_conv_7_conv = *(LDKTxOut*)(outputs_conv_7_ptr);
26824 outputs_conv_7_conv = TxOut_clone((LDKTxOut*)untag_ptr(outputs_conv_7));
26825 outputs_constr.data[h] = outputs_conv_7_conv;
26828 LDKCVec_u8Z change_destination_script_ref;
26829 change_destination_script_ref.datalen = change_destination_script->arr_len;
26830 change_destination_script_ref.data = MALLOC(change_destination_script_ref.datalen, "LDKCVec_u8Z Bytes");
26831 memcpy(change_destination_script_ref.data, change_destination_script->elems, change_destination_script_ref.datalen); FREE(change_destination_script);
26832 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
26833 *ret_conv = KeysManager_spend_spendable_outputs(&this_arg_conv, descriptors_constr, outputs_constr, change_destination_script_ref, feerate_sat_per_1000_weight);
26834 return tag_ptr(ret_conv, true);
26837 uint64_t __attribute__((export_name("TS_KeysManager_as_KeysInterface"))) TS_KeysManager_as_KeysInterface(uint64_t this_arg) {
26838 LDKKeysManager this_arg_conv;
26839 this_arg_conv.inner = untag_ptr(this_arg);
26840 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26841 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26842 this_arg_conv.is_owned = false;
26843 LDKKeysInterface* ret_ret = MALLOC(sizeof(LDKKeysInterface), "LDKKeysInterface");
26844 *ret_ret = KeysManager_as_KeysInterface(&this_arg_conv);
26845 return tag_ptr(ret_ret, true);
26848 void __attribute__((export_name("TS_PhantomKeysManager_free"))) TS_PhantomKeysManager_free(uint64_t this_obj) {
26849 LDKPhantomKeysManager this_obj_conv;
26850 this_obj_conv.inner = untag_ptr(this_obj);
26851 this_obj_conv.is_owned = ptr_is_owned(this_obj);
26852 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
26853 PhantomKeysManager_free(this_obj_conv);
26856 uint64_t __attribute__((export_name("TS_PhantomKeysManager_as_KeysInterface"))) TS_PhantomKeysManager_as_KeysInterface(uint64_t this_arg) {
26857 LDKPhantomKeysManager this_arg_conv;
26858 this_arg_conv.inner = untag_ptr(this_arg);
26859 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26860 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26861 this_arg_conv.is_owned = false;
26862 LDKKeysInterface* ret_ret = MALLOC(sizeof(LDKKeysInterface), "LDKKeysInterface");
26863 *ret_ret = PhantomKeysManager_as_KeysInterface(&this_arg_conv);
26864 return tag_ptr(ret_ret, true);
26867 uint64_t __attribute__((export_name("TS_PhantomKeysManager_new"))) TS_PhantomKeysManager_new(int8_tArray seed, int64_t starting_time_secs, int32_t starting_time_nanos, int8_tArray cross_node_seed) {
26868 unsigned char seed_arr[32];
26869 CHECK(seed->arr_len == 32);
26870 memcpy(seed_arr, seed->elems, 32); FREE(seed);
26871 unsigned char (*seed_ref)[32] = &seed_arr;
26872 unsigned char cross_node_seed_arr[32];
26873 CHECK(cross_node_seed->arr_len == 32);
26874 memcpy(cross_node_seed_arr, cross_node_seed->elems, 32); FREE(cross_node_seed);
26875 unsigned char (*cross_node_seed_ref)[32] = &cross_node_seed_arr;
26876 LDKPhantomKeysManager ret_var = PhantomKeysManager_new(seed_ref, starting_time_secs, starting_time_nanos, cross_node_seed_ref);
26877 uint64_t ret_ref = 0;
26878 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26879 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26883 uint64_t __attribute__((export_name("TS_PhantomKeysManager_spend_spendable_outputs"))) TS_PhantomKeysManager_spend_spendable_outputs(uint64_t this_arg, uint64_tArray descriptors, uint64_tArray outputs, int8_tArray change_destination_script, int32_t feerate_sat_per_1000_weight) {
26884 LDKPhantomKeysManager this_arg_conv;
26885 this_arg_conv.inner = untag_ptr(this_arg);
26886 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26887 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26888 this_arg_conv.is_owned = false;
26889 LDKCVec_SpendableOutputDescriptorZ descriptors_constr;
26890 descriptors_constr.datalen = descriptors->arr_len;
26891 if (descriptors_constr.datalen > 0)
26892 descriptors_constr.data = MALLOC(descriptors_constr.datalen * sizeof(LDKSpendableOutputDescriptor), "LDKCVec_SpendableOutputDescriptorZ Elements");
26894 descriptors_constr.data = NULL;
26895 uint64_t* descriptors_vals = descriptors->elems;
26896 for (size_t b = 0; b < descriptors_constr.datalen; b++) {
26897 uint64_t descriptors_conv_27 = descriptors_vals[b];
26898 void* descriptors_conv_27_ptr = untag_ptr(descriptors_conv_27);
26899 CHECK_ACCESS(descriptors_conv_27_ptr);
26900 LDKSpendableOutputDescriptor descriptors_conv_27_conv = *(LDKSpendableOutputDescriptor*)(descriptors_conv_27_ptr);
26901 descriptors_conv_27_conv = SpendableOutputDescriptor_clone((LDKSpendableOutputDescriptor*)untag_ptr(descriptors_conv_27));
26902 descriptors_constr.data[b] = descriptors_conv_27_conv;
26905 LDKCVec_TxOutZ outputs_constr;
26906 outputs_constr.datalen = outputs->arr_len;
26907 if (outputs_constr.datalen > 0)
26908 outputs_constr.data = MALLOC(outputs_constr.datalen * sizeof(LDKTxOut), "LDKCVec_TxOutZ Elements");
26910 outputs_constr.data = NULL;
26911 uint64_t* outputs_vals = outputs->elems;
26912 for (size_t h = 0; h < outputs_constr.datalen; h++) {
26913 uint64_t outputs_conv_7 = outputs_vals[h];
26914 void* outputs_conv_7_ptr = untag_ptr(outputs_conv_7);
26915 CHECK_ACCESS(outputs_conv_7_ptr);
26916 LDKTxOut outputs_conv_7_conv = *(LDKTxOut*)(outputs_conv_7_ptr);
26917 outputs_conv_7_conv = TxOut_clone((LDKTxOut*)untag_ptr(outputs_conv_7));
26918 outputs_constr.data[h] = outputs_conv_7_conv;
26921 LDKCVec_u8Z change_destination_script_ref;
26922 change_destination_script_ref.datalen = change_destination_script->arr_len;
26923 change_destination_script_ref.data = MALLOC(change_destination_script_ref.datalen, "LDKCVec_u8Z Bytes");
26924 memcpy(change_destination_script_ref.data, change_destination_script->elems, change_destination_script_ref.datalen); FREE(change_destination_script);
26925 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
26926 *ret_conv = PhantomKeysManager_spend_spendable_outputs(&this_arg_conv, descriptors_constr, outputs_constr, change_destination_script_ref, feerate_sat_per_1000_weight);
26927 return tag_ptr(ret_conv, true);
26930 uint64_t __attribute__((export_name("TS_PhantomKeysManager_derive_channel_keys"))) TS_PhantomKeysManager_derive_channel_keys(uint64_t this_arg, int64_t channel_value_satoshis, int8_tArray params) {
26931 LDKPhantomKeysManager this_arg_conv;
26932 this_arg_conv.inner = untag_ptr(this_arg);
26933 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26934 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26935 this_arg_conv.is_owned = false;
26936 unsigned char params_arr[32];
26937 CHECK(params->arr_len == 32);
26938 memcpy(params_arr, params->elems, 32); FREE(params);
26939 unsigned char (*params_ref)[32] = ¶ms_arr;
26940 LDKInMemorySigner ret_var = PhantomKeysManager_derive_channel_keys(&this_arg_conv, channel_value_satoshis, params_ref);
26941 uint64_t ret_ref = 0;
26942 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26943 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26947 void __attribute__((export_name("TS_ChannelManager_free"))) TS_ChannelManager_free(uint64_t this_obj) {
26948 LDKChannelManager this_obj_conv;
26949 this_obj_conv.inner = untag_ptr(this_obj);
26950 this_obj_conv.is_owned = ptr_is_owned(this_obj);
26951 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
26952 ChannelManager_free(this_obj_conv);
26955 void __attribute__((export_name("TS_ChainParameters_free"))) TS_ChainParameters_free(uint64_t this_obj) {
26956 LDKChainParameters this_obj_conv;
26957 this_obj_conv.inner = untag_ptr(this_obj);
26958 this_obj_conv.is_owned = ptr_is_owned(this_obj);
26959 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
26960 ChainParameters_free(this_obj_conv);
26963 uint32_t __attribute__((export_name("TS_ChainParameters_get_network"))) TS_ChainParameters_get_network(uint64_t this_ptr) {
26964 LDKChainParameters this_ptr_conv;
26965 this_ptr_conv.inner = untag_ptr(this_ptr);
26966 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26967 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26968 this_ptr_conv.is_owned = false;
26969 uint32_t ret_conv = LDKNetwork_to_js(ChainParameters_get_network(&this_ptr_conv));
26973 void __attribute__((export_name("TS_ChainParameters_set_network"))) TS_ChainParameters_set_network(uint64_t this_ptr, uint32_t val) {
26974 LDKChainParameters this_ptr_conv;
26975 this_ptr_conv.inner = untag_ptr(this_ptr);
26976 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26977 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26978 this_ptr_conv.is_owned = false;
26979 LDKNetwork val_conv = LDKNetwork_from_js(val);
26980 ChainParameters_set_network(&this_ptr_conv, val_conv);
26983 uint64_t __attribute__((export_name("TS_ChainParameters_get_best_block"))) TS_ChainParameters_get_best_block(uint64_t this_ptr) {
26984 LDKChainParameters this_ptr_conv;
26985 this_ptr_conv.inner = untag_ptr(this_ptr);
26986 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26987 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26988 this_ptr_conv.is_owned = false;
26989 LDKBestBlock ret_var = ChainParameters_get_best_block(&this_ptr_conv);
26990 uint64_t ret_ref = 0;
26991 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26992 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26996 void __attribute__((export_name("TS_ChainParameters_set_best_block"))) TS_ChainParameters_set_best_block(uint64_t this_ptr, uint64_t val) {
26997 LDKChainParameters this_ptr_conv;
26998 this_ptr_conv.inner = untag_ptr(this_ptr);
26999 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27000 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27001 this_ptr_conv.is_owned = false;
27002 LDKBestBlock val_conv;
27003 val_conv.inner = untag_ptr(val);
27004 val_conv.is_owned = ptr_is_owned(val);
27005 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
27006 val_conv = BestBlock_clone(&val_conv);
27007 ChainParameters_set_best_block(&this_ptr_conv, val_conv);
27010 uint64_t __attribute__((export_name("TS_ChainParameters_new"))) TS_ChainParameters_new(uint32_t network_arg, uint64_t best_block_arg) {
27011 LDKNetwork network_arg_conv = LDKNetwork_from_js(network_arg);
27012 LDKBestBlock best_block_arg_conv;
27013 best_block_arg_conv.inner = untag_ptr(best_block_arg);
27014 best_block_arg_conv.is_owned = ptr_is_owned(best_block_arg);
27015 CHECK_INNER_FIELD_ACCESS_OR_NULL(best_block_arg_conv);
27016 best_block_arg_conv = BestBlock_clone(&best_block_arg_conv);
27017 LDKChainParameters ret_var = ChainParameters_new(network_arg_conv, best_block_arg_conv);
27018 uint64_t ret_ref = 0;
27019 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27020 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27024 static inline uint64_t ChainParameters_clone_ptr(LDKChainParameters *NONNULL_PTR arg) {
27025 LDKChainParameters ret_var = ChainParameters_clone(arg);
27026 uint64_t ret_ref = 0;
27027 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27028 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27031 int64_t __attribute__((export_name("TS_ChainParameters_clone_ptr"))) TS_ChainParameters_clone_ptr(uint64_t arg) {
27032 LDKChainParameters arg_conv;
27033 arg_conv.inner = untag_ptr(arg);
27034 arg_conv.is_owned = ptr_is_owned(arg);
27035 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
27036 arg_conv.is_owned = false;
27037 int64_t ret_conv = ChainParameters_clone_ptr(&arg_conv);
27041 uint64_t __attribute__((export_name("TS_ChainParameters_clone"))) TS_ChainParameters_clone(uint64_t orig) {
27042 LDKChainParameters orig_conv;
27043 orig_conv.inner = untag_ptr(orig);
27044 orig_conv.is_owned = ptr_is_owned(orig);
27045 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
27046 orig_conv.is_owned = false;
27047 LDKChainParameters ret_var = ChainParameters_clone(&orig_conv);
27048 uint64_t ret_ref = 0;
27049 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27050 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27054 void __attribute__((export_name("TS_CounterpartyForwardingInfo_free"))) TS_CounterpartyForwardingInfo_free(uint64_t this_obj) {
27055 LDKCounterpartyForwardingInfo this_obj_conv;
27056 this_obj_conv.inner = untag_ptr(this_obj);
27057 this_obj_conv.is_owned = ptr_is_owned(this_obj);
27058 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
27059 CounterpartyForwardingInfo_free(this_obj_conv);
27062 int32_t __attribute__((export_name("TS_CounterpartyForwardingInfo_get_fee_base_msat"))) TS_CounterpartyForwardingInfo_get_fee_base_msat(uint64_t this_ptr) {
27063 LDKCounterpartyForwardingInfo this_ptr_conv;
27064 this_ptr_conv.inner = untag_ptr(this_ptr);
27065 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27066 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27067 this_ptr_conv.is_owned = false;
27068 int32_t ret_conv = CounterpartyForwardingInfo_get_fee_base_msat(&this_ptr_conv);
27072 void __attribute__((export_name("TS_CounterpartyForwardingInfo_set_fee_base_msat"))) TS_CounterpartyForwardingInfo_set_fee_base_msat(uint64_t this_ptr, int32_t val) {
27073 LDKCounterpartyForwardingInfo this_ptr_conv;
27074 this_ptr_conv.inner = untag_ptr(this_ptr);
27075 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27076 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27077 this_ptr_conv.is_owned = false;
27078 CounterpartyForwardingInfo_set_fee_base_msat(&this_ptr_conv, val);
27081 int32_t __attribute__((export_name("TS_CounterpartyForwardingInfo_get_fee_proportional_millionths"))) TS_CounterpartyForwardingInfo_get_fee_proportional_millionths(uint64_t this_ptr) {
27082 LDKCounterpartyForwardingInfo this_ptr_conv;
27083 this_ptr_conv.inner = untag_ptr(this_ptr);
27084 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27085 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27086 this_ptr_conv.is_owned = false;
27087 int32_t ret_conv = CounterpartyForwardingInfo_get_fee_proportional_millionths(&this_ptr_conv);
27091 void __attribute__((export_name("TS_CounterpartyForwardingInfo_set_fee_proportional_millionths"))) TS_CounterpartyForwardingInfo_set_fee_proportional_millionths(uint64_t this_ptr, int32_t val) {
27092 LDKCounterpartyForwardingInfo this_ptr_conv;
27093 this_ptr_conv.inner = untag_ptr(this_ptr);
27094 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27095 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27096 this_ptr_conv.is_owned = false;
27097 CounterpartyForwardingInfo_set_fee_proportional_millionths(&this_ptr_conv, val);
27100 int16_t __attribute__((export_name("TS_CounterpartyForwardingInfo_get_cltv_expiry_delta"))) TS_CounterpartyForwardingInfo_get_cltv_expiry_delta(uint64_t this_ptr) {
27101 LDKCounterpartyForwardingInfo this_ptr_conv;
27102 this_ptr_conv.inner = untag_ptr(this_ptr);
27103 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27104 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27105 this_ptr_conv.is_owned = false;
27106 int16_t ret_conv = CounterpartyForwardingInfo_get_cltv_expiry_delta(&this_ptr_conv);
27110 void __attribute__((export_name("TS_CounterpartyForwardingInfo_set_cltv_expiry_delta"))) TS_CounterpartyForwardingInfo_set_cltv_expiry_delta(uint64_t this_ptr, int16_t val) {
27111 LDKCounterpartyForwardingInfo this_ptr_conv;
27112 this_ptr_conv.inner = untag_ptr(this_ptr);
27113 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27114 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27115 this_ptr_conv.is_owned = false;
27116 CounterpartyForwardingInfo_set_cltv_expiry_delta(&this_ptr_conv, val);
27119 uint64_t __attribute__((export_name("TS_CounterpartyForwardingInfo_new"))) TS_CounterpartyForwardingInfo_new(int32_t fee_base_msat_arg, int32_t fee_proportional_millionths_arg, int16_t cltv_expiry_delta_arg) {
27120 LDKCounterpartyForwardingInfo ret_var = CounterpartyForwardingInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg);
27121 uint64_t ret_ref = 0;
27122 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27123 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27127 static inline uint64_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg) {
27128 LDKCounterpartyForwardingInfo ret_var = CounterpartyForwardingInfo_clone(arg);
27129 uint64_t ret_ref = 0;
27130 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27131 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27134 int64_t __attribute__((export_name("TS_CounterpartyForwardingInfo_clone_ptr"))) TS_CounterpartyForwardingInfo_clone_ptr(uint64_t arg) {
27135 LDKCounterpartyForwardingInfo arg_conv;
27136 arg_conv.inner = untag_ptr(arg);
27137 arg_conv.is_owned = ptr_is_owned(arg);
27138 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
27139 arg_conv.is_owned = false;
27140 int64_t ret_conv = CounterpartyForwardingInfo_clone_ptr(&arg_conv);
27144 uint64_t __attribute__((export_name("TS_CounterpartyForwardingInfo_clone"))) TS_CounterpartyForwardingInfo_clone(uint64_t orig) {
27145 LDKCounterpartyForwardingInfo orig_conv;
27146 orig_conv.inner = untag_ptr(orig);
27147 orig_conv.is_owned = ptr_is_owned(orig);
27148 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
27149 orig_conv.is_owned = false;
27150 LDKCounterpartyForwardingInfo ret_var = CounterpartyForwardingInfo_clone(&orig_conv);
27151 uint64_t ret_ref = 0;
27152 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27153 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27157 void __attribute__((export_name("TS_ChannelCounterparty_free"))) TS_ChannelCounterparty_free(uint64_t this_obj) {
27158 LDKChannelCounterparty this_obj_conv;
27159 this_obj_conv.inner = untag_ptr(this_obj);
27160 this_obj_conv.is_owned = ptr_is_owned(this_obj);
27161 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
27162 ChannelCounterparty_free(this_obj_conv);
27165 int8_tArray __attribute__((export_name("TS_ChannelCounterparty_get_node_id"))) TS_ChannelCounterparty_get_node_id(uint64_t this_ptr) {
27166 LDKChannelCounterparty this_ptr_conv;
27167 this_ptr_conv.inner = untag_ptr(this_ptr);
27168 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27169 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27170 this_ptr_conv.is_owned = false;
27171 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
27172 memcpy(ret_arr->elems, ChannelCounterparty_get_node_id(&this_ptr_conv).compressed_form, 33);
27176 void __attribute__((export_name("TS_ChannelCounterparty_set_node_id"))) TS_ChannelCounterparty_set_node_id(uint64_t this_ptr, int8_tArray val) {
27177 LDKChannelCounterparty this_ptr_conv;
27178 this_ptr_conv.inner = untag_ptr(this_ptr);
27179 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27180 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27181 this_ptr_conv.is_owned = false;
27182 LDKPublicKey val_ref;
27183 CHECK(val->arr_len == 33);
27184 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
27185 ChannelCounterparty_set_node_id(&this_ptr_conv, val_ref);
27188 uint64_t __attribute__((export_name("TS_ChannelCounterparty_get_features"))) TS_ChannelCounterparty_get_features(uint64_t this_ptr) {
27189 LDKChannelCounterparty this_ptr_conv;
27190 this_ptr_conv.inner = untag_ptr(this_ptr);
27191 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27192 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27193 this_ptr_conv.is_owned = false;
27194 LDKInitFeatures ret_var = ChannelCounterparty_get_features(&this_ptr_conv);
27195 uint64_t ret_ref = 0;
27196 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27197 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27201 void __attribute__((export_name("TS_ChannelCounterparty_set_features"))) TS_ChannelCounterparty_set_features(uint64_t this_ptr, uint64_t val) {
27202 LDKChannelCounterparty this_ptr_conv;
27203 this_ptr_conv.inner = untag_ptr(this_ptr);
27204 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27205 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27206 this_ptr_conv.is_owned = false;
27207 LDKInitFeatures val_conv;
27208 val_conv.inner = untag_ptr(val);
27209 val_conv.is_owned = ptr_is_owned(val);
27210 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
27211 val_conv = InitFeatures_clone(&val_conv);
27212 ChannelCounterparty_set_features(&this_ptr_conv, val_conv);
27215 int64_t __attribute__((export_name("TS_ChannelCounterparty_get_unspendable_punishment_reserve"))) TS_ChannelCounterparty_get_unspendable_punishment_reserve(uint64_t this_ptr) {
27216 LDKChannelCounterparty this_ptr_conv;
27217 this_ptr_conv.inner = untag_ptr(this_ptr);
27218 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27219 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27220 this_ptr_conv.is_owned = false;
27221 int64_t ret_conv = ChannelCounterparty_get_unspendable_punishment_reserve(&this_ptr_conv);
27225 void __attribute__((export_name("TS_ChannelCounterparty_set_unspendable_punishment_reserve"))) TS_ChannelCounterparty_set_unspendable_punishment_reserve(uint64_t this_ptr, int64_t val) {
27226 LDKChannelCounterparty this_ptr_conv;
27227 this_ptr_conv.inner = untag_ptr(this_ptr);
27228 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27229 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27230 this_ptr_conv.is_owned = false;
27231 ChannelCounterparty_set_unspendable_punishment_reserve(&this_ptr_conv, val);
27234 uint64_t __attribute__((export_name("TS_ChannelCounterparty_get_forwarding_info"))) TS_ChannelCounterparty_get_forwarding_info(uint64_t this_ptr) {
27235 LDKChannelCounterparty this_ptr_conv;
27236 this_ptr_conv.inner = untag_ptr(this_ptr);
27237 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27238 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27239 this_ptr_conv.is_owned = false;
27240 LDKCounterpartyForwardingInfo ret_var = ChannelCounterparty_get_forwarding_info(&this_ptr_conv);
27241 uint64_t ret_ref = 0;
27242 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27243 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27247 void __attribute__((export_name("TS_ChannelCounterparty_set_forwarding_info"))) TS_ChannelCounterparty_set_forwarding_info(uint64_t this_ptr, uint64_t val) {
27248 LDKChannelCounterparty this_ptr_conv;
27249 this_ptr_conv.inner = untag_ptr(this_ptr);
27250 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27251 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27252 this_ptr_conv.is_owned = false;
27253 LDKCounterpartyForwardingInfo val_conv;
27254 val_conv.inner = untag_ptr(val);
27255 val_conv.is_owned = ptr_is_owned(val);
27256 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
27257 val_conv = CounterpartyForwardingInfo_clone(&val_conv);
27258 ChannelCounterparty_set_forwarding_info(&this_ptr_conv, val_conv);
27261 uint64_t __attribute__((export_name("TS_ChannelCounterparty_get_outbound_htlc_minimum_msat"))) TS_ChannelCounterparty_get_outbound_htlc_minimum_msat(uint64_t this_ptr) {
27262 LDKChannelCounterparty this_ptr_conv;
27263 this_ptr_conv.inner = untag_ptr(this_ptr);
27264 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27265 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27266 this_ptr_conv.is_owned = false;
27267 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
27268 *ret_copy = ChannelCounterparty_get_outbound_htlc_minimum_msat(&this_ptr_conv);
27269 uint64_t ret_ref = tag_ptr(ret_copy, true);
27273 void __attribute__((export_name("TS_ChannelCounterparty_set_outbound_htlc_minimum_msat"))) TS_ChannelCounterparty_set_outbound_htlc_minimum_msat(uint64_t this_ptr, uint64_t val) {
27274 LDKChannelCounterparty this_ptr_conv;
27275 this_ptr_conv.inner = untag_ptr(this_ptr);
27276 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27277 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27278 this_ptr_conv.is_owned = false;
27279 void* val_ptr = untag_ptr(val);
27280 CHECK_ACCESS(val_ptr);
27281 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
27282 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
27283 ChannelCounterparty_set_outbound_htlc_minimum_msat(&this_ptr_conv, val_conv);
27286 uint64_t __attribute__((export_name("TS_ChannelCounterparty_get_outbound_htlc_maximum_msat"))) TS_ChannelCounterparty_get_outbound_htlc_maximum_msat(uint64_t this_ptr) {
27287 LDKChannelCounterparty this_ptr_conv;
27288 this_ptr_conv.inner = untag_ptr(this_ptr);
27289 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27290 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27291 this_ptr_conv.is_owned = false;
27292 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
27293 *ret_copy = ChannelCounterparty_get_outbound_htlc_maximum_msat(&this_ptr_conv);
27294 uint64_t ret_ref = tag_ptr(ret_copy, true);
27298 void __attribute__((export_name("TS_ChannelCounterparty_set_outbound_htlc_maximum_msat"))) TS_ChannelCounterparty_set_outbound_htlc_maximum_msat(uint64_t this_ptr, uint64_t val) {
27299 LDKChannelCounterparty this_ptr_conv;
27300 this_ptr_conv.inner = untag_ptr(this_ptr);
27301 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27302 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27303 this_ptr_conv.is_owned = false;
27304 void* val_ptr = untag_ptr(val);
27305 CHECK_ACCESS(val_ptr);
27306 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
27307 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
27308 ChannelCounterparty_set_outbound_htlc_maximum_msat(&this_ptr_conv, val_conv);
27311 uint64_t __attribute__((export_name("TS_ChannelCounterparty_new"))) TS_ChannelCounterparty_new(int8_tArray node_id_arg, uint64_t features_arg, int64_t unspendable_punishment_reserve_arg, uint64_t forwarding_info_arg, uint64_t outbound_htlc_minimum_msat_arg, uint64_t outbound_htlc_maximum_msat_arg) {
27312 LDKPublicKey node_id_arg_ref;
27313 CHECK(node_id_arg->arr_len == 33);
27314 memcpy(node_id_arg_ref.compressed_form, node_id_arg->elems, 33); FREE(node_id_arg);
27315 LDKInitFeatures features_arg_conv;
27316 features_arg_conv.inner = untag_ptr(features_arg);
27317 features_arg_conv.is_owned = ptr_is_owned(features_arg);
27318 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
27319 features_arg_conv = InitFeatures_clone(&features_arg_conv);
27320 LDKCounterpartyForwardingInfo forwarding_info_arg_conv;
27321 forwarding_info_arg_conv.inner = untag_ptr(forwarding_info_arg);
27322 forwarding_info_arg_conv.is_owned = ptr_is_owned(forwarding_info_arg);
27323 CHECK_INNER_FIELD_ACCESS_OR_NULL(forwarding_info_arg_conv);
27324 forwarding_info_arg_conv = CounterpartyForwardingInfo_clone(&forwarding_info_arg_conv);
27325 void* outbound_htlc_minimum_msat_arg_ptr = untag_ptr(outbound_htlc_minimum_msat_arg);
27326 CHECK_ACCESS(outbound_htlc_minimum_msat_arg_ptr);
27327 LDKCOption_u64Z outbound_htlc_minimum_msat_arg_conv = *(LDKCOption_u64Z*)(outbound_htlc_minimum_msat_arg_ptr);
27328 outbound_htlc_minimum_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(outbound_htlc_minimum_msat_arg));
27329 void* outbound_htlc_maximum_msat_arg_ptr = untag_ptr(outbound_htlc_maximum_msat_arg);
27330 CHECK_ACCESS(outbound_htlc_maximum_msat_arg_ptr);
27331 LDKCOption_u64Z outbound_htlc_maximum_msat_arg_conv = *(LDKCOption_u64Z*)(outbound_htlc_maximum_msat_arg_ptr);
27332 outbound_htlc_maximum_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(outbound_htlc_maximum_msat_arg));
27333 LDKChannelCounterparty ret_var = ChannelCounterparty_new(node_id_arg_ref, features_arg_conv, unspendable_punishment_reserve_arg, forwarding_info_arg_conv, outbound_htlc_minimum_msat_arg_conv, outbound_htlc_maximum_msat_arg_conv);
27334 uint64_t ret_ref = 0;
27335 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27336 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27340 static inline uint64_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg) {
27341 LDKChannelCounterparty ret_var = ChannelCounterparty_clone(arg);
27342 uint64_t ret_ref = 0;
27343 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27344 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27347 int64_t __attribute__((export_name("TS_ChannelCounterparty_clone_ptr"))) TS_ChannelCounterparty_clone_ptr(uint64_t arg) {
27348 LDKChannelCounterparty arg_conv;
27349 arg_conv.inner = untag_ptr(arg);
27350 arg_conv.is_owned = ptr_is_owned(arg);
27351 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
27352 arg_conv.is_owned = false;
27353 int64_t ret_conv = ChannelCounterparty_clone_ptr(&arg_conv);
27357 uint64_t __attribute__((export_name("TS_ChannelCounterparty_clone"))) TS_ChannelCounterparty_clone(uint64_t orig) {
27358 LDKChannelCounterparty orig_conv;
27359 orig_conv.inner = untag_ptr(orig);
27360 orig_conv.is_owned = ptr_is_owned(orig);
27361 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
27362 orig_conv.is_owned = false;
27363 LDKChannelCounterparty ret_var = ChannelCounterparty_clone(&orig_conv);
27364 uint64_t ret_ref = 0;
27365 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27366 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27370 void __attribute__((export_name("TS_ChannelDetails_free"))) TS_ChannelDetails_free(uint64_t this_obj) {
27371 LDKChannelDetails this_obj_conv;
27372 this_obj_conv.inner = untag_ptr(this_obj);
27373 this_obj_conv.is_owned = ptr_is_owned(this_obj);
27374 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
27375 ChannelDetails_free(this_obj_conv);
27378 int8_tArray __attribute__((export_name("TS_ChannelDetails_get_channel_id"))) TS_ChannelDetails_get_channel_id(uint64_t this_ptr) {
27379 LDKChannelDetails this_ptr_conv;
27380 this_ptr_conv.inner = untag_ptr(this_ptr);
27381 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27382 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27383 this_ptr_conv.is_owned = false;
27384 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
27385 memcpy(ret_arr->elems, *ChannelDetails_get_channel_id(&this_ptr_conv), 32);
27389 void __attribute__((export_name("TS_ChannelDetails_set_channel_id"))) TS_ChannelDetails_set_channel_id(uint64_t this_ptr, int8_tArray val) {
27390 LDKChannelDetails this_ptr_conv;
27391 this_ptr_conv.inner = untag_ptr(this_ptr);
27392 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27393 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27394 this_ptr_conv.is_owned = false;
27395 LDKThirtyTwoBytes val_ref;
27396 CHECK(val->arr_len == 32);
27397 memcpy(val_ref.data, val->elems, 32); FREE(val);
27398 ChannelDetails_set_channel_id(&this_ptr_conv, val_ref);
27401 uint64_t __attribute__((export_name("TS_ChannelDetails_get_counterparty"))) TS_ChannelDetails_get_counterparty(uint64_t this_ptr) {
27402 LDKChannelDetails this_ptr_conv;
27403 this_ptr_conv.inner = untag_ptr(this_ptr);
27404 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27405 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27406 this_ptr_conv.is_owned = false;
27407 LDKChannelCounterparty ret_var = ChannelDetails_get_counterparty(&this_ptr_conv);
27408 uint64_t ret_ref = 0;
27409 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27410 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27414 void __attribute__((export_name("TS_ChannelDetails_set_counterparty"))) TS_ChannelDetails_set_counterparty(uint64_t this_ptr, uint64_t val) {
27415 LDKChannelDetails this_ptr_conv;
27416 this_ptr_conv.inner = untag_ptr(this_ptr);
27417 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27418 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27419 this_ptr_conv.is_owned = false;
27420 LDKChannelCounterparty val_conv;
27421 val_conv.inner = untag_ptr(val);
27422 val_conv.is_owned = ptr_is_owned(val);
27423 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
27424 val_conv = ChannelCounterparty_clone(&val_conv);
27425 ChannelDetails_set_counterparty(&this_ptr_conv, val_conv);
27428 uint64_t __attribute__((export_name("TS_ChannelDetails_get_funding_txo"))) TS_ChannelDetails_get_funding_txo(uint64_t this_ptr) {
27429 LDKChannelDetails this_ptr_conv;
27430 this_ptr_conv.inner = untag_ptr(this_ptr);
27431 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27432 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27433 this_ptr_conv.is_owned = false;
27434 LDKOutPoint ret_var = ChannelDetails_get_funding_txo(&this_ptr_conv);
27435 uint64_t ret_ref = 0;
27436 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27437 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27441 void __attribute__((export_name("TS_ChannelDetails_set_funding_txo"))) TS_ChannelDetails_set_funding_txo(uint64_t this_ptr, uint64_t val) {
27442 LDKChannelDetails this_ptr_conv;
27443 this_ptr_conv.inner = untag_ptr(this_ptr);
27444 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27445 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27446 this_ptr_conv.is_owned = false;
27447 LDKOutPoint val_conv;
27448 val_conv.inner = untag_ptr(val);
27449 val_conv.is_owned = ptr_is_owned(val);
27450 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
27451 val_conv = OutPoint_clone(&val_conv);
27452 ChannelDetails_set_funding_txo(&this_ptr_conv, val_conv);
27455 uint64_t __attribute__((export_name("TS_ChannelDetails_get_channel_type"))) TS_ChannelDetails_get_channel_type(uint64_t this_ptr) {
27456 LDKChannelDetails this_ptr_conv;
27457 this_ptr_conv.inner = untag_ptr(this_ptr);
27458 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27459 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27460 this_ptr_conv.is_owned = false;
27461 LDKChannelTypeFeatures ret_var = ChannelDetails_get_channel_type(&this_ptr_conv);
27462 uint64_t ret_ref = 0;
27463 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27464 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27468 void __attribute__((export_name("TS_ChannelDetails_set_channel_type"))) TS_ChannelDetails_set_channel_type(uint64_t this_ptr, uint64_t val) {
27469 LDKChannelDetails this_ptr_conv;
27470 this_ptr_conv.inner = untag_ptr(this_ptr);
27471 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27472 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27473 this_ptr_conv.is_owned = false;
27474 LDKChannelTypeFeatures val_conv;
27475 val_conv.inner = untag_ptr(val);
27476 val_conv.is_owned = ptr_is_owned(val);
27477 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
27478 val_conv = ChannelTypeFeatures_clone(&val_conv);
27479 ChannelDetails_set_channel_type(&this_ptr_conv, val_conv);
27482 uint64_t __attribute__((export_name("TS_ChannelDetails_get_short_channel_id"))) TS_ChannelDetails_get_short_channel_id(uint64_t this_ptr) {
27483 LDKChannelDetails this_ptr_conv;
27484 this_ptr_conv.inner = untag_ptr(this_ptr);
27485 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27486 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27487 this_ptr_conv.is_owned = false;
27488 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
27489 *ret_copy = ChannelDetails_get_short_channel_id(&this_ptr_conv);
27490 uint64_t ret_ref = tag_ptr(ret_copy, true);
27494 void __attribute__((export_name("TS_ChannelDetails_set_short_channel_id"))) TS_ChannelDetails_set_short_channel_id(uint64_t this_ptr, uint64_t val) {
27495 LDKChannelDetails this_ptr_conv;
27496 this_ptr_conv.inner = untag_ptr(this_ptr);
27497 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27498 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27499 this_ptr_conv.is_owned = false;
27500 void* val_ptr = untag_ptr(val);
27501 CHECK_ACCESS(val_ptr);
27502 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
27503 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
27504 ChannelDetails_set_short_channel_id(&this_ptr_conv, val_conv);
27507 uint64_t __attribute__((export_name("TS_ChannelDetails_get_outbound_scid_alias"))) TS_ChannelDetails_get_outbound_scid_alias(uint64_t this_ptr) {
27508 LDKChannelDetails this_ptr_conv;
27509 this_ptr_conv.inner = untag_ptr(this_ptr);
27510 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27511 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27512 this_ptr_conv.is_owned = false;
27513 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
27514 *ret_copy = ChannelDetails_get_outbound_scid_alias(&this_ptr_conv);
27515 uint64_t ret_ref = tag_ptr(ret_copy, true);
27519 void __attribute__((export_name("TS_ChannelDetails_set_outbound_scid_alias"))) TS_ChannelDetails_set_outbound_scid_alias(uint64_t this_ptr, uint64_t val) {
27520 LDKChannelDetails this_ptr_conv;
27521 this_ptr_conv.inner = untag_ptr(this_ptr);
27522 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27523 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27524 this_ptr_conv.is_owned = false;
27525 void* val_ptr = untag_ptr(val);
27526 CHECK_ACCESS(val_ptr);
27527 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
27528 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
27529 ChannelDetails_set_outbound_scid_alias(&this_ptr_conv, val_conv);
27532 uint64_t __attribute__((export_name("TS_ChannelDetails_get_inbound_scid_alias"))) TS_ChannelDetails_get_inbound_scid_alias(uint64_t this_ptr) {
27533 LDKChannelDetails this_ptr_conv;
27534 this_ptr_conv.inner = untag_ptr(this_ptr);
27535 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27536 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27537 this_ptr_conv.is_owned = false;
27538 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
27539 *ret_copy = ChannelDetails_get_inbound_scid_alias(&this_ptr_conv);
27540 uint64_t ret_ref = tag_ptr(ret_copy, true);
27544 void __attribute__((export_name("TS_ChannelDetails_set_inbound_scid_alias"))) TS_ChannelDetails_set_inbound_scid_alias(uint64_t this_ptr, uint64_t val) {
27545 LDKChannelDetails this_ptr_conv;
27546 this_ptr_conv.inner = untag_ptr(this_ptr);
27547 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27548 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27549 this_ptr_conv.is_owned = false;
27550 void* val_ptr = untag_ptr(val);
27551 CHECK_ACCESS(val_ptr);
27552 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
27553 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
27554 ChannelDetails_set_inbound_scid_alias(&this_ptr_conv, val_conv);
27557 int64_t __attribute__((export_name("TS_ChannelDetails_get_channel_value_satoshis"))) TS_ChannelDetails_get_channel_value_satoshis(uint64_t this_ptr) {
27558 LDKChannelDetails this_ptr_conv;
27559 this_ptr_conv.inner = untag_ptr(this_ptr);
27560 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27561 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27562 this_ptr_conv.is_owned = false;
27563 int64_t ret_conv = ChannelDetails_get_channel_value_satoshis(&this_ptr_conv);
27567 void __attribute__((export_name("TS_ChannelDetails_set_channel_value_satoshis"))) TS_ChannelDetails_set_channel_value_satoshis(uint64_t this_ptr, int64_t val) {
27568 LDKChannelDetails this_ptr_conv;
27569 this_ptr_conv.inner = untag_ptr(this_ptr);
27570 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27571 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27572 this_ptr_conv.is_owned = false;
27573 ChannelDetails_set_channel_value_satoshis(&this_ptr_conv, val);
27576 uint64_t __attribute__((export_name("TS_ChannelDetails_get_unspendable_punishment_reserve"))) TS_ChannelDetails_get_unspendable_punishment_reserve(uint64_t this_ptr) {
27577 LDKChannelDetails this_ptr_conv;
27578 this_ptr_conv.inner = untag_ptr(this_ptr);
27579 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27580 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27581 this_ptr_conv.is_owned = false;
27582 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
27583 *ret_copy = ChannelDetails_get_unspendable_punishment_reserve(&this_ptr_conv);
27584 uint64_t ret_ref = tag_ptr(ret_copy, true);
27588 void __attribute__((export_name("TS_ChannelDetails_set_unspendable_punishment_reserve"))) TS_ChannelDetails_set_unspendable_punishment_reserve(uint64_t this_ptr, uint64_t val) {
27589 LDKChannelDetails this_ptr_conv;
27590 this_ptr_conv.inner = untag_ptr(this_ptr);
27591 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27592 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27593 this_ptr_conv.is_owned = false;
27594 void* val_ptr = untag_ptr(val);
27595 CHECK_ACCESS(val_ptr);
27596 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
27597 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
27598 ChannelDetails_set_unspendable_punishment_reserve(&this_ptr_conv, val_conv);
27601 int8_tArray __attribute__((export_name("TS_ChannelDetails_get_user_channel_id"))) TS_ChannelDetails_get_user_channel_id(uint64_t this_ptr) {
27602 LDKChannelDetails this_ptr_conv;
27603 this_ptr_conv.inner = untag_ptr(this_ptr);
27604 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27605 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27606 this_ptr_conv.is_owned = false;
27607 int8_tArray ret_arr = init_int8_tArray(16, __LINE__);
27608 memcpy(ret_arr->elems, ChannelDetails_get_user_channel_id(&this_ptr_conv).le_bytes, 16);
27612 void __attribute__((export_name("TS_ChannelDetails_set_user_channel_id"))) TS_ChannelDetails_set_user_channel_id(uint64_t this_ptr, int8_tArray val) {
27613 LDKChannelDetails this_ptr_conv;
27614 this_ptr_conv.inner = untag_ptr(this_ptr);
27615 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27616 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27617 this_ptr_conv.is_owned = false;
27619 CHECK(val->arr_len == 16);
27620 memcpy(val_ref.le_bytes, val->elems, 16); FREE(val);
27621 ChannelDetails_set_user_channel_id(&this_ptr_conv, val_ref);
27624 int64_t __attribute__((export_name("TS_ChannelDetails_get_balance_msat"))) TS_ChannelDetails_get_balance_msat(uint64_t this_ptr) {
27625 LDKChannelDetails this_ptr_conv;
27626 this_ptr_conv.inner = untag_ptr(this_ptr);
27627 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27628 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27629 this_ptr_conv.is_owned = false;
27630 int64_t ret_conv = ChannelDetails_get_balance_msat(&this_ptr_conv);
27634 void __attribute__((export_name("TS_ChannelDetails_set_balance_msat"))) TS_ChannelDetails_set_balance_msat(uint64_t this_ptr, int64_t val) {
27635 LDKChannelDetails this_ptr_conv;
27636 this_ptr_conv.inner = untag_ptr(this_ptr);
27637 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27638 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27639 this_ptr_conv.is_owned = false;
27640 ChannelDetails_set_balance_msat(&this_ptr_conv, val);
27643 int64_t __attribute__((export_name("TS_ChannelDetails_get_outbound_capacity_msat"))) TS_ChannelDetails_get_outbound_capacity_msat(uint64_t this_ptr) {
27644 LDKChannelDetails this_ptr_conv;
27645 this_ptr_conv.inner = untag_ptr(this_ptr);
27646 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27647 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27648 this_ptr_conv.is_owned = false;
27649 int64_t ret_conv = ChannelDetails_get_outbound_capacity_msat(&this_ptr_conv);
27653 void __attribute__((export_name("TS_ChannelDetails_set_outbound_capacity_msat"))) TS_ChannelDetails_set_outbound_capacity_msat(uint64_t this_ptr, int64_t val) {
27654 LDKChannelDetails this_ptr_conv;
27655 this_ptr_conv.inner = untag_ptr(this_ptr);
27656 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27657 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27658 this_ptr_conv.is_owned = false;
27659 ChannelDetails_set_outbound_capacity_msat(&this_ptr_conv, val);
27662 int64_t __attribute__((export_name("TS_ChannelDetails_get_next_outbound_htlc_limit_msat"))) TS_ChannelDetails_get_next_outbound_htlc_limit_msat(uint64_t this_ptr) {
27663 LDKChannelDetails this_ptr_conv;
27664 this_ptr_conv.inner = untag_ptr(this_ptr);
27665 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27666 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27667 this_ptr_conv.is_owned = false;
27668 int64_t ret_conv = ChannelDetails_get_next_outbound_htlc_limit_msat(&this_ptr_conv);
27672 void __attribute__((export_name("TS_ChannelDetails_set_next_outbound_htlc_limit_msat"))) TS_ChannelDetails_set_next_outbound_htlc_limit_msat(uint64_t this_ptr, int64_t val) {
27673 LDKChannelDetails this_ptr_conv;
27674 this_ptr_conv.inner = untag_ptr(this_ptr);
27675 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27676 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27677 this_ptr_conv.is_owned = false;
27678 ChannelDetails_set_next_outbound_htlc_limit_msat(&this_ptr_conv, val);
27681 int64_t __attribute__((export_name("TS_ChannelDetails_get_inbound_capacity_msat"))) TS_ChannelDetails_get_inbound_capacity_msat(uint64_t this_ptr) {
27682 LDKChannelDetails this_ptr_conv;
27683 this_ptr_conv.inner = untag_ptr(this_ptr);
27684 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27685 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27686 this_ptr_conv.is_owned = false;
27687 int64_t ret_conv = ChannelDetails_get_inbound_capacity_msat(&this_ptr_conv);
27691 void __attribute__((export_name("TS_ChannelDetails_set_inbound_capacity_msat"))) TS_ChannelDetails_set_inbound_capacity_msat(uint64_t this_ptr, int64_t val) {
27692 LDKChannelDetails this_ptr_conv;
27693 this_ptr_conv.inner = untag_ptr(this_ptr);
27694 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27695 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27696 this_ptr_conv.is_owned = false;
27697 ChannelDetails_set_inbound_capacity_msat(&this_ptr_conv, val);
27700 uint64_t __attribute__((export_name("TS_ChannelDetails_get_confirmations_required"))) TS_ChannelDetails_get_confirmations_required(uint64_t this_ptr) {
27701 LDKChannelDetails this_ptr_conv;
27702 this_ptr_conv.inner = untag_ptr(this_ptr);
27703 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27704 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27705 this_ptr_conv.is_owned = false;
27706 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
27707 *ret_copy = ChannelDetails_get_confirmations_required(&this_ptr_conv);
27708 uint64_t ret_ref = tag_ptr(ret_copy, true);
27712 void __attribute__((export_name("TS_ChannelDetails_set_confirmations_required"))) TS_ChannelDetails_set_confirmations_required(uint64_t this_ptr, uint64_t val) {
27713 LDKChannelDetails this_ptr_conv;
27714 this_ptr_conv.inner = untag_ptr(this_ptr);
27715 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27716 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27717 this_ptr_conv.is_owned = false;
27718 void* val_ptr = untag_ptr(val);
27719 CHECK_ACCESS(val_ptr);
27720 LDKCOption_u32Z val_conv = *(LDKCOption_u32Z*)(val_ptr);
27721 val_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(val));
27722 ChannelDetails_set_confirmations_required(&this_ptr_conv, val_conv);
27725 uint64_t __attribute__((export_name("TS_ChannelDetails_get_confirmations"))) TS_ChannelDetails_get_confirmations(uint64_t this_ptr) {
27726 LDKChannelDetails this_ptr_conv;
27727 this_ptr_conv.inner = untag_ptr(this_ptr);
27728 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27729 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27730 this_ptr_conv.is_owned = false;
27731 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
27732 *ret_copy = ChannelDetails_get_confirmations(&this_ptr_conv);
27733 uint64_t ret_ref = tag_ptr(ret_copy, true);
27737 void __attribute__((export_name("TS_ChannelDetails_set_confirmations"))) TS_ChannelDetails_set_confirmations(uint64_t this_ptr, uint64_t val) {
27738 LDKChannelDetails this_ptr_conv;
27739 this_ptr_conv.inner = untag_ptr(this_ptr);
27740 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27741 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27742 this_ptr_conv.is_owned = false;
27743 void* val_ptr = untag_ptr(val);
27744 CHECK_ACCESS(val_ptr);
27745 LDKCOption_u32Z val_conv = *(LDKCOption_u32Z*)(val_ptr);
27746 val_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(val));
27747 ChannelDetails_set_confirmations(&this_ptr_conv, val_conv);
27750 uint64_t __attribute__((export_name("TS_ChannelDetails_get_force_close_spend_delay"))) TS_ChannelDetails_get_force_close_spend_delay(uint64_t this_ptr) {
27751 LDKChannelDetails this_ptr_conv;
27752 this_ptr_conv.inner = untag_ptr(this_ptr);
27753 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27754 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27755 this_ptr_conv.is_owned = false;
27756 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
27757 *ret_copy = ChannelDetails_get_force_close_spend_delay(&this_ptr_conv);
27758 uint64_t ret_ref = tag_ptr(ret_copy, true);
27762 void __attribute__((export_name("TS_ChannelDetails_set_force_close_spend_delay"))) TS_ChannelDetails_set_force_close_spend_delay(uint64_t this_ptr, uint64_t val) {
27763 LDKChannelDetails this_ptr_conv;
27764 this_ptr_conv.inner = untag_ptr(this_ptr);
27765 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27766 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27767 this_ptr_conv.is_owned = false;
27768 void* val_ptr = untag_ptr(val);
27769 CHECK_ACCESS(val_ptr);
27770 LDKCOption_u16Z val_conv = *(LDKCOption_u16Z*)(val_ptr);
27771 val_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(val));
27772 ChannelDetails_set_force_close_spend_delay(&this_ptr_conv, val_conv);
27775 jboolean __attribute__((export_name("TS_ChannelDetails_get_is_outbound"))) TS_ChannelDetails_get_is_outbound(uint64_t this_ptr) {
27776 LDKChannelDetails this_ptr_conv;
27777 this_ptr_conv.inner = untag_ptr(this_ptr);
27778 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27779 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27780 this_ptr_conv.is_owned = false;
27781 jboolean ret_conv = ChannelDetails_get_is_outbound(&this_ptr_conv);
27785 void __attribute__((export_name("TS_ChannelDetails_set_is_outbound"))) TS_ChannelDetails_set_is_outbound(uint64_t this_ptr, jboolean val) {
27786 LDKChannelDetails this_ptr_conv;
27787 this_ptr_conv.inner = untag_ptr(this_ptr);
27788 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27789 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27790 this_ptr_conv.is_owned = false;
27791 ChannelDetails_set_is_outbound(&this_ptr_conv, val);
27794 jboolean __attribute__((export_name("TS_ChannelDetails_get_is_channel_ready"))) TS_ChannelDetails_get_is_channel_ready(uint64_t this_ptr) {
27795 LDKChannelDetails this_ptr_conv;
27796 this_ptr_conv.inner = untag_ptr(this_ptr);
27797 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27798 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27799 this_ptr_conv.is_owned = false;
27800 jboolean ret_conv = ChannelDetails_get_is_channel_ready(&this_ptr_conv);
27804 void __attribute__((export_name("TS_ChannelDetails_set_is_channel_ready"))) TS_ChannelDetails_set_is_channel_ready(uint64_t this_ptr, jboolean val) {
27805 LDKChannelDetails this_ptr_conv;
27806 this_ptr_conv.inner = untag_ptr(this_ptr);
27807 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27808 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27809 this_ptr_conv.is_owned = false;
27810 ChannelDetails_set_is_channel_ready(&this_ptr_conv, val);
27813 jboolean __attribute__((export_name("TS_ChannelDetails_get_is_usable"))) TS_ChannelDetails_get_is_usable(uint64_t this_ptr) {
27814 LDKChannelDetails this_ptr_conv;
27815 this_ptr_conv.inner = untag_ptr(this_ptr);
27816 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27817 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27818 this_ptr_conv.is_owned = false;
27819 jboolean ret_conv = ChannelDetails_get_is_usable(&this_ptr_conv);
27823 void __attribute__((export_name("TS_ChannelDetails_set_is_usable"))) TS_ChannelDetails_set_is_usable(uint64_t this_ptr, jboolean val) {
27824 LDKChannelDetails this_ptr_conv;
27825 this_ptr_conv.inner = untag_ptr(this_ptr);
27826 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27827 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27828 this_ptr_conv.is_owned = false;
27829 ChannelDetails_set_is_usable(&this_ptr_conv, val);
27832 jboolean __attribute__((export_name("TS_ChannelDetails_get_is_public"))) TS_ChannelDetails_get_is_public(uint64_t this_ptr) {
27833 LDKChannelDetails this_ptr_conv;
27834 this_ptr_conv.inner = untag_ptr(this_ptr);
27835 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27836 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27837 this_ptr_conv.is_owned = false;
27838 jboolean ret_conv = ChannelDetails_get_is_public(&this_ptr_conv);
27842 void __attribute__((export_name("TS_ChannelDetails_set_is_public"))) TS_ChannelDetails_set_is_public(uint64_t this_ptr, jboolean val) {
27843 LDKChannelDetails this_ptr_conv;
27844 this_ptr_conv.inner = untag_ptr(this_ptr);
27845 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27846 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27847 this_ptr_conv.is_owned = false;
27848 ChannelDetails_set_is_public(&this_ptr_conv, val);
27851 uint64_t __attribute__((export_name("TS_ChannelDetails_get_inbound_htlc_minimum_msat"))) TS_ChannelDetails_get_inbound_htlc_minimum_msat(uint64_t this_ptr) {
27852 LDKChannelDetails this_ptr_conv;
27853 this_ptr_conv.inner = untag_ptr(this_ptr);
27854 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27855 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27856 this_ptr_conv.is_owned = false;
27857 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
27858 *ret_copy = ChannelDetails_get_inbound_htlc_minimum_msat(&this_ptr_conv);
27859 uint64_t ret_ref = tag_ptr(ret_copy, true);
27863 void __attribute__((export_name("TS_ChannelDetails_set_inbound_htlc_minimum_msat"))) TS_ChannelDetails_set_inbound_htlc_minimum_msat(uint64_t this_ptr, uint64_t val) {
27864 LDKChannelDetails this_ptr_conv;
27865 this_ptr_conv.inner = untag_ptr(this_ptr);
27866 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27867 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27868 this_ptr_conv.is_owned = false;
27869 void* val_ptr = untag_ptr(val);
27870 CHECK_ACCESS(val_ptr);
27871 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
27872 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
27873 ChannelDetails_set_inbound_htlc_minimum_msat(&this_ptr_conv, val_conv);
27876 uint64_t __attribute__((export_name("TS_ChannelDetails_get_inbound_htlc_maximum_msat"))) TS_ChannelDetails_get_inbound_htlc_maximum_msat(uint64_t this_ptr) {
27877 LDKChannelDetails this_ptr_conv;
27878 this_ptr_conv.inner = untag_ptr(this_ptr);
27879 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27880 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27881 this_ptr_conv.is_owned = false;
27882 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
27883 *ret_copy = ChannelDetails_get_inbound_htlc_maximum_msat(&this_ptr_conv);
27884 uint64_t ret_ref = tag_ptr(ret_copy, true);
27888 void __attribute__((export_name("TS_ChannelDetails_set_inbound_htlc_maximum_msat"))) TS_ChannelDetails_set_inbound_htlc_maximum_msat(uint64_t this_ptr, uint64_t val) {
27889 LDKChannelDetails this_ptr_conv;
27890 this_ptr_conv.inner = untag_ptr(this_ptr);
27891 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27892 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27893 this_ptr_conv.is_owned = false;
27894 void* val_ptr = untag_ptr(val);
27895 CHECK_ACCESS(val_ptr);
27896 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
27897 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
27898 ChannelDetails_set_inbound_htlc_maximum_msat(&this_ptr_conv, val_conv);
27901 uint64_t __attribute__((export_name("TS_ChannelDetails_get_config"))) TS_ChannelDetails_get_config(uint64_t this_ptr) {
27902 LDKChannelDetails this_ptr_conv;
27903 this_ptr_conv.inner = untag_ptr(this_ptr);
27904 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27905 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27906 this_ptr_conv.is_owned = false;
27907 LDKChannelConfig ret_var = ChannelDetails_get_config(&this_ptr_conv);
27908 uint64_t ret_ref = 0;
27909 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27910 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27914 void __attribute__((export_name("TS_ChannelDetails_set_config"))) TS_ChannelDetails_set_config(uint64_t this_ptr, uint64_t val) {
27915 LDKChannelDetails this_ptr_conv;
27916 this_ptr_conv.inner = untag_ptr(this_ptr);
27917 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27918 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27919 this_ptr_conv.is_owned = false;
27920 LDKChannelConfig val_conv;
27921 val_conv.inner = untag_ptr(val);
27922 val_conv.is_owned = ptr_is_owned(val);
27923 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
27924 val_conv = ChannelConfig_clone(&val_conv);
27925 ChannelDetails_set_config(&this_ptr_conv, val_conv);
27928 uint64_t __attribute__((export_name("TS_ChannelDetails_new"))) TS_ChannelDetails_new(int8_tArray channel_id_arg, uint64_t counterparty_arg, uint64_t funding_txo_arg, uint64_t channel_type_arg, uint64_t short_channel_id_arg, uint64_t outbound_scid_alias_arg, uint64_t inbound_scid_alias_arg, int64_t channel_value_satoshis_arg, uint64_t unspendable_punishment_reserve_arg, int8_tArray user_channel_id_arg, int64_t balance_msat_arg, int64_t outbound_capacity_msat_arg, int64_t next_outbound_htlc_limit_msat_arg, int64_t inbound_capacity_msat_arg, uint64_t confirmations_required_arg, uint64_t confirmations_arg, uint64_t force_close_spend_delay_arg, jboolean is_outbound_arg, jboolean is_channel_ready_arg, jboolean is_usable_arg, jboolean is_public_arg, uint64_t inbound_htlc_minimum_msat_arg, uint64_t inbound_htlc_maximum_msat_arg, uint64_t config_arg) {
27929 LDKThirtyTwoBytes channel_id_arg_ref;
27930 CHECK(channel_id_arg->arr_len == 32);
27931 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
27932 LDKChannelCounterparty counterparty_arg_conv;
27933 counterparty_arg_conv.inner = untag_ptr(counterparty_arg);
27934 counterparty_arg_conv.is_owned = ptr_is_owned(counterparty_arg);
27935 CHECK_INNER_FIELD_ACCESS_OR_NULL(counterparty_arg_conv);
27936 counterparty_arg_conv = ChannelCounterparty_clone(&counterparty_arg_conv);
27937 LDKOutPoint funding_txo_arg_conv;
27938 funding_txo_arg_conv.inner = untag_ptr(funding_txo_arg);
27939 funding_txo_arg_conv.is_owned = ptr_is_owned(funding_txo_arg);
27940 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_arg_conv);
27941 funding_txo_arg_conv = OutPoint_clone(&funding_txo_arg_conv);
27942 LDKChannelTypeFeatures channel_type_arg_conv;
27943 channel_type_arg_conv.inner = untag_ptr(channel_type_arg);
27944 channel_type_arg_conv.is_owned = ptr_is_owned(channel_type_arg);
27945 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_arg_conv);
27946 channel_type_arg_conv = ChannelTypeFeatures_clone(&channel_type_arg_conv);
27947 void* short_channel_id_arg_ptr = untag_ptr(short_channel_id_arg);
27948 CHECK_ACCESS(short_channel_id_arg_ptr);
27949 LDKCOption_u64Z short_channel_id_arg_conv = *(LDKCOption_u64Z*)(short_channel_id_arg_ptr);
27950 short_channel_id_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(short_channel_id_arg));
27951 void* outbound_scid_alias_arg_ptr = untag_ptr(outbound_scid_alias_arg);
27952 CHECK_ACCESS(outbound_scid_alias_arg_ptr);
27953 LDKCOption_u64Z outbound_scid_alias_arg_conv = *(LDKCOption_u64Z*)(outbound_scid_alias_arg_ptr);
27954 outbound_scid_alias_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(outbound_scid_alias_arg));
27955 void* inbound_scid_alias_arg_ptr = untag_ptr(inbound_scid_alias_arg);
27956 CHECK_ACCESS(inbound_scid_alias_arg_ptr);
27957 LDKCOption_u64Z inbound_scid_alias_arg_conv = *(LDKCOption_u64Z*)(inbound_scid_alias_arg_ptr);
27958 inbound_scid_alias_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(inbound_scid_alias_arg));
27959 void* unspendable_punishment_reserve_arg_ptr = untag_ptr(unspendable_punishment_reserve_arg);
27960 CHECK_ACCESS(unspendable_punishment_reserve_arg_ptr);
27961 LDKCOption_u64Z unspendable_punishment_reserve_arg_conv = *(LDKCOption_u64Z*)(unspendable_punishment_reserve_arg_ptr);
27962 LDKU128 user_channel_id_arg_ref;
27963 CHECK(user_channel_id_arg->arr_len == 16);
27964 memcpy(user_channel_id_arg_ref.le_bytes, user_channel_id_arg->elems, 16); FREE(user_channel_id_arg);
27965 void* confirmations_required_arg_ptr = untag_ptr(confirmations_required_arg);
27966 CHECK_ACCESS(confirmations_required_arg_ptr);
27967 LDKCOption_u32Z confirmations_required_arg_conv = *(LDKCOption_u32Z*)(confirmations_required_arg_ptr);
27968 confirmations_required_arg_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(confirmations_required_arg));
27969 void* confirmations_arg_ptr = untag_ptr(confirmations_arg);
27970 CHECK_ACCESS(confirmations_arg_ptr);
27971 LDKCOption_u32Z confirmations_arg_conv = *(LDKCOption_u32Z*)(confirmations_arg_ptr);
27972 confirmations_arg_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(confirmations_arg));
27973 void* force_close_spend_delay_arg_ptr = untag_ptr(force_close_spend_delay_arg);
27974 CHECK_ACCESS(force_close_spend_delay_arg_ptr);
27975 LDKCOption_u16Z force_close_spend_delay_arg_conv = *(LDKCOption_u16Z*)(force_close_spend_delay_arg_ptr);
27976 force_close_spend_delay_arg_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(force_close_spend_delay_arg));
27977 void* inbound_htlc_minimum_msat_arg_ptr = untag_ptr(inbound_htlc_minimum_msat_arg);
27978 CHECK_ACCESS(inbound_htlc_minimum_msat_arg_ptr);
27979 LDKCOption_u64Z inbound_htlc_minimum_msat_arg_conv = *(LDKCOption_u64Z*)(inbound_htlc_minimum_msat_arg_ptr);
27980 inbound_htlc_minimum_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(inbound_htlc_minimum_msat_arg));
27981 void* inbound_htlc_maximum_msat_arg_ptr = untag_ptr(inbound_htlc_maximum_msat_arg);
27982 CHECK_ACCESS(inbound_htlc_maximum_msat_arg_ptr);
27983 LDKCOption_u64Z inbound_htlc_maximum_msat_arg_conv = *(LDKCOption_u64Z*)(inbound_htlc_maximum_msat_arg_ptr);
27984 inbound_htlc_maximum_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(inbound_htlc_maximum_msat_arg));
27985 LDKChannelConfig config_arg_conv;
27986 config_arg_conv.inner = untag_ptr(config_arg);
27987 config_arg_conv.is_owned = ptr_is_owned(config_arg);
27988 CHECK_INNER_FIELD_ACCESS_OR_NULL(config_arg_conv);
27989 config_arg_conv = ChannelConfig_clone(&config_arg_conv);
27990 LDKChannelDetails ret_var = ChannelDetails_new(channel_id_arg_ref, counterparty_arg_conv, funding_txo_arg_conv, channel_type_arg_conv, short_channel_id_arg_conv, outbound_scid_alias_arg_conv, inbound_scid_alias_arg_conv, channel_value_satoshis_arg, unspendable_punishment_reserve_arg_conv, user_channel_id_arg_ref, balance_msat_arg, outbound_capacity_msat_arg, next_outbound_htlc_limit_msat_arg, inbound_capacity_msat_arg, confirmations_required_arg_conv, confirmations_arg_conv, force_close_spend_delay_arg_conv, is_outbound_arg, is_channel_ready_arg, is_usable_arg, is_public_arg, inbound_htlc_minimum_msat_arg_conv, inbound_htlc_maximum_msat_arg_conv, config_arg_conv);
27991 uint64_t ret_ref = 0;
27992 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27993 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27997 static inline uint64_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg) {
27998 LDKChannelDetails ret_var = ChannelDetails_clone(arg);
27999 uint64_t ret_ref = 0;
28000 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28001 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
28004 int64_t __attribute__((export_name("TS_ChannelDetails_clone_ptr"))) TS_ChannelDetails_clone_ptr(uint64_t arg) {
28005 LDKChannelDetails arg_conv;
28006 arg_conv.inner = untag_ptr(arg);
28007 arg_conv.is_owned = ptr_is_owned(arg);
28008 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
28009 arg_conv.is_owned = false;
28010 int64_t ret_conv = ChannelDetails_clone_ptr(&arg_conv);
28014 uint64_t __attribute__((export_name("TS_ChannelDetails_clone"))) TS_ChannelDetails_clone(uint64_t orig) {
28015 LDKChannelDetails orig_conv;
28016 orig_conv.inner = untag_ptr(orig);
28017 orig_conv.is_owned = ptr_is_owned(orig);
28018 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
28019 orig_conv.is_owned = false;
28020 LDKChannelDetails ret_var = ChannelDetails_clone(&orig_conv);
28021 uint64_t ret_ref = 0;
28022 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28023 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
28027 uint64_t __attribute__((export_name("TS_ChannelDetails_get_inbound_payment_scid"))) TS_ChannelDetails_get_inbound_payment_scid(uint64_t this_arg) {
28028 LDKChannelDetails this_arg_conv;
28029 this_arg_conv.inner = untag_ptr(this_arg);
28030 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28031 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28032 this_arg_conv.is_owned = false;
28033 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
28034 *ret_copy = ChannelDetails_get_inbound_payment_scid(&this_arg_conv);
28035 uint64_t ret_ref = tag_ptr(ret_copy, true);
28039 uint64_t __attribute__((export_name("TS_ChannelDetails_get_outbound_payment_scid"))) TS_ChannelDetails_get_outbound_payment_scid(uint64_t this_arg) {
28040 LDKChannelDetails this_arg_conv;
28041 this_arg_conv.inner = untag_ptr(this_arg);
28042 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28043 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28044 this_arg_conv.is_owned = false;
28045 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
28046 *ret_copy = ChannelDetails_get_outbound_payment_scid(&this_arg_conv);
28047 uint64_t ret_ref = tag_ptr(ret_copy, true);
28051 void __attribute__((export_name("TS_PaymentSendFailure_free"))) TS_PaymentSendFailure_free(uint64_t this_ptr) {
28052 if (!ptr_is_owned(this_ptr)) return;
28053 void* this_ptr_ptr = untag_ptr(this_ptr);
28054 CHECK_ACCESS(this_ptr_ptr);
28055 LDKPaymentSendFailure this_ptr_conv = *(LDKPaymentSendFailure*)(this_ptr_ptr);
28056 FREE(untag_ptr(this_ptr));
28057 PaymentSendFailure_free(this_ptr_conv);
28060 static inline uint64_t PaymentSendFailure_clone_ptr(LDKPaymentSendFailure *NONNULL_PTR arg) {
28061 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
28062 *ret_copy = PaymentSendFailure_clone(arg);
28063 uint64_t ret_ref = tag_ptr(ret_copy, true);
28066 int64_t __attribute__((export_name("TS_PaymentSendFailure_clone_ptr"))) TS_PaymentSendFailure_clone_ptr(uint64_t arg) {
28067 LDKPaymentSendFailure* arg_conv = (LDKPaymentSendFailure*)untag_ptr(arg);
28068 int64_t ret_conv = PaymentSendFailure_clone_ptr(arg_conv);
28072 uint64_t __attribute__((export_name("TS_PaymentSendFailure_clone"))) TS_PaymentSendFailure_clone(uint64_t orig) {
28073 LDKPaymentSendFailure* orig_conv = (LDKPaymentSendFailure*)untag_ptr(orig);
28074 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
28075 *ret_copy = PaymentSendFailure_clone(orig_conv);
28076 uint64_t ret_ref = tag_ptr(ret_copy, true);
28080 uint64_t __attribute__((export_name("TS_PaymentSendFailure_parameter_error"))) TS_PaymentSendFailure_parameter_error(uint64_t a) {
28081 void* a_ptr = untag_ptr(a);
28082 CHECK_ACCESS(a_ptr);
28083 LDKAPIError a_conv = *(LDKAPIError*)(a_ptr);
28084 a_conv = APIError_clone((LDKAPIError*)untag_ptr(a));
28085 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
28086 *ret_copy = PaymentSendFailure_parameter_error(a_conv);
28087 uint64_t ret_ref = tag_ptr(ret_copy, true);
28091 uint64_t __attribute__((export_name("TS_PaymentSendFailure_path_parameter_error"))) TS_PaymentSendFailure_path_parameter_error(uint64_tArray a) {
28092 LDKCVec_CResult_NoneAPIErrorZZ a_constr;
28093 a_constr.datalen = a->arr_len;
28094 if (a_constr.datalen > 0)
28095 a_constr.data = MALLOC(a_constr.datalen * sizeof(LDKCResult_NoneAPIErrorZ), "LDKCVec_CResult_NoneAPIErrorZZ Elements");
28097 a_constr.data = NULL;
28098 uint64_t* a_vals = a->elems;
28099 for (size_t w = 0; w < a_constr.datalen; w++) {
28100 uint64_t a_conv_22 = a_vals[w];
28101 void* a_conv_22_ptr = untag_ptr(a_conv_22);
28102 CHECK_ACCESS(a_conv_22_ptr);
28103 LDKCResult_NoneAPIErrorZ a_conv_22_conv = *(LDKCResult_NoneAPIErrorZ*)(a_conv_22_ptr);
28104 a_conv_22_conv = CResult_NoneAPIErrorZ_clone((LDKCResult_NoneAPIErrorZ*)untag_ptr(a_conv_22));
28105 a_constr.data[w] = a_conv_22_conv;
28108 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
28109 *ret_copy = PaymentSendFailure_path_parameter_error(a_constr);
28110 uint64_t ret_ref = tag_ptr(ret_copy, true);
28114 uint64_t __attribute__((export_name("TS_PaymentSendFailure_all_failed_resend_safe"))) TS_PaymentSendFailure_all_failed_resend_safe(uint64_tArray a) {
28115 LDKCVec_APIErrorZ a_constr;
28116 a_constr.datalen = a->arr_len;
28117 if (a_constr.datalen > 0)
28118 a_constr.data = MALLOC(a_constr.datalen * sizeof(LDKAPIError), "LDKCVec_APIErrorZ Elements");
28120 a_constr.data = NULL;
28121 uint64_t* a_vals = a->elems;
28122 for (size_t k = 0; k < a_constr.datalen; k++) {
28123 uint64_t a_conv_10 = a_vals[k];
28124 void* a_conv_10_ptr = untag_ptr(a_conv_10);
28125 CHECK_ACCESS(a_conv_10_ptr);
28126 LDKAPIError a_conv_10_conv = *(LDKAPIError*)(a_conv_10_ptr);
28127 a_conv_10_conv = APIError_clone((LDKAPIError*)untag_ptr(a_conv_10));
28128 a_constr.data[k] = a_conv_10_conv;
28131 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
28132 *ret_copy = PaymentSendFailure_all_failed_resend_safe(a_constr);
28133 uint64_t ret_ref = tag_ptr(ret_copy, true);
28137 uint64_t __attribute__((export_name("TS_PaymentSendFailure_duplicate_payment"))) TS_PaymentSendFailure_duplicate_payment() {
28138 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
28139 *ret_copy = PaymentSendFailure_duplicate_payment();
28140 uint64_t ret_ref = tag_ptr(ret_copy, true);
28144 uint64_t __attribute__((export_name("TS_PaymentSendFailure_partial_failure"))) TS_PaymentSendFailure_partial_failure(uint64_tArray results, uint64_t failed_paths_retry, int8_tArray payment_id) {
28145 LDKCVec_CResult_NoneAPIErrorZZ results_constr;
28146 results_constr.datalen = results->arr_len;
28147 if (results_constr.datalen > 0)
28148 results_constr.data = MALLOC(results_constr.datalen * sizeof(LDKCResult_NoneAPIErrorZ), "LDKCVec_CResult_NoneAPIErrorZZ Elements");
28150 results_constr.data = NULL;
28151 uint64_t* results_vals = results->elems;
28152 for (size_t w = 0; w < results_constr.datalen; w++) {
28153 uint64_t results_conv_22 = results_vals[w];
28154 void* results_conv_22_ptr = untag_ptr(results_conv_22);
28155 CHECK_ACCESS(results_conv_22_ptr);
28156 LDKCResult_NoneAPIErrorZ results_conv_22_conv = *(LDKCResult_NoneAPIErrorZ*)(results_conv_22_ptr);
28157 results_constr.data[w] = results_conv_22_conv;
28160 LDKRouteParameters failed_paths_retry_conv;
28161 failed_paths_retry_conv.inner = untag_ptr(failed_paths_retry);
28162 failed_paths_retry_conv.is_owned = ptr_is_owned(failed_paths_retry);
28163 CHECK_INNER_FIELD_ACCESS_OR_NULL(failed_paths_retry_conv);
28164 failed_paths_retry_conv = RouteParameters_clone(&failed_paths_retry_conv);
28165 LDKThirtyTwoBytes payment_id_ref;
28166 CHECK(payment_id->arr_len == 32);
28167 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
28168 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
28169 *ret_copy = PaymentSendFailure_partial_failure(results_constr, failed_paths_retry_conv, payment_id_ref);
28170 uint64_t ret_ref = tag_ptr(ret_copy, true);
28174 void __attribute__((export_name("TS_PhantomRouteHints_free"))) TS_PhantomRouteHints_free(uint64_t this_obj) {
28175 LDKPhantomRouteHints this_obj_conv;
28176 this_obj_conv.inner = untag_ptr(this_obj);
28177 this_obj_conv.is_owned = ptr_is_owned(this_obj);
28178 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
28179 PhantomRouteHints_free(this_obj_conv);
28182 uint64_tArray __attribute__((export_name("TS_PhantomRouteHints_get_channels"))) TS_PhantomRouteHints_get_channels(uint64_t this_ptr) {
28183 LDKPhantomRouteHints this_ptr_conv;
28184 this_ptr_conv.inner = untag_ptr(this_ptr);
28185 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28186 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28187 this_ptr_conv.is_owned = false;
28188 LDKCVec_ChannelDetailsZ ret_var = PhantomRouteHints_get_channels(&this_ptr_conv);
28189 uint64_tArray ret_arr = NULL;
28190 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
28191 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
28192 for (size_t q = 0; q < ret_var.datalen; q++) {
28193 LDKChannelDetails ret_conv_16_var = ret_var.data[q];
28194 uint64_t ret_conv_16_ref = 0;
28195 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
28196 ret_conv_16_ref = tag_ptr(ret_conv_16_var.inner, ret_conv_16_var.is_owned);
28197 ret_arr_ptr[q] = ret_conv_16_ref;
28200 FREE(ret_var.data);
28204 void __attribute__((export_name("TS_PhantomRouteHints_set_channels"))) TS_PhantomRouteHints_set_channels(uint64_t this_ptr, uint64_tArray val) {
28205 LDKPhantomRouteHints this_ptr_conv;
28206 this_ptr_conv.inner = untag_ptr(this_ptr);
28207 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28208 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28209 this_ptr_conv.is_owned = false;
28210 LDKCVec_ChannelDetailsZ val_constr;
28211 val_constr.datalen = val->arr_len;
28212 if (val_constr.datalen > 0)
28213 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
28215 val_constr.data = NULL;
28216 uint64_t* val_vals = val->elems;
28217 for (size_t q = 0; q < val_constr.datalen; q++) {
28218 uint64_t val_conv_16 = val_vals[q];
28219 LDKChannelDetails val_conv_16_conv;
28220 val_conv_16_conv.inner = untag_ptr(val_conv_16);
28221 val_conv_16_conv.is_owned = ptr_is_owned(val_conv_16);
28222 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_16_conv);
28223 val_conv_16_conv = ChannelDetails_clone(&val_conv_16_conv);
28224 val_constr.data[q] = val_conv_16_conv;
28227 PhantomRouteHints_set_channels(&this_ptr_conv, val_constr);
28230 int64_t __attribute__((export_name("TS_PhantomRouteHints_get_phantom_scid"))) TS_PhantomRouteHints_get_phantom_scid(uint64_t this_ptr) {
28231 LDKPhantomRouteHints this_ptr_conv;
28232 this_ptr_conv.inner = untag_ptr(this_ptr);
28233 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28234 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28235 this_ptr_conv.is_owned = false;
28236 int64_t ret_conv = PhantomRouteHints_get_phantom_scid(&this_ptr_conv);
28240 void __attribute__((export_name("TS_PhantomRouteHints_set_phantom_scid"))) TS_PhantomRouteHints_set_phantom_scid(uint64_t this_ptr, int64_t val) {
28241 LDKPhantomRouteHints this_ptr_conv;
28242 this_ptr_conv.inner = untag_ptr(this_ptr);
28243 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28244 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28245 this_ptr_conv.is_owned = false;
28246 PhantomRouteHints_set_phantom_scid(&this_ptr_conv, val);
28249 int8_tArray __attribute__((export_name("TS_PhantomRouteHints_get_real_node_pubkey"))) TS_PhantomRouteHints_get_real_node_pubkey(uint64_t this_ptr) {
28250 LDKPhantomRouteHints this_ptr_conv;
28251 this_ptr_conv.inner = untag_ptr(this_ptr);
28252 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28253 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28254 this_ptr_conv.is_owned = false;
28255 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
28256 memcpy(ret_arr->elems, PhantomRouteHints_get_real_node_pubkey(&this_ptr_conv).compressed_form, 33);
28260 void __attribute__((export_name("TS_PhantomRouteHints_set_real_node_pubkey"))) TS_PhantomRouteHints_set_real_node_pubkey(uint64_t this_ptr, int8_tArray val) {
28261 LDKPhantomRouteHints this_ptr_conv;
28262 this_ptr_conv.inner = untag_ptr(this_ptr);
28263 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28264 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28265 this_ptr_conv.is_owned = false;
28266 LDKPublicKey val_ref;
28267 CHECK(val->arr_len == 33);
28268 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
28269 PhantomRouteHints_set_real_node_pubkey(&this_ptr_conv, val_ref);
28272 uint64_t __attribute__((export_name("TS_PhantomRouteHints_new"))) TS_PhantomRouteHints_new(uint64_tArray channels_arg, int64_t phantom_scid_arg, int8_tArray real_node_pubkey_arg) {
28273 LDKCVec_ChannelDetailsZ channels_arg_constr;
28274 channels_arg_constr.datalen = channels_arg->arr_len;
28275 if (channels_arg_constr.datalen > 0)
28276 channels_arg_constr.data = MALLOC(channels_arg_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
28278 channels_arg_constr.data = NULL;
28279 uint64_t* channels_arg_vals = channels_arg->elems;
28280 for (size_t q = 0; q < channels_arg_constr.datalen; q++) {
28281 uint64_t channels_arg_conv_16 = channels_arg_vals[q];
28282 LDKChannelDetails channels_arg_conv_16_conv;
28283 channels_arg_conv_16_conv.inner = untag_ptr(channels_arg_conv_16);
28284 channels_arg_conv_16_conv.is_owned = ptr_is_owned(channels_arg_conv_16);
28285 CHECK_INNER_FIELD_ACCESS_OR_NULL(channels_arg_conv_16_conv);
28286 channels_arg_conv_16_conv = ChannelDetails_clone(&channels_arg_conv_16_conv);
28287 channels_arg_constr.data[q] = channels_arg_conv_16_conv;
28289 FREE(channels_arg);
28290 LDKPublicKey real_node_pubkey_arg_ref;
28291 CHECK(real_node_pubkey_arg->arr_len == 33);
28292 memcpy(real_node_pubkey_arg_ref.compressed_form, real_node_pubkey_arg->elems, 33); FREE(real_node_pubkey_arg);
28293 LDKPhantomRouteHints ret_var = PhantomRouteHints_new(channels_arg_constr, phantom_scid_arg, real_node_pubkey_arg_ref);
28294 uint64_t ret_ref = 0;
28295 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28296 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
28300 static inline uint64_t PhantomRouteHints_clone_ptr(LDKPhantomRouteHints *NONNULL_PTR arg) {
28301 LDKPhantomRouteHints ret_var = PhantomRouteHints_clone(arg);
28302 uint64_t ret_ref = 0;
28303 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28304 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
28307 int64_t __attribute__((export_name("TS_PhantomRouteHints_clone_ptr"))) TS_PhantomRouteHints_clone_ptr(uint64_t arg) {
28308 LDKPhantomRouteHints arg_conv;
28309 arg_conv.inner = untag_ptr(arg);
28310 arg_conv.is_owned = ptr_is_owned(arg);
28311 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
28312 arg_conv.is_owned = false;
28313 int64_t ret_conv = PhantomRouteHints_clone_ptr(&arg_conv);
28317 uint64_t __attribute__((export_name("TS_PhantomRouteHints_clone"))) TS_PhantomRouteHints_clone(uint64_t orig) {
28318 LDKPhantomRouteHints orig_conv;
28319 orig_conv.inner = untag_ptr(orig);
28320 orig_conv.is_owned = ptr_is_owned(orig);
28321 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
28322 orig_conv.is_owned = false;
28323 LDKPhantomRouteHints ret_var = PhantomRouteHints_clone(&orig_conv);
28324 uint64_t ret_ref = 0;
28325 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28326 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
28330 uint64_t __attribute__((export_name("TS_ChannelManager_new"))) TS_ChannelManager_new(uint64_t fee_est, uint64_t chain_monitor, uint64_t tx_broadcaster, uint64_t logger, uint64_t keys_manager, uint64_t config, uint64_t params) {
28331 void* fee_est_ptr = untag_ptr(fee_est);
28332 CHECK_ACCESS(fee_est_ptr);
28333 LDKFeeEstimator fee_est_conv = *(LDKFeeEstimator*)(fee_est_ptr);
28334 if (fee_est_conv.free == LDKFeeEstimator_JCalls_free) {
28335 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
28336 LDKFeeEstimator_JCalls_cloned(&fee_est_conv);
28338 void* chain_monitor_ptr = untag_ptr(chain_monitor);
28339 CHECK_ACCESS(chain_monitor_ptr);
28340 LDKWatch chain_monitor_conv = *(LDKWatch*)(chain_monitor_ptr);
28341 if (chain_monitor_conv.free == LDKWatch_JCalls_free) {
28342 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
28343 LDKWatch_JCalls_cloned(&chain_monitor_conv);
28345 void* tx_broadcaster_ptr = untag_ptr(tx_broadcaster);
28346 CHECK_ACCESS(tx_broadcaster_ptr);
28347 LDKBroadcasterInterface tx_broadcaster_conv = *(LDKBroadcasterInterface*)(tx_broadcaster_ptr);
28348 if (tx_broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
28349 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
28350 LDKBroadcasterInterface_JCalls_cloned(&tx_broadcaster_conv);
28352 void* logger_ptr = untag_ptr(logger);
28353 CHECK_ACCESS(logger_ptr);
28354 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
28355 if (logger_conv.free == LDKLogger_JCalls_free) {
28356 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
28357 LDKLogger_JCalls_cloned(&logger_conv);
28359 void* keys_manager_ptr = untag_ptr(keys_manager);
28360 CHECK_ACCESS(keys_manager_ptr);
28361 LDKKeysInterface keys_manager_conv = *(LDKKeysInterface*)(keys_manager_ptr);
28362 if (keys_manager_conv.free == LDKKeysInterface_JCalls_free) {
28363 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
28364 LDKKeysInterface_JCalls_cloned(&keys_manager_conv);
28366 LDKUserConfig config_conv;
28367 config_conv.inner = untag_ptr(config);
28368 config_conv.is_owned = ptr_is_owned(config);
28369 CHECK_INNER_FIELD_ACCESS_OR_NULL(config_conv);
28370 config_conv = UserConfig_clone(&config_conv);
28371 LDKChainParameters params_conv;
28372 params_conv.inner = untag_ptr(params);
28373 params_conv.is_owned = ptr_is_owned(params);
28374 CHECK_INNER_FIELD_ACCESS_OR_NULL(params_conv);
28375 params_conv = ChainParameters_clone(¶ms_conv);
28376 LDKChannelManager ret_var = ChannelManager_new(fee_est_conv, chain_monitor_conv, tx_broadcaster_conv, logger_conv, keys_manager_conv, config_conv, params_conv);
28377 uint64_t ret_ref = 0;
28378 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28379 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
28383 uint64_t __attribute__((export_name("TS_ChannelManager_get_current_default_configuration"))) TS_ChannelManager_get_current_default_configuration(uint64_t this_arg) {
28384 LDKChannelManager this_arg_conv;
28385 this_arg_conv.inner = untag_ptr(this_arg);
28386 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28387 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28388 this_arg_conv.is_owned = false;
28389 LDKUserConfig ret_var = ChannelManager_get_current_default_configuration(&this_arg_conv);
28390 uint64_t ret_ref = 0;
28391 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28392 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
28396 uint64_t __attribute__((export_name("TS_ChannelManager_create_channel"))) TS_ChannelManager_create_channel(uint64_t this_arg, int8_tArray their_network_key, int64_t channel_value_satoshis, int64_t push_msat, int8_tArray user_channel_id, uint64_t override_config) {
28397 LDKChannelManager this_arg_conv;
28398 this_arg_conv.inner = untag_ptr(this_arg);
28399 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28400 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28401 this_arg_conv.is_owned = false;
28402 LDKPublicKey their_network_key_ref;
28403 CHECK(their_network_key->arr_len == 33);
28404 memcpy(their_network_key_ref.compressed_form, their_network_key->elems, 33); FREE(their_network_key);
28405 LDKU128 user_channel_id_ref;
28406 CHECK(user_channel_id->arr_len == 16);
28407 memcpy(user_channel_id_ref.le_bytes, user_channel_id->elems, 16); FREE(user_channel_id);
28408 LDKUserConfig override_config_conv;
28409 override_config_conv.inner = untag_ptr(override_config);
28410 override_config_conv.is_owned = ptr_is_owned(override_config);
28411 CHECK_INNER_FIELD_ACCESS_OR_NULL(override_config_conv);
28412 override_config_conv = UserConfig_clone(&override_config_conv);
28413 LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
28414 *ret_conv = ChannelManager_create_channel(&this_arg_conv, their_network_key_ref, channel_value_satoshis, push_msat, user_channel_id_ref, override_config_conv);
28415 return tag_ptr(ret_conv, true);
28418 uint64_tArray __attribute__((export_name("TS_ChannelManager_list_channels"))) TS_ChannelManager_list_channels(uint64_t this_arg) {
28419 LDKChannelManager this_arg_conv;
28420 this_arg_conv.inner = untag_ptr(this_arg);
28421 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28422 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28423 this_arg_conv.is_owned = false;
28424 LDKCVec_ChannelDetailsZ ret_var = ChannelManager_list_channels(&this_arg_conv);
28425 uint64_tArray ret_arr = NULL;
28426 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
28427 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
28428 for (size_t q = 0; q < ret_var.datalen; q++) {
28429 LDKChannelDetails ret_conv_16_var = ret_var.data[q];
28430 uint64_t ret_conv_16_ref = 0;
28431 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
28432 ret_conv_16_ref = tag_ptr(ret_conv_16_var.inner, ret_conv_16_var.is_owned);
28433 ret_arr_ptr[q] = ret_conv_16_ref;
28436 FREE(ret_var.data);
28440 uint64_tArray __attribute__((export_name("TS_ChannelManager_list_usable_channels"))) TS_ChannelManager_list_usable_channels(uint64_t this_arg) {
28441 LDKChannelManager this_arg_conv;
28442 this_arg_conv.inner = untag_ptr(this_arg);
28443 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28444 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28445 this_arg_conv.is_owned = false;
28446 LDKCVec_ChannelDetailsZ ret_var = ChannelManager_list_usable_channels(&this_arg_conv);
28447 uint64_tArray ret_arr = NULL;
28448 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
28449 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
28450 for (size_t q = 0; q < ret_var.datalen; q++) {
28451 LDKChannelDetails ret_conv_16_var = ret_var.data[q];
28452 uint64_t ret_conv_16_ref = 0;
28453 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
28454 ret_conv_16_ref = tag_ptr(ret_conv_16_var.inner, ret_conv_16_var.is_owned);
28455 ret_arr_ptr[q] = ret_conv_16_ref;
28458 FREE(ret_var.data);
28462 uint64_t __attribute__((export_name("TS_ChannelManager_close_channel"))) TS_ChannelManager_close_channel(uint64_t this_arg, int8_tArray channel_id, int8_tArray counterparty_node_id) {
28463 LDKChannelManager this_arg_conv;
28464 this_arg_conv.inner = untag_ptr(this_arg);
28465 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28466 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28467 this_arg_conv.is_owned = false;
28468 unsigned char channel_id_arr[32];
28469 CHECK(channel_id->arr_len == 32);
28470 memcpy(channel_id_arr, channel_id->elems, 32); FREE(channel_id);
28471 unsigned char (*channel_id_ref)[32] = &channel_id_arr;
28472 LDKPublicKey counterparty_node_id_ref;
28473 CHECK(counterparty_node_id->arr_len == 33);
28474 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
28475 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
28476 *ret_conv = ChannelManager_close_channel(&this_arg_conv, channel_id_ref, counterparty_node_id_ref);
28477 return tag_ptr(ret_conv, true);
28480 uint64_t __attribute__((export_name("TS_ChannelManager_close_channel_with_target_feerate"))) TS_ChannelManager_close_channel_with_target_feerate(uint64_t this_arg, int8_tArray channel_id, int8_tArray counterparty_node_id, int32_t target_feerate_sats_per_1000_weight) {
28481 LDKChannelManager this_arg_conv;
28482 this_arg_conv.inner = untag_ptr(this_arg);
28483 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28484 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28485 this_arg_conv.is_owned = false;
28486 unsigned char channel_id_arr[32];
28487 CHECK(channel_id->arr_len == 32);
28488 memcpy(channel_id_arr, channel_id->elems, 32); FREE(channel_id);
28489 unsigned char (*channel_id_ref)[32] = &channel_id_arr;
28490 LDKPublicKey counterparty_node_id_ref;
28491 CHECK(counterparty_node_id->arr_len == 33);
28492 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
28493 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
28494 *ret_conv = ChannelManager_close_channel_with_target_feerate(&this_arg_conv, channel_id_ref, counterparty_node_id_ref, target_feerate_sats_per_1000_weight);
28495 return tag_ptr(ret_conv, true);
28498 uint64_t __attribute__((export_name("TS_ChannelManager_force_close_broadcasting_latest_txn"))) TS_ChannelManager_force_close_broadcasting_latest_txn(uint64_t this_arg, int8_tArray channel_id, int8_tArray counterparty_node_id) {
28499 LDKChannelManager this_arg_conv;
28500 this_arg_conv.inner = untag_ptr(this_arg);
28501 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28502 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28503 this_arg_conv.is_owned = false;
28504 unsigned char channel_id_arr[32];
28505 CHECK(channel_id->arr_len == 32);
28506 memcpy(channel_id_arr, channel_id->elems, 32); FREE(channel_id);
28507 unsigned char (*channel_id_ref)[32] = &channel_id_arr;
28508 LDKPublicKey counterparty_node_id_ref;
28509 CHECK(counterparty_node_id->arr_len == 33);
28510 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
28511 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
28512 *ret_conv = ChannelManager_force_close_broadcasting_latest_txn(&this_arg_conv, channel_id_ref, counterparty_node_id_ref);
28513 return tag_ptr(ret_conv, true);
28516 uint64_t __attribute__((export_name("TS_ChannelManager_force_close_without_broadcasting_txn"))) TS_ChannelManager_force_close_without_broadcasting_txn(uint64_t this_arg, int8_tArray channel_id, int8_tArray counterparty_node_id) {
28517 LDKChannelManager this_arg_conv;
28518 this_arg_conv.inner = untag_ptr(this_arg);
28519 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28520 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28521 this_arg_conv.is_owned = false;
28522 unsigned char channel_id_arr[32];
28523 CHECK(channel_id->arr_len == 32);
28524 memcpy(channel_id_arr, channel_id->elems, 32); FREE(channel_id);
28525 unsigned char (*channel_id_ref)[32] = &channel_id_arr;
28526 LDKPublicKey counterparty_node_id_ref;
28527 CHECK(counterparty_node_id->arr_len == 33);
28528 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
28529 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
28530 *ret_conv = ChannelManager_force_close_without_broadcasting_txn(&this_arg_conv, channel_id_ref, counterparty_node_id_ref);
28531 return tag_ptr(ret_conv, true);
28534 void __attribute__((export_name("TS_ChannelManager_force_close_all_channels_broadcasting_latest_txn"))) TS_ChannelManager_force_close_all_channels_broadcasting_latest_txn(uint64_t this_arg) {
28535 LDKChannelManager this_arg_conv;
28536 this_arg_conv.inner = untag_ptr(this_arg);
28537 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28538 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28539 this_arg_conv.is_owned = false;
28540 ChannelManager_force_close_all_channels_broadcasting_latest_txn(&this_arg_conv);
28543 void __attribute__((export_name("TS_ChannelManager_force_close_all_channels_without_broadcasting_txn"))) TS_ChannelManager_force_close_all_channels_without_broadcasting_txn(uint64_t this_arg) {
28544 LDKChannelManager this_arg_conv;
28545 this_arg_conv.inner = untag_ptr(this_arg);
28546 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28547 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28548 this_arg_conv.is_owned = false;
28549 ChannelManager_force_close_all_channels_without_broadcasting_txn(&this_arg_conv);
28552 uint64_t __attribute__((export_name("TS_ChannelManager_send_payment"))) TS_ChannelManager_send_payment(uint64_t this_arg, uint64_t route, int8_tArray payment_hash, int8_tArray payment_secret, int8_tArray payment_id) {
28553 LDKChannelManager this_arg_conv;
28554 this_arg_conv.inner = untag_ptr(this_arg);
28555 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28556 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28557 this_arg_conv.is_owned = false;
28558 LDKRoute route_conv;
28559 route_conv.inner = untag_ptr(route);
28560 route_conv.is_owned = ptr_is_owned(route);
28561 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
28562 route_conv.is_owned = false;
28563 LDKThirtyTwoBytes payment_hash_ref;
28564 CHECK(payment_hash->arr_len == 32);
28565 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
28566 LDKThirtyTwoBytes payment_secret_ref;
28567 CHECK(payment_secret->arr_len == 32);
28568 memcpy(payment_secret_ref.data, payment_secret->elems, 32); FREE(payment_secret);
28569 LDKThirtyTwoBytes payment_id_ref;
28570 CHECK(payment_id->arr_len == 32);
28571 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
28572 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
28573 *ret_conv = ChannelManager_send_payment(&this_arg_conv, &route_conv, payment_hash_ref, payment_secret_ref, payment_id_ref);
28574 return tag_ptr(ret_conv, true);
28577 uint64_t __attribute__((export_name("TS_ChannelManager_retry_payment"))) TS_ChannelManager_retry_payment(uint64_t this_arg, uint64_t route, int8_tArray payment_id) {
28578 LDKChannelManager this_arg_conv;
28579 this_arg_conv.inner = untag_ptr(this_arg);
28580 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28581 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28582 this_arg_conv.is_owned = false;
28583 LDKRoute route_conv;
28584 route_conv.inner = untag_ptr(route);
28585 route_conv.is_owned = ptr_is_owned(route);
28586 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
28587 route_conv.is_owned = false;
28588 LDKThirtyTwoBytes payment_id_ref;
28589 CHECK(payment_id->arr_len == 32);
28590 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
28591 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
28592 *ret_conv = ChannelManager_retry_payment(&this_arg_conv, &route_conv, payment_id_ref);
28593 return tag_ptr(ret_conv, true);
28596 void __attribute__((export_name("TS_ChannelManager_abandon_payment"))) TS_ChannelManager_abandon_payment(uint64_t this_arg, int8_tArray payment_id) {
28597 LDKChannelManager this_arg_conv;
28598 this_arg_conv.inner = untag_ptr(this_arg);
28599 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28600 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28601 this_arg_conv.is_owned = false;
28602 LDKThirtyTwoBytes payment_id_ref;
28603 CHECK(payment_id->arr_len == 32);
28604 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
28605 ChannelManager_abandon_payment(&this_arg_conv, payment_id_ref);
28608 uint64_t __attribute__((export_name("TS_ChannelManager_send_spontaneous_payment"))) TS_ChannelManager_send_spontaneous_payment(uint64_t this_arg, uint64_t route, int8_tArray payment_preimage, int8_tArray payment_id) {
28609 LDKChannelManager this_arg_conv;
28610 this_arg_conv.inner = untag_ptr(this_arg);
28611 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28612 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28613 this_arg_conv.is_owned = false;
28614 LDKRoute route_conv;
28615 route_conv.inner = untag_ptr(route);
28616 route_conv.is_owned = ptr_is_owned(route);
28617 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
28618 route_conv.is_owned = false;
28619 LDKThirtyTwoBytes payment_preimage_ref;
28620 CHECK(payment_preimage->arr_len == 32);
28621 memcpy(payment_preimage_ref.data, payment_preimage->elems, 32); FREE(payment_preimage);
28622 LDKThirtyTwoBytes payment_id_ref;
28623 CHECK(payment_id->arr_len == 32);
28624 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
28625 LDKCResult_PaymentHashPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentHashPaymentSendFailureZ), "LDKCResult_PaymentHashPaymentSendFailureZ");
28626 *ret_conv = ChannelManager_send_spontaneous_payment(&this_arg_conv, &route_conv, payment_preimage_ref, payment_id_ref);
28627 return tag_ptr(ret_conv, true);
28630 uint64_t __attribute__((export_name("TS_ChannelManager_send_probe"))) TS_ChannelManager_send_probe(uint64_t this_arg, uint64_tArray hops) {
28631 LDKChannelManager this_arg_conv;
28632 this_arg_conv.inner = untag_ptr(this_arg);
28633 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28634 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28635 this_arg_conv.is_owned = false;
28636 LDKCVec_RouteHopZ hops_constr;
28637 hops_constr.datalen = hops->arr_len;
28638 if (hops_constr.datalen > 0)
28639 hops_constr.data = MALLOC(hops_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
28641 hops_constr.data = NULL;
28642 uint64_t* hops_vals = hops->elems;
28643 for (size_t k = 0; k < hops_constr.datalen; k++) {
28644 uint64_t hops_conv_10 = hops_vals[k];
28645 LDKRouteHop hops_conv_10_conv;
28646 hops_conv_10_conv.inner = untag_ptr(hops_conv_10);
28647 hops_conv_10_conv.is_owned = ptr_is_owned(hops_conv_10);
28648 CHECK_INNER_FIELD_ACCESS_OR_NULL(hops_conv_10_conv);
28649 hops_conv_10_conv = RouteHop_clone(&hops_conv_10_conv);
28650 hops_constr.data[k] = hops_conv_10_conv;
28653 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ");
28654 *ret_conv = ChannelManager_send_probe(&this_arg_conv, hops_constr);
28655 return tag_ptr(ret_conv, true);
28658 uint64_t __attribute__((export_name("TS_ChannelManager_funding_transaction_generated"))) TS_ChannelManager_funding_transaction_generated(uint64_t this_arg, int8_tArray temporary_channel_id, int8_tArray counterparty_node_id, int8_tArray funding_transaction) {
28659 LDKChannelManager this_arg_conv;
28660 this_arg_conv.inner = untag_ptr(this_arg);
28661 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28662 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28663 this_arg_conv.is_owned = false;
28664 unsigned char temporary_channel_id_arr[32];
28665 CHECK(temporary_channel_id->arr_len == 32);
28666 memcpy(temporary_channel_id_arr, temporary_channel_id->elems, 32); FREE(temporary_channel_id);
28667 unsigned char (*temporary_channel_id_ref)[32] = &temporary_channel_id_arr;
28668 LDKPublicKey counterparty_node_id_ref;
28669 CHECK(counterparty_node_id->arr_len == 33);
28670 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
28671 LDKTransaction funding_transaction_ref;
28672 funding_transaction_ref.datalen = funding_transaction->arr_len;
28673 funding_transaction_ref.data = MALLOC(funding_transaction_ref.datalen, "LDKTransaction Bytes");
28674 memcpy(funding_transaction_ref.data, funding_transaction->elems, funding_transaction_ref.datalen); FREE(funding_transaction);
28675 funding_transaction_ref.data_is_owned = true;
28676 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
28677 *ret_conv = ChannelManager_funding_transaction_generated(&this_arg_conv, temporary_channel_id_ref, counterparty_node_id_ref, funding_transaction_ref);
28678 return tag_ptr(ret_conv, true);
28681 uint64_t __attribute__((export_name("TS_ChannelManager_update_channel_config"))) TS_ChannelManager_update_channel_config(uint64_t this_arg, int8_tArray counterparty_node_id, ptrArray channel_ids, uint64_t config) {
28682 LDKChannelManager this_arg_conv;
28683 this_arg_conv.inner = untag_ptr(this_arg);
28684 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28685 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28686 this_arg_conv.is_owned = false;
28687 LDKPublicKey counterparty_node_id_ref;
28688 CHECK(counterparty_node_id->arr_len == 33);
28689 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
28690 LDKCVec_ThirtyTwoBytesZ channel_ids_constr;
28691 channel_ids_constr.datalen = channel_ids->arr_len;
28692 if (channel_ids_constr.datalen > 0)
28693 channel_ids_constr.data = MALLOC(channel_ids_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_ThirtyTwoBytesZ Elements");
28695 channel_ids_constr.data = NULL;
28696 int8_tArray* channel_ids_vals = (void*) channel_ids->elems;
28697 for (size_t m = 0; m < channel_ids_constr.datalen; m++) {
28698 int8_tArray channel_ids_conv_12 = channel_ids_vals[m];
28699 LDKThirtyTwoBytes channel_ids_conv_12_ref;
28700 CHECK(channel_ids_conv_12->arr_len == 32);
28701 memcpy(channel_ids_conv_12_ref.data, channel_ids_conv_12->elems, 32); FREE(channel_ids_conv_12);
28702 channel_ids_constr.data[m] = channel_ids_conv_12_ref;
28705 LDKChannelConfig config_conv;
28706 config_conv.inner = untag_ptr(config);
28707 config_conv.is_owned = ptr_is_owned(config);
28708 CHECK_INNER_FIELD_ACCESS_OR_NULL(config_conv);
28709 config_conv.is_owned = false;
28710 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
28711 *ret_conv = ChannelManager_update_channel_config(&this_arg_conv, counterparty_node_id_ref, channel_ids_constr, &config_conv);
28712 return tag_ptr(ret_conv, true);
28715 uint64_t __attribute__((export_name("TS_ChannelManager_forward_intercepted_htlc"))) TS_ChannelManager_forward_intercepted_htlc(uint64_t this_arg, int8_tArray intercept_id, int8_tArray next_hop_channel_id, int8_tArray _next_node_id, int64_t amt_to_forward_msat) {
28716 LDKChannelManager this_arg_conv;
28717 this_arg_conv.inner = untag_ptr(this_arg);
28718 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28719 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28720 this_arg_conv.is_owned = false;
28721 LDKThirtyTwoBytes intercept_id_ref;
28722 CHECK(intercept_id->arr_len == 32);
28723 memcpy(intercept_id_ref.data, intercept_id->elems, 32); FREE(intercept_id);
28724 unsigned char next_hop_channel_id_arr[32];
28725 CHECK(next_hop_channel_id->arr_len == 32);
28726 memcpy(next_hop_channel_id_arr, next_hop_channel_id->elems, 32); FREE(next_hop_channel_id);
28727 unsigned char (*next_hop_channel_id_ref)[32] = &next_hop_channel_id_arr;
28728 LDKPublicKey _next_node_id_ref;
28729 CHECK(_next_node_id->arr_len == 33);
28730 memcpy(_next_node_id_ref.compressed_form, _next_node_id->elems, 33); FREE(_next_node_id);
28731 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
28732 *ret_conv = ChannelManager_forward_intercepted_htlc(&this_arg_conv, intercept_id_ref, next_hop_channel_id_ref, _next_node_id_ref, amt_to_forward_msat);
28733 return tag_ptr(ret_conv, true);
28736 uint64_t __attribute__((export_name("TS_ChannelManager_fail_intercepted_htlc"))) TS_ChannelManager_fail_intercepted_htlc(uint64_t this_arg, int8_tArray intercept_id) {
28737 LDKChannelManager this_arg_conv;
28738 this_arg_conv.inner = untag_ptr(this_arg);
28739 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28740 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28741 this_arg_conv.is_owned = false;
28742 LDKThirtyTwoBytes intercept_id_ref;
28743 CHECK(intercept_id->arr_len == 32);
28744 memcpy(intercept_id_ref.data, intercept_id->elems, 32); FREE(intercept_id);
28745 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
28746 *ret_conv = ChannelManager_fail_intercepted_htlc(&this_arg_conv, intercept_id_ref);
28747 return tag_ptr(ret_conv, true);
28750 void __attribute__((export_name("TS_ChannelManager_process_pending_htlc_forwards"))) TS_ChannelManager_process_pending_htlc_forwards(uint64_t this_arg) {
28751 LDKChannelManager this_arg_conv;
28752 this_arg_conv.inner = untag_ptr(this_arg);
28753 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28754 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28755 this_arg_conv.is_owned = false;
28756 ChannelManager_process_pending_htlc_forwards(&this_arg_conv);
28759 void __attribute__((export_name("TS_ChannelManager_timer_tick_occurred"))) TS_ChannelManager_timer_tick_occurred(uint64_t this_arg) {
28760 LDKChannelManager this_arg_conv;
28761 this_arg_conv.inner = untag_ptr(this_arg);
28762 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28763 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28764 this_arg_conv.is_owned = false;
28765 ChannelManager_timer_tick_occurred(&this_arg_conv);
28768 void __attribute__((export_name("TS_ChannelManager_fail_htlc_backwards"))) TS_ChannelManager_fail_htlc_backwards(uint64_t this_arg, int8_tArray payment_hash) {
28769 LDKChannelManager this_arg_conv;
28770 this_arg_conv.inner = untag_ptr(this_arg);
28771 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28772 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28773 this_arg_conv.is_owned = false;
28774 unsigned char payment_hash_arr[32];
28775 CHECK(payment_hash->arr_len == 32);
28776 memcpy(payment_hash_arr, payment_hash->elems, 32); FREE(payment_hash);
28777 unsigned char (*payment_hash_ref)[32] = &payment_hash_arr;
28778 ChannelManager_fail_htlc_backwards(&this_arg_conv, payment_hash_ref);
28781 void __attribute__((export_name("TS_ChannelManager_claim_funds"))) TS_ChannelManager_claim_funds(uint64_t this_arg, int8_tArray payment_preimage) {
28782 LDKChannelManager this_arg_conv;
28783 this_arg_conv.inner = untag_ptr(this_arg);
28784 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28785 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28786 this_arg_conv.is_owned = false;
28787 LDKThirtyTwoBytes payment_preimage_ref;
28788 CHECK(payment_preimage->arr_len == 32);
28789 memcpy(payment_preimage_ref.data, payment_preimage->elems, 32); FREE(payment_preimage);
28790 ChannelManager_claim_funds(&this_arg_conv, payment_preimage_ref);
28793 int8_tArray __attribute__((export_name("TS_ChannelManager_get_our_node_id"))) TS_ChannelManager_get_our_node_id(uint64_t this_arg) {
28794 LDKChannelManager this_arg_conv;
28795 this_arg_conv.inner = untag_ptr(this_arg);
28796 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28797 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28798 this_arg_conv.is_owned = false;
28799 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
28800 memcpy(ret_arr->elems, ChannelManager_get_our_node_id(&this_arg_conv).compressed_form, 33);
28804 uint64_t __attribute__((export_name("TS_ChannelManager_accept_inbound_channel"))) TS_ChannelManager_accept_inbound_channel(uint64_t this_arg, int8_tArray temporary_channel_id, int8_tArray counterparty_node_id, int8_tArray user_channel_id) {
28805 LDKChannelManager this_arg_conv;
28806 this_arg_conv.inner = untag_ptr(this_arg);
28807 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28808 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28809 this_arg_conv.is_owned = false;
28810 unsigned char temporary_channel_id_arr[32];
28811 CHECK(temporary_channel_id->arr_len == 32);
28812 memcpy(temporary_channel_id_arr, temporary_channel_id->elems, 32); FREE(temporary_channel_id);
28813 unsigned char (*temporary_channel_id_ref)[32] = &temporary_channel_id_arr;
28814 LDKPublicKey counterparty_node_id_ref;
28815 CHECK(counterparty_node_id->arr_len == 33);
28816 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
28817 LDKU128 user_channel_id_ref;
28818 CHECK(user_channel_id->arr_len == 16);
28819 memcpy(user_channel_id_ref.le_bytes, user_channel_id->elems, 16); FREE(user_channel_id);
28820 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
28821 *ret_conv = ChannelManager_accept_inbound_channel(&this_arg_conv, temporary_channel_id_ref, counterparty_node_id_ref, user_channel_id_ref);
28822 return tag_ptr(ret_conv, true);
28825 uint64_t __attribute__((export_name("TS_ChannelManager_accept_inbound_channel_from_trusted_peer_0conf"))) TS_ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(uint64_t this_arg, int8_tArray temporary_channel_id, int8_tArray counterparty_node_id, int8_tArray user_channel_id) {
28826 LDKChannelManager this_arg_conv;
28827 this_arg_conv.inner = untag_ptr(this_arg);
28828 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28829 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28830 this_arg_conv.is_owned = false;
28831 unsigned char temporary_channel_id_arr[32];
28832 CHECK(temporary_channel_id->arr_len == 32);
28833 memcpy(temporary_channel_id_arr, temporary_channel_id->elems, 32); FREE(temporary_channel_id);
28834 unsigned char (*temporary_channel_id_ref)[32] = &temporary_channel_id_arr;
28835 LDKPublicKey counterparty_node_id_ref;
28836 CHECK(counterparty_node_id->arr_len == 33);
28837 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
28838 LDKU128 user_channel_id_ref;
28839 CHECK(user_channel_id->arr_len == 16);
28840 memcpy(user_channel_id_ref.le_bytes, user_channel_id->elems, 16); FREE(user_channel_id);
28841 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
28842 *ret_conv = ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(&this_arg_conv, temporary_channel_id_ref, counterparty_node_id_ref, user_channel_id_ref);
28843 return tag_ptr(ret_conv, true);
28846 uint64_t __attribute__((export_name("TS_ChannelManager_create_inbound_payment"))) TS_ChannelManager_create_inbound_payment(uint64_t this_arg, uint64_t min_value_msat, int32_t invoice_expiry_delta_secs) {
28847 LDKChannelManager this_arg_conv;
28848 this_arg_conv.inner = untag_ptr(this_arg);
28849 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28850 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28851 this_arg_conv.is_owned = false;
28852 void* min_value_msat_ptr = untag_ptr(min_value_msat);
28853 CHECK_ACCESS(min_value_msat_ptr);
28854 LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(min_value_msat_ptr);
28855 min_value_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(min_value_msat));
28856 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ");
28857 *ret_conv = ChannelManager_create_inbound_payment(&this_arg_conv, min_value_msat_conv, invoice_expiry_delta_secs);
28858 return tag_ptr(ret_conv, true);
28861 uint64_t __attribute__((export_name("TS_ChannelManager_create_inbound_payment_legacy"))) TS_ChannelManager_create_inbound_payment_legacy(uint64_t this_arg, uint64_t min_value_msat, int32_t invoice_expiry_delta_secs) {
28862 LDKChannelManager this_arg_conv;
28863 this_arg_conv.inner = untag_ptr(this_arg);
28864 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28865 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28866 this_arg_conv.is_owned = false;
28867 void* min_value_msat_ptr = untag_ptr(min_value_msat);
28868 CHECK_ACCESS(min_value_msat_ptr);
28869 LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(min_value_msat_ptr);
28870 min_value_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(min_value_msat));
28871 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ");
28872 *ret_conv = ChannelManager_create_inbound_payment_legacy(&this_arg_conv, min_value_msat_conv, invoice_expiry_delta_secs);
28873 return tag_ptr(ret_conv, true);
28876 uint64_t __attribute__((export_name("TS_ChannelManager_create_inbound_payment_for_hash"))) TS_ChannelManager_create_inbound_payment_for_hash(uint64_t this_arg, int8_tArray payment_hash, uint64_t min_value_msat, int32_t invoice_expiry_delta_secs) {
28877 LDKChannelManager this_arg_conv;
28878 this_arg_conv.inner = untag_ptr(this_arg);
28879 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28880 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28881 this_arg_conv.is_owned = false;
28882 LDKThirtyTwoBytes payment_hash_ref;
28883 CHECK(payment_hash->arr_len == 32);
28884 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
28885 void* min_value_msat_ptr = untag_ptr(min_value_msat);
28886 CHECK_ACCESS(min_value_msat_ptr);
28887 LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(min_value_msat_ptr);
28888 min_value_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(min_value_msat));
28889 LDKCResult_PaymentSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretNoneZ), "LDKCResult_PaymentSecretNoneZ");
28890 *ret_conv = ChannelManager_create_inbound_payment_for_hash(&this_arg_conv, payment_hash_ref, min_value_msat_conv, invoice_expiry_delta_secs);
28891 return tag_ptr(ret_conv, true);
28894 uint64_t __attribute__((export_name("TS_ChannelManager_create_inbound_payment_for_hash_legacy"))) TS_ChannelManager_create_inbound_payment_for_hash_legacy(uint64_t this_arg, int8_tArray payment_hash, uint64_t min_value_msat, int32_t invoice_expiry_delta_secs) {
28895 LDKChannelManager this_arg_conv;
28896 this_arg_conv.inner = untag_ptr(this_arg);
28897 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28898 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28899 this_arg_conv.is_owned = false;
28900 LDKThirtyTwoBytes payment_hash_ref;
28901 CHECK(payment_hash->arr_len == 32);
28902 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
28903 void* min_value_msat_ptr = untag_ptr(min_value_msat);
28904 CHECK_ACCESS(min_value_msat_ptr);
28905 LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(min_value_msat_ptr);
28906 min_value_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(min_value_msat));
28907 LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
28908 *ret_conv = ChannelManager_create_inbound_payment_for_hash_legacy(&this_arg_conv, payment_hash_ref, min_value_msat_conv, invoice_expiry_delta_secs);
28909 return tag_ptr(ret_conv, true);
28912 uint64_t __attribute__((export_name("TS_ChannelManager_get_payment_preimage"))) TS_ChannelManager_get_payment_preimage(uint64_t this_arg, int8_tArray payment_hash, int8_tArray payment_secret) {
28913 LDKChannelManager this_arg_conv;
28914 this_arg_conv.inner = untag_ptr(this_arg);
28915 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28916 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28917 this_arg_conv.is_owned = false;
28918 LDKThirtyTwoBytes payment_hash_ref;
28919 CHECK(payment_hash->arr_len == 32);
28920 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
28921 LDKThirtyTwoBytes payment_secret_ref;
28922 CHECK(payment_secret->arr_len == 32);
28923 memcpy(payment_secret_ref.data, payment_secret->elems, 32); FREE(payment_secret);
28924 LDKCResult_PaymentPreimageAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPreimageAPIErrorZ), "LDKCResult_PaymentPreimageAPIErrorZ");
28925 *ret_conv = ChannelManager_get_payment_preimage(&this_arg_conv, payment_hash_ref, payment_secret_ref);
28926 return tag_ptr(ret_conv, true);
28929 int64_t __attribute__((export_name("TS_ChannelManager_get_phantom_scid"))) TS_ChannelManager_get_phantom_scid(uint64_t this_arg) {
28930 LDKChannelManager this_arg_conv;
28931 this_arg_conv.inner = untag_ptr(this_arg);
28932 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28933 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28934 this_arg_conv.is_owned = false;
28935 int64_t ret_conv = ChannelManager_get_phantom_scid(&this_arg_conv);
28939 uint64_t __attribute__((export_name("TS_ChannelManager_get_phantom_route_hints"))) TS_ChannelManager_get_phantom_route_hints(uint64_t this_arg) {
28940 LDKChannelManager this_arg_conv;
28941 this_arg_conv.inner = untag_ptr(this_arg);
28942 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28943 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28944 this_arg_conv.is_owned = false;
28945 LDKPhantomRouteHints ret_var = ChannelManager_get_phantom_route_hints(&this_arg_conv);
28946 uint64_t ret_ref = 0;
28947 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28948 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
28952 int64_t __attribute__((export_name("TS_ChannelManager_get_intercept_scid"))) TS_ChannelManager_get_intercept_scid(uint64_t this_arg) {
28953 LDKChannelManager this_arg_conv;
28954 this_arg_conv.inner = untag_ptr(this_arg);
28955 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28956 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28957 this_arg_conv.is_owned = false;
28958 int64_t ret_conv = ChannelManager_get_intercept_scid(&this_arg_conv);
28962 uint64_t __attribute__((export_name("TS_ChannelManager_compute_inflight_htlcs"))) TS_ChannelManager_compute_inflight_htlcs(uint64_t this_arg) {
28963 LDKChannelManager this_arg_conv;
28964 this_arg_conv.inner = untag_ptr(this_arg);
28965 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28966 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28967 this_arg_conv.is_owned = false;
28968 LDKInFlightHtlcs ret_var = ChannelManager_compute_inflight_htlcs(&this_arg_conv);
28969 uint64_t ret_ref = 0;
28970 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28971 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
28975 uint64_t __attribute__((export_name("TS_ChannelManager_as_MessageSendEventsProvider"))) TS_ChannelManager_as_MessageSendEventsProvider(uint64_t this_arg) {
28976 LDKChannelManager this_arg_conv;
28977 this_arg_conv.inner = untag_ptr(this_arg);
28978 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28979 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28980 this_arg_conv.is_owned = false;
28981 LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
28982 *ret_ret = ChannelManager_as_MessageSendEventsProvider(&this_arg_conv);
28983 return tag_ptr(ret_ret, true);
28986 uint64_t __attribute__((export_name("TS_ChannelManager_as_EventsProvider"))) TS_ChannelManager_as_EventsProvider(uint64_t this_arg) {
28987 LDKChannelManager this_arg_conv;
28988 this_arg_conv.inner = untag_ptr(this_arg);
28989 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28990 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28991 this_arg_conv.is_owned = false;
28992 LDKEventsProvider* ret_ret = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider");
28993 *ret_ret = ChannelManager_as_EventsProvider(&this_arg_conv);
28994 return tag_ptr(ret_ret, true);
28997 uint64_t __attribute__((export_name("TS_ChannelManager_as_Listen"))) TS_ChannelManager_as_Listen(uint64_t this_arg) {
28998 LDKChannelManager this_arg_conv;
28999 this_arg_conv.inner = untag_ptr(this_arg);
29000 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29001 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29002 this_arg_conv.is_owned = false;
29003 LDKListen* ret_ret = MALLOC(sizeof(LDKListen), "LDKListen");
29004 *ret_ret = ChannelManager_as_Listen(&this_arg_conv);
29005 return tag_ptr(ret_ret, true);
29008 uint64_t __attribute__((export_name("TS_ChannelManager_as_Confirm"))) TS_ChannelManager_as_Confirm(uint64_t this_arg) {
29009 LDKChannelManager this_arg_conv;
29010 this_arg_conv.inner = untag_ptr(this_arg);
29011 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29012 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29013 this_arg_conv.is_owned = false;
29014 LDKConfirm* ret_ret = MALLOC(sizeof(LDKConfirm), "LDKConfirm");
29015 *ret_ret = ChannelManager_as_Confirm(&this_arg_conv);
29016 return tag_ptr(ret_ret, true);
29019 void __attribute__((export_name("TS_ChannelManager_await_persistable_update"))) TS_ChannelManager_await_persistable_update(uint64_t this_arg) {
29020 LDKChannelManager this_arg_conv;
29021 this_arg_conv.inner = untag_ptr(this_arg);
29022 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29023 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29024 this_arg_conv.is_owned = false;
29025 ChannelManager_await_persistable_update(&this_arg_conv);
29028 uint64_t __attribute__((export_name("TS_ChannelManager_get_persistable_update_future"))) TS_ChannelManager_get_persistable_update_future(uint64_t this_arg) {
29029 LDKChannelManager this_arg_conv;
29030 this_arg_conv.inner = untag_ptr(this_arg);
29031 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29032 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29033 this_arg_conv.is_owned = false;
29034 LDKFuture ret_var = ChannelManager_get_persistable_update_future(&this_arg_conv);
29035 uint64_t ret_ref = 0;
29036 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29037 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29041 uint64_t __attribute__((export_name("TS_ChannelManager_current_best_block"))) TS_ChannelManager_current_best_block(uint64_t this_arg) {
29042 LDKChannelManager this_arg_conv;
29043 this_arg_conv.inner = untag_ptr(this_arg);
29044 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29045 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29046 this_arg_conv.is_owned = false;
29047 LDKBestBlock ret_var = ChannelManager_current_best_block(&this_arg_conv);
29048 uint64_t ret_ref = 0;
29049 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29050 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29054 uint64_t __attribute__((export_name("TS_ChannelManager_as_ChannelMessageHandler"))) TS_ChannelManager_as_ChannelMessageHandler(uint64_t this_arg) {
29055 LDKChannelManager this_arg_conv;
29056 this_arg_conv.inner = untag_ptr(this_arg);
29057 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29058 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29059 this_arg_conv.is_owned = false;
29060 LDKChannelMessageHandler* ret_ret = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
29061 *ret_ret = ChannelManager_as_ChannelMessageHandler(&this_arg_conv);
29062 return tag_ptr(ret_ret, true);
29065 uint64_t __attribute__((export_name("TS_provided_node_features"))) TS_provided_node_features() {
29066 LDKNodeFeatures ret_var = provided_node_features();
29067 uint64_t ret_ref = 0;
29068 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29069 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29073 uint64_t __attribute__((export_name("TS_provided_channel_features"))) TS_provided_channel_features() {
29074 LDKChannelFeatures ret_var = provided_channel_features();
29075 uint64_t ret_ref = 0;
29076 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29077 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29081 uint64_t __attribute__((export_name("TS_provided_init_features"))) TS_provided_init_features() {
29082 LDKInitFeatures ret_var = provided_init_features();
29083 uint64_t ret_ref = 0;
29084 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29085 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29089 int8_tArray __attribute__((export_name("TS_CounterpartyForwardingInfo_write"))) TS_CounterpartyForwardingInfo_write(uint64_t obj) {
29090 LDKCounterpartyForwardingInfo obj_conv;
29091 obj_conv.inner = untag_ptr(obj);
29092 obj_conv.is_owned = ptr_is_owned(obj);
29093 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
29094 obj_conv.is_owned = false;
29095 LDKCVec_u8Z ret_var = CounterpartyForwardingInfo_write(&obj_conv);
29096 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
29097 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
29098 CVec_u8Z_free(ret_var);
29102 uint64_t __attribute__((export_name("TS_CounterpartyForwardingInfo_read"))) TS_CounterpartyForwardingInfo_read(int8_tArray ser) {
29103 LDKu8slice ser_ref;
29104 ser_ref.datalen = ser->arr_len;
29105 ser_ref.data = ser->elems;
29106 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ), "LDKCResult_CounterpartyForwardingInfoDecodeErrorZ");
29107 *ret_conv = CounterpartyForwardingInfo_read(ser_ref);
29109 return tag_ptr(ret_conv, true);
29112 int8_tArray __attribute__((export_name("TS_ChannelCounterparty_write"))) TS_ChannelCounterparty_write(uint64_t obj) {
29113 LDKChannelCounterparty obj_conv;
29114 obj_conv.inner = untag_ptr(obj);
29115 obj_conv.is_owned = ptr_is_owned(obj);
29116 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
29117 obj_conv.is_owned = false;
29118 LDKCVec_u8Z ret_var = ChannelCounterparty_write(&obj_conv);
29119 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
29120 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
29121 CVec_u8Z_free(ret_var);
29125 uint64_t __attribute__((export_name("TS_ChannelCounterparty_read"))) TS_ChannelCounterparty_read(int8_tArray ser) {
29126 LDKu8slice ser_ref;
29127 ser_ref.datalen = ser->arr_len;
29128 ser_ref.data = ser->elems;
29129 LDKCResult_ChannelCounterpartyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ), "LDKCResult_ChannelCounterpartyDecodeErrorZ");
29130 *ret_conv = ChannelCounterparty_read(ser_ref);
29132 return tag_ptr(ret_conv, true);
29135 int8_tArray __attribute__((export_name("TS_ChannelDetails_write"))) TS_ChannelDetails_write(uint64_t obj) {
29136 LDKChannelDetails obj_conv;
29137 obj_conv.inner = untag_ptr(obj);
29138 obj_conv.is_owned = ptr_is_owned(obj);
29139 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
29140 obj_conv.is_owned = false;
29141 LDKCVec_u8Z ret_var = ChannelDetails_write(&obj_conv);
29142 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
29143 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
29144 CVec_u8Z_free(ret_var);
29148 uint64_t __attribute__((export_name("TS_ChannelDetails_read"))) TS_ChannelDetails_read(int8_tArray ser) {
29149 LDKu8slice ser_ref;
29150 ser_ref.datalen = ser->arr_len;
29151 ser_ref.data = ser->elems;
29152 LDKCResult_ChannelDetailsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelDetailsDecodeErrorZ), "LDKCResult_ChannelDetailsDecodeErrorZ");
29153 *ret_conv = ChannelDetails_read(ser_ref);
29155 return tag_ptr(ret_conv, true);
29158 int8_tArray __attribute__((export_name("TS_PhantomRouteHints_write"))) TS_PhantomRouteHints_write(uint64_t obj) {
29159 LDKPhantomRouteHints obj_conv;
29160 obj_conv.inner = untag_ptr(obj);
29161 obj_conv.is_owned = ptr_is_owned(obj);
29162 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
29163 obj_conv.is_owned = false;
29164 LDKCVec_u8Z ret_var = PhantomRouteHints_write(&obj_conv);
29165 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
29166 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
29167 CVec_u8Z_free(ret_var);
29171 uint64_t __attribute__((export_name("TS_PhantomRouteHints_read"))) TS_PhantomRouteHints_read(int8_tArray ser) {
29172 LDKu8slice ser_ref;
29173 ser_ref.datalen = ser->arr_len;
29174 ser_ref.data = ser->elems;
29175 LDKCResult_PhantomRouteHintsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ), "LDKCResult_PhantomRouteHintsDecodeErrorZ");
29176 *ret_conv = PhantomRouteHints_read(ser_ref);
29178 return tag_ptr(ret_conv, true);
29181 int8_tArray __attribute__((export_name("TS_ChannelManager_write"))) TS_ChannelManager_write(uint64_t obj) {
29182 LDKChannelManager obj_conv;
29183 obj_conv.inner = untag_ptr(obj);
29184 obj_conv.is_owned = ptr_is_owned(obj);
29185 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
29186 obj_conv.is_owned = false;
29187 LDKCVec_u8Z ret_var = ChannelManager_write(&obj_conv);
29188 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
29189 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
29190 CVec_u8Z_free(ret_var);
29194 void __attribute__((export_name("TS_ChannelManagerReadArgs_free"))) TS_ChannelManagerReadArgs_free(uint64_t this_obj) {
29195 LDKChannelManagerReadArgs this_obj_conv;
29196 this_obj_conv.inner = untag_ptr(this_obj);
29197 this_obj_conv.is_owned = ptr_is_owned(this_obj);
29198 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
29199 ChannelManagerReadArgs_free(this_obj_conv);
29202 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_keys_manager"))) TS_ChannelManagerReadArgs_get_keys_manager(uint64_t this_ptr) {
29203 LDKChannelManagerReadArgs this_ptr_conv;
29204 this_ptr_conv.inner = untag_ptr(this_ptr);
29205 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29206 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29207 this_ptr_conv.is_owned = false;
29208 // WARNING: This object doesn't live past this scope, needs clone!
29209 uint64_t ret_ret = tag_ptr(ChannelManagerReadArgs_get_keys_manager(&this_ptr_conv), false);
29213 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_keys_manager"))) TS_ChannelManagerReadArgs_set_keys_manager(uint64_t this_ptr, uint64_t val) {
29214 LDKChannelManagerReadArgs this_ptr_conv;
29215 this_ptr_conv.inner = untag_ptr(this_ptr);
29216 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29217 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29218 this_ptr_conv.is_owned = false;
29219 void* val_ptr = untag_ptr(val);
29220 CHECK_ACCESS(val_ptr);
29221 LDKKeysInterface val_conv = *(LDKKeysInterface*)(val_ptr);
29222 if (val_conv.free == LDKKeysInterface_JCalls_free) {
29223 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29224 LDKKeysInterface_JCalls_cloned(&val_conv);
29226 ChannelManagerReadArgs_set_keys_manager(&this_ptr_conv, val_conv);
29229 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_fee_estimator"))) TS_ChannelManagerReadArgs_get_fee_estimator(uint64_t this_ptr) {
29230 LDKChannelManagerReadArgs this_ptr_conv;
29231 this_ptr_conv.inner = untag_ptr(this_ptr);
29232 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29233 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29234 this_ptr_conv.is_owned = false;
29235 // WARNING: This object doesn't live past this scope, needs clone!
29236 uint64_t ret_ret = tag_ptr(ChannelManagerReadArgs_get_fee_estimator(&this_ptr_conv), false);
29240 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_fee_estimator"))) TS_ChannelManagerReadArgs_set_fee_estimator(uint64_t this_ptr, uint64_t val) {
29241 LDKChannelManagerReadArgs this_ptr_conv;
29242 this_ptr_conv.inner = untag_ptr(this_ptr);
29243 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29244 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29245 this_ptr_conv.is_owned = false;
29246 void* val_ptr = untag_ptr(val);
29247 CHECK_ACCESS(val_ptr);
29248 LDKFeeEstimator val_conv = *(LDKFeeEstimator*)(val_ptr);
29249 if (val_conv.free == LDKFeeEstimator_JCalls_free) {
29250 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29251 LDKFeeEstimator_JCalls_cloned(&val_conv);
29253 ChannelManagerReadArgs_set_fee_estimator(&this_ptr_conv, val_conv);
29256 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_chain_monitor"))) TS_ChannelManagerReadArgs_get_chain_monitor(uint64_t this_ptr) {
29257 LDKChannelManagerReadArgs this_ptr_conv;
29258 this_ptr_conv.inner = untag_ptr(this_ptr);
29259 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29260 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29261 this_ptr_conv.is_owned = false;
29262 // WARNING: This object doesn't live past this scope, needs clone!
29263 uint64_t ret_ret = tag_ptr(ChannelManagerReadArgs_get_chain_monitor(&this_ptr_conv), false);
29267 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_chain_monitor"))) TS_ChannelManagerReadArgs_set_chain_monitor(uint64_t this_ptr, uint64_t val) {
29268 LDKChannelManagerReadArgs this_ptr_conv;
29269 this_ptr_conv.inner = untag_ptr(this_ptr);
29270 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29271 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29272 this_ptr_conv.is_owned = false;
29273 void* val_ptr = untag_ptr(val);
29274 CHECK_ACCESS(val_ptr);
29275 LDKWatch val_conv = *(LDKWatch*)(val_ptr);
29276 if (val_conv.free == LDKWatch_JCalls_free) {
29277 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29278 LDKWatch_JCalls_cloned(&val_conv);
29280 ChannelManagerReadArgs_set_chain_monitor(&this_ptr_conv, val_conv);
29283 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_tx_broadcaster"))) TS_ChannelManagerReadArgs_get_tx_broadcaster(uint64_t this_ptr) {
29284 LDKChannelManagerReadArgs this_ptr_conv;
29285 this_ptr_conv.inner = untag_ptr(this_ptr);
29286 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29287 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29288 this_ptr_conv.is_owned = false;
29289 // WARNING: This object doesn't live past this scope, needs clone!
29290 uint64_t ret_ret = tag_ptr(ChannelManagerReadArgs_get_tx_broadcaster(&this_ptr_conv), false);
29294 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_tx_broadcaster"))) TS_ChannelManagerReadArgs_set_tx_broadcaster(uint64_t this_ptr, uint64_t val) {
29295 LDKChannelManagerReadArgs this_ptr_conv;
29296 this_ptr_conv.inner = untag_ptr(this_ptr);
29297 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29298 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29299 this_ptr_conv.is_owned = false;
29300 void* val_ptr = untag_ptr(val);
29301 CHECK_ACCESS(val_ptr);
29302 LDKBroadcasterInterface val_conv = *(LDKBroadcasterInterface*)(val_ptr);
29303 if (val_conv.free == LDKBroadcasterInterface_JCalls_free) {
29304 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29305 LDKBroadcasterInterface_JCalls_cloned(&val_conv);
29307 ChannelManagerReadArgs_set_tx_broadcaster(&this_ptr_conv, val_conv);
29310 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_logger"))) TS_ChannelManagerReadArgs_get_logger(uint64_t this_ptr) {
29311 LDKChannelManagerReadArgs this_ptr_conv;
29312 this_ptr_conv.inner = untag_ptr(this_ptr);
29313 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29314 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29315 this_ptr_conv.is_owned = false;
29316 // WARNING: This object doesn't live past this scope, needs clone!
29317 uint64_t ret_ret = tag_ptr(ChannelManagerReadArgs_get_logger(&this_ptr_conv), false);
29321 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_logger"))) TS_ChannelManagerReadArgs_set_logger(uint64_t this_ptr, uint64_t val) {
29322 LDKChannelManagerReadArgs this_ptr_conv;
29323 this_ptr_conv.inner = untag_ptr(this_ptr);
29324 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29325 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29326 this_ptr_conv.is_owned = false;
29327 void* val_ptr = untag_ptr(val);
29328 CHECK_ACCESS(val_ptr);
29329 LDKLogger val_conv = *(LDKLogger*)(val_ptr);
29330 if (val_conv.free == LDKLogger_JCalls_free) {
29331 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29332 LDKLogger_JCalls_cloned(&val_conv);
29334 ChannelManagerReadArgs_set_logger(&this_ptr_conv, val_conv);
29337 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_default_config"))) TS_ChannelManagerReadArgs_get_default_config(uint64_t this_ptr) {
29338 LDKChannelManagerReadArgs this_ptr_conv;
29339 this_ptr_conv.inner = untag_ptr(this_ptr);
29340 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29341 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29342 this_ptr_conv.is_owned = false;
29343 LDKUserConfig ret_var = ChannelManagerReadArgs_get_default_config(&this_ptr_conv);
29344 uint64_t ret_ref = 0;
29345 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29346 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29350 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_default_config"))) TS_ChannelManagerReadArgs_set_default_config(uint64_t this_ptr, uint64_t val) {
29351 LDKChannelManagerReadArgs this_ptr_conv;
29352 this_ptr_conv.inner = untag_ptr(this_ptr);
29353 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29354 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29355 this_ptr_conv.is_owned = false;
29356 LDKUserConfig val_conv;
29357 val_conv.inner = untag_ptr(val);
29358 val_conv.is_owned = ptr_is_owned(val);
29359 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
29360 val_conv = UserConfig_clone(&val_conv);
29361 ChannelManagerReadArgs_set_default_config(&this_ptr_conv, val_conv);
29364 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_new"))) TS_ChannelManagerReadArgs_new(uint64_t keys_manager, uint64_t fee_estimator, uint64_t chain_monitor, uint64_t tx_broadcaster, uint64_t logger, uint64_t default_config, uint64_tArray channel_monitors) {
29365 void* keys_manager_ptr = untag_ptr(keys_manager);
29366 CHECK_ACCESS(keys_manager_ptr);
29367 LDKKeysInterface keys_manager_conv = *(LDKKeysInterface*)(keys_manager_ptr);
29368 if (keys_manager_conv.free == LDKKeysInterface_JCalls_free) {
29369 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29370 LDKKeysInterface_JCalls_cloned(&keys_manager_conv);
29372 void* fee_estimator_ptr = untag_ptr(fee_estimator);
29373 CHECK_ACCESS(fee_estimator_ptr);
29374 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
29375 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
29376 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29377 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
29379 void* chain_monitor_ptr = untag_ptr(chain_monitor);
29380 CHECK_ACCESS(chain_monitor_ptr);
29381 LDKWatch chain_monitor_conv = *(LDKWatch*)(chain_monitor_ptr);
29382 if (chain_monitor_conv.free == LDKWatch_JCalls_free) {
29383 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29384 LDKWatch_JCalls_cloned(&chain_monitor_conv);
29386 void* tx_broadcaster_ptr = untag_ptr(tx_broadcaster);
29387 CHECK_ACCESS(tx_broadcaster_ptr);
29388 LDKBroadcasterInterface tx_broadcaster_conv = *(LDKBroadcasterInterface*)(tx_broadcaster_ptr);
29389 if (tx_broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
29390 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29391 LDKBroadcasterInterface_JCalls_cloned(&tx_broadcaster_conv);
29393 void* logger_ptr = untag_ptr(logger);
29394 CHECK_ACCESS(logger_ptr);
29395 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
29396 if (logger_conv.free == LDKLogger_JCalls_free) {
29397 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29398 LDKLogger_JCalls_cloned(&logger_conv);
29400 LDKUserConfig default_config_conv;
29401 default_config_conv.inner = untag_ptr(default_config);
29402 default_config_conv.is_owned = ptr_is_owned(default_config);
29403 CHECK_INNER_FIELD_ACCESS_OR_NULL(default_config_conv);
29404 default_config_conv = UserConfig_clone(&default_config_conv);
29405 LDKCVec_ChannelMonitorZ channel_monitors_constr;
29406 channel_monitors_constr.datalen = channel_monitors->arr_len;
29407 if (channel_monitors_constr.datalen > 0)
29408 channel_monitors_constr.data = MALLOC(channel_monitors_constr.datalen * sizeof(LDKChannelMonitor), "LDKCVec_ChannelMonitorZ Elements");
29410 channel_monitors_constr.data = NULL;
29411 uint64_t* channel_monitors_vals = channel_monitors->elems;
29412 for (size_t q = 0; q < channel_monitors_constr.datalen; q++) {
29413 uint64_t channel_monitors_conv_16 = channel_monitors_vals[q];
29414 LDKChannelMonitor channel_monitors_conv_16_conv;
29415 channel_monitors_conv_16_conv.inner = untag_ptr(channel_monitors_conv_16);
29416 channel_monitors_conv_16_conv.is_owned = ptr_is_owned(channel_monitors_conv_16);
29417 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_monitors_conv_16_conv);
29418 channel_monitors_conv_16_conv.is_owned = false;
29419 channel_monitors_constr.data[q] = channel_monitors_conv_16_conv;
29421 FREE(channel_monitors);
29422 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);
29423 uint64_t ret_ref = 0;
29424 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29425 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29429 uint64_t __attribute__((export_name("TS_C2Tuple_BlockHashChannelManagerZ_read"))) TS_C2Tuple_BlockHashChannelManagerZ_read(int8_tArray ser, uint64_t arg) {
29430 LDKu8slice ser_ref;
29431 ser_ref.datalen = ser->arr_len;
29432 ser_ref.data = ser->elems;
29433 LDKChannelManagerReadArgs arg_conv;
29434 arg_conv.inner = untag_ptr(arg);
29435 arg_conv.is_owned = ptr_is_owned(arg);
29436 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
29437 // WARNING: we need a move here but no clone is available for LDKChannelManagerReadArgs
29439 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ");
29440 *ret_conv = C2Tuple_BlockHashChannelManagerZ_read(ser_ref, arg_conv);
29442 return tag_ptr(ret_conv, true);
29445 void __attribute__((export_name("TS_ExpandedKey_free"))) TS_ExpandedKey_free(uint64_t this_obj) {
29446 LDKExpandedKey this_obj_conv;
29447 this_obj_conv.inner = untag_ptr(this_obj);
29448 this_obj_conv.is_owned = ptr_is_owned(this_obj);
29449 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
29450 ExpandedKey_free(this_obj_conv);
29453 uint64_t __attribute__((export_name("TS_ExpandedKey_new"))) TS_ExpandedKey_new(int8_tArray key_material) {
29454 unsigned char key_material_arr[32];
29455 CHECK(key_material->arr_len == 32);
29456 memcpy(key_material_arr, key_material->elems, 32); FREE(key_material);
29457 unsigned char (*key_material_ref)[32] = &key_material_arr;
29458 LDKExpandedKey ret_var = ExpandedKey_new(key_material_ref);
29459 uint64_t ret_ref = 0;
29460 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29461 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29465 uint64_t __attribute__((export_name("TS_create"))) TS_create(uint64_t keys, uint64_t min_value_msat, int32_t invoice_expiry_delta_secs, uint64_t keys_manager, int64_t current_time) {
29466 LDKExpandedKey keys_conv;
29467 keys_conv.inner = untag_ptr(keys);
29468 keys_conv.is_owned = ptr_is_owned(keys);
29469 CHECK_INNER_FIELD_ACCESS_OR_NULL(keys_conv);
29470 keys_conv.is_owned = false;
29471 void* min_value_msat_ptr = untag_ptr(min_value_msat);
29472 CHECK_ACCESS(min_value_msat_ptr);
29473 LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(min_value_msat_ptr);
29474 min_value_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(min_value_msat));
29475 void* keys_manager_ptr = untag_ptr(keys_manager);
29476 if (ptr_is_owned(keys_manager)) { CHECK_ACCESS(keys_manager_ptr); }
29477 LDKKeysInterface* keys_manager_conv = (LDKKeysInterface*)keys_manager_ptr;
29478 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ");
29479 *ret_conv = create(&keys_conv, min_value_msat_conv, invoice_expiry_delta_secs, keys_manager_conv, current_time);
29480 return tag_ptr(ret_conv, true);
29483 uint64_t __attribute__((export_name("TS_create_from_hash"))) TS_create_from_hash(uint64_t keys, uint64_t min_value_msat, int8_tArray payment_hash, int32_t invoice_expiry_delta_secs, int64_t current_time) {
29484 LDKExpandedKey keys_conv;
29485 keys_conv.inner = untag_ptr(keys);
29486 keys_conv.is_owned = ptr_is_owned(keys);
29487 CHECK_INNER_FIELD_ACCESS_OR_NULL(keys_conv);
29488 keys_conv.is_owned = false;
29489 void* min_value_msat_ptr = untag_ptr(min_value_msat);
29490 CHECK_ACCESS(min_value_msat_ptr);
29491 LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(min_value_msat_ptr);
29492 min_value_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(min_value_msat));
29493 LDKThirtyTwoBytes payment_hash_ref;
29494 CHECK(payment_hash->arr_len == 32);
29495 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
29496 LDKCResult_PaymentSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretNoneZ), "LDKCResult_PaymentSecretNoneZ");
29497 *ret_conv = create_from_hash(&keys_conv, min_value_msat_conv, payment_hash_ref, invoice_expiry_delta_secs, current_time);
29498 return tag_ptr(ret_conv, true);
29501 void __attribute__((export_name("TS_DecodeError_free"))) TS_DecodeError_free(uint64_t this_ptr) {
29502 if (!ptr_is_owned(this_ptr)) return;
29503 void* this_ptr_ptr = untag_ptr(this_ptr);
29504 CHECK_ACCESS(this_ptr_ptr);
29505 LDKDecodeError this_ptr_conv = *(LDKDecodeError*)(this_ptr_ptr);
29506 FREE(untag_ptr(this_ptr));
29507 DecodeError_free(this_ptr_conv);
29510 static inline uint64_t DecodeError_clone_ptr(LDKDecodeError *NONNULL_PTR arg) {
29511 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
29512 *ret_copy = DecodeError_clone(arg);
29513 uint64_t ret_ref = tag_ptr(ret_copy, true);
29516 int64_t __attribute__((export_name("TS_DecodeError_clone_ptr"))) TS_DecodeError_clone_ptr(uint64_t arg) {
29517 LDKDecodeError* arg_conv = (LDKDecodeError*)untag_ptr(arg);
29518 int64_t ret_conv = DecodeError_clone_ptr(arg_conv);
29522 uint64_t __attribute__((export_name("TS_DecodeError_clone"))) TS_DecodeError_clone(uint64_t orig) {
29523 LDKDecodeError* orig_conv = (LDKDecodeError*)untag_ptr(orig);
29524 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
29525 *ret_copy = DecodeError_clone(orig_conv);
29526 uint64_t ret_ref = tag_ptr(ret_copy, true);
29530 uint64_t __attribute__((export_name("TS_DecodeError_unknown_version"))) TS_DecodeError_unknown_version() {
29531 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
29532 *ret_copy = DecodeError_unknown_version();
29533 uint64_t ret_ref = tag_ptr(ret_copy, true);
29537 uint64_t __attribute__((export_name("TS_DecodeError_unknown_required_feature"))) TS_DecodeError_unknown_required_feature() {
29538 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
29539 *ret_copy = DecodeError_unknown_required_feature();
29540 uint64_t ret_ref = tag_ptr(ret_copy, true);
29544 uint64_t __attribute__((export_name("TS_DecodeError_invalid_value"))) TS_DecodeError_invalid_value() {
29545 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
29546 *ret_copy = DecodeError_invalid_value();
29547 uint64_t ret_ref = tag_ptr(ret_copy, true);
29551 uint64_t __attribute__((export_name("TS_DecodeError_short_read"))) TS_DecodeError_short_read() {
29552 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
29553 *ret_copy = DecodeError_short_read();
29554 uint64_t ret_ref = tag_ptr(ret_copy, true);
29558 uint64_t __attribute__((export_name("TS_DecodeError_bad_length_descriptor"))) TS_DecodeError_bad_length_descriptor() {
29559 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
29560 *ret_copy = DecodeError_bad_length_descriptor();
29561 uint64_t ret_ref = tag_ptr(ret_copy, true);
29565 uint64_t __attribute__((export_name("TS_DecodeError_io"))) TS_DecodeError_io(uint32_t a) {
29566 LDKIOError a_conv = LDKIOError_from_js(a);
29567 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
29568 *ret_copy = DecodeError_io(a_conv);
29569 uint64_t ret_ref = tag_ptr(ret_copy, true);
29573 uint64_t __attribute__((export_name("TS_DecodeError_unsupported_compression"))) TS_DecodeError_unsupported_compression() {
29574 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
29575 *ret_copy = DecodeError_unsupported_compression();
29576 uint64_t ret_ref = tag_ptr(ret_copy, true);
29580 jboolean __attribute__((export_name("TS_DecodeError_eq"))) TS_DecodeError_eq(uint64_t a, uint64_t b) {
29581 LDKDecodeError* a_conv = (LDKDecodeError*)untag_ptr(a);
29582 LDKDecodeError* b_conv = (LDKDecodeError*)untag_ptr(b);
29583 jboolean ret_conv = DecodeError_eq(a_conv, b_conv);
29587 void __attribute__((export_name("TS_Init_free"))) TS_Init_free(uint64_t this_obj) {
29588 LDKInit this_obj_conv;
29589 this_obj_conv.inner = untag_ptr(this_obj);
29590 this_obj_conv.is_owned = ptr_is_owned(this_obj);
29591 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
29592 Init_free(this_obj_conv);
29595 uint64_t __attribute__((export_name("TS_Init_get_features"))) TS_Init_get_features(uint64_t this_ptr) {
29596 LDKInit this_ptr_conv;
29597 this_ptr_conv.inner = untag_ptr(this_ptr);
29598 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29599 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29600 this_ptr_conv.is_owned = false;
29601 LDKInitFeatures ret_var = Init_get_features(&this_ptr_conv);
29602 uint64_t ret_ref = 0;
29603 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29604 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29608 void __attribute__((export_name("TS_Init_set_features"))) TS_Init_set_features(uint64_t this_ptr, uint64_t val) {
29609 LDKInit this_ptr_conv;
29610 this_ptr_conv.inner = untag_ptr(this_ptr);
29611 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29612 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29613 this_ptr_conv.is_owned = false;
29614 LDKInitFeatures val_conv;
29615 val_conv.inner = untag_ptr(val);
29616 val_conv.is_owned = ptr_is_owned(val);
29617 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
29618 val_conv = InitFeatures_clone(&val_conv);
29619 Init_set_features(&this_ptr_conv, val_conv);
29622 uint64_t __attribute__((export_name("TS_Init_get_remote_network_address"))) TS_Init_get_remote_network_address(uint64_t this_ptr) {
29623 LDKInit this_ptr_conv;
29624 this_ptr_conv.inner = untag_ptr(this_ptr);
29625 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29626 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29627 this_ptr_conv.is_owned = false;
29628 LDKCOption_NetAddressZ *ret_copy = MALLOC(sizeof(LDKCOption_NetAddressZ), "LDKCOption_NetAddressZ");
29629 *ret_copy = Init_get_remote_network_address(&this_ptr_conv);
29630 uint64_t ret_ref = tag_ptr(ret_copy, true);
29634 void __attribute__((export_name("TS_Init_set_remote_network_address"))) TS_Init_set_remote_network_address(uint64_t this_ptr, uint64_t val) {
29635 LDKInit this_ptr_conv;
29636 this_ptr_conv.inner = untag_ptr(this_ptr);
29637 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29638 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29639 this_ptr_conv.is_owned = false;
29640 void* val_ptr = untag_ptr(val);
29641 CHECK_ACCESS(val_ptr);
29642 LDKCOption_NetAddressZ val_conv = *(LDKCOption_NetAddressZ*)(val_ptr);
29643 val_conv = COption_NetAddressZ_clone((LDKCOption_NetAddressZ*)untag_ptr(val));
29644 Init_set_remote_network_address(&this_ptr_conv, val_conv);
29647 uint64_t __attribute__((export_name("TS_Init_new"))) TS_Init_new(uint64_t features_arg, uint64_t remote_network_address_arg) {
29648 LDKInitFeatures features_arg_conv;
29649 features_arg_conv.inner = untag_ptr(features_arg);
29650 features_arg_conv.is_owned = ptr_is_owned(features_arg);
29651 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
29652 features_arg_conv = InitFeatures_clone(&features_arg_conv);
29653 void* remote_network_address_arg_ptr = untag_ptr(remote_network_address_arg);
29654 CHECK_ACCESS(remote_network_address_arg_ptr);
29655 LDKCOption_NetAddressZ remote_network_address_arg_conv = *(LDKCOption_NetAddressZ*)(remote_network_address_arg_ptr);
29656 LDKInit ret_var = Init_new(features_arg_conv, remote_network_address_arg_conv);
29657 uint64_t ret_ref = 0;
29658 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29659 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29663 static inline uint64_t Init_clone_ptr(LDKInit *NONNULL_PTR arg) {
29664 LDKInit ret_var = Init_clone(arg);
29665 uint64_t ret_ref = 0;
29666 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29667 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29670 int64_t __attribute__((export_name("TS_Init_clone_ptr"))) TS_Init_clone_ptr(uint64_t arg) {
29672 arg_conv.inner = untag_ptr(arg);
29673 arg_conv.is_owned = ptr_is_owned(arg);
29674 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
29675 arg_conv.is_owned = false;
29676 int64_t ret_conv = Init_clone_ptr(&arg_conv);
29680 uint64_t __attribute__((export_name("TS_Init_clone"))) TS_Init_clone(uint64_t orig) {
29682 orig_conv.inner = untag_ptr(orig);
29683 orig_conv.is_owned = ptr_is_owned(orig);
29684 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
29685 orig_conv.is_owned = false;
29686 LDKInit ret_var = Init_clone(&orig_conv);
29687 uint64_t ret_ref = 0;
29688 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29689 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29693 jboolean __attribute__((export_name("TS_Init_eq"))) TS_Init_eq(uint64_t a, uint64_t b) {
29695 a_conv.inner = untag_ptr(a);
29696 a_conv.is_owned = ptr_is_owned(a);
29697 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
29698 a_conv.is_owned = false;
29700 b_conv.inner = untag_ptr(b);
29701 b_conv.is_owned = ptr_is_owned(b);
29702 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
29703 b_conv.is_owned = false;
29704 jboolean ret_conv = Init_eq(&a_conv, &b_conv);
29708 void __attribute__((export_name("TS_ErrorMessage_free"))) TS_ErrorMessage_free(uint64_t this_obj) {
29709 LDKErrorMessage this_obj_conv;
29710 this_obj_conv.inner = untag_ptr(this_obj);
29711 this_obj_conv.is_owned = ptr_is_owned(this_obj);
29712 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
29713 ErrorMessage_free(this_obj_conv);
29716 int8_tArray __attribute__((export_name("TS_ErrorMessage_get_channel_id"))) TS_ErrorMessage_get_channel_id(uint64_t this_ptr) {
29717 LDKErrorMessage this_ptr_conv;
29718 this_ptr_conv.inner = untag_ptr(this_ptr);
29719 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29720 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29721 this_ptr_conv.is_owned = false;
29722 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
29723 memcpy(ret_arr->elems, *ErrorMessage_get_channel_id(&this_ptr_conv), 32);
29727 void __attribute__((export_name("TS_ErrorMessage_set_channel_id"))) TS_ErrorMessage_set_channel_id(uint64_t this_ptr, int8_tArray val) {
29728 LDKErrorMessage this_ptr_conv;
29729 this_ptr_conv.inner = untag_ptr(this_ptr);
29730 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29731 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29732 this_ptr_conv.is_owned = false;
29733 LDKThirtyTwoBytes val_ref;
29734 CHECK(val->arr_len == 32);
29735 memcpy(val_ref.data, val->elems, 32); FREE(val);
29736 ErrorMessage_set_channel_id(&this_ptr_conv, val_ref);
29739 jstring __attribute__((export_name("TS_ErrorMessage_get_data"))) TS_ErrorMessage_get_data(uint64_t this_ptr) {
29740 LDKErrorMessage this_ptr_conv;
29741 this_ptr_conv.inner = untag_ptr(this_ptr);
29742 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29743 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29744 this_ptr_conv.is_owned = false;
29745 LDKStr ret_str = ErrorMessage_get_data(&this_ptr_conv);
29746 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
29751 void __attribute__((export_name("TS_ErrorMessage_set_data"))) TS_ErrorMessage_set_data(uint64_t this_ptr, jstring val) {
29752 LDKErrorMessage this_ptr_conv;
29753 this_ptr_conv.inner = untag_ptr(this_ptr);
29754 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29755 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29756 this_ptr_conv.is_owned = false;
29757 LDKStr val_conv = str_ref_to_owned_c(val);
29758 ErrorMessage_set_data(&this_ptr_conv, val_conv);
29761 uint64_t __attribute__((export_name("TS_ErrorMessage_new"))) TS_ErrorMessage_new(int8_tArray channel_id_arg, jstring data_arg) {
29762 LDKThirtyTwoBytes channel_id_arg_ref;
29763 CHECK(channel_id_arg->arr_len == 32);
29764 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
29765 LDKStr data_arg_conv = str_ref_to_owned_c(data_arg);
29766 LDKErrorMessage ret_var = ErrorMessage_new(channel_id_arg_ref, data_arg_conv);
29767 uint64_t ret_ref = 0;
29768 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29769 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29773 static inline uint64_t ErrorMessage_clone_ptr(LDKErrorMessage *NONNULL_PTR arg) {
29774 LDKErrorMessage ret_var = ErrorMessage_clone(arg);
29775 uint64_t ret_ref = 0;
29776 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29777 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29780 int64_t __attribute__((export_name("TS_ErrorMessage_clone_ptr"))) TS_ErrorMessage_clone_ptr(uint64_t arg) {
29781 LDKErrorMessage arg_conv;
29782 arg_conv.inner = untag_ptr(arg);
29783 arg_conv.is_owned = ptr_is_owned(arg);
29784 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
29785 arg_conv.is_owned = false;
29786 int64_t ret_conv = ErrorMessage_clone_ptr(&arg_conv);
29790 uint64_t __attribute__((export_name("TS_ErrorMessage_clone"))) TS_ErrorMessage_clone(uint64_t orig) {
29791 LDKErrorMessage orig_conv;
29792 orig_conv.inner = untag_ptr(orig);
29793 orig_conv.is_owned = ptr_is_owned(orig);
29794 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
29795 orig_conv.is_owned = false;
29796 LDKErrorMessage ret_var = ErrorMessage_clone(&orig_conv);
29797 uint64_t ret_ref = 0;
29798 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29799 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29803 jboolean __attribute__((export_name("TS_ErrorMessage_eq"))) TS_ErrorMessage_eq(uint64_t a, uint64_t b) {
29804 LDKErrorMessage a_conv;
29805 a_conv.inner = untag_ptr(a);
29806 a_conv.is_owned = ptr_is_owned(a);
29807 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
29808 a_conv.is_owned = false;
29809 LDKErrorMessage b_conv;
29810 b_conv.inner = untag_ptr(b);
29811 b_conv.is_owned = ptr_is_owned(b);
29812 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
29813 b_conv.is_owned = false;
29814 jboolean ret_conv = ErrorMessage_eq(&a_conv, &b_conv);
29818 void __attribute__((export_name("TS_WarningMessage_free"))) TS_WarningMessage_free(uint64_t this_obj) {
29819 LDKWarningMessage this_obj_conv;
29820 this_obj_conv.inner = untag_ptr(this_obj);
29821 this_obj_conv.is_owned = ptr_is_owned(this_obj);
29822 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
29823 WarningMessage_free(this_obj_conv);
29826 int8_tArray __attribute__((export_name("TS_WarningMessage_get_channel_id"))) TS_WarningMessage_get_channel_id(uint64_t this_ptr) {
29827 LDKWarningMessage this_ptr_conv;
29828 this_ptr_conv.inner = untag_ptr(this_ptr);
29829 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29830 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29831 this_ptr_conv.is_owned = false;
29832 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
29833 memcpy(ret_arr->elems, *WarningMessage_get_channel_id(&this_ptr_conv), 32);
29837 void __attribute__((export_name("TS_WarningMessage_set_channel_id"))) TS_WarningMessage_set_channel_id(uint64_t this_ptr, int8_tArray val) {
29838 LDKWarningMessage this_ptr_conv;
29839 this_ptr_conv.inner = untag_ptr(this_ptr);
29840 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29841 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29842 this_ptr_conv.is_owned = false;
29843 LDKThirtyTwoBytes val_ref;
29844 CHECK(val->arr_len == 32);
29845 memcpy(val_ref.data, val->elems, 32); FREE(val);
29846 WarningMessage_set_channel_id(&this_ptr_conv, val_ref);
29849 jstring __attribute__((export_name("TS_WarningMessage_get_data"))) TS_WarningMessage_get_data(uint64_t this_ptr) {
29850 LDKWarningMessage this_ptr_conv;
29851 this_ptr_conv.inner = untag_ptr(this_ptr);
29852 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29853 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29854 this_ptr_conv.is_owned = false;
29855 LDKStr ret_str = WarningMessage_get_data(&this_ptr_conv);
29856 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
29861 void __attribute__((export_name("TS_WarningMessage_set_data"))) TS_WarningMessage_set_data(uint64_t this_ptr, jstring val) {
29862 LDKWarningMessage this_ptr_conv;
29863 this_ptr_conv.inner = untag_ptr(this_ptr);
29864 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29865 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29866 this_ptr_conv.is_owned = false;
29867 LDKStr val_conv = str_ref_to_owned_c(val);
29868 WarningMessage_set_data(&this_ptr_conv, val_conv);
29871 uint64_t __attribute__((export_name("TS_WarningMessage_new"))) TS_WarningMessage_new(int8_tArray channel_id_arg, jstring data_arg) {
29872 LDKThirtyTwoBytes channel_id_arg_ref;
29873 CHECK(channel_id_arg->arr_len == 32);
29874 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
29875 LDKStr data_arg_conv = str_ref_to_owned_c(data_arg);
29876 LDKWarningMessage ret_var = WarningMessage_new(channel_id_arg_ref, data_arg_conv);
29877 uint64_t ret_ref = 0;
29878 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29879 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29883 static inline uint64_t WarningMessage_clone_ptr(LDKWarningMessage *NONNULL_PTR arg) {
29884 LDKWarningMessage ret_var = WarningMessage_clone(arg);
29885 uint64_t ret_ref = 0;
29886 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29887 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29890 int64_t __attribute__((export_name("TS_WarningMessage_clone_ptr"))) TS_WarningMessage_clone_ptr(uint64_t arg) {
29891 LDKWarningMessage arg_conv;
29892 arg_conv.inner = untag_ptr(arg);
29893 arg_conv.is_owned = ptr_is_owned(arg);
29894 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
29895 arg_conv.is_owned = false;
29896 int64_t ret_conv = WarningMessage_clone_ptr(&arg_conv);
29900 uint64_t __attribute__((export_name("TS_WarningMessage_clone"))) TS_WarningMessage_clone(uint64_t orig) {
29901 LDKWarningMessage orig_conv;
29902 orig_conv.inner = untag_ptr(orig);
29903 orig_conv.is_owned = ptr_is_owned(orig);
29904 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
29905 orig_conv.is_owned = false;
29906 LDKWarningMessage ret_var = WarningMessage_clone(&orig_conv);
29907 uint64_t ret_ref = 0;
29908 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29909 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29913 jboolean __attribute__((export_name("TS_WarningMessage_eq"))) TS_WarningMessage_eq(uint64_t a, uint64_t b) {
29914 LDKWarningMessage a_conv;
29915 a_conv.inner = untag_ptr(a);
29916 a_conv.is_owned = ptr_is_owned(a);
29917 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
29918 a_conv.is_owned = false;
29919 LDKWarningMessage b_conv;
29920 b_conv.inner = untag_ptr(b);
29921 b_conv.is_owned = ptr_is_owned(b);
29922 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
29923 b_conv.is_owned = false;
29924 jboolean ret_conv = WarningMessage_eq(&a_conv, &b_conv);
29928 void __attribute__((export_name("TS_Ping_free"))) TS_Ping_free(uint64_t this_obj) {
29929 LDKPing this_obj_conv;
29930 this_obj_conv.inner = untag_ptr(this_obj);
29931 this_obj_conv.is_owned = ptr_is_owned(this_obj);
29932 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
29933 Ping_free(this_obj_conv);
29936 int16_t __attribute__((export_name("TS_Ping_get_ponglen"))) TS_Ping_get_ponglen(uint64_t this_ptr) {
29937 LDKPing this_ptr_conv;
29938 this_ptr_conv.inner = untag_ptr(this_ptr);
29939 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29940 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29941 this_ptr_conv.is_owned = false;
29942 int16_t ret_conv = Ping_get_ponglen(&this_ptr_conv);
29946 void __attribute__((export_name("TS_Ping_set_ponglen"))) TS_Ping_set_ponglen(uint64_t this_ptr, int16_t val) {
29947 LDKPing this_ptr_conv;
29948 this_ptr_conv.inner = untag_ptr(this_ptr);
29949 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29950 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29951 this_ptr_conv.is_owned = false;
29952 Ping_set_ponglen(&this_ptr_conv, val);
29955 int16_t __attribute__((export_name("TS_Ping_get_byteslen"))) TS_Ping_get_byteslen(uint64_t this_ptr) {
29956 LDKPing this_ptr_conv;
29957 this_ptr_conv.inner = untag_ptr(this_ptr);
29958 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29959 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29960 this_ptr_conv.is_owned = false;
29961 int16_t ret_conv = Ping_get_byteslen(&this_ptr_conv);
29965 void __attribute__((export_name("TS_Ping_set_byteslen"))) TS_Ping_set_byteslen(uint64_t this_ptr, int16_t val) {
29966 LDKPing this_ptr_conv;
29967 this_ptr_conv.inner = untag_ptr(this_ptr);
29968 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29969 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29970 this_ptr_conv.is_owned = false;
29971 Ping_set_byteslen(&this_ptr_conv, val);
29974 uint64_t __attribute__((export_name("TS_Ping_new"))) TS_Ping_new(int16_t ponglen_arg, int16_t byteslen_arg) {
29975 LDKPing ret_var = Ping_new(ponglen_arg, byteslen_arg);
29976 uint64_t ret_ref = 0;
29977 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29978 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29982 static inline uint64_t Ping_clone_ptr(LDKPing *NONNULL_PTR arg) {
29983 LDKPing ret_var = Ping_clone(arg);
29984 uint64_t ret_ref = 0;
29985 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29986 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29989 int64_t __attribute__((export_name("TS_Ping_clone_ptr"))) TS_Ping_clone_ptr(uint64_t arg) {
29991 arg_conv.inner = untag_ptr(arg);
29992 arg_conv.is_owned = ptr_is_owned(arg);
29993 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
29994 arg_conv.is_owned = false;
29995 int64_t ret_conv = Ping_clone_ptr(&arg_conv);
29999 uint64_t __attribute__((export_name("TS_Ping_clone"))) TS_Ping_clone(uint64_t orig) {
30001 orig_conv.inner = untag_ptr(orig);
30002 orig_conv.is_owned = ptr_is_owned(orig);
30003 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
30004 orig_conv.is_owned = false;
30005 LDKPing ret_var = Ping_clone(&orig_conv);
30006 uint64_t ret_ref = 0;
30007 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30008 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30012 jboolean __attribute__((export_name("TS_Ping_eq"))) TS_Ping_eq(uint64_t a, uint64_t b) {
30014 a_conv.inner = untag_ptr(a);
30015 a_conv.is_owned = ptr_is_owned(a);
30016 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
30017 a_conv.is_owned = false;
30019 b_conv.inner = untag_ptr(b);
30020 b_conv.is_owned = ptr_is_owned(b);
30021 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
30022 b_conv.is_owned = false;
30023 jboolean ret_conv = Ping_eq(&a_conv, &b_conv);
30027 void __attribute__((export_name("TS_Pong_free"))) TS_Pong_free(uint64_t this_obj) {
30028 LDKPong this_obj_conv;
30029 this_obj_conv.inner = untag_ptr(this_obj);
30030 this_obj_conv.is_owned = ptr_is_owned(this_obj);
30031 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
30032 Pong_free(this_obj_conv);
30035 int16_t __attribute__((export_name("TS_Pong_get_byteslen"))) TS_Pong_get_byteslen(uint64_t this_ptr) {
30036 LDKPong this_ptr_conv;
30037 this_ptr_conv.inner = untag_ptr(this_ptr);
30038 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30039 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30040 this_ptr_conv.is_owned = false;
30041 int16_t ret_conv = Pong_get_byteslen(&this_ptr_conv);
30045 void __attribute__((export_name("TS_Pong_set_byteslen"))) TS_Pong_set_byteslen(uint64_t this_ptr, int16_t val) {
30046 LDKPong this_ptr_conv;
30047 this_ptr_conv.inner = untag_ptr(this_ptr);
30048 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30049 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30050 this_ptr_conv.is_owned = false;
30051 Pong_set_byteslen(&this_ptr_conv, val);
30054 uint64_t __attribute__((export_name("TS_Pong_new"))) TS_Pong_new(int16_t byteslen_arg) {
30055 LDKPong ret_var = Pong_new(byteslen_arg);
30056 uint64_t ret_ref = 0;
30057 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30058 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30062 static inline uint64_t Pong_clone_ptr(LDKPong *NONNULL_PTR arg) {
30063 LDKPong ret_var = Pong_clone(arg);
30064 uint64_t ret_ref = 0;
30065 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30066 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30069 int64_t __attribute__((export_name("TS_Pong_clone_ptr"))) TS_Pong_clone_ptr(uint64_t arg) {
30071 arg_conv.inner = untag_ptr(arg);
30072 arg_conv.is_owned = ptr_is_owned(arg);
30073 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
30074 arg_conv.is_owned = false;
30075 int64_t ret_conv = Pong_clone_ptr(&arg_conv);
30079 uint64_t __attribute__((export_name("TS_Pong_clone"))) TS_Pong_clone(uint64_t orig) {
30081 orig_conv.inner = untag_ptr(orig);
30082 orig_conv.is_owned = ptr_is_owned(orig);
30083 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
30084 orig_conv.is_owned = false;
30085 LDKPong ret_var = Pong_clone(&orig_conv);
30086 uint64_t ret_ref = 0;
30087 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30088 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30092 jboolean __attribute__((export_name("TS_Pong_eq"))) TS_Pong_eq(uint64_t a, uint64_t b) {
30094 a_conv.inner = untag_ptr(a);
30095 a_conv.is_owned = ptr_is_owned(a);
30096 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
30097 a_conv.is_owned = false;
30099 b_conv.inner = untag_ptr(b);
30100 b_conv.is_owned = ptr_is_owned(b);
30101 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
30102 b_conv.is_owned = false;
30103 jboolean ret_conv = Pong_eq(&a_conv, &b_conv);
30107 void __attribute__((export_name("TS_OpenChannel_free"))) TS_OpenChannel_free(uint64_t this_obj) {
30108 LDKOpenChannel this_obj_conv;
30109 this_obj_conv.inner = untag_ptr(this_obj);
30110 this_obj_conv.is_owned = ptr_is_owned(this_obj);
30111 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
30112 OpenChannel_free(this_obj_conv);
30115 int8_tArray __attribute__((export_name("TS_OpenChannel_get_chain_hash"))) TS_OpenChannel_get_chain_hash(uint64_t this_ptr) {
30116 LDKOpenChannel this_ptr_conv;
30117 this_ptr_conv.inner = untag_ptr(this_ptr);
30118 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30119 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30120 this_ptr_conv.is_owned = false;
30121 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
30122 memcpy(ret_arr->elems, *OpenChannel_get_chain_hash(&this_ptr_conv), 32);
30126 void __attribute__((export_name("TS_OpenChannel_set_chain_hash"))) TS_OpenChannel_set_chain_hash(uint64_t this_ptr, int8_tArray val) {
30127 LDKOpenChannel this_ptr_conv;
30128 this_ptr_conv.inner = untag_ptr(this_ptr);
30129 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30130 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30131 this_ptr_conv.is_owned = false;
30132 LDKThirtyTwoBytes val_ref;
30133 CHECK(val->arr_len == 32);
30134 memcpy(val_ref.data, val->elems, 32); FREE(val);
30135 OpenChannel_set_chain_hash(&this_ptr_conv, val_ref);
30138 int8_tArray __attribute__((export_name("TS_OpenChannel_get_temporary_channel_id"))) TS_OpenChannel_get_temporary_channel_id(uint64_t this_ptr) {
30139 LDKOpenChannel this_ptr_conv;
30140 this_ptr_conv.inner = untag_ptr(this_ptr);
30141 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30142 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30143 this_ptr_conv.is_owned = false;
30144 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
30145 memcpy(ret_arr->elems, *OpenChannel_get_temporary_channel_id(&this_ptr_conv), 32);
30149 void __attribute__((export_name("TS_OpenChannel_set_temporary_channel_id"))) TS_OpenChannel_set_temporary_channel_id(uint64_t this_ptr, int8_tArray val) {
30150 LDKOpenChannel this_ptr_conv;
30151 this_ptr_conv.inner = untag_ptr(this_ptr);
30152 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30153 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30154 this_ptr_conv.is_owned = false;
30155 LDKThirtyTwoBytes val_ref;
30156 CHECK(val->arr_len == 32);
30157 memcpy(val_ref.data, val->elems, 32); FREE(val);
30158 OpenChannel_set_temporary_channel_id(&this_ptr_conv, val_ref);
30161 int64_t __attribute__((export_name("TS_OpenChannel_get_funding_satoshis"))) TS_OpenChannel_get_funding_satoshis(uint64_t this_ptr) {
30162 LDKOpenChannel this_ptr_conv;
30163 this_ptr_conv.inner = untag_ptr(this_ptr);
30164 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30165 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30166 this_ptr_conv.is_owned = false;
30167 int64_t ret_conv = OpenChannel_get_funding_satoshis(&this_ptr_conv);
30171 void __attribute__((export_name("TS_OpenChannel_set_funding_satoshis"))) TS_OpenChannel_set_funding_satoshis(uint64_t this_ptr, int64_t val) {
30172 LDKOpenChannel this_ptr_conv;
30173 this_ptr_conv.inner = untag_ptr(this_ptr);
30174 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30175 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30176 this_ptr_conv.is_owned = false;
30177 OpenChannel_set_funding_satoshis(&this_ptr_conv, val);
30180 int64_t __attribute__((export_name("TS_OpenChannel_get_push_msat"))) TS_OpenChannel_get_push_msat(uint64_t this_ptr) {
30181 LDKOpenChannel this_ptr_conv;
30182 this_ptr_conv.inner = untag_ptr(this_ptr);
30183 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30184 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30185 this_ptr_conv.is_owned = false;
30186 int64_t ret_conv = OpenChannel_get_push_msat(&this_ptr_conv);
30190 void __attribute__((export_name("TS_OpenChannel_set_push_msat"))) TS_OpenChannel_set_push_msat(uint64_t this_ptr, int64_t val) {
30191 LDKOpenChannel this_ptr_conv;
30192 this_ptr_conv.inner = untag_ptr(this_ptr);
30193 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30194 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30195 this_ptr_conv.is_owned = false;
30196 OpenChannel_set_push_msat(&this_ptr_conv, val);
30199 int64_t __attribute__((export_name("TS_OpenChannel_get_dust_limit_satoshis"))) TS_OpenChannel_get_dust_limit_satoshis(uint64_t this_ptr) {
30200 LDKOpenChannel this_ptr_conv;
30201 this_ptr_conv.inner = untag_ptr(this_ptr);
30202 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30203 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30204 this_ptr_conv.is_owned = false;
30205 int64_t ret_conv = OpenChannel_get_dust_limit_satoshis(&this_ptr_conv);
30209 void __attribute__((export_name("TS_OpenChannel_set_dust_limit_satoshis"))) TS_OpenChannel_set_dust_limit_satoshis(uint64_t this_ptr, int64_t val) {
30210 LDKOpenChannel this_ptr_conv;
30211 this_ptr_conv.inner = untag_ptr(this_ptr);
30212 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30213 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30214 this_ptr_conv.is_owned = false;
30215 OpenChannel_set_dust_limit_satoshis(&this_ptr_conv, val);
30218 int64_t __attribute__((export_name("TS_OpenChannel_get_max_htlc_value_in_flight_msat"))) TS_OpenChannel_get_max_htlc_value_in_flight_msat(uint64_t this_ptr) {
30219 LDKOpenChannel this_ptr_conv;
30220 this_ptr_conv.inner = untag_ptr(this_ptr);
30221 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30222 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30223 this_ptr_conv.is_owned = false;
30224 int64_t ret_conv = OpenChannel_get_max_htlc_value_in_flight_msat(&this_ptr_conv);
30228 void __attribute__((export_name("TS_OpenChannel_set_max_htlc_value_in_flight_msat"))) TS_OpenChannel_set_max_htlc_value_in_flight_msat(uint64_t this_ptr, int64_t val) {
30229 LDKOpenChannel this_ptr_conv;
30230 this_ptr_conv.inner = untag_ptr(this_ptr);
30231 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30232 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30233 this_ptr_conv.is_owned = false;
30234 OpenChannel_set_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
30237 int64_t __attribute__((export_name("TS_OpenChannel_get_channel_reserve_satoshis"))) TS_OpenChannel_get_channel_reserve_satoshis(uint64_t this_ptr) {
30238 LDKOpenChannel this_ptr_conv;
30239 this_ptr_conv.inner = untag_ptr(this_ptr);
30240 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30241 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30242 this_ptr_conv.is_owned = false;
30243 int64_t ret_conv = OpenChannel_get_channel_reserve_satoshis(&this_ptr_conv);
30247 void __attribute__((export_name("TS_OpenChannel_set_channel_reserve_satoshis"))) TS_OpenChannel_set_channel_reserve_satoshis(uint64_t this_ptr, int64_t val) {
30248 LDKOpenChannel this_ptr_conv;
30249 this_ptr_conv.inner = untag_ptr(this_ptr);
30250 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30251 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30252 this_ptr_conv.is_owned = false;
30253 OpenChannel_set_channel_reserve_satoshis(&this_ptr_conv, val);
30256 int64_t __attribute__((export_name("TS_OpenChannel_get_htlc_minimum_msat"))) TS_OpenChannel_get_htlc_minimum_msat(uint64_t this_ptr) {
30257 LDKOpenChannel this_ptr_conv;
30258 this_ptr_conv.inner = untag_ptr(this_ptr);
30259 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30260 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30261 this_ptr_conv.is_owned = false;
30262 int64_t ret_conv = OpenChannel_get_htlc_minimum_msat(&this_ptr_conv);
30266 void __attribute__((export_name("TS_OpenChannel_set_htlc_minimum_msat"))) TS_OpenChannel_set_htlc_minimum_msat(uint64_t this_ptr, int64_t val) {
30267 LDKOpenChannel this_ptr_conv;
30268 this_ptr_conv.inner = untag_ptr(this_ptr);
30269 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30270 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30271 this_ptr_conv.is_owned = false;
30272 OpenChannel_set_htlc_minimum_msat(&this_ptr_conv, val);
30275 int32_t __attribute__((export_name("TS_OpenChannel_get_feerate_per_kw"))) TS_OpenChannel_get_feerate_per_kw(uint64_t this_ptr) {
30276 LDKOpenChannel this_ptr_conv;
30277 this_ptr_conv.inner = untag_ptr(this_ptr);
30278 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30279 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30280 this_ptr_conv.is_owned = false;
30281 int32_t ret_conv = OpenChannel_get_feerate_per_kw(&this_ptr_conv);
30285 void __attribute__((export_name("TS_OpenChannel_set_feerate_per_kw"))) TS_OpenChannel_set_feerate_per_kw(uint64_t this_ptr, int32_t val) {
30286 LDKOpenChannel this_ptr_conv;
30287 this_ptr_conv.inner = untag_ptr(this_ptr);
30288 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30289 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30290 this_ptr_conv.is_owned = false;
30291 OpenChannel_set_feerate_per_kw(&this_ptr_conv, val);
30294 int16_t __attribute__((export_name("TS_OpenChannel_get_to_self_delay"))) TS_OpenChannel_get_to_self_delay(uint64_t this_ptr) {
30295 LDKOpenChannel this_ptr_conv;
30296 this_ptr_conv.inner = untag_ptr(this_ptr);
30297 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30298 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30299 this_ptr_conv.is_owned = false;
30300 int16_t ret_conv = OpenChannel_get_to_self_delay(&this_ptr_conv);
30304 void __attribute__((export_name("TS_OpenChannel_set_to_self_delay"))) TS_OpenChannel_set_to_self_delay(uint64_t this_ptr, int16_t val) {
30305 LDKOpenChannel this_ptr_conv;
30306 this_ptr_conv.inner = untag_ptr(this_ptr);
30307 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30308 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30309 this_ptr_conv.is_owned = false;
30310 OpenChannel_set_to_self_delay(&this_ptr_conv, val);
30313 int16_t __attribute__((export_name("TS_OpenChannel_get_max_accepted_htlcs"))) TS_OpenChannel_get_max_accepted_htlcs(uint64_t this_ptr) {
30314 LDKOpenChannel this_ptr_conv;
30315 this_ptr_conv.inner = untag_ptr(this_ptr);
30316 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30317 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30318 this_ptr_conv.is_owned = false;
30319 int16_t ret_conv = OpenChannel_get_max_accepted_htlcs(&this_ptr_conv);
30323 void __attribute__((export_name("TS_OpenChannel_set_max_accepted_htlcs"))) TS_OpenChannel_set_max_accepted_htlcs(uint64_t this_ptr, int16_t val) {
30324 LDKOpenChannel this_ptr_conv;
30325 this_ptr_conv.inner = untag_ptr(this_ptr);
30326 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30327 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30328 this_ptr_conv.is_owned = false;
30329 OpenChannel_set_max_accepted_htlcs(&this_ptr_conv, val);
30332 int8_tArray __attribute__((export_name("TS_OpenChannel_get_funding_pubkey"))) TS_OpenChannel_get_funding_pubkey(uint64_t this_ptr) {
30333 LDKOpenChannel this_ptr_conv;
30334 this_ptr_conv.inner = untag_ptr(this_ptr);
30335 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30336 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30337 this_ptr_conv.is_owned = false;
30338 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
30339 memcpy(ret_arr->elems, OpenChannel_get_funding_pubkey(&this_ptr_conv).compressed_form, 33);
30343 void __attribute__((export_name("TS_OpenChannel_set_funding_pubkey"))) TS_OpenChannel_set_funding_pubkey(uint64_t this_ptr, int8_tArray val) {
30344 LDKOpenChannel this_ptr_conv;
30345 this_ptr_conv.inner = untag_ptr(this_ptr);
30346 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30347 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30348 this_ptr_conv.is_owned = false;
30349 LDKPublicKey val_ref;
30350 CHECK(val->arr_len == 33);
30351 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
30352 OpenChannel_set_funding_pubkey(&this_ptr_conv, val_ref);
30355 int8_tArray __attribute__((export_name("TS_OpenChannel_get_revocation_basepoint"))) TS_OpenChannel_get_revocation_basepoint(uint64_t this_ptr) {
30356 LDKOpenChannel this_ptr_conv;
30357 this_ptr_conv.inner = untag_ptr(this_ptr);
30358 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30359 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30360 this_ptr_conv.is_owned = false;
30361 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
30362 memcpy(ret_arr->elems, OpenChannel_get_revocation_basepoint(&this_ptr_conv).compressed_form, 33);
30366 void __attribute__((export_name("TS_OpenChannel_set_revocation_basepoint"))) TS_OpenChannel_set_revocation_basepoint(uint64_t this_ptr, int8_tArray val) {
30367 LDKOpenChannel this_ptr_conv;
30368 this_ptr_conv.inner = untag_ptr(this_ptr);
30369 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30370 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30371 this_ptr_conv.is_owned = false;
30372 LDKPublicKey val_ref;
30373 CHECK(val->arr_len == 33);
30374 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
30375 OpenChannel_set_revocation_basepoint(&this_ptr_conv, val_ref);
30378 int8_tArray __attribute__((export_name("TS_OpenChannel_get_payment_point"))) TS_OpenChannel_get_payment_point(uint64_t this_ptr) {
30379 LDKOpenChannel this_ptr_conv;
30380 this_ptr_conv.inner = untag_ptr(this_ptr);
30381 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30382 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30383 this_ptr_conv.is_owned = false;
30384 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
30385 memcpy(ret_arr->elems, OpenChannel_get_payment_point(&this_ptr_conv).compressed_form, 33);
30389 void __attribute__((export_name("TS_OpenChannel_set_payment_point"))) TS_OpenChannel_set_payment_point(uint64_t this_ptr, int8_tArray val) {
30390 LDKOpenChannel this_ptr_conv;
30391 this_ptr_conv.inner = untag_ptr(this_ptr);
30392 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30393 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30394 this_ptr_conv.is_owned = false;
30395 LDKPublicKey val_ref;
30396 CHECK(val->arr_len == 33);
30397 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
30398 OpenChannel_set_payment_point(&this_ptr_conv, val_ref);
30401 int8_tArray __attribute__((export_name("TS_OpenChannel_get_delayed_payment_basepoint"))) TS_OpenChannel_get_delayed_payment_basepoint(uint64_t this_ptr) {
30402 LDKOpenChannel this_ptr_conv;
30403 this_ptr_conv.inner = untag_ptr(this_ptr);
30404 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30405 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30406 this_ptr_conv.is_owned = false;
30407 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
30408 memcpy(ret_arr->elems, OpenChannel_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form, 33);
30412 void __attribute__((export_name("TS_OpenChannel_set_delayed_payment_basepoint"))) TS_OpenChannel_set_delayed_payment_basepoint(uint64_t this_ptr, int8_tArray val) {
30413 LDKOpenChannel this_ptr_conv;
30414 this_ptr_conv.inner = untag_ptr(this_ptr);
30415 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30416 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30417 this_ptr_conv.is_owned = false;
30418 LDKPublicKey val_ref;
30419 CHECK(val->arr_len == 33);
30420 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
30421 OpenChannel_set_delayed_payment_basepoint(&this_ptr_conv, val_ref);
30424 int8_tArray __attribute__((export_name("TS_OpenChannel_get_htlc_basepoint"))) TS_OpenChannel_get_htlc_basepoint(uint64_t this_ptr) {
30425 LDKOpenChannel this_ptr_conv;
30426 this_ptr_conv.inner = untag_ptr(this_ptr);
30427 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30428 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30429 this_ptr_conv.is_owned = false;
30430 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
30431 memcpy(ret_arr->elems, OpenChannel_get_htlc_basepoint(&this_ptr_conv).compressed_form, 33);
30435 void __attribute__((export_name("TS_OpenChannel_set_htlc_basepoint"))) TS_OpenChannel_set_htlc_basepoint(uint64_t this_ptr, int8_tArray val) {
30436 LDKOpenChannel this_ptr_conv;
30437 this_ptr_conv.inner = untag_ptr(this_ptr);
30438 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30439 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30440 this_ptr_conv.is_owned = false;
30441 LDKPublicKey val_ref;
30442 CHECK(val->arr_len == 33);
30443 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
30444 OpenChannel_set_htlc_basepoint(&this_ptr_conv, val_ref);
30447 int8_tArray __attribute__((export_name("TS_OpenChannel_get_first_per_commitment_point"))) TS_OpenChannel_get_first_per_commitment_point(uint64_t this_ptr) {
30448 LDKOpenChannel this_ptr_conv;
30449 this_ptr_conv.inner = untag_ptr(this_ptr);
30450 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30451 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30452 this_ptr_conv.is_owned = false;
30453 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
30454 memcpy(ret_arr->elems, OpenChannel_get_first_per_commitment_point(&this_ptr_conv).compressed_form, 33);
30458 void __attribute__((export_name("TS_OpenChannel_set_first_per_commitment_point"))) TS_OpenChannel_set_first_per_commitment_point(uint64_t this_ptr, int8_tArray val) {
30459 LDKOpenChannel this_ptr_conv;
30460 this_ptr_conv.inner = untag_ptr(this_ptr);
30461 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30462 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30463 this_ptr_conv.is_owned = false;
30464 LDKPublicKey val_ref;
30465 CHECK(val->arr_len == 33);
30466 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
30467 OpenChannel_set_first_per_commitment_point(&this_ptr_conv, val_ref);
30470 int8_t __attribute__((export_name("TS_OpenChannel_get_channel_flags"))) TS_OpenChannel_get_channel_flags(uint64_t this_ptr) {
30471 LDKOpenChannel this_ptr_conv;
30472 this_ptr_conv.inner = untag_ptr(this_ptr);
30473 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30474 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30475 this_ptr_conv.is_owned = false;
30476 int8_t ret_conv = OpenChannel_get_channel_flags(&this_ptr_conv);
30480 void __attribute__((export_name("TS_OpenChannel_set_channel_flags"))) TS_OpenChannel_set_channel_flags(uint64_t this_ptr, int8_t val) {
30481 LDKOpenChannel this_ptr_conv;
30482 this_ptr_conv.inner = untag_ptr(this_ptr);
30483 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30484 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30485 this_ptr_conv.is_owned = false;
30486 OpenChannel_set_channel_flags(&this_ptr_conv, val);
30489 uint64_t __attribute__((export_name("TS_OpenChannel_get_channel_type"))) TS_OpenChannel_get_channel_type(uint64_t this_ptr) {
30490 LDKOpenChannel this_ptr_conv;
30491 this_ptr_conv.inner = untag_ptr(this_ptr);
30492 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30493 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30494 this_ptr_conv.is_owned = false;
30495 LDKChannelTypeFeatures ret_var = OpenChannel_get_channel_type(&this_ptr_conv);
30496 uint64_t ret_ref = 0;
30497 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30498 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30502 void __attribute__((export_name("TS_OpenChannel_set_channel_type"))) TS_OpenChannel_set_channel_type(uint64_t this_ptr, uint64_t val) {
30503 LDKOpenChannel this_ptr_conv;
30504 this_ptr_conv.inner = untag_ptr(this_ptr);
30505 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30506 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30507 this_ptr_conv.is_owned = false;
30508 LDKChannelTypeFeatures val_conv;
30509 val_conv.inner = untag_ptr(val);
30510 val_conv.is_owned = ptr_is_owned(val);
30511 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
30512 val_conv = ChannelTypeFeatures_clone(&val_conv);
30513 OpenChannel_set_channel_type(&this_ptr_conv, val_conv);
30516 static inline uint64_t OpenChannel_clone_ptr(LDKOpenChannel *NONNULL_PTR arg) {
30517 LDKOpenChannel ret_var = OpenChannel_clone(arg);
30518 uint64_t ret_ref = 0;
30519 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30520 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30523 int64_t __attribute__((export_name("TS_OpenChannel_clone_ptr"))) TS_OpenChannel_clone_ptr(uint64_t arg) {
30524 LDKOpenChannel arg_conv;
30525 arg_conv.inner = untag_ptr(arg);
30526 arg_conv.is_owned = ptr_is_owned(arg);
30527 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
30528 arg_conv.is_owned = false;
30529 int64_t ret_conv = OpenChannel_clone_ptr(&arg_conv);
30533 uint64_t __attribute__((export_name("TS_OpenChannel_clone"))) TS_OpenChannel_clone(uint64_t orig) {
30534 LDKOpenChannel orig_conv;
30535 orig_conv.inner = untag_ptr(orig);
30536 orig_conv.is_owned = ptr_is_owned(orig);
30537 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
30538 orig_conv.is_owned = false;
30539 LDKOpenChannel ret_var = OpenChannel_clone(&orig_conv);
30540 uint64_t ret_ref = 0;
30541 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30542 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30546 jboolean __attribute__((export_name("TS_OpenChannel_eq"))) TS_OpenChannel_eq(uint64_t a, uint64_t b) {
30547 LDKOpenChannel a_conv;
30548 a_conv.inner = untag_ptr(a);
30549 a_conv.is_owned = ptr_is_owned(a);
30550 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
30551 a_conv.is_owned = false;
30552 LDKOpenChannel b_conv;
30553 b_conv.inner = untag_ptr(b);
30554 b_conv.is_owned = ptr_is_owned(b);
30555 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
30556 b_conv.is_owned = false;
30557 jboolean ret_conv = OpenChannel_eq(&a_conv, &b_conv);
30561 void __attribute__((export_name("TS_AcceptChannel_free"))) TS_AcceptChannel_free(uint64_t this_obj) {
30562 LDKAcceptChannel this_obj_conv;
30563 this_obj_conv.inner = untag_ptr(this_obj);
30564 this_obj_conv.is_owned = ptr_is_owned(this_obj);
30565 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
30566 AcceptChannel_free(this_obj_conv);
30569 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_temporary_channel_id"))) TS_AcceptChannel_get_temporary_channel_id(uint64_t this_ptr) {
30570 LDKAcceptChannel this_ptr_conv;
30571 this_ptr_conv.inner = untag_ptr(this_ptr);
30572 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30573 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30574 this_ptr_conv.is_owned = false;
30575 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
30576 memcpy(ret_arr->elems, *AcceptChannel_get_temporary_channel_id(&this_ptr_conv), 32);
30580 void __attribute__((export_name("TS_AcceptChannel_set_temporary_channel_id"))) TS_AcceptChannel_set_temporary_channel_id(uint64_t this_ptr, int8_tArray val) {
30581 LDKAcceptChannel this_ptr_conv;
30582 this_ptr_conv.inner = untag_ptr(this_ptr);
30583 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30584 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30585 this_ptr_conv.is_owned = false;
30586 LDKThirtyTwoBytes val_ref;
30587 CHECK(val->arr_len == 32);
30588 memcpy(val_ref.data, val->elems, 32); FREE(val);
30589 AcceptChannel_set_temporary_channel_id(&this_ptr_conv, val_ref);
30592 int64_t __attribute__((export_name("TS_AcceptChannel_get_dust_limit_satoshis"))) TS_AcceptChannel_get_dust_limit_satoshis(uint64_t this_ptr) {
30593 LDKAcceptChannel this_ptr_conv;
30594 this_ptr_conv.inner = untag_ptr(this_ptr);
30595 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30596 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30597 this_ptr_conv.is_owned = false;
30598 int64_t ret_conv = AcceptChannel_get_dust_limit_satoshis(&this_ptr_conv);
30602 void __attribute__((export_name("TS_AcceptChannel_set_dust_limit_satoshis"))) TS_AcceptChannel_set_dust_limit_satoshis(uint64_t this_ptr, int64_t val) {
30603 LDKAcceptChannel this_ptr_conv;
30604 this_ptr_conv.inner = untag_ptr(this_ptr);
30605 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30606 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30607 this_ptr_conv.is_owned = false;
30608 AcceptChannel_set_dust_limit_satoshis(&this_ptr_conv, val);
30611 int64_t __attribute__((export_name("TS_AcceptChannel_get_max_htlc_value_in_flight_msat"))) TS_AcceptChannel_get_max_htlc_value_in_flight_msat(uint64_t this_ptr) {
30612 LDKAcceptChannel this_ptr_conv;
30613 this_ptr_conv.inner = untag_ptr(this_ptr);
30614 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30615 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30616 this_ptr_conv.is_owned = false;
30617 int64_t ret_conv = AcceptChannel_get_max_htlc_value_in_flight_msat(&this_ptr_conv);
30621 void __attribute__((export_name("TS_AcceptChannel_set_max_htlc_value_in_flight_msat"))) TS_AcceptChannel_set_max_htlc_value_in_flight_msat(uint64_t this_ptr, int64_t val) {
30622 LDKAcceptChannel this_ptr_conv;
30623 this_ptr_conv.inner = untag_ptr(this_ptr);
30624 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30625 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30626 this_ptr_conv.is_owned = false;
30627 AcceptChannel_set_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
30630 int64_t __attribute__((export_name("TS_AcceptChannel_get_channel_reserve_satoshis"))) TS_AcceptChannel_get_channel_reserve_satoshis(uint64_t this_ptr) {
30631 LDKAcceptChannel this_ptr_conv;
30632 this_ptr_conv.inner = untag_ptr(this_ptr);
30633 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30634 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30635 this_ptr_conv.is_owned = false;
30636 int64_t ret_conv = AcceptChannel_get_channel_reserve_satoshis(&this_ptr_conv);
30640 void __attribute__((export_name("TS_AcceptChannel_set_channel_reserve_satoshis"))) TS_AcceptChannel_set_channel_reserve_satoshis(uint64_t this_ptr, int64_t val) {
30641 LDKAcceptChannel this_ptr_conv;
30642 this_ptr_conv.inner = untag_ptr(this_ptr);
30643 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30644 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30645 this_ptr_conv.is_owned = false;
30646 AcceptChannel_set_channel_reserve_satoshis(&this_ptr_conv, val);
30649 int64_t __attribute__((export_name("TS_AcceptChannel_get_htlc_minimum_msat"))) TS_AcceptChannel_get_htlc_minimum_msat(uint64_t this_ptr) {
30650 LDKAcceptChannel this_ptr_conv;
30651 this_ptr_conv.inner = untag_ptr(this_ptr);
30652 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30653 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30654 this_ptr_conv.is_owned = false;
30655 int64_t ret_conv = AcceptChannel_get_htlc_minimum_msat(&this_ptr_conv);
30659 void __attribute__((export_name("TS_AcceptChannel_set_htlc_minimum_msat"))) TS_AcceptChannel_set_htlc_minimum_msat(uint64_t this_ptr, int64_t val) {
30660 LDKAcceptChannel this_ptr_conv;
30661 this_ptr_conv.inner = untag_ptr(this_ptr);
30662 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30663 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30664 this_ptr_conv.is_owned = false;
30665 AcceptChannel_set_htlc_minimum_msat(&this_ptr_conv, val);
30668 int32_t __attribute__((export_name("TS_AcceptChannel_get_minimum_depth"))) TS_AcceptChannel_get_minimum_depth(uint64_t this_ptr) {
30669 LDKAcceptChannel this_ptr_conv;
30670 this_ptr_conv.inner = untag_ptr(this_ptr);
30671 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30672 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30673 this_ptr_conv.is_owned = false;
30674 int32_t ret_conv = AcceptChannel_get_minimum_depth(&this_ptr_conv);
30678 void __attribute__((export_name("TS_AcceptChannel_set_minimum_depth"))) TS_AcceptChannel_set_minimum_depth(uint64_t this_ptr, int32_t val) {
30679 LDKAcceptChannel this_ptr_conv;
30680 this_ptr_conv.inner = untag_ptr(this_ptr);
30681 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30682 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30683 this_ptr_conv.is_owned = false;
30684 AcceptChannel_set_minimum_depth(&this_ptr_conv, val);
30687 int16_t __attribute__((export_name("TS_AcceptChannel_get_to_self_delay"))) TS_AcceptChannel_get_to_self_delay(uint64_t this_ptr) {
30688 LDKAcceptChannel this_ptr_conv;
30689 this_ptr_conv.inner = untag_ptr(this_ptr);
30690 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30691 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30692 this_ptr_conv.is_owned = false;
30693 int16_t ret_conv = AcceptChannel_get_to_self_delay(&this_ptr_conv);
30697 void __attribute__((export_name("TS_AcceptChannel_set_to_self_delay"))) TS_AcceptChannel_set_to_self_delay(uint64_t this_ptr, int16_t val) {
30698 LDKAcceptChannel this_ptr_conv;
30699 this_ptr_conv.inner = untag_ptr(this_ptr);
30700 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30701 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30702 this_ptr_conv.is_owned = false;
30703 AcceptChannel_set_to_self_delay(&this_ptr_conv, val);
30706 int16_t __attribute__((export_name("TS_AcceptChannel_get_max_accepted_htlcs"))) TS_AcceptChannel_get_max_accepted_htlcs(uint64_t this_ptr) {
30707 LDKAcceptChannel this_ptr_conv;
30708 this_ptr_conv.inner = untag_ptr(this_ptr);
30709 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30710 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30711 this_ptr_conv.is_owned = false;
30712 int16_t ret_conv = AcceptChannel_get_max_accepted_htlcs(&this_ptr_conv);
30716 void __attribute__((export_name("TS_AcceptChannel_set_max_accepted_htlcs"))) TS_AcceptChannel_set_max_accepted_htlcs(uint64_t this_ptr, int16_t val) {
30717 LDKAcceptChannel this_ptr_conv;
30718 this_ptr_conv.inner = untag_ptr(this_ptr);
30719 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30720 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30721 this_ptr_conv.is_owned = false;
30722 AcceptChannel_set_max_accepted_htlcs(&this_ptr_conv, val);
30725 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_funding_pubkey"))) TS_AcceptChannel_get_funding_pubkey(uint64_t this_ptr) {
30726 LDKAcceptChannel this_ptr_conv;
30727 this_ptr_conv.inner = untag_ptr(this_ptr);
30728 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30729 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30730 this_ptr_conv.is_owned = false;
30731 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
30732 memcpy(ret_arr->elems, AcceptChannel_get_funding_pubkey(&this_ptr_conv).compressed_form, 33);
30736 void __attribute__((export_name("TS_AcceptChannel_set_funding_pubkey"))) TS_AcceptChannel_set_funding_pubkey(uint64_t this_ptr, int8_tArray val) {
30737 LDKAcceptChannel this_ptr_conv;
30738 this_ptr_conv.inner = untag_ptr(this_ptr);
30739 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30740 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30741 this_ptr_conv.is_owned = false;
30742 LDKPublicKey val_ref;
30743 CHECK(val->arr_len == 33);
30744 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
30745 AcceptChannel_set_funding_pubkey(&this_ptr_conv, val_ref);
30748 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_revocation_basepoint"))) TS_AcceptChannel_get_revocation_basepoint(uint64_t this_ptr) {
30749 LDKAcceptChannel this_ptr_conv;
30750 this_ptr_conv.inner = untag_ptr(this_ptr);
30751 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30752 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30753 this_ptr_conv.is_owned = false;
30754 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
30755 memcpy(ret_arr->elems, AcceptChannel_get_revocation_basepoint(&this_ptr_conv).compressed_form, 33);
30759 void __attribute__((export_name("TS_AcceptChannel_set_revocation_basepoint"))) TS_AcceptChannel_set_revocation_basepoint(uint64_t this_ptr, int8_tArray val) {
30760 LDKAcceptChannel this_ptr_conv;
30761 this_ptr_conv.inner = untag_ptr(this_ptr);
30762 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30763 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30764 this_ptr_conv.is_owned = false;
30765 LDKPublicKey val_ref;
30766 CHECK(val->arr_len == 33);
30767 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
30768 AcceptChannel_set_revocation_basepoint(&this_ptr_conv, val_ref);
30771 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_payment_point"))) TS_AcceptChannel_get_payment_point(uint64_t this_ptr) {
30772 LDKAcceptChannel this_ptr_conv;
30773 this_ptr_conv.inner = untag_ptr(this_ptr);
30774 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30775 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30776 this_ptr_conv.is_owned = false;
30777 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
30778 memcpy(ret_arr->elems, AcceptChannel_get_payment_point(&this_ptr_conv).compressed_form, 33);
30782 void __attribute__((export_name("TS_AcceptChannel_set_payment_point"))) TS_AcceptChannel_set_payment_point(uint64_t this_ptr, int8_tArray val) {
30783 LDKAcceptChannel this_ptr_conv;
30784 this_ptr_conv.inner = untag_ptr(this_ptr);
30785 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30786 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30787 this_ptr_conv.is_owned = false;
30788 LDKPublicKey val_ref;
30789 CHECK(val->arr_len == 33);
30790 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
30791 AcceptChannel_set_payment_point(&this_ptr_conv, val_ref);
30794 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_delayed_payment_basepoint"))) TS_AcceptChannel_get_delayed_payment_basepoint(uint64_t this_ptr) {
30795 LDKAcceptChannel this_ptr_conv;
30796 this_ptr_conv.inner = untag_ptr(this_ptr);
30797 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30798 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30799 this_ptr_conv.is_owned = false;
30800 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
30801 memcpy(ret_arr->elems, AcceptChannel_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form, 33);
30805 void __attribute__((export_name("TS_AcceptChannel_set_delayed_payment_basepoint"))) TS_AcceptChannel_set_delayed_payment_basepoint(uint64_t this_ptr, int8_tArray val) {
30806 LDKAcceptChannel this_ptr_conv;
30807 this_ptr_conv.inner = untag_ptr(this_ptr);
30808 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30809 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30810 this_ptr_conv.is_owned = false;
30811 LDKPublicKey val_ref;
30812 CHECK(val->arr_len == 33);
30813 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
30814 AcceptChannel_set_delayed_payment_basepoint(&this_ptr_conv, val_ref);
30817 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_htlc_basepoint"))) TS_AcceptChannel_get_htlc_basepoint(uint64_t this_ptr) {
30818 LDKAcceptChannel this_ptr_conv;
30819 this_ptr_conv.inner = untag_ptr(this_ptr);
30820 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30821 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30822 this_ptr_conv.is_owned = false;
30823 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
30824 memcpy(ret_arr->elems, AcceptChannel_get_htlc_basepoint(&this_ptr_conv).compressed_form, 33);
30828 void __attribute__((export_name("TS_AcceptChannel_set_htlc_basepoint"))) TS_AcceptChannel_set_htlc_basepoint(uint64_t this_ptr, int8_tArray val) {
30829 LDKAcceptChannel this_ptr_conv;
30830 this_ptr_conv.inner = untag_ptr(this_ptr);
30831 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30832 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30833 this_ptr_conv.is_owned = false;
30834 LDKPublicKey val_ref;
30835 CHECK(val->arr_len == 33);
30836 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
30837 AcceptChannel_set_htlc_basepoint(&this_ptr_conv, val_ref);
30840 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_first_per_commitment_point"))) TS_AcceptChannel_get_first_per_commitment_point(uint64_t this_ptr) {
30841 LDKAcceptChannel this_ptr_conv;
30842 this_ptr_conv.inner = untag_ptr(this_ptr);
30843 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30844 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30845 this_ptr_conv.is_owned = false;
30846 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
30847 memcpy(ret_arr->elems, AcceptChannel_get_first_per_commitment_point(&this_ptr_conv).compressed_form, 33);
30851 void __attribute__((export_name("TS_AcceptChannel_set_first_per_commitment_point"))) TS_AcceptChannel_set_first_per_commitment_point(uint64_t this_ptr, int8_tArray val) {
30852 LDKAcceptChannel this_ptr_conv;
30853 this_ptr_conv.inner = untag_ptr(this_ptr);
30854 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30855 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30856 this_ptr_conv.is_owned = false;
30857 LDKPublicKey val_ref;
30858 CHECK(val->arr_len == 33);
30859 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
30860 AcceptChannel_set_first_per_commitment_point(&this_ptr_conv, val_ref);
30863 uint64_t __attribute__((export_name("TS_AcceptChannel_get_channel_type"))) TS_AcceptChannel_get_channel_type(uint64_t this_ptr) {
30864 LDKAcceptChannel this_ptr_conv;
30865 this_ptr_conv.inner = untag_ptr(this_ptr);
30866 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30867 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30868 this_ptr_conv.is_owned = false;
30869 LDKChannelTypeFeatures ret_var = AcceptChannel_get_channel_type(&this_ptr_conv);
30870 uint64_t ret_ref = 0;
30871 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30872 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30876 void __attribute__((export_name("TS_AcceptChannel_set_channel_type"))) TS_AcceptChannel_set_channel_type(uint64_t this_ptr, uint64_t val) {
30877 LDKAcceptChannel this_ptr_conv;
30878 this_ptr_conv.inner = untag_ptr(this_ptr);
30879 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30880 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30881 this_ptr_conv.is_owned = false;
30882 LDKChannelTypeFeatures val_conv;
30883 val_conv.inner = untag_ptr(val);
30884 val_conv.is_owned = ptr_is_owned(val);
30885 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
30886 val_conv = ChannelTypeFeatures_clone(&val_conv);
30887 AcceptChannel_set_channel_type(&this_ptr_conv, val_conv);
30890 static inline uint64_t AcceptChannel_clone_ptr(LDKAcceptChannel *NONNULL_PTR arg) {
30891 LDKAcceptChannel ret_var = AcceptChannel_clone(arg);
30892 uint64_t ret_ref = 0;
30893 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30894 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30897 int64_t __attribute__((export_name("TS_AcceptChannel_clone_ptr"))) TS_AcceptChannel_clone_ptr(uint64_t arg) {
30898 LDKAcceptChannel arg_conv;
30899 arg_conv.inner = untag_ptr(arg);
30900 arg_conv.is_owned = ptr_is_owned(arg);
30901 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
30902 arg_conv.is_owned = false;
30903 int64_t ret_conv = AcceptChannel_clone_ptr(&arg_conv);
30907 uint64_t __attribute__((export_name("TS_AcceptChannel_clone"))) TS_AcceptChannel_clone(uint64_t orig) {
30908 LDKAcceptChannel orig_conv;
30909 orig_conv.inner = untag_ptr(orig);
30910 orig_conv.is_owned = ptr_is_owned(orig);
30911 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
30912 orig_conv.is_owned = false;
30913 LDKAcceptChannel ret_var = AcceptChannel_clone(&orig_conv);
30914 uint64_t ret_ref = 0;
30915 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30916 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30920 jboolean __attribute__((export_name("TS_AcceptChannel_eq"))) TS_AcceptChannel_eq(uint64_t a, uint64_t b) {
30921 LDKAcceptChannel a_conv;
30922 a_conv.inner = untag_ptr(a);
30923 a_conv.is_owned = ptr_is_owned(a);
30924 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
30925 a_conv.is_owned = false;
30926 LDKAcceptChannel b_conv;
30927 b_conv.inner = untag_ptr(b);
30928 b_conv.is_owned = ptr_is_owned(b);
30929 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
30930 b_conv.is_owned = false;
30931 jboolean ret_conv = AcceptChannel_eq(&a_conv, &b_conv);
30935 void __attribute__((export_name("TS_FundingCreated_free"))) TS_FundingCreated_free(uint64_t this_obj) {
30936 LDKFundingCreated this_obj_conv;
30937 this_obj_conv.inner = untag_ptr(this_obj);
30938 this_obj_conv.is_owned = ptr_is_owned(this_obj);
30939 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
30940 FundingCreated_free(this_obj_conv);
30943 int8_tArray __attribute__((export_name("TS_FundingCreated_get_temporary_channel_id"))) TS_FundingCreated_get_temporary_channel_id(uint64_t this_ptr) {
30944 LDKFundingCreated this_ptr_conv;
30945 this_ptr_conv.inner = untag_ptr(this_ptr);
30946 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30947 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30948 this_ptr_conv.is_owned = false;
30949 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
30950 memcpy(ret_arr->elems, *FundingCreated_get_temporary_channel_id(&this_ptr_conv), 32);
30954 void __attribute__((export_name("TS_FundingCreated_set_temporary_channel_id"))) TS_FundingCreated_set_temporary_channel_id(uint64_t this_ptr, int8_tArray val) {
30955 LDKFundingCreated this_ptr_conv;
30956 this_ptr_conv.inner = untag_ptr(this_ptr);
30957 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30958 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30959 this_ptr_conv.is_owned = false;
30960 LDKThirtyTwoBytes val_ref;
30961 CHECK(val->arr_len == 32);
30962 memcpy(val_ref.data, val->elems, 32); FREE(val);
30963 FundingCreated_set_temporary_channel_id(&this_ptr_conv, val_ref);
30966 int8_tArray __attribute__((export_name("TS_FundingCreated_get_funding_txid"))) TS_FundingCreated_get_funding_txid(uint64_t this_ptr) {
30967 LDKFundingCreated this_ptr_conv;
30968 this_ptr_conv.inner = untag_ptr(this_ptr);
30969 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30970 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30971 this_ptr_conv.is_owned = false;
30972 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
30973 memcpy(ret_arr->elems, *FundingCreated_get_funding_txid(&this_ptr_conv), 32);
30977 void __attribute__((export_name("TS_FundingCreated_set_funding_txid"))) TS_FundingCreated_set_funding_txid(uint64_t this_ptr, int8_tArray val) {
30978 LDKFundingCreated this_ptr_conv;
30979 this_ptr_conv.inner = untag_ptr(this_ptr);
30980 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30981 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30982 this_ptr_conv.is_owned = false;
30983 LDKThirtyTwoBytes val_ref;
30984 CHECK(val->arr_len == 32);
30985 memcpy(val_ref.data, val->elems, 32); FREE(val);
30986 FundingCreated_set_funding_txid(&this_ptr_conv, val_ref);
30989 int16_t __attribute__((export_name("TS_FundingCreated_get_funding_output_index"))) TS_FundingCreated_get_funding_output_index(uint64_t this_ptr) {
30990 LDKFundingCreated this_ptr_conv;
30991 this_ptr_conv.inner = untag_ptr(this_ptr);
30992 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30993 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30994 this_ptr_conv.is_owned = false;
30995 int16_t ret_conv = FundingCreated_get_funding_output_index(&this_ptr_conv);
30999 void __attribute__((export_name("TS_FundingCreated_set_funding_output_index"))) TS_FundingCreated_set_funding_output_index(uint64_t this_ptr, int16_t val) {
31000 LDKFundingCreated this_ptr_conv;
31001 this_ptr_conv.inner = untag_ptr(this_ptr);
31002 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31003 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31004 this_ptr_conv.is_owned = false;
31005 FundingCreated_set_funding_output_index(&this_ptr_conv, val);
31008 int8_tArray __attribute__((export_name("TS_FundingCreated_get_signature"))) TS_FundingCreated_get_signature(uint64_t this_ptr) {
31009 LDKFundingCreated this_ptr_conv;
31010 this_ptr_conv.inner = untag_ptr(this_ptr);
31011 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31012 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31013 this_ptr_conv.is_owned = false;
31014 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
31015 memcpy(ret_arr->elems, FundingCreated_get_signature(&this_ptr_conv).compact_form, 64);
31019 void __attribute__((export_name("TS_FundingCreated_set_signature"))) TS_FundingCreated_set_signature(uint64_t this_ptr, int8_tArray val) {
31020 LDKFundingCreated this_ptr_conv;
31021 this_ptr_conv.inner = untag_ptr(this_ptr);
31022 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31023 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31024 this_ptr_conv.is_owned = false;
31025 LDKSignature val_ref;
31026 CHECK(val->arr_len == 64);
31027 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
31028 FundingCreated_set_signature(&this_ptr_conv, val_ref);
31031 uint64_t __attribute__((export_name("TS_FundingCreated_new"))) TS_FundingCreated_new(int8_tArray temporary_channel_id_arg, int8_tArray funding_txid_arg, int16_t funding_output_index_arg, int8_tArray signature_arg) {
31032 LDKThirtyTwoBytes temporary_channel_id_arg_ref;
31033 CHECK(temporary_channel_id_arg->arr_len == 32);
31034 memcpy(temporary_channel_id_arg_ref.data, temporary_channel_id_arg->elems, 32); FREE(temporary_channel_id_arg);
31035 LDKThirtyTwoBytes funding_txid_arg_ref;
31036 CHECK(funding_txid_arg->arr_len == 32);
31037 memcpy(funding_txid_arg_ref.data, funding_txid_arg->elems, 32); FREE(funding_txid_arg);
31038 LDKSignature signature_arg_ref;
31039 CHECK(signature_arg->arr_len == 64);
31040 memcpy(signature_arg_ref.compact_form, signature_arg->elems, 64); FREE(signature_arg);
31041 LDKFundingCreated ret_var = FundingCreated_new(temporary_channel_id_arg_ref, funding_txid_arg_ref, funding_output_index_arg, signature_arg_ref);
31042 uint64_t ret_ref = 0;
31043 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31044 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31048 static inline uint64_t FundingCreated_clone_ptr(LDKFundingCreated *NONNULL_PTR arg) {
31049 LDKFundingCreated ret_var = FundingCreated_clone(arg);
31050 uint64_t ret_ref = 0;
31051 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31052 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31055 int64_t __attribute__((export_name("TS_FundingCreated_clone_ptr"))) TS_FundingCreated_clone_ptr(uint64_t arg) {
31056 LDKFundingCreated arg_conv;
31057 arg_conv.inner = untag_ptr(arg);
31058 arg_conv.is_owned = ptr_is_owned(arg);
31059 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
31060 arg_conv.is_owned = false;
31061 int64_t ret_conv = FundingCreated_clone_ptr(&arg_conv);
31065 uint64_t __attribute__((export_name("TS_FundingCreated_clone"))) TS_FundingCreated_clone(uint64_t orig) {
31066 LDKFundingCreated orig_conv;
31067 orig_conv.inner = untag_ptr(orig);
31068 orig_conv.is_owned = ptr_is_owned(orig);
31069 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
31070 orig_conv.is_owned = false;
31071 LDKFundingCreated ret_var = FundingCreated_clone(&orig_conv);
31072 uint64_t ret_ref = 0;
31073 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31074 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31078 jboolean __attribute__((export_name("TS_FundingCreated_eq"))) TS_FundingCreated_eq(uint64_t a, uint64_t b) {
31079 LDKFundingCreated a_conv;
31080 a_conv.inner = untag_ptr(a);
31081 a_conv.is_owned = ptr_is_owned(a);
31082 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
31083 a_conv.is_owned = false;
31084 LDKFundingCreated b_conv;
31085 b_conv.inner = untag_ptr(b);
31086 b_conv.is_owned = ptr_is_owned(b);
31087 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
31088 b_conv.is_owned = false;
31089 jboolean ret_conv = FundingCreated_eq(&a_conv, &b_conv);
31093 void __attribute__((export_name("TS_FundingSigned_free"))) TS_FundingSigned_free(uint64_t this_obj) {
31094 LDKFundingSigned this_obj_conv;
31095 this_obj_conv.inner = untag_ptr(this_obj);
31096 this_obj_conv.is_owned = ptr_is_owned(this_obj);
31097 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
31098 FundingSigned_free(this_obj_conv);
31101 int8_tArray __attribute__((export_name("TS_FundingSigned_get_channel_id"))) TS_FundingSigned_get_channel_id(uint64_t this_ptr) {
31102 LDKFundingSigned this_ptr_conv;
31103 this_ptr_conv.inner = untag_ptr(this_ptr);
31104 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31105 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31106 this_ptr_conv.is_owned = false;
31107 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
31108 memcpy(ret_arr->elems, *FundingSigned_get_channel_id(&this_ptr_conv), 32);
31112 void __attribute__((export_name("TS_FundingSigned_set_channel_id"))) TS_FundingSigned_set_channel_id(uint64_t this_ptr, int8_tArray val) {
31113 LDKFundingSigned this_ptr_conv;
31114 this_ptr_conv.inner = untag_ptr(this_ptr);
31115 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31116 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31117 this_ptr_conv.is_owned = false;
31118 LDKThirtyTwoBytes val_ref;
31119 CHECK(val->arr_len == 32);
31120 memcpy(val_ref.data, val->elems, 32); FREE(val);
31121 FundingSigned_set_channel_id(&this_ptr_conv, val_ref);
31124 int8_tArray __attribute__((export_name("TS_FundingSigned_get_signature"))) TS_FundingSigned_get_signature(uint64_t this_ptr) {
31125 LDKFundingSigned this_ptr_conv;
31126 this_ptr_conv.inner = untag_ptr(this_ptr);
31127 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31128 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31129 this_ptr_conv.is_owned = false;
31130 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
31131 memcpy(ret_arr->elems, FundingSigned_get_signature(&this_ptr_conv).compact_form, 64);
31135 void __attribute__((export_name("TS_FundingSigned_set_signature"))) TS_FundingSigned_set_signature(uint64_t this_ptr, int8_tArray val) {
31136 LDKFundingSigned this_ptr_conv;
31137 this_ptr_conv.inner = untag_ptr(this_ptr);
31138 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31139 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31140 this_ptr_conv.is_owned = false;
31141 LDKSignature val_ref;
31142 CHECK(val->arr_len == 64);
31143 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
31144 FundingSigned_set_signature(&this_ptr_conv, val_ref);
31147 uint64_t __attribute__((export_name("TS_FundingSigned_new"))) TS_FundingSigned_new(int8_tArray channel_id_arg, int8_tArray signature_arg) {
31148 LDKThirtyTwoBytes channel_id_arg_ref;
31149 CHECK(channel_id_arg->arr_len == 32);
31150 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
31151 LDKSignature signature_arg_ref;
31152 CHECK(signature_arg->arr_len == 64);
31153 memcpy(signature_arg_ref.compact_form, signature_arg->elems, 64); FREE(signature_arg);
31154 LDKFundingSigned ret_var = FundingSigned_new(channel_id_arg_ref, signature_arg_ref);
31155 uint64_t ret_ref = 0;
31156 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31157 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31161 static inline uint64_t FundingSigned_clone_ptr(LDKFundingSigned *NONNULL_PTR arg) {
31162 LDKFundingSigned ret_var = FundingSigned_clone(arg);
31163 uint64_t ret_ref = 0;
31164 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31165 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31168 int64_t __attribute__((export_name("TS_FundingSigned_clone_ptr"))) TS_FundingSigned_clone_ptr(uint64_t arg) {
31169 LDKFundingSigned arg_conv;
31170 arg_conv.inner = untag_ptr(arg);
31171 arg_conv.is_owned = ptr_is_owned(arg);
31172 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
31173 arg_conv.is_owned = false;
31174 int64_t ret_conv = FundingSigned_clone_ptr(&arg_conv);
31178 uint64_t __attribute__((export_name("TS_FundingSigned_clone"))) TS_FundingSigned_clone(uint64_t orig) {
31179 LDKFundingSigned orig_conv;
31180 orig_conv.inner = untag_ptr(orig);
31181 orig_conv.is_owned = ptr_is_owned(orig);
31182 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
31183 orig_conv.is_owned = false;
31184 LDKFundingSigned ret_var = FundingSigned_clone(&orig_conv);
31185 uint64_t ret_ref = 0;
31186 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31187 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31191 jboolean __attribute__((export_name("TS_FundingSigned_eq"))) TS_FundingSigned_eq(uint64_t a, uint64_t b) {
31192 LDKFundingSigned a_conv;
31193 a_conv.inner = untag_ptr(a);
31194 a_conv.is_owned = ptr_is_owned(a);
31195 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
31196 a_conv.is_owned = false;
31197 LDKFundingSigned b_conv;
31198 b_conv.inner = untag_ptr(b);
31199 b_conv.is_owned = ptr_is_owned(b);
31200 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
31201 b_conv.is_owned = false;
31202 jboolean ret_conv = FundingSigned_eq(&a_conv, &b_conv);
31206 void __attribute__((export_name("TS_ChannelReady_free"))) TS_ChannelReady_free(uint64_t this_obj) {
31207 LDKChannelReady this_obj_conv;
31208 this_obj_conv.inner = untag_ptr(this_obj);
31209 this_obj_conv.is_owned = ptr_is_owned(this_obj);
31210 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
31211 ChannelReady_free(this_obj_conv);
31214 int8_tArray __attribute__((export_name("TS_ChannelReady_get_channel_id"))) TS_ChannelReady_get_channel_id(uint64_t this_ptr) {
31215 LDKChannelReady this_ptr_conv;
31216 this_ptr_conv.inner = untag_ptr(this_ptr);
31217 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31218 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31219 this_ptr_conv.is_owned = false;
31220 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
31221 memcpy(ret_arr->elems, *ChannelReady_get_channel_id(&this_ptr_conv), 32);
31225 void __attribute__((export_name("TS_ChannelReady_set_channel_id"))) TS_ChannelReady_set_channel_id(uint64_t this_ptr, int8_tArray val) {
31226 LDKChannelReady this_ptr_conv;
31227 this_ptr_conv.inner = untag_ptr(this_ptr);
31228 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31229 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31230 this_ptr_conv.is_owned = false;
31231 LDKThirtyTwoBytes val_ref;
31232 CHECK(val->arr_len == 32);
31233 memcpy(val_ref.data, val->elems, 32); FREE(val);
31234 ChannelReady_set_channel_id(&this_ptr_conv, val_ref);
31237 int8_tArray __attribute__((export_name("TS_ChannelReady_get_next_per_commitment_point"))) TS_ChannelReady_get_next_per_commitment_point(uint64_t this_ptr) {
31238 LDKChannelReady this_ptr_conv;
31239 this_ptr_conv.inner = untag_ptr(this_ptr);
31240 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31241 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31242 this_ptr_conv.is_owned = false;
31243 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
31244 memcpy(ret_arr->elems, ChannelReady_get_next_per_commitment_point(&this_ptr_conv).compressed_form, 33);
31248 void __attribute__((export_name("TS_ChannelReady_set_next_per_commitment_point"))) TS_ChannelReady_set_next_per_commitment_point(uint64_t this_ptr, int8_tArray val) {
31249 LDKChannelReady this_ptr_conv;
31250 this_ptr_conv.inner = untag_ptr(this_ptr);
31251 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31252 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31253 this_ptr_conv.is_owned = false;
31254 LDKPublicKey val_ref;
31255 CHECK(val->arr_len == 33);
31256 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
31257 ChannelReady_set_next_per_commitment_point(&this_ptr_conv, val_ref);
31260 uint64_t __attribute__((export_name("TS_ChannelReady_get_short_channel_id_alias"))) TS_ChannelReady_get_short_channel_id_alias(uint64_t this_ptr) {
31261 LDKChannelReady this_ptr_conv;
31262 this_ptr_conv.inner = untag_ptr(this_ptr);
31263 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31264 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31265 this_ptr_conv.is_owned = false;
31266 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
31267 *ret_copy = ChannelReady_get_short_channel_id_alias(&this_ptr_conv);
31268 uint64_t ret_ref = tag_ptr(ret_copy, true);
31272 void __attribute__((export_name("TS_ChannelReady_set_short_channel_id_alias"))) TS_ChannelReady_set_short_channel_id_alias(uint64_t this_ptr, uint64_t val) {
31273 LDKChannelReady this_ptr_conv;
31274 this_ptr_conv.inner = untag_ptr(this_ptr);
31275 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31276 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31277 this_ptr_conv.is_owned = false;
31278 void* val_ptr = untag_ptr(val);
31279 CHECK_ACCESS(val_ptr);
31280 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
31281 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
31282 ChannelReady_set_short_channel_id_alias(&this_ptr_conv, val_conv);
31285 uint64_t __attribute__((export_name("TS_ChannelReady_new"))) TS_ChannelReady_new(int8_tArray channel_id_arg, int8_tArray next_per_commitment_point_arg, uint64_t short_channel_id_alias_arg) {
31286 LDKThirtyTwoBytes channel_id_arg_ref;
31287 CHECK(channel_id_arg->arr_len == 32);
31288 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
31289 LDKPublicKey next_per_commitment_point_arg_ref;
31290 CHECK(next_per_commitment_point_arg->arr_len == 33);
31291 memcpy(next_per_commitment_point_arg_ref.compressed_form, next_per_commitment_point_arg->elems, 33); FREE(next_per_commitment_point_arg);
31292 void* short_channel_id_alias_arg_ptr = untag_ptr(short_channel_id_alias_arg);
31293 CHECK_ACCESS(short_channel_id_alias_arg_ptr);
31294 LDKCOption_u64Z short_channel_id_alias_arg_conv = *(LDKCOption_u64Z*)(short_channel_id_alias_arg_ptr);
31295 short_channel_id_alias_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(short_channel_id_alias_arg));
31296 LDKChannelReady ret_var = ChannelReady_new(channel_id_arg_ref, next_per_commitment_point_arg_ref, short_channel_id_alias_arg_conv);
31297 uint64_t ret_ref = 0;
31298 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31299 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31303 static inline uint64_t ChannelReady_clone_ptr(LDKChannelReady *NONNULL_PTR arg) {
31304 LDKChannelReady ret_var = ChannelReady_clone(arg);
31305 uint64_t ret_ref = 0;
31306 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31307 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31310 int64_t __attribute__((export_name("TS_ChannelReady_clone_ptr"))) TS_ChannelReady_clone_ptr(uint64_t arg) {
31311 LDKChannelReady arg_conv;
31312 arg_conv.inner = untag_ptr(arg);
31313 arg_conv.is_owned = ptr_is_owned(arg);
31314 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
31315 arg_conv.is_owned = false;
31316 int64_t ret_conv = ChannelReady_clone_ptr(&arg_conv);
31320 uint64_t __attribute__((export_name("TS_ChannelReady_clone"))) TS_ChannelReady_clone(uint64_t orig) {
31321 LDKChannelReady orig_conv;
31322 orig_conv.inner = untag_ptr(orig);
31323 orig_conv.is_owned = ptr_is_owned(orig);
31324 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
31325 orig_conv.is_owned = false;
31326 LDKChannelReady ret_var = ChannelReady_clone(&orig_conv);
31327 uint64_t ret_ref = 0;
31328 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31329 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31333 jboolean __attribute__((export_name("TS_ChannelReady_eq"))) TS_ChannelReady_eq(uint64_t a, uint64_t b) {
31334 LDKChannelReady a_conv;
31335 a_conv.inner = untag_ptr(a);
31336 a_conv.is_owned = ptr_is_owned(a);
31337 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
31338 a_conv.is_owned = false;
31339 LDKChannelReady b_conv;
31340 b_conv.inner = untag_ptr(b);
31341 b_conv.is_owned = ptr_is_owned(b);
31342 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
31343 b_conv.is_owned = false;
31344 jboolean ret_conv = ChannelReady_eq(&a_conv, &b_conv);
31348 void __attribute__((export_name("TS_Shutdown_free"))) TS_Shutdown_free(uint64_t this_obj) {
31349 LDKShutdown this_obj_conv;
31350 this_obj_conv.inner = untag_ptr(this_obj);
31351 this_obj_conv.is_owned = ptr_is_owned(this_obj);
31352 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
31353 Shutdown_free(this_obj_conv);
31356 int8_tArray __attribute__((export_name("TS_Shutdown_get_channel_id"))) TS_Shutdown_get_channel_id(uint64_t this_ptr) {
31357 LDKShutdown this_ptr_conv;
31358 this_ptr_conv.inner = untag_ptr(this_ptr);
31359 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31360 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31361 this_ptr_conv.is_owned = false;
31362 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
31363 memcpy(ret_arr->elems, *Shutdown_get_channel_id(&this_ptr_conv), 32);
31367 void __attribute__((export_name("TS_Shutdown_set_channel_id"))) TS_Shutdown_set_channel_id(uint64_t this_ptr, int8_tArray val) {
31368 LDKShutdown this_ptr_conv;
31369 this_ptr_conv.inner = untag_ptr(this_ptr);
31370 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31371 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31372 this_ptr_conv.is_owned = false;
31373 LDKThirtyTwoBytes val_ref;
31374 CHECK(val->arr_len == 32);
31375 memcpy(val_ref.data, val->elems, 32); FREE(val);
31376 Shutdown_set_channel_id(&this_ptr_conv, val_ref);
31379 int8_tArray __attribute__((export_name("TS_Shutdown_get_scriptpubkey"))) TS_Shutdown_get_scriptpubkey(uint64_t this_ptr) {
31380 LDKShutdown this_ptr_conv;
31381 this_ptr_conv.inner = untag_ptr(this_ptr);
31382 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31383 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31384 this_ptr_conv.is_owned = false;
31385 LDKu8slice ret_var = Shutdown_get_scriptpubkey(&this_ptr_conv);
31386 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
31387 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
31391 void __attribute__((export_name("TS_Shutdown_set_scriptpubkey"))) TS_Shutdown_set_scriptpubkey(uint64_t this_ptr, int8_tArray val) {
31392 LDKShutdown this_ptr_conv;
31393 this_ptr_conv.inner = untag_ptr(this_ptr);
31394 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31395 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31396 this_ptr_conv.is_owned = false;
31397 LDKCVec_u8Z val_ref;
31398 val_ref.datalen = val->arr_len;
31399 val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
31400 memcpy(val_ref.data, val->elems, val_ref.datalen); FREE(val);
31401 Shutdown_set_scriptpubkey(&this_ptr_conv, val_ref);
31404 uint64_t __attribute__((export_name("TS_Shutdown_new"))) TS_Shutdown_new(int8_tArray channel_id_arg, int8_tArray scriptpubkey_arg) {
31405 LDKThirtyTwoBytes channel_id_arg_ref;
31406 CHECK(channel_id_arg->arr_len == 32);
31407 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
31408 LDKCVec_u8Z scriptpubkey_arg_ref;
31409 scriptpubkey_arg_ref.datalen = scriptpubkey_arg->arr_len;
31410 scriptpubkey_arg_ref.data = MALLOC(scriptpubkey_arg_ref.datalen, "LDKCVec_u8Z Bytes");
31411 memcpy(scriptpubkey_arg_ref.data, scriptpubkey_arg->elems, scriptpubkey_arg_ref.datalen); FREE(scriptpubkey_arg);
31412 LDKShutdown ret_var = Shutdown_new(channel_id_arg_ref, scriptpubkey_arg_ref);
31413 uint64_t ret_ref = 0;
31414 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31415 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31419 static inline uint64_t Shutdown_clone_ptr(LDKShutdown *NONNULL_PTR arg) {
31420 LDKShutdown ret_var = Shutdown_clone(arg);
31421 uint64_t ret_ref = 0;
31422 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31423 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31426 int64_t __attribute__((export_name("TS_Shutdown_clone_ptr"))) TS_Shutdown_clone_ptr(uint64_t arg) {
31427 LDKShutdown arg_conv;
31428 arg_conv.inner = untag_ptr(arg);
31429 arg_conv.is_owned = ptr_is_owned(arg);
31430 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
31431 arg_conv.is_owned = false;
31432 int64_t ret_conv = Shutdown_clone_ptr(&arg_conv);
31436 uint64_t __attribute__((export_name("TS_Shutdown_clone"))) TS_Shutdown_clone(uint64_t orig) {
31437 LDKShutdown orig_conv;
31438 orig_conv.inner = untag_ptr(orig);
31439 orig_conv.is_owned = ptr_is_owned(orig);
31440 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
31441 orig_conv.is_owned = false;
31442 LDKShutdown ret_var = Shutdown_clone(&orig_conv);
31443 uint64_t ret_ref = 0;
31444 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31445 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31449 jboolean __attribute__((export_name("TS_Shutdown_eq"))) TS_Shutdown_eq(uint64_t a, uint64_t b) {
31450 LDKShutdown a_conv;
31451 a_conv.inner = untag_ptr(a);
31452 a_conv.is_owned = ptr_is_owned(a);
31453 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
31454 a_conv.is_owned = false;
31455 LDKShutdown b_conv;
31456 b_conv.inner = untag_ptr(b);
31457 b_conv.is_owned = ptr_is_owned(b);
31458 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
31459 b_conv.is_owned = false;
31460 jboolean ret_conv = Shutdown_eq(&a_conv, &b_conv);
31464 void __attribute__((export_name("TS_ClosingSignedFeeRange_free"))) TS_ClosingSignedFeeRange_free(uint64_t this_obj) {
31465 LDKClosingSignedFeeRange this_obj_conv;
31466 this_obj_conv.inner = untag_ptr(this_obj);
31467 this_obj_conv.is_owned = ptr_is_owned(this_obj);
31468 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
31469 ClosingSignedFeeRange_free(this_obj_conv);
31472 int64_t __attribute__((export_name("TS_ClosingSignedFeeRange_get_min_fee_satoshis"))) TS_ClosingSignedFeeRange_get_min_fee_satoshis(uint64_t this_ptr) {
31473 LDKClosingSignedFeeRange this_ptr_conv;
31474 this_ptr_conv.inner = untag_ptr(this_ptr);
31475 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31476 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31477 this_ptr_conv.is_owned = false;
31478 int64_t ret_conv = ClosingSignedFeeRange_get_min_fee_satoshis(&this_ptr_conv);
31482 void __attribute__((export_name("TS_ClosingSignedFeeRange_set_min_fee_satoshis"))) TS_ClosingSignedFeeRange_set_min_fee_satoshis(uint64_t this_ptr, int64_t val) {
31483 LDKClosingSignedFeeRange this_ptr_conv;
31484 this_ptr_conv.inner = untag_ptr(this_ptr);
31485 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31486 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31487 this_ptr_conv.is_owned = false;
31488 ClosingSignedFeeRange_set_min_fee_satoshis(&this_ptr_conv, val);
31491 int64_t __attribute__((export_name("TS_ClosingSignedFeeRange_get_max_fee_satoshis"))) TS_ClosingSignedFeeRange_get_max_fee_satoshis(uint64_t this_ptr) {
31492 LDKClosingSignedFeeRange this_ptr_conv;
31493 this_ptr_conv.inner = untag_ptr(this_ptr);
31494 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31495 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31496 this_ptr_conv.is_owned = false;
31497 int64_t ret_conv = ClosingSignedFeeRange_get_max_fee_satoshis(&this_ptr_conv);
31501 void __attribute__((export_name("TS_ClosingSignedFeeRange_set_max_fee_satoshis"))) TS_ClosingSignedFeeRange_set_max_fee_satoshis(uint64_t this_ptr, int64_t val) {
31502 LDKClosingSignedFeeRange this_ptr_conv;
31503 this_ptr_conv.inner = untag_ptr(this_ptr);
31504 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31505 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31506 this_ptr_conv.is_owned = false;
31507 ClosingSignedFeeRange_set_max_fee_satoshis(&this_ptr_conv, val);
31510 uint64_t __attribute__((export_name("TS_ClosingSignedFeeRange_new"))) TS_ClosingSignedFeeRange_new(int64_t min_fee_satoshis_arg, int64_t max_fee_satoshis_arg) {
31511 LDKClosingSignedFeeRange ret_var = ClosingSignedFeeRange_new(min_fee_satoshis_arg, max_fee_satoshis_arg);
31512 uint64_t ret_ref = 0;
31513 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31514 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31518 static inline uint64_t ClosingSignedFeeRange_clone_ptr(LDKClosingSignedFeeRange *NONNULL_PTR arg) {
31519 LDKClosingSignedFeeRange ret_var = ClosingSignedFeeRange_clone(arg);
31520 uint64_t ret_ref = 0;
31521 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31522 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31525 int64_t __attribute__((export_name("TS_ClosingSignedFeeRange_clone_ptr"))) TS_ClosingSignedFeeRange_clone_ptr(uint64_t arg) {
31526 LDKClosingSignedFeeRange arg_conv;
31527 arg_conv.inner = untag_ptr(arg);
31528 arg_conv.is_owned = ptr_is_owned(arg);
31529 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
31530 arg_conv.is_owned = false;
31531 int64_t ret_conv = ClosingSignedFeeRange_clone_ptr(&arg_conv);
31535 uint64_t __attribute__((export_name("TS_ClosingSignedFeeRange_clone"))) TS_ClosingSignedFeeRange_clone(uint64_t orig) {
31536 LDKClosingSignedFeeRange orig_conv;
31537 orig_conv.inner = untag_ptr(orig);
31538 orig_conv.is_owned = ptr_is_owned(orig);
31539 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
31540 orig_conv.is_owned = false;
31541 LDKClosingSignedFeeRange ret_var = ClosingSignedFeeRange_clone(&orig_conv);
31542 uint64_t ret_ref = 0;
31543 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31544 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31548 jboolean __attribute__((export_name("TS_ClosingSignedFeeRange_eq"))) TS_ClosingSignedFeeRange_eq(uint64_t a, uint64_t b) {
31549 LDKClosingSignedFeeRange a_conv;
31550 a_conv.inner = untag_ptr(a);
31551 a_conv.is_owned = ptr_is_owned(a);
31552 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
31553 a_conv.is_owned = false;
31554 LDKClosingSignedFeeRange b_conv;
31555 b_conv.inner = untag_ptr(b);
31556 b_conv.is_owned = ptr_is_owned(b);
31557 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
31558 b_conv.is_owned = false;
31559 jboolean ret_conv = ClosingSignedFeeRange_eq(&a_conv, &b_conv);
31563 void __attribute__((export_name("TS_ClosingSigned_free"))) TS_ClosingSigned_free(uint64_t this_obj) {
31564 LDKClosingSigned this_obj_conv;
31565 this_obj_conv.inner = untag_ptr(this_obj);
31566 this_obj_conv.is_owned = ptr_is_owned(this_obj);
31567 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
31568 ClosingSigned_free(this_obj_conv);
31571 int8_tArray __attribute__((export_name("TS_ClosingSigned_get_channel_id"))) TS_ClosingSigned_get_channel_id(uint64_t this_ptr) {
31572 LDKClosingSigned this_ptr_conv;
31573 this_ptr_conv.inner = untag_ptr(this_ptr);
31574 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31575 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31576 this_ptr_conv.is_owned = false;
31577 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
31578 memcpy(ret_arr->elems, *ClosingSigned_get_channel_id(&this_ptr_conv), 32);
31582 void __attribute__((export_name("TS_ClosingSigned_set_channel_id"))) TS_ClosingSigned_set_channel_id(uint64_t this_ptr, int8_tArray val) {
31583 LDKClosingSigned this_ptr_conv;
31584 this_ptr_conv.inner = untag_ptr(this_ptr);
31585 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31586 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31587 this_ptr_conv.is_owned = false;
31588 LDKThirtyTwoBytes val_ref;
31589 CHECK(val->arr_len == 32);
31590 memcpy(val_ref.data, val->elems, 32); FREE(val);
31591 ClosingSigned_set_channel_id(&this_ptr_conv, val_ref);
31594 int64_t __attribute__((export_name("TS_ClosingSigned_get_fee_satoshis"))) TS_ClosingSigned_get_fee_satoshis(uint64_t this_ptr) {
31595 LDKClosingSigned this_ptr_conv;
31596 this_ptr_conv.inner = untag_ptr(this_ptr);
31597 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31598 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31599 this_ptr_conv.is_owned = false;
31600 int64_t ret_conv = ClosingSigned_get_fee_satoshis(&this_ptr_conv);
31604 void __attribute__((export_name("TS_ClosingSigned_set_fee_satoshis"))) TS_ClosingSigned_set_fee_satoshis(uint64_t this_ptr, int64_t val) {
31605 LDKClosingSigned this_ptr_conv;
31606 this_ptr_conv.inner = untag_ptr(this_ptr);
31607 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31608 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31609 this_ptr_conv.is_owned = false;
31610 ClosingSigned_set_fee_satoshis(&this_ptr_conv, val);
31613 int8_tArray __attribute__((export_name("TS_ClosingSigned_get_signature"))) TS_ClosingSigned_get_signature(uint64_t this_ptr) {
31614 LDKClosingSigned this_ptr_conv;
31615 this_ptr_conv.inner = untag_ptr(this_ptr);
31616 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31617 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31618 this_ptr_conv.is_owned = false;
31619 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
31620 memcpy(ret_arr->elems, ClosingSigned_get_signature(&this_ptr_conv).compact_form, 64);
31624 void __attribute__((export_name("TS_ClosingSigned_set_signature"))) TS_ClosingSigned_set_signature(uint64_t this_ptr, int8_tArray val) {
31625 LDKClosingSigned this_ptr_conv;
31626 this_ptr_conv.inner = untag_ptr(this_ptr);
31627 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31628 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31629 this_ptr_conv.is_owned = false;
31630 LDKSignature val_ref;
31631 CHECK(val->arr_len == 64);
31632 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
31633 ClosingSigned_set_signature(&this_ptr_conv, val_ref);
31636 uint64_t __attribute__((export_name("TS_ClosingSigned_get_fee_range"))) TS_ClosingSigned_get_fee_range(uint64_t this_ptr) {
31637 LDKClosingSigned this_ptr_conv;
31638 this_ptr_conv.inner = untag_ptr(this_ptr);
31639 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31640 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31641 this_ptr_conv.is_owned = false;
31642 LDKClosingSignedFeeRange ret_var = ClosingSigned_get_fee_range(&this_ptr_conv);
31643 uint64_t ret_ref = 0;
31644 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31645 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31649 void __attribute__((export_name("TS_ClosingSigned_set_fee_range"))) TS_ClosingSigned_set_fee_range(uint64_t this_ptr, uint64_t val) {
31650 LDKClosingSigned this_ptr_conv;
31651 this_ptr_conv.inner = untag_ptr(this_ptr);
31652 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31653 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31654 this_ptr_conv.is_owned = false;
31655 LDKClosingSignedFeeRange val_conv;
31656 val_conv.inner = untag_ptr(val);
31657 val_conv.is_owned = ptr_is_owned(val);
31658 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
31659 val_conv = ClosingSignedFeeRange_clone(&val_conv);
31660 ClosingSigned_set_fee_range(&this_ptr_conv, val_conv);
31663 uint64_t __attribute__((export_name("TS_ClosingSigned_new"))) TS_ClosingSigned_new(int8_tArray channel_id_arg, int64_t fee_satoshis_arg, int8_tArray signature_arg, uint64_t fee_range_arg) {
31664 LDKThirtyTwoBytes channel_id_arg_ref;
31665 CHECK(channel_id_arg->arr_len == 32);
31666 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
31667 LDKSignature signature_arg_ref;
31668 CHECK(signature_arg->arr_len == 64);
31669 memcpy(signature_arg_ref.compact_form, signature_arg->elems, 64); FREE(signature_arg);
31670 LDKClosingSignedFeeRange fee_range_arg_conv;
31671 fee_range_arg_conv.inner = untag_ptr(fee_range_arg);
31672 fee_range_arg_conv.is_owned = ptr_is_owned(fee_range_arg);
31673 CHECK_INNER_FIELD_ACCESS_OR_NULL(fee_range_arg_conv);
31674 fee_range_arg_conv = ClosingSignedFeeRange_clone(&fee_range_arg_conv);
31675 LDKClosingSigned ret_var = ClosingSigned_new(channel_id_arg_ref, fee_satoshis_arg, signature_arg_ref, fee_range_arg_conv);
31676 uint64_t ret_ref = 0;
31677 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31678 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31682 static inline uint64_t ClosingSigned_clone_ptr(LDKClosingSigned *NONNULL_PTR arg) {
31683 LDKClosingSigned ret_var = ClosingSigned_clone(arg);
31684 uint64_t ret_ref = 0;
31685 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31686 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31689 int64_t __attribute__((export_name("TS_ClosingSigned_clone_ptr"))) TS_ClosingSigned_clone_ptr(uint64_t arg) {
31690 LDKClosingSigned arg_conv;
31691 arg_conv.inner = untag_ptr(arg);
31692 arg_conv.is_owned = ptr_is_owned(arg);
31693 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
31694 arg_conv.is_owned = false;
31695 int64_t ret_conv = ClosingSigned_clone_ptr(&arg_conv);
31699 uint64_t __attribute__((export_name("TS_ClosingSigned_clone"))) TS_ClosingSigned_clone(uint64_t orig) {
31700 LDKClosingSigned orig_conv;
31701 orig_conv.inner = untag_ptr(orig);
31702 orig_conv.is_owned = ptr_is_owned(orig);
31703 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
31704 orig_conv.is_owned = false;
31705 LDKClosingSigned ret_var = ClosingSigned_clone(&orig_conv);
31706 uint64_t ret_ref = 0;
31707 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31708 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31712 jboolean __attribute__((export_name("TS_ClosingSigned_eq"))) TS_ClosingSigned_eq(uint64_t a, uint64_t b) {
31713 LDKClosingSigned a_conv;
31714 a_conv.inner = untag_ptr(a);
31715 a_conv.is_owned = ptr_is_owned(a);
31716 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
31717 a_conv.is_owned = false;
31718 LDKClosingSigned b_conv;
31719 b_conv.inner = untag_ptr(b);
31720 b_conv.is_owned = ptr_is_owned(b);
31721 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
31722 b_conv.is_owned = false;
31723 jboolean ret_conv = ClosingSigned_eq(&a_conv, &b_conv);
31727 void __attribute__((export_name("TS_UpdateAddHTLC_free"))) TS_UpdateAddHTLC_free(uint64_t this_obj) {
31728 LDKUpdateAddHTLC this_obj_conv;
31729 this_obj_conv.inner = untag_ptr(this_obj);
31730 this_obj_conv.is_owned = ptr_is_owned(this_obj);
31731 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
31732 UpdateAddHTLC_free(this_obj_conv);
31735 int8_tArray __attribute__((export_name("TS_UpdateAddHTLC_get_channel_id"))) TS_UpdateAddHTLC_get_channel_id(uint64_t this_ptr) {
31736 LDKUpdateAddHTLC this_ptr_conv;
31737 this_ptr_conv.inner = untag_ptr(this_ptr);
31738 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31739 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31740 this_ptr_conv.is_owned = false;
31741 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
31742 memcpy(ret_arr->elems, *UpdateAddHTLC_get_channel_id(&this_ptr_conv), 32);
31746 void __attribute__((export_name("TS_UpdateAddHTLC_set_channel_id"))) TS_UpdateAddHTLC_set_channel_id(uint64_t this_ptr, int8_tArray val) {
31747 LDKUpdateAddHTLC this_ptr_conv;
31748 this_ptr_conv.inner = untag_ptr(this_ptr);
31749 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31750 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31751 this_ptr_conv.is_owned = false;
31752 LDKThirtyTwoBytes val_ref;
31753 CHECK(val->arr_len == 32);
31754 memcpy(val_ref.data, val->elems, 32); FREE(val);
31755 UpdateAddHTLC_set_channel_id(&this_ptr_conv, val_ref);
31758 int64_t __attribute__((export_name("TS_UpdateAddHTLC_get_htlc_id"))) TS_UpdateAddHTLC_get_htlc_id(uint64_t this_ptr) {
31759 LDKUpdateAddHTLC this_ptr_conv;
31760 this_ptr_conv.inner = untag_ptr(this_ptr);
31761 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31762 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31763 this_ptr_conv.is_owned = false;
31764 int64_t ret_conv = UpdateAddHTLC_get_htlc_id(&this_ptr_conv);
31768 void __attribute__((export_name("TS_UpdateAddHTLC_set_htlc_id"))) TS_UpdateAddHTLC_set_htlc_id(uint64_t this_ptr, int64_t val) {
31769 LDKUpdateAddHTLC this_ptr_conv;
31770 this_ptr_conv.inner = untag_ptr(this_ptr);
31771 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31772 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31773 this_ptr_conv.is_owned = false;
31774 UpdateAddHTLC_set_htlc_id(&this_ptr_conv, val);
31777 int64_t __attribute__((export_name("TS_UpdateAddHTLC_get_amount_msat"))) TS_UpdateAddHTLC_get_amount_msat(uint64_t this_ptr) {
31778 LDKUpdateAddHTLC this_ptr_conv;
31779 this_ptr_conv.inner = untag_ptr(this_ptr);
31780 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31781 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31782 this_ptr_conv.is_owned = false;
31783 int64_t ret_conv = UpdateAddHTLC_get_amount_msat(&this_ptr_conv);
31787 void __attribute__((export_name("TS_UpdateAddHTLC_set_amount_msat"))) TS_UpdateAddHTLC_set_amount_msat(uint64_t this_ptr, int64_t val) {
31788 LDKUpdateAddHTLC this_ptr_conv;
31789 this_ptr_conv.inner = untag_ptr(this_ptr);
31790 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31791 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31792 this_ptr_conv.is_owned = false;
31793 UpdateAddHTLC_set_amount_msat(&this_ptr_conv, val);
31796 int8_tArray __attribute__((export_name("TS_UpdateAddHTLC_get_payment_hash"))) TS_UpdateAddHTLC_get_payment_hash(uint64_t this_ptr) {
31797 LDKUpdateAddHTLC this_ptr_conv;
31798 this_ptr_conv.inner = untag_ptr(this_ptr);
31799 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31800 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31801 this_ptr_conv.is_owned = false;
31802 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
31803 memcpy(ret_arr->elems, *UpdateAddHTLC_get_payment_hash(&this_ptr_conv), 32);
31807 void __attribute__((export_name("TS_UpdateAddHTLC_set_payment_hash"))) TS_UpdateAddHTLC_set_payment_hash(uint64_t this_ptr, int8_tArray val) {
31808 LDKUpdateAddHTLC this_ptr_conv;
31809 this_ptr_conv.inner = untag_ptr(this_ptr);
31810 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31811 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31812 this_ptr_conv.is_owned = false;
31813 LDKThirtyTwoBytes val_ref;
31814 CHECK(val->arr_len == 32);
31815 memcpy(val_ref.data, val->elems, 32); FREE(val);
31816 UpdateAddHTLC_set_payment_hash(&this_ptr_conv, val_ref);
31819 int32_t __attribute__((export_name("TS_UpdateAddHTLC_get_cltv_expiry"))) TS_UpdateAddHTLC_get_cltv_expiry(uint64_t this_ptr) {
31820 LDKUpdateAddHTLC this_ptr_conv;
31821 this_ptr_conv.inner = untag_ptr(this_ptr);
31822 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31823 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31824 this_ptr_conv.is_owned = false;
31825 int32_t ret_conv = UpdateAddHTLC_get_cltv_expiry(&this_ptr_conv);
31829 void __attribute__((export_name("TS_UpdateAddHTLC_set_cltv_expiry"))) TS_UpdateAddHTLC_set_cltv_expiry(uint64_t this_ptr, int32_t val) {
31830 LDKUpdateAddHTLC this_ptr_conv;
31831 this_ptr_conv.inner = untag_ptr(this_ptr);
31832 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31833 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31834 this_ptr_conv.is_owned = false;
31835 UpdateAddHTLC_set_cltv_expiry(&this_ptr_conv, val);
31838 static inline uint64_t UpdateAddHTLC_clone_ptr(LDKUpdateAddHTLC *NONNULL_PTR arg) {
31839 LDKUpdateAddHTLC ret_var = UpdateAddHTLC_clone(arg);
31840 uint64_t ret_ref = 0;
31841 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31842 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31845 int64_t __attribute__((export_name("TS_UpdateAddHTLC_clone_ptr"))) TS_UpdateAddHTLC_clone_ptr(uint64_t arg) {
31846 LDKUpdateAddHTLC arg_conv;
31847 arg_conv.inner = untag_ptr(arg);
31848 arg_conv.is_owned = ptr_is_owned(arg);
31849 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
31850 arg_conv.is_owned = false;
31851 int64_t ret_conv = UpdateAddHTLC_clone_ptr(&arg_conv);
31855 uint64_t __attribute__((export_name("TS_UpdateAddHTLC_clone"))) TS_UpdateAddHTLC_clone(uint64_t orig) {
31856 LDKUpdateAddHTLC orig_conv;
31857 orig_conv.inner = untag_ptr(orig);
31858 orig_conv.is_owned = ptr_is_owned(orig);
31859 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
31860 orig_conv.is_owned = false;
31861 LDKUpdateAddHTLC ret_var = UpdateAddHTLC_clone(&orig_conv);
31862 uint64_t ret_ref = 0;
31863 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31864 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31868 jboolean __attribute__((export_name("TS_UpdateAddHTLC_eq"))) TS_UpdateAddHTLC_eq(uint64_t a, uint64_t b) {
31869 LDKUpdateAddHTLC a_conv;
31870 a_conv.inner = untag_ptr(a);
31871 a_conv.is_owned = ptr_is_owned(a);
31872 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
31873 a_conv.is_owned = false;
31874 LDKUpdateAddHTLC b_conv;
31875 b_conv.inner = untag_ptr(b);
31876 b_conv.is_owned = ptr_is_owned(b);
31877 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
31878 b_conv.is_owned = false;
31879 jboolean ret_conv = UpdateAddHTLC_eq(&a_conv, &b_conv);
31883 void __attribute__((export_name("TS_OnionMessage_free"))) TS_OnionMessage_free(uint64_t this_obj) {
31884 LDKOnionMessage this_obj_conv;
31885 this_obj_conv.inner = untag_ptr(this_obj);
31886 this_obj_conv.is_owned = ptr_is_owned(this_obj);
31887 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
31888 OnionMessage_free(this_obj_conv);
31891 int8_tArray __attribute__((export_name("TS_OnionMessage_get_blinding_point"))) TS_OnionMessage_get_blinding_point(uint64_t this_ptr) {
31892 LDKOnionMessage this_ptr_conv;
31893 this_ptr_conv.inner = untag_ptr(this_ptr);
31894 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31895 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31896 this_ptr_conv.is_owned = false;
31897 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
31898 memcpy(ret_arr->elems, OnionMessage_get_blinding_point(&this_ptr_conv).compressed_form, 33);
31902 void __attribute__((export_name("TS_OnionMessage_set_blinding_point"))) TS_OnionMessage_set_blinding_point(uint64_t this_ptr, int8_tArray val) {
31903 LDKOnionMessage this_ptr_conv;
31904 this_ptr_conv.inner = untag_ptr(this_ptr);
31905 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31906 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31907 this_ptr_conv.is_owned = false;
31908 LDKPublicKey val_ref;
31909 CHECK(val->arr_len == 33);
31910 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
31911 OnionMessage_set_blinding_point(&this_ptr_conv, val_ref);
31914 static inline uint64_t OnionMessage_clone_ptr(LDKOnionMessage *NONNULL_PTR arg) {
31915 LDKOnionMessage ret_var = OnionMessage_clone(arg);
31916 uint64_t ret_ref = 0;
31917 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31918 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31921 int64_t __attribute__((export_name("TS_OnionMessage_clone_ptr"))) TS_OnionMessage_clone_ptr(uint64_t arg) {
31922 LDKOnionMessage arg_conv;
31923 arg_conv.inner = untag_ptr(arg);
31924 arg_conv.is_owned = ptr_is_owned(arg);
31925 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
31926 arg_conv.is_owned = false;
31927 int64_t ret_conv = OnionMessage_clone_ptr(&arg_conv);
31931 uint64_t __attribute__((export_name("TS_OnionMessage_clone"))) TS_OnionMessage_clone(uint64_t orig) {
31932 LDKOnionMessage orig_conv;
31933 orig_conv.inner = untag_ptr(orig);
31934 orig_conv.is_owned = ptr_is_owned(orig);
31935 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
31936 orig_conv.is_owned = false;
31937 LDKOnionMessage ret_var = OnionMessage_clone(&orig_conv);
31938 uint64_t ret_ref = 0;
31939 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31940 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31944 jboolean __attribute__((export_name("TS_OnionMessage_eq"))) TS_OnionMessage_eq(uint64_t a, uint64_t b) {
31945 LDKOnionMessage a_conv;
31946 a_conv.inner = untag_ptr(a);
31947 a_conv.is_owned = ptr_is_owned(a);
31948 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
31949 a_conv.is_owned = false;
31950 LDKOnionMessage b_conv;
31951 b_conv.inner = untag_ptr(b);
31952 b_conv.is_owned = ptr_is_owned(b);
31953 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
31954 b_conv.is_owned = false;
31955 jboolean ret_conv = OnionMessage_eq(&a_conv, &b_conv);
31959 void __attribute__((export_name("TS_UpdateFulfillHTLC_free"))) TS_UpdateFulfillHTLC_free(uint64_t this_obj) {
31960 LDKUpdateFulfillHTLC this_obj_conv;
31961 this_obj_conv.inner = untag_ptr(this_obj);
31962 this_obj_conv.is_owned = ptr_is_owned(this_obj);
31963 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
31964 UpdateFulfillHTLC_free(this_obj_conv);
31967 int8_tArray __attribute__((export_name("TS_UpdateFulfillHTLC_get_channel_id"))) TS_UpdateFulfillHTLC_get_channel_id(uint64_t this_ptr) {
31968 LDKUpdateFulfillHTLC this_ptr_conv;
31969 this_ptr_conv.inner = untag_ptr(this_ptr);
31970 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31971 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31972 this_ptr_conv.is_owned = false;
31973 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
31974 memcpy(ret_arr->elems, *UpdateFulfillHTLC_get_channel_id(&this_ptr_conv), 32);
31978 void __attribute__((export_name("TS_UpdateFulfillHTLC_set_channel_id"))) TS_UpdateFulfillHTLC_set_channel_id(uint64_t this_ptr, int8_tArray val) {
31979 LDKUpdateFulfillHTLC this_ptr_conv;
31980 this_ptr_conv.inner = untag_ptr(this_ptr);
31981 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31982 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31983 this_ptr_conv.is_owned = false;
31984 LDKThirtyTwoBytes val_ref;
31985 CHECK(val->arr_len == 32);
31986 memcpy(val_ref.data, val->elems, 32); FREE(val);
31987 UpdateFulfillHTLC_set_channel_id(&this_ptr_conv, val_ref);
31990 int64_t __attribute__((export_name("TS_UpdateFulfillHTLC_get_htlc_id"))) TS_UpdateFulfillHTLC_get_htlc_id(uint64_t this_ptr) {
31991 LDKUpdateFulfillHTLC this_ptr_conv;
31992 this_ptr_conv.inner = untag_ptr(this_ptr);
31993 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31994 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31995 this_ptr_conv.is_owned = false;
31996 int64_t ret_conv = UpdateFulfillHTLC_get_htlc_id(&this_ptr_conv);
32000 void __attribute__((export_name("TS_UpdateFulfillHTLC_set_htlc_id"))) TS_UpdateFulfillHTLC_set_htlc_id(uint64_t this_ptr, int64_t val) {
32001 LDKUpdateFulfillHTLC this_ptr_conv;
32002 this_ptr_conv.inner = untag_ptr(this_ptr);
32003 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32004 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32005 this_ptr_conv.is_owned = false;
32006 UpdateFulfillHTLC_set_htlc_id(&this_ptr_conv, val);
32009 int8_tArray __attribute__((export_name("TS_UpdateFulfillHTLC_get_payment_preimage"))) TS_UpdateFulfillHTLC_get_payment_preimage(uint64_t this_ptr) {
32010 LDKUpdateFulfillHTLC this_ptr_conv;
32011 this_ptr_conv.inner = untag_ptr(this_ptr);
32012 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32013 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32014 this_ptr_conv.is_owned = false;
32015 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
32016 memcpy(ret_arr->elems, *UpdateFulfillHTLC_get_payment_preimage(&this_ptr_conv), 32);
32020 void __attribute__((export_name("TS_UpdateFulfillHTLC_set_payment_preimage"))) TS_UpdateFulfillHTLC_set_payment_preimage(uint64_t this_ptr, int8_tArray val) {
32021 LDKUpdateFulfillHTLC this_ptr_conv;
32022 this_ptr_conv.inner = untag_ptr(this_ptr);
32023 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32024 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32025 this_ptr_conv.is_owned = false;
32026 LDKThirtyTwoBytes val_ref;
32027 CHECK(val->arr_len == 32);
32028 memcpy(val_ref.data, val->elems, 32); FREE(val);
32029 UpdateFulfillHTLC_set_payment_preimage(&this_ptr_conv, val_ref);
32032 uint64_t __attribute__((export_name("TS_UpdateFulfillHTLC_new"))) TS_UpdateFulfillHTLC_new(int8_tArray channel_id_arg, int64_t htlc_id_arg, int8_tArray payment_preimage_arg) {
32033 LDKThirtyTwoBytes channel_id_arg_ref;
32034 CHECK(channel_id_arg->arr_len == 32);
32035 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
32036 LDKThirtyTwoBytes payment_preimage_arg_ref;
32037 CHECK(payment_preimage_arg->arr_len == 32);
32038 memcpy(payment_preimage_arg_ref.data, payment_preimage_arg->elems, 32); FREE(payment_preimage_arg);
32039 LDKUpdateFulfillHTLC ret_var = UpdateFulfillHTLC_new(channel_id_arg_ref, htlc_id_arg, payment_preimage_arg_ref);
32040 uint64_t ret_ref = 0;
32041 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32042 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32046 static inline uint64_t UpdateFulfillHTLC_clone_ptr(LDKUpdateFulfillHTLC *NONNULL_PTR arg) {
32047 LDKUpdateFulfillHTLC ret_var = UpdateFulfillHTLC_clone(arg);
32048 uint64_t ret_ref = 0;
32049 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32050 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32053 int64_t __attribute__((export_name("TS_UpdateFulfillHTLC_clone_ptr"))) TS_UpdateFulfillHTLC_clone_ptr(uint64_t arg) {
32054 LDKUpdateFulfillHTLC arg_conv;
32055 arg_conv.inner = untag_ptr(arg);
32056 arg_conv.is_owned = ptr_is_owned(arg);
32057 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32058 arg_conv.is_owned = false;
32059 int64_t ret_conv = UpdateFulfillHTLC_clone_ptr(&arg_conv);
32063 uint64_t __attribute__((export_name("TS_UpdateFulfillHTLC_clone"))) TS_UpdateFulfillHTLC_clone(uint64_t orig) {
32064 LDKUpdateFulfillHTLC orig_conv;
32065 orig_conv.inner = untag_ptr(orig);
32066 orig_conv.is_owned = ptr_is_owned(orig);
32067 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
32068 orig_conv.is_owned = false;
32069 LDKUpdateFulfillHTLC ret_var = UpdateFulfillHTLC_clone(&orig_conv);
32070 uint64_t ret_ref = 0;
32071 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32072 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32076 jboolean __attribute__((export_name("TS_UpdateFulfillHTLC_eq"))) TS_UpdateFulfillHTLC_eq(uint64_t a, uint64_t b) {
32077 LDKUpdateFulfillHTLC a_conv;
32078 a_conv.inner = untag_ptr(a);
32079 a_conv.is_owned = ptr_is_owned(a);
32080 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
32081 a_conv.is_owned = false;
32082 LDKUpdateFulfillHTLC b_conv;
32083 b_conv.inner = untag_ptr(b);
32084 b_conv.is_owned = ptr_is_owned(b);
32085 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
32086 b_conv.is_owned = false;
32087 jboolean ret_conv = UpdateFulfillHTLC_eq(&a_conv, &b_conv);
32091 void __attribute__((export_name("TS_UpdateFailHTLC_free"))) TS_UpdateFailHTLC_free(uint64_t this_obj) {
32092 LDKUpdateFailHTLC this_obj_conv;
32093 this_obj_conv.inner = untag_ptr(this_obj);
32094 this_obj_conv.is_owned = ptr_is_owned(this_obj);
32095 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
32096 UpdateFailHTLC_free(this_obj_conv);
32099 int8_tArray __attribute__((export_name("TS_UpdateFailHTLC_get_channel_id"))) TS_UpdateFailHTLC_get_channel_id(uint64_t this_ptr) {
32100 LDKUpdateFailHTLC this_ptr_conv;
32101 this_ptr_conv.inner = untag_ptr(this_ptr);
32102 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32103 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32104 this_ptr_conv.is_owned = false;
32105 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
32106 memcpy(ret_arr->elems, *UpdateFailHTLC_get_channel_id(&this_ptr_conv), 32);
32110 void __attribute__((export_name("TS_UpdateFailHTLC_set_channel_id"))) TS_UpdateFailHTLC_set_channel_id(uint64_t this_ptr, int8_tArray val) {
32111 LDKUpdateFailHTLC this_ptr_conv;
32112 this_ptr_conv.inner = untag_ptr(this_ptr);
32113 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32114 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32115 this_ptr_conv.is_owned = false;
32116 LDKThirtyTwoBytes val_ref;
32117 CHECK(val->arr_len == 32);
32118 memcpy(val_ref.data, val->elems, 32); FREE(val);
32119 UpdateFailHTLC_set_channel_id(&this_ptr_conv, val_ref);
32122 int64_t __attribute__((export_name("TS_UpdateFailHTLC_get_htlc_id"))) TS_UpdateFailHTLC_get_htlc_id(uint64_t this_ptr) {
32123 LDKUpdateFailHTLC this_ptr_conv;
32124 this_ptr_conv.inner = untag_ptr(this_ptr);
32125 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32126 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32127 this_ptr_conv.is_owned = false;
32128 int64_t ret_conv = UpdateFailHTLC_get_htlc_id(&this_ptr_conv);
32132 void __attribute__((export_name("TS_UpdateFailHTLC_set_htlc_id"))) TS_UpdateFailHTLC_set_htlc_id(uint64_t this_ptr, int64_t val) {
32133 LDKUpdateFailHTLC this_ptr_conv;
32134 this_ptr_conv.inner = untag_ptr(this_ptr);
32135 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32136 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32137 this_ptr_conv.is_owned = false;
32138 UpdateFailHTLC_set_htlc_id(&this_ptr_conv, val);
32141 static inline uint64_t UpdateFailHTLC_clone_ptr(LDKUpdateFailHTLC *NONNULL_PTR arg) {
32142 LDKUpdateFailHTLC ret_var = UpdateFailHTLC_clone(arg);
32143 uint64_t ret_ref = 0;
32144 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32145 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32148 int64_t __attribute__((export_name("TS_UpdateFailHTLC_clone_ptr"))) TS_UpdateFailHTLC_clone_ptr(uint64_t arg) {
32149 LDKUpdateFailHTLC arg_conv;
32150 arg_conv.inner = untag_ptr(arg);
32151 arg_conv.is_owned = ptr_is_owned(arg);
32152 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32153 arg_conv.is_owned = false;
32154 int64_t ret_conv = UpdateFailHTLC_clone_ptr(&arg_conv);
32158 uint64_t __attribute__((export_name("TS_UpdateFailHTLC_clone"))) TS_UpdateFailHTLC_clone(uint64_t orig) {
32159 LDKUpdateFailHTLC orig_conv;
32160 orig_conv.inner = untag_ptr(orig);
32161 orig_conv.is_owned = ptr_is_owned(orig);
32162 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
32163 orig_conv.is_owned = false;
32164 LDKUpdateFailHTLC ret_var = UpdateFailHTLC_clone(&orig_conv);
32165 uint64_t ret_ref = 0;
32166 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32167 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32171 jboolean __attribute__((export_name("TS_UpdateFailHTLC_eq"))) TS_UpdateFailHTLC_eq(uint64_t a, uint64_t b) {
32172 LDKUpdateFailHTLC a_conv;
32173 a_conv.inner = untag_ptr(a);
32174 a_conv.is_owned = ptr_is_owned(a);
32175 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
32176 a_conv.is_owned = false;
32177 LDKUpdateFailHTLC b_conv;
32178 b_conv.inner = untag_ptr(b);
32179 b_conv.is_owned = ptr_is_owned(b);
32180 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
32181 b_conv.is_owned = false;
32182 jboolean ret_conv = UpdateFailHTLC_eq(&a_conv, &b_conv);
32186 void __attribute__((export_name("TS_UpdateFailMalformedHTLC_free"))) TS_UpdateFailMalformedHTLC_free(uint64_t this_obj) {
32187 LDKUpdateFailMalformedHTLC this_obj_conv;
32188 this_obj_conv.inner = untag_ptr(this_obj);
32189 this_obj_conv.is_owned = ptr_is_owned(this_obj);
32190 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
32191 UpdateFailMalformedHTLC_free(this_obj_conv);
32194 int8_tArray __attribute__((export_name("TS_UpdateFailMalformedHTLC_get_channel_id"))) TS_UpdateFailMalformedHTLC_get_channel_id(uint64_t this_ptr) {
32195 LDKUpdateFailMalformedHTLC this_ptr_conv;
32196 this_ptr_conv.inner = untag_ptr(this_ptr);
32197 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32198 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32199 this_ptr_conv.is_owned = false;
32200 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
32201 memcpy(ret_arr->elems, *UpdateFailMalformedHTLC_get_channel_id(&this_ptr_conv), 32);
32205 void __attribute__((export_name("TS_UpdateFailMalformedHTLC_set_channel_id"))) TS_UpdateFailMalformedHTLC_set_channel_id(uint64_t this_ptr, int8_tArray val) {
32206 LDKUpdateFailMalformedHTLC this_ptr_conv;
32207 this_ptr_conv.inner = untag_ptr(this_ptr);
32208 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32209 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32210 this_ptr_conv.is_owned = false;
32211 LDKThirtyTwoBytes val_ref;
32212 CHECK(val->arr_len == 32);
32213 memcpy(val_ref.data, val->elems, 32); FREE(val);
32214 UpdateFailMalformedHTLC_set_channel_id(&this_ptr_conv, val_ref);
32217 int64_t __attribute__((export_name("TS_UpdateFailMalformedHTLC_get_htlc_id"))) TS_UpdateFailMalformedHTLC_get_htlc_id(uint64_t this_ptr) {
32218 LDKUpdateFailMalformedHTLC this_ptr_conv;
32219 this_ptr_conv.inner = untag_ptr(this_ptr);
32220 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32221 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32222 this_ptr_conv.is_owned = false;
32223 int64_t ret_conv = UpdateFailMalformedHTLC_get_htlc_id(&this_ptr_conv);
32227 void __attribute__((export_name("TS_UpdateFailMalformedHTLC_set_htlc_id"))) TS_UpdateFailMalformedHTLC_set_htlc_id(uint64_t this_ptr, int64_t val) {
32228 LDKUpdateFailMalformedHTLC this_ptr_conv;
32229 this_ptr_conv.inner = untag_ptr(this_ptr);
32230 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32231 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32232 this_ptr_conv.is_owned = false;
32233 UpdateFailMalformedHTLC_set_htlc_id(&this_ptr_conv, val);
32236 int16_t __attribute__((export_name("TS_UpdateFailMalformedHTLC_get_failure_code"))) TS_UpdateFailMalformedHTLC_get_failure_code(uint64_t this_ptr) {
32237 LDKUpdateFailMalformedHTLC this_ptr_conv;
32238 this_ptr_conv.inner = untag_ptr(this_ptr);
32239 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32240 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32241 this_ptr_conv.is_owned = false;
32242 int16_t ret_conv = UpdateFailMalformedHTLC_get_failure_code(&this_ptr_conv);
32246 void __attribute__((export_name("TS_UpdateFailMalformedHTLC_set_failure_code"))) TS_UpdateFailMalformedHTLC_set_failure_code(uint64_t this_ptr, int16_t val) {
32247 LDKUpdateFailMalformedHTLC this_ptr_conv;
32248 this_ptr_conv.inner = untag_ptr(this_ptr);
32249 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32250 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32251 this_ptr_conv.is_owned = false;
32252 UpdateFailMalformedHTLC_set_failure_code(&this_ptr_conv, val);
32255 static inline uint64_t UpdateFailMalformedHTLC_clone_ptr(LDKUpdateFailMalformedHTLC *NONNULL_PTR arg) {
32256 LDKUpdateFailMalformedHTLC ret_var = UpdateFailMalformedHTLC_clone(arg);
32257 uint64_t ret_ref = 0;
32258 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32259 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32262 int64_t __attribute__((export_name("TS_UpdateFailMalformedHTLC_clone_ptr"))) TS_UpdateFailMalformedHTLC_clone_ptr(uint64_t arg) {
32263 LDKUpdateFailMalformedHTLC arg_conv;
32264 arg_conv.inner = untag_ptr(arg);
32265 arg_conv.is_owned = ptr_is_owned(arg);
32266 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32267 arg_conv.is_owned = false;
32268 int64_t ret_conv = UpdateFailMalformedHTLC_clone_ptr(&arg_conv);
32272 uint64_t __attribute__((export_name("TS_UpdateFailMalformedHTLC_clone"))) TS_UpdateFailMalformedHTLC_clone(uint64_t orig) {
32273 LDKUpdateFailMalformedHTLC orig_conv;
32274 orig_conv.inner = untag_ptr(orig);
32275 orig_conv.is_owned = ptr_is_owned(orig);
32276 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
32277 orig_conv.is_owned = false;
32278 LDKUpdateFailMalformedHTLC ret_var = UpdateFailMalformedHTLC_clone(&orig_conv);
32279 uint64_t ret_ref = 0;
32280 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32281 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32285 jboolean __attribute__((export_name("TS_UpdateFailMalformedHTLC_eq"))) TS_UpdateFailMalformedHTLC_eq(uint64_t a, uint64_t b) {
32286 LDKUpdateFailMalformedHTLC a_conv;
32287 a_conv.inner = untag_ptr(a);
32288 a_conv.is_owned = ptr_is_owned(a);
32289 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
32290 a_conv.is_owned = false;
32291 LDKUpdateFailMalformedHTLC b_conv;
32292 b_conv.inner = untag_ptr(b);
32293 b_conv.is_owned = ptr_is_owned(b);
32294 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
32295 b_conv.is_owned = false;
32296 jboolean ret_conv = UpdateFailMalformedHTLC_eq(&a_conv, &b_conv);
32300 void __attribute__((export_name("TS_CommitmentSigned_free"))) TS_CommitmentSigned_free(uint64_t this_obj) {
32301 LDKCommitmentSigned this_obj_conv;
32302 this_obj_conv.inner = untag_ptr(this_obj);
32303 this_obj_conv.is_owned = ptr_is_owned(this_obj);
32304 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
32305 CommitmentSigned_free(this_obj_conv);
32308 int8_tArray __attribute__((export_name("TS_CommitmentSigned_get_channel_id"))) TS_CommitmentSigned_get_channel_id(uint64_t this_ptr) {
32309 LDKCommitmentSigned this_ptr_conv;
32310 this_ptr_conv.inner = untag_ptr(this_ptr);
32311 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32312 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32313 this_ptr_conv.is_owned = false;
32314 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
32315 memcpy(ret_arr->elems, *CommitmentSigned_get_channel_id(&this_ptr_conv), 32);
32319 void __attribute__((export_name("TS_CommitmentSigned_set_channel_id"))) TS_CommitmentSigned_set_channel_id(uint64_t this_ptr, int8_tArray val) {
32320 LDKCommitmentSigned this_ptr_conv;
32321 this_ptr_conv.inner = untag_ptr(this_ptr);
32322 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32323 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32324 this_ptr_conv.is_owned = false;
32325 LDKThirtyTwoBytes val_ref;
32326 CHECK(val->arr_len == 32);
32327 memcpy(val_ref.data, val->elems, 32); FREE(val);
32328 CommitmentSigned_set_channel_id(&this_ptr_conv, val_ref);
32331 int8_tArray __attribute__((export_name("TS_CommitmentSigned_get_signature"))) TS_CommitmentSigned_get_signature(uint64_t this_ptr) {
32332 LDKCommitmentSigned this_ptr_conv;
32333 this_ptr_conv.inner = untag_ptr(this_ptr);
32334 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32335 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32336 this_ptr_conv.is_owned = false;
32337 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
32338 memcpy(ret_arr->elems, CommitmentSigned_get_signature(&this_ptr_conv).compact_form, 64);
32342 void __attribute__((export_name("TS_CommitmentSigned_set_signature"))) TS_CommitmentSigned_set_signature(uint64_t this_ptr, int8_tArray val) {
32343 LDKCommitmentSigned this_ptr_conv;
32344 this_ptr_conv.inner = untag_ptr(this_ptr);
32345 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32346 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32347 this_ptr_conv.is_owned = false;
32348 LDKSignature val_ref;
32349 CHECK(val->arr_len == 64);
32350 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
32351 CommitmentSigned_set_signature(&this_ptr_conv, val_ref);
32354 ptrArray __attribute__((export_name("TS_CommitmentSigned_get_htlc_signatures"))) TS_CommitmentSigned_get_htlc_signatures(uint64_t this_ptr) {
32355 LDKCommitmentSigned this_ptr_conv;
32356 this_ptr_conv.inner = untag_ptr(this_ptr);
32357 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32358 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32359 this_ptr_conv.is_owned = false;
32360 LDKCVec_SignatureZ ret_var = CommitmentSigned_get_htlc_signatures(&this_ptr_conv);
32361 ptrArray ret_arr = NULL;
32362 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
32363 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 8);
32364 for (size_t m = 0; m < ret_var.datalen; m++) {
32365 int8_tArray ret_conv_12_arr = init_int8_tArray(64, __LINE__);
32366 memcpy(ret_conv_12_arr->elems, ret_var.data[m].compact_form, 64);
32367 ret_arr_ptr[m] = ret_conv_12_arr;
32370 FREE(ret_var.data);
32374 void __attribute__((export_name("TS_CommitmentSigned_set_htlc_signatures"))) TS_CommitmentSigned_set_htlc_signatures(uint64_t this_ptr, ptrArray val) {
32375 LDKCommitmentSigned this_ptr_conv;
32376 this_ptr_conv.inner = untag_ptr(this_ptr);
32377 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32378 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32379 this_ptr_conv.is_owned = false;
32380 LDKCVec_SignatureZ val_constr;
32381 val_constr.datalen = val->arr_len;
32382 if (val_constr.datalen > 0)
32383 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
32385 val_constr.data = NULL;
32386 int8_tArray* val_vals = (void*) val->elems;
32387 for (size_t m = 0; m < val_constr.datalen; m++) {
32388 int8_tArray val_conv_12 = val_vals[m];
32389 LDKSignature val_conv_12_ref;
32390 CHECK(val_conv_12->arr_len == 64);
32391 memcpy(val_conv_12_ref.compact_form, val_conv_12->elems, 64); FREE(val_conv_12);
32392 val_constr.data[m] = val_conv_12_ref;
32395 CommitmentSigned_set_htlc_signatures(&this_ptr_conv, val_constr);
32398 uint64_t __attribute__((export_name("TS_CommitmentSigned_new"))) TS_CommitmentSigned_new(int8_tArray channel_id_arg, int8_tArray signature_arg, ptrArray htlc_signatures_arg) {
32399 LDKThirtyTwoBytes channel_id_arg_ref;
32400 CHECK(channel_id_arg->arr_len == 32);
32401 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
32402 LDKSignature signature_arg_ref;
32403 CHECK(signature_arg->arr_len == 64);
32404 memcpy(signature_arg_ref.compact_form, signature_arg->elems, 64); FREE(signature_arg);
32405 LDKCVec_SignatureZ htlc_signatures_arg_constr;
32406 htlc_signatures_arg_constr.datalen = htlc_signatures_arg->arr_len;
32407 if (htlc_signatures_arg_constr.datalen > 0)
32408 htlc_signatures_arg_constr.data = MALLOC(htlc_signatures_arg_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
32410 htlc_signatures_arg_constr.data = NULL;
32411 int8_tArray* htlc_signatures_arg_vals = (void*) htlc_signatures_arg->elems;
32412 for (size_t m = 0; m < htlc_signatures_arg_constr.datalen; m++) {
32413 int8_tArray htlc_signatures_arg_conv_12 = htlc_signatures_arg_vals[m];
32414 LDKSignature htlc_signatures_arg_conv_12_ref;
32415 CHECK(htlc_signatures_arg_conv_12->arr_len == 64);
32416 memcpy(htlc_signatures_arg_conv_12_ref.compact_form, htlc_signatures_arg_conv_12->elems, 64); FREE(htlc_signatures_arg_conv_12);
32417 htlc_signatures_arg_constr.data[m] = htlc_signatures_arg_conv_12_ref;
32419 FREE(htlc_signatures_arg);
32420 LDKCommitmentSigned ret_var = CommitmentSigned_new(channel_id_arg_ref, signature_arg_ref, htlc_signatures_arg_constr);
32421 uint64_t ret_ref = 0;
32422 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32423 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32427 static inline uint64_t CommitmentSigned_clone_ptr(LDKCommitmentSigned *NONNULL_PTR arg) {
32428 LDKCommitmentSigned ret_var = CommitmentSigned_clone(arg);
32429 uint64_t ret_ref = 0;
32430 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32431 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32434 int64_t __attribute__((export_name("TS_CommitmentSigned_clone_ptr"))) TS_CommitmentSigned_clone_ptr(uint64_t arg) {
32435 LDKCommitmentSigned arg_conv;
32436 arg_conv.inner = untag_ptr(arg);
32437 arg_conv.is_owned = ptr_is_owned(arg);
32438 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32439 arg_conv.is_owned = false;
32440 int64_t ret_conv = CommitmentSigned_clone_ptr(&arg_conv);
32444 uint64_t __attribute__((export_name("TS_CommitmentSigned_clone"))) TS_CommitmentSigned_clone(uint64_t orig) {
32445 LDKCommitmentSigned orig_conv;
32446 orig_conv.inner = untag_ptr(orig);
32447 orig_conv.is_owned = ptr_is_owned(orig);
32448 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
32449 orig_conv.is_owned = false;
32450 LDKCommitmentSigned ret_var = CommitmentSigned_clone(&orig_conv);
32451 uint64_t ret_ref = 0;
32452 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32453 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32457 jboolean __attribute__((export_name("TS_CommitmentSigned_eq"))) TS_CommitmentSigned_eq(uint64_t a, uint64_t b) {
32458 LDKCommitmentSigned a_conv;
32459 a_conv.inner = untag_ptr(a);
32460 a_conv.is_owned = ptr_is_owned(a);
32461 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
32462 a_conv.is_owned = false;
32463 LDKCommitmentSigned b_conv;
32464 b_conv.inner = untag_ptr(b);
32465 b_conv.is_owned = ptr_is_owned(b);
32466 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
32467 b_conv.is_owned = false;
32468 jboolean ret_conv = CommitmentSigned_eq(&a_conv, &b_conv);
32472 void __attribute__((export_name("TS_RevokeAndACK_free"))) TS_RevokeAndACK_free(uint64_t this_obj) {
32473 LDKRevokeAndACK this_obj_conv;
32474 this_obj_conv.inner = untag_ptr(this_obj);
32475 this_obj_conv.is_owned = ptr_is_owned(this_obj);
32476 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
32477 RevokeAndACK_free(this_obj_conv);
32480 int8_tArray __attribute__((export_name("TS_RevokeAndACK_get_channel_id"))) TS_RevokeAndACK_get_channel_id(uint64_t this_ptr) {
32481 LDKRevokeAndACK this_ptr_conv;
32482 this_ptr_conv.inner = untag_ptr(this_ptr);
32483 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32484 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32485 this_ptr_conv.is_owned = false;
32486 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
32487 memcpy(ret_arr->elems, *RevokeAndACK_get_channel_id(&this_ptr_conv), 32);
32491 void __attribute__((export_name("TS_RevokeAndACK_set_channel_id"))) TS_RevokeAndACK_set_channel_id(uint64_t this_ptr, int8_tArray val) {
32492 LDKRevokeAndACK this_ptr_conv;
32493 this_ptr_conv.inner = untag_ptr(this_ptr);
32494 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32495 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32496 this_ptr_conv.is_owned = false;
32497 LDKThirtyTwoBytes val_ref;
32498 CHECK(val->arr_len == 32);
32499 memcpy(val_ref.data, val->elems, 32); FREE(val);
32500 RevokeAndACK_set_channel_id(&this_ptr_conv, val_ref);
32503 int8_tArray __attribute__((export_name("TS_RevokeAndACK_get_per_commitment_secret"))) TS_RevokeAndACK_get_per_commitment_secret(uint64_t this_ptr) {
32504 LDKRevokeAndACK this_ptr_conv;
32505 this_ptr_conv.inner = untag_ptr(this_ptr);
32506 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32507 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32508 this_ptr_conv.is_owned = false;
32509 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
32510 memcpy(ret_arr->elems, *RevokeAndACK_get_per_commitment_secret(&this_ptr_conv), 32);
32514 void __attribute__((export_name("TS_RevokeAndACK_set_per_commitment_secret"))) TS_RevokeAndACK_set_per_commitment_secret(uint64_t this_ptr, int8_tArray val) {
32515 LDKRevokeAndACK this_ptr_conv;
32516 this_ptr_conv.inner = untag_ptr(this_ptr);
32517 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32518 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32519 this_ptr_conv.is_owned = false;
32520 LDKThirtyTwoBytes val_ref;
32521 CHECK(val->arr_len == 32);
32522 memcpy(val_ref.data, val->elems, 32); FREE(val);
32523 RevokeAndACK_set_per_commitment_secret(&this_ptr_conv, val_ref);
32526 int8_tArray __attribute__((export_name("TS_RevokeAndACK_get_next_per_commitment_point"))) TS_RevokeAndACK_get_next_per_commitment_point(uint64_t this_ptr) {
32527 LDKRevokeAndACK this_ptr_conv;
32528 this_ptr_conv.inner = untag_ptr(this_ptr);
32529 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32530 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32531 this_ptr_conv.is_owned = false;
32532 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
32533 memcpy(ret_arr->elems, RevokeAndACK_get_next_per_commitment_point(&this_ptr_conv).compressed_form, 33);
32537 void __attribute__((export_name("TS_RevokeAndACK_set_next_per_commitment_point"))) TS_RevokeAndACK_set_next_per_commitment_point(uint64_t this_ptr, int8_tArray val) {
32538 LDKRevokeAndACK this_ptr_conv;
32539 this_ptr_conv.inner = untag_ptr(this_ptr);
32540 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32541 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32542 this_ptr_conv.is_owned = false;
32543 LDKPublicKey val_ref;
32544 CHECK(val->arr_len == 33);
32545 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
32546 RevokeAndACK_set_next_per_commitment_point(&this_ptr_conv, val_ref);
32549 uint64_t __attribute__((export_name("TS_RevokeAndACK_new"))) TS_RevokeAndACK_new(int8_tArray channel_id_arg, int8_tArray per_commitment_secret_arg, int8_tArray next_per_commitment_point_arg) {
32550 LDKThirtyTwoBytes channel_id_arg_ref;
32551 CHECK(channel_id_arg->arr_len == 32);
32552 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
32553 LDKThirtyTwoBytes per_commitment_secret_arg_ref;
32554 CHECK(per_commitment_secret_arg->arr_len == 32);
32555 memcpy(per_commitment_secret_arg_ref.data, per_commitment_secret_arg->elems, 32); FREE(per_commitment_secret_arg);
32556 LDKPublicKey next_per_commitment_point_arg_ref;
32557 CHECK(next_per_commitment_point_arg->arr_len == 33);
32558 memcpy(next_per_commitment_point_arg_ref.compressed_form, next_per_commitment_point_arg->elems, 33); FREE(next_per_commitment_point_arg);
32559 LDKRevokeAndACK ret_var = RevokeAndACK_new(channel_id_arg_ref, per_commitment_secret_arg_ref, next_per_commitment_point_arg_ref);
32560 uint64_t ret_ref = 0;
32561 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32562 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32566 static inline uint64_t RevokeAndACK_clone_ptr(LDKRevokeAndACK *NONNULL_PTR arg) {
32567 LDKRevokeAndACK ret_var = RevokeAndACK_clone(arg);
32568 uint64_t ret_ref = 0;
32569 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32570 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32573 int64_t __attribute__((export_name("TS_RevokeAndACK_clone_ptr"))) TS_RevokeAndACK_clone_ptr(uint64_t arg) {
32574 LDKRevokeAndACK arg_conv;
32575 arg_conv.inner = untag_ptr(arg);
32576 arg_conv.is_owned = ptr_is_owned(arg);
32577 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32578 arg_conv.is_owned = false;
32579 int64_t ret_conv = RevokeAndACK_clone_ptr(&arg_conv);
32583 uint64_t __attribute__((export_name("TS_RevokeAndACK_clone"))) TS_RevokeAndACK_clone(uint64_t orig) {
32584 LDKRevokeAndACK orig_conv;
32585 orig_conv.inner = untag_ptr(orig);
32586 orig_conv.is_owned = ptr_is_owned(orig);
32587 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
32588 orig_conv.is_owned = false;
32589 LDKRevokeAndACK ret_var = RevokeAndACK_clone(&orig_conv);
32590 uint64_t ret_ref = 0;
32591 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32592 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32596 jboolean __attribute__((export_name("TS_RevokeAndACK_eq"))) TS_RevokeAndACK_eq(uint64_t a, uint64_t b) {
32597 LDKRevokeAndACK a_conv;
32598 a_conv.inner = untag_ptr(a);
32599 a_conv.is_owned = ptr_is_owned(a);
32600 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
32601 a_conv.is_owned = false;
32602 LDKRevokeAndACK b_conv;
32603 b_conv.inner = untag_ptr(b);
32604 b_conv.is_owned = ptr_is_owned(b);
32605 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
32606 b_conv.is_owned = false;
32607 jboolean ret_conv = RevokeAndACK_eq(&a_conv, &b_conv);
32611 void __attribute__((export_name("TS_UpdateFee_free"))) TS_UpdateFee_free(uint64_t this_obj) {
32612 LDKUpdateFee this_obj_conv;
32613 this_obj_conv.inner = untag_ptr(this_obj);
32614 this_obj_conv.is_owned = ptr_is_owned(this_obj);
32615 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
32616 UpdateFee_free(this_obj_conv);
32619 int8_tArray __attribute__((export_name("TS_UpdateFee_get_channel_id"))) TS_UpdateFee_get_channel_id(uint64_t this_ptr) {
32620 LDKUpdateFee this_ptr_conv;
32621 this_ptr_conv.inner = untag_ptr(this_ptr);
32622 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32623 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32624 this_ptr_conv.is_owned = false;
32625 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
32626 memcpy(ret_arr->elems, *UpdateFee_get_channel_id(&this_ptr_conv), 32);
32630 void __attribute__((export_name("TS_UpdateFee_set_channel_id"))) TS_UpdateFee_set_channel_id(uint64_t this_ptr, int8_tArray val) {
32631 LDKUpdateFee this_ptr_conv;
32632 this_ptr_conv.inner = untag_ptr(this_ptr);
32633 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32634 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32635 this_ptr_conv.is_owned = false;
32636 LDKThirtyTwoBytes val_ref;
32637 CHECK(val->arr_len == 32);
32638 memcpy(val_ref.data, val->elems, 32); FREE(val);
32639 UpdateFee_set_channel_id(&this_ptr_conv, val_ref);
32642 int32_t __attribute__((export_name("TS_UpdateFee_get_feerate_per_kw"))) TS_UpdateFee_get_feerate_per_kw(uint64_t this_ptr) {
32643 LDKUpdateFee this_ptr_conv;
32644 this_ptr_conv.inner = untag_ptr(this_ptr);
32645 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32646 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32647 this_ptr_conv.is_owned = false;
32648 int32_t ret_conv = UpdateFee_get_feerate_per_kw(&this_ptr_conv);
32652 void __attribute__((export_name("TS_UpdateFee_set_feerate_per_kw"))) TS_UpdateFee_set_feerate_per_kw(uint64_t this_ptr, int32_t val) {
32653 LDKUpdateFee this_ptr_conv;
32654 this_ptr_conv.inner = untag_ptr(this_ptr);
32655 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32656 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32657 this_ptr_conv.is_owned = false;
32658 UpdateFee_set_feerate_per_kw(&this_ptr_conv, val);
32661 uint64_t __attribute__((export_name("TS_UpdateFee_new"))) TS_UpdateFee_new(int8_tArray channel_id_arg, int32_t feerate_per_kw_arg) {
32662 LDKThirtyTwoBytes channel_id_arg_ref;
32663 CHECK(channel_id_arg->arr_len == 32);
32664 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
32665 LDKUpdateFee ret_var = UpdateFee_new(channel_id_arg_ref, feerate_per_kw_arg);
32666 uint64_t ret_ref = 0;
32667 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32668 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32672 static inline uint64_t UpdateFee_clone_ptr(LDKUpdateFee *NONNULL_PTR arg) {
32673 LDKUpdateFee ret_var = UpdateFee_clone(arg);
32674 uint64_t ret_ref = 0;
32675 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32676 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32679 int64_t __attribute__((export_name("TS_UpdateFee_clone_ptr"))) TS_UpdateFee_clone_ptr(uint64_t arg) {
32680 LDKUpdateFee arg_conv;
32681 arg_conv.inner = untag_ptr(arg);
32682 arg_conv.is_owned = ptr_is_owned(arg);
32683 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32684 arg_conv.is_owned = false;
32685 int64_t ret_conv = UpdateFee_clone_ptr(&arg_conv);
32689 uint64_t __attribute__((export_name("TS_UpdateFee_clone"))) TS_UpdateFee_clone(uint64_t orig) {
32690 LDKUpdateFee orig_conv;
32691 orig_conv.inner = untag_ptr(orig);
32692 orig_conv.is_owned = ptr_is_owned(orig);
32693 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
32694 orig_conv.is_owned = false;
32695 LDKUpdateFee ret_var = UpdateFee_clone(&orig_conv);
32696 uint64_t ret_ref = 0;
32697 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32698 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32702 jboolean __attribute__((export_name("TS_UpdateFee_eq"))) TS_UpdateFee_eq(uint64_t a, uint64_t b) {
32703 LDKUpdateFee a_conv;
32704 a_conv.inner = untag_ptr(a);
32705 a_conv.is_owned = ptr_is_owned(a);
32706 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
32707 a_conv.is_owned = false;
32708 LDKUpdateFee b_conv;
32709 b_conv.inner = untag_ptr(b);
32710 b_conv.is_owned = ptr_is_owned(b);
32711 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
32712 b_conv.is_owned = false;
32713 jboolean ret_conv = UpdateFee_eq(&a_conv, &b_conv);
32717 void __attribute__((export_name("TS_DataLossProtect_free"))) TS_DataLossProtect_free(uint64_t this_obj) {
32718 LDKDataLossProtect this_obj_conv;
32719 this_obj_conv.inner = untag_ptr(this_obj);
32720 this_obj_conv.is_owned = ptr_is_owned(this_obj);
32721 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
32722 DataLossProtect_free(this_obj_conv);
32725 int8_tArray __attribute__((export_name("TS_DataLossProtect_get_your_last_per_commitment_secret"))) TS_DataLossProtect_get_your_last_per_commitment_secret(uint64_t this_ptr) {
32726 LDKDataLossProtect this_ptr_conv;
32727 this_ptr_conv.inner = untag_ptr(this_ptr);
32728 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32729 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32730 this_ptr_conv.is_owned = false;
32731 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
32732 memcpy(ret_arr->elems, *DataLossProtect_get_your_last_per_commitment_secret(&this_ptr_conv), 32);
32736 void __attribute__((export_name("TS_DataLossProtect_set_your_last_per_commitment_secret"))) TS_DataLossProtect_set_your_last_per_commitment_secret(uint64_t this_ptr, int8_tArray val) {
32737 LDKDataLossProtect this_ptr_conv;
32738 this_ptr_conv.inner = untag_ptr(this_ptr);
32739 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32740 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32741 this_ptr_conv.is_owned = false;
32742 LDKThirtyTwoBytes val_ref;
32743 CHECK(val->arr_len == 32);
32744 memcpy(val_ref.data, val->elems, 32); FREE(val);
32745 DataLossProtect_set_your_last_per_commitment_secret(&this_ptr_conv, val_ref);
32748 int8_tArray __attribute__((export_name("TS_DataLossProtect_get_my_current_per_commitment_point"))) TS_DataLossProtect_get_my_current_per_commitment_point(uint64_t this_ptr) {
32749 LDKDataLossProtect this_ptr_conv;
32750 this_ptr_conv.inner = untag_ptr(this_ptr);
32751 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32752 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32753 this_ptr_conv.is_owned = false;
32754 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
32755 memcpy(ret_arr->elems, DataLossProtect_get_my_current_per_commitment_point(&this_ptr_conv).compressed_form, 33);
32759 void __attribute__((export_name("TS_DataLossProtect_set_my_current_per_commitment_point"))) TS_DataLossProtect_set_my_current_per_commitment_point(uint64_t this_ptr, int8_tArray val) {
32760 LDKDataLossProtect this_ptr_conv;
32761 this_ptr_conv.inner = untag_ptr(this_ptr);
32762 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32763 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32764 this_ptr_conv.is_owned = false;
32765 LDKPublicKey val_ref;
32766 CHECK(val->arr_len == 33);
32767 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
32768 DataLossProtect_set_my_current_per_commitment_point(&this_ptr_conv, val_ref);
32771 uint64_t __attribute__((export_name("TS_DataLossProtect_new"))) TS_DataLossProtect_new(int8_tArray your_last_per_commitment_secret_arg, int8_tArray my_current_per_commitment_point_arg) {
32772 LDKThirtyTwoBytes your_last_per_commitment_secret_arg_ref;
32773 CHECK(your_last_per_commitment_secret_arg->arr_len == 32);
32774 memcpy(your_last_per_commitment_secret_arg_ref.data, your_last_per_commitment_secret_arg->elems, 32); FREE(your_last_per_commitment_secret_arg);
32775 LDKPublicKey my_current_per_commitment_point_arg_ref;
32776 CHECK(my_current_per_commitment_point_arg->arr_len == 33);
32777 memcpy(my_current_per_commitment_point_arg_ref.compressed_form, my_current_per_commitment_point_arg->elems, 33); FREE(my_current_per_commitment_point_arg);
32778 LDKDataLossProtect ret_var = DataLossProtect_new(your_last_per_commitment_secret_arg_ref, my_current_per_commitment_point_arg_ref);
32779 uint64_t ret_ref = 0;
32780 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32781 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32785 static inline uint64_t DataLossProtect_clone_ptr(LDKDataLossProtect *NONNULL_PTR arg) {
32786 LDKDataLossProtect ret_var = DataLossProtect_clone(arg);
32787 uint64_t ret_ref = 0;
32788 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32789 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32792 int64_t __attribute__((export_name("TS_DataLossProtect_clone_ptr"))) TS_DataLossProtect_clone_ptr(uint64_t arg) {
32793 LDKDataLossProtect arg_conv;
32794 arg_conv.inner = untag_ptr(arg);
32795 arg_conv.is_owned = ptr_is_owned(arg);
32796 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32797 arg_conv.is_owned = false;
32798 int64_t ret_conv = DataLossProtect_clone_ptr(&arg_conv);
32802 uint64_t __attribute__((export_name("TS_DataLossProtect_clone"))) TS_DataLossProtect_clone(uint64_t orig) {
32803 LDKDataLossProtect orig_conv;
32804 orig_conv.inner = untag_ptr(orig);
32805 orig_conv.is_owned = ptr_is_owned(orig);
32806 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
32807 orig_conv.is_owned = false;
32808 LDKDataLossProtect ret_var = DataLossProtect_clone(&orig_conv);
32809 uint64_t ret_ref = 0;
32810 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32811 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32815 jboolean __attribute__((export_name("TS_DataLossProtect_eq"))) TS_DataLossProtect_eq(uint64_t a, uint64_t b) {
32816 LDKDataLossProtect a_conv;
32817 a_conv.inner = untag_ptr(a);
32818 a_conv.is_owned = ptr_is_owned(a);
32819 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
32820 a_conv.is_owned = false;
32821 LDKDataLossProtect b_conv;
32822 b_conv.inner = untag_ptr(b);
32823 b_conv.is_owned = ptr_is_owned(b);
32824 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
32825 b_conv.is_owned = false;
32826 jboolean ret_conv = DataLossProtect_eq(&a_conv, &b_conv);
32830 void __attribute__((export_name("TS_ChannelReestablish_free"))) TS_ChannelReestablish_free(uint64_t this_obj) {
32831 LDKChannelReestablish this_obj_conv;
32832 this_obj_conv.inner = untag_ptr(this_obj);
32833 this_obj_conv.is_owned = ptr_is_owned(this_obj);
32834 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
32835 ChannelReestablish_free(this_obj_conv);
32838 int8_tArray __attribute__((export_name("TS_ChannelReestablish_get_channel_id"))) TS_ChannelReestablish_get_channel_id(uint64_t this_ptr) {
32839 LDKChannelReestablish this_ptr_conv;
32840 this_ptr_conv.inner = untag_ptr(this_ptr);
32841 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32842 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32843 this_ptr_conv.is_owned = false;
32844 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
32845 memcpy(ret_arr->elems, *ChannelReestablish_get_channel_id(&this_ptr_conv), 32);
32849 void __attribute__((export_name("TS_ChannelReestablish_set_channel_id"))) TS_ChannelReestablish_set_channel_id(uint64_t this_ptr, int8_tArray val) {
32850 LDKChannelReestablish this_ptr_conv;
32851 this_ptr_conv.inner = untag_ptr(this_ptr);
32852 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32853 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32854 this_ptr_conv.is_owned = false;
32855 LDKThirtyTwoBytes val_ref;
32856 CHECK(val->arr_len == 32);
32857 memcpy(val_ref.data, val->elems, 32); FREE(val);
32858 ChannelReestablish_set_channel_id(&this_ptr_conv, val_ref);
32861 int64_t __attribute__((export_name("TS_ChannelReestablish_get_next_local_commitment_number"))) TS_ChannelReestablish_get_next_local_commitment_number(uint64_t this_ptr) {
32862 LDKChannelReestablish this_ptr_conv;
32863 this_ptr_conv.inner = untag_ptr(this_ptr);
32864 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32865 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32866 this_ptr_conv.is_owned = false;
32867 int64_t ret_conv = ChannelReestablish_get_next_local_commitment_number(&this_ptr_conv);
32871 void __attribute__((export_name("TS_ChannelReestablish_set_next_local_commitment_number"))) TS_ChannelReestablish_set_next_local_commitment_number(uint64_t this_ptr, int64_t val) {
32872 LDKChannelReestablish this_ptr_conv;
32873 this_ptr_conv.inner = untag_ptr(this_ptr);
32874 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32875 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32876 this_ptr_conv.is_owned = false;
32877 ChannelReestablish_set_next_local_commitment_number(&this_ptr_conv, val);
32880 int64_t __attribute__((export_name("TS_ChannelReestablish_get_next_remote_commitment_number"))) TS_ChannelReestablish_get_next_remote_commitment_number(uint64_t this_ptr) {
32881 LDKChannelReestablish this_ptr_conv;
32882 this_ptr_conv.inner = untag_ptr(this_ptr);
32883 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32884 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32885 this_ptr_conv.is_owned = false;
32886 int64_t ret_conv = ChannelReestablish_get_next_remote_commitment_number(&this_ptr_conv);
32890 void __attribute__((export_name("TS_ChannelReestablish_set_next_remote_commitment_number"))) TS_ChannelReestablish_set_next_remote_commitment_number(uint64_t this_ptr, int64_t val) {
32891 LDKChannelReestablish this_ptr_conv;
32892 this_ptr_conv.inner = untag_ptr(this_ptr);
32893 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32894 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32895 this_ptr_conv.is_owned = false;
32896 ChannelReestablish_set_next_remote_commitment_number(&this_ptr_conv, val);
32899 static inline uint64_t ChannelReestablish_clone_ptr(LDKChannelReestablish *NONNULL_PTR arg) {
32900 LDKChannelReestablish ret_var = ChannelReestablish_clone(arg);
32901 uint64_t ret_ref = 0;
32902 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32903 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32906 int64_t __attribute__((export_name("TS_ChannelReestablish_clone_ptr"))) TS_ChannelReestablish_clone_ptr(uint64_t arg) {
32907 LDKChannelReestablish arg_conv;
32908 arg_conv.inner = untag_ptr(arg);
32909 arg_conv.is_owned = ptr_is_owned(arg);
32910 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32911 arg_conv.is_owned = false;
32912 int64_t ret_conv = ChannelReestablish_clone_ptr(&arg_conv);
32916 uint64_t __attribute__((export_name("TS_ChannelReestablish_clone"))) TS_ChannelReestablish_clone(uint64_t orig) {
32917 LDKChannelReestablish orig_conv;
32918 orig_conv.inner = untag_ptr(orig);
32919 orig_conv.is_owned = ptr_is_owned(orig);
32920 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
32921 orig_conv.is_owned = false;
32922 LDKChannelReestablish ret_var = ChannelReestablish_clone(&orig_conv);
32923 uint64_t ret_ref = 0;
32924 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32925 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32929 jboolean __attribute__((export_name("TS_ChannelReestablish_eq"))) TS_ChannelReestablish_eq(uint64_t a, uint64_t b) {
32930 LDKChannelReestablish a_conv;
32931 a_conv.inner = untag_ptr(a);
32932 a_conv.is_owned = ptr_is_owned(a);
32933 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
32934 a_conv.is_owned = false;
32935 LDKChannelReestablish b_conv;
32936 b_conv.inner = untag_ptr(b);
32937 b_conv.is_owned = ptr_is_owned(b);
32938 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
32939 b_conv.is_owned = false;
32940 jboolean ret_conv = ChannelReestablish_eq(&a_conv, &b_conv);
32944 void __attribute__((export_name("TS_AnnouncementSignatures_free"))) TS_AnnouncementSignatures_free(uint64_t this_obj) {
32945 LDKAnnouncementSignatures this_obj_conv;
32946 this_obj_conv.inner = untag_ptr(this_obj);
32947 this_obj_conv.is_owned = ptr_is_owned(this_obj);
32948 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
32949 AnnouncementSignatures_free(this_obj_conv);
32952 int8_tArray __attribute__((export_name("TS_AnnouncementSignatures_get_channel_id"))) TS_AnnouncementSignatures_get_channel_id(uint64_t this_ptr) {
32953 LDKAnnouncementSignatures this_ptr_conv;
32954 this_ptr_conv.inner = untag_ptr(this_ptr);
32955 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32956 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32957 this_ptr_conv.is_owned = false;
32958 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
32959 memcpy(ret_arr->elems, *AnnouncementSignatures_get_channel_id(&this_ptr_conv), 32);
32963 void __attribute__((export_name("TS_AnnouncementSignatures_set_channel_id"))) TS_AnnouncementSignatures_set_channel_id(uint64_t this_ptr, int8_tArray val) {
32964 LDKAnnouncementSignatures this_ptr_conv;
32965 this_ptr_conv.inner = untag_ptr(this_ptr);
32966 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32967 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32968 this_ptr_conv.is_owned = false;
32969 LDKThirtyTwoBytes val_ref;
32970 CHECK(val->arr_len == 32);
32971 memcpy(val_ref.data, val->elems, 32); FREE(val);
32972 AnnouncementSignatures_set_channel_id(&this_ptr_conv, val_ref);
32975 int64_t __attribute__((export_name("TS_AnnouncementSignatures_get_short_channel_id"))) TS_AnnouncementSignatures_get_short_channel_id(uint64_t this_ptr) {
32976 LDKAnnouncementSignatures this_ptr_conv;
32977 this_ptr_conv.inner = untag_ptr(this_ptr);
32978 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32979 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32980 this_ptr_conv.is_owned = false;
32981 int64_t ret_conv = AnnouncementSignatures_get_short_channel_id(&this_ptr_conv);
32985 void __attribute__((export_name("TS_AnnouncementSignatures_set_short_channel_id"))) TS_AnnouncementSignatures_set_short_channel_id(uint64_t this_ptr, int64_t val) {
32986 LDKAnnouncementSignatures this_ptr_conv;
32987 this_ptr_conv.inner = untag_ptr(this_ptr);
32988 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32989 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32990 this_ptr_conv.is_owned = false;
32991 AnnouncementSignatures_set_short_channel_id(&this_ptr_conv, val);
32994 int8_tArray __attribute__((export_name("TS_AnnouncementSignatures_get_node_signature"))) TS_AnnouncementSignatures_get_node_signature(uint64_t this_ptr) {
32995 LDKAnnouncementSignatures this_ptr_conv;
32996 this_ptr_conv.inner = untag_ptr(this_ptr);
32997 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32998 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32999 this_ptr_conv.is_owned = false;
33000 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
33001 memcpy(ret_arr->elems, AnnouncementSignatures_get_node_signature(&this_ptr_conv).compact_form, 64);
33005 void __attribute__((export_name("TS_AnnouncementSignatures_set_node_signature"))) TS_AnnouncementSignatures_set_node_signature(uint64_t this_ptr, int8_tArray val) {
33006 LDKAnnouncementSignatures this_ptr_conv;
33007 this_ptr_conv.inner = untag_ptr(this_ptr);
33008 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33009 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33010 this_ptr_conv.is_owned = false;
33011 LDKSignature val_ref;
33012 CHECK(val->arr_len == 64);
33013 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
33014 AnnouncementSignatures_set_node_signature(&this_ptr_conv, val_ref);
33017 int8_tArray __attribute__((export_name("TS_AnnouncementSignatures_get_bitcoin_signature"))) TS_AnnouncementSignatures_get_bitcoin_signature(uint64_t this_ptr) {
33018 LDKAnnouncementSignatures this_ptr_conv;
33019 this_ptr_conv.inner = untag_ptr(this_ptr);
33020 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33021 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33022 this_ptr_conv.is_owned = false;
33023 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
33024 memcpy(ret_arr->elems, AnnouncementSignatures_get_bitcoin_signature(&this_ptr_conv).compact_form, 64);
33028 void __attribute__((export_name("TS_AnnouncementSignatures_set_bitcoin_signature"))) TS_AnnouncementSignatures_set_bitcoin_signature(uint64_t this_ptr, int8_tArray val) {
33029 LDKAnnouncementSignatures this_ptr_conv;
33030 this_ptr_conv.inner = untag_ptr(this_ptr);
33031 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33032 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33033 this_ptr_conv.is_owned = false;
33034 LDKSignature val_ref;
33035 CHECK(val->arr_len == 64);
33036 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
33037 AnnouncementSignatures_set_bitcoin_signature(&this_ptr_conv, val_ref);
33040 uint64_t __attribute__((export_name("TS_AnnouncementSignatures_new"))) TS_AnnouncementSignatures_new(int8_tArray channel_id_arg, int64_t short_channel_id_arg, int8_tArray node_signature_arg, int8_tArray bitcoin_signature_arg) {
33041 LDKThirtyTwoBytes channel_id_arg_ref;
33042 CHECK(channel_id_arg->arr_len == 32);
33043 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
33044 LDKSignature node_signature_arg_ref;
33045 CHECK(node_signature_arg->arr_len == 64);
33046 memcpy(node_signature_arg_ref.compact_form, node_signature_arg->elems, 64); FREE(node_signature_arg);
33047 LDKSignature bitcoin_signature_arg_ref;
33048 CHECK(bitcoin_signature_arg->arr_len == 64);
33049 memcpy(bitcoin_signature_arg_ref.compact_form, bitcoin_signature_arg->elems, 64); FREE(bitcoin_signature_arg);
33050 LDKAnnouncementSignatures ret_var = AnnouncementSignatures_new(channel_id_arg_ref, short_channel_id_arg, node_signature_arg_ref, bitcoin_signature_arg_ref);
33051 uint64_t ret_ref = 0;
33052 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33053 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33057 static inline uint64_t AnnouncementSignatures_clone_ptr(LDKAnnouncementSignatures *NONNULL_PTR arg) {
33058 LDKAnnouncementSignatures ret_var = AnnouncementSignatures_clone(arg);
33059 uint64_t ret_ref = 0;
33060 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33061 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33064 int64_t __attribute__((export_name("TS_AnnouncementSignatures_clone_ptr"))) TS_AnnouncementSignatures_clone_ptr(uint64_t arg) {
33065 LDKAnnouncementSignatures arg_conv;
33066 arg_conv.inner = untag_ptr(arg);
33067 arg_conv.is_owned = ptr_is_owned(arg);
33068 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
33069 arg_conv.is_owned = false;
33070 int64_t ret_conv = AnnouncementSignatures_clone_ptr(&arg_conv);
33074 uint64_t __attribute__((export_name("TS_AnnouncementSignatures_clone"))) TS_AnnouncementSignatures_clone(uint64_t orig) {
33075 LDKAnnouncementSignatures orig_conv;
33076 orig_conv.inner = untag_ptr(orig);
33077 orig_conv.is_owned = ptr_is_owned(orig);
33078 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
33079 orig_conv.is_owned = false;
33080 LDKAnnouncementSignatures ret_var = AnnouncementSignatures_clone(&orig_conv);
33081 uint64_t ret_ref = 0;
33082 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33083 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33087 jboolean __attribute__((export_name("TS_AnnouncementSignatures_eq"))) TS_AnnouncementSignatures_eq(uint64_t a, uint64_t b) {
33088 LDKAnnouncementSignatures a_conv;
33089 a_conv.inner = untag_ptr(a);
33090 a_conv.is_owned = ptr_is_owned(a);
33091 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
33092 a_conv.is_owned = false;
33093 LDKAnnouncementSignatures b_conv;
33094 b_conv.inner = untag_ptr(b);
33095 b_conv.is_owned = ptr_is_owned(b);
33096 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
33097 b_conv.is_owned = false;
33098 jboolean ret_conv = AnnouncementSignatures_eq(&a_conv, &b_conv);
33102 void __attribute__((export_name("TS_NetAddress_free"))) TS_NetAddress_free(uint64_t this_ptr) {
33103 if (!ptr_is_owned(this_ptr)) return;
33104 void* this_ptr_ptr = untag_ptr(this_ptr);
33105 CHECK_ACCESS(this_ptr_ptr);
33106 LDKNetAddress this_ptr_conv = *(LDKNetAddress*)(this_ptr_ptr);
33107 FREE(untag_ptr(this_ptr));
33108 NetAddress_free(this_ptr_conv);
33111 static inline uint64_t NetAddress_clone_ptr(LDKNetAddress *NONNULL_PTR arg) {
33112 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
33113 *ret_copy = NetAddress_clone(arg);
33114 uint64_t ret_ref = tag_ptr(ret_copy, true);
33117 int64_t __attribute__((export_name("TS_NetAddress_clone_ptr"))) TS_NetAddress_clone_ptr(uint64_t arg) {
33118 LDKNetAddress* arg_conv = (LDKNetAddress*)untag_ptr(arg);
33119 int64_t ret_conv = NetAddress_clone_ptr(arg_conv);
33123 uint64_t __attribute__((export_name("TS_NetAddress_clone"))) TS_NetAddress_clone(uint64_t orig) {
33124 LDKNetAddress* orig_conv = (LDKNetAddress*)untag_ptr(orig);
33125 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
33126 *ret_copy = NetAddress_clone(orig_conv);
33127 uint64_t ret_ref = tag_ptr(ret_copy, true);
33131 uint64_t __attribute__((export_name("TS_NetAddress_ipv4"))) TS_NetAddress_ipv4(int8_tArray addr, int16_t port) {
33132 LDKFourBytes addr_ref;
33133 CHECK(addr->arr_len == 4);
33134 memcpy(addr_ref.data, addr->elems, 4); FREE(addr);
33135 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
33136 *ret_copy = NetAddress_ipv4(addr_ref, port);
33137 uint64_t ret_ref = tag_ptr(ret_copy, true);
33141 uint64_t __attribute__((export_name("TS_NetAddress_ipv6"))) TS_NetAddress_ipv6(int8_tArray addr, int16_t port) {
33142 LDKSixteenBytes addr_ref;
33143 CHECK(addr->arr_len == 16);
33144 memcpy(addr_ref.data, addr->elems, 16); FREE(addr);
33145 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
33146 *ret_copy = NetAddress_ipv6(addr_ref, port);
33147 uint64_t ret_ref = tag_ptr(ret_copy, true);
33151 uint64_t __attribute__((export_name("TS_NetAddress_onion_v2"))) TS_NetAddress_onion_v2(int8_tArray a) {
33152 LDKTwelveBytes a_ref;
33153 CHECK(a->arr_len == 12);
33154 memcpy(a_ref.data, a->elems, 12); FREE(a);
33155 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
33156 *ret_copy = NetAddress_onion_v2(a_ref);
33157 uint64_t ret_ref = tag_ptr(ret_copy, true);
33161 uint64_t __attribute__((export_name("TS_NetAddress_onion_v3"))) TS_NetAddress_onion_v3(int8_tArray ed25519_pubkey, int16_t checksum, int8_t version, int16_t port) {
33162 LDKThirtyTwoBytes ed25519_pubkey_ref;
33163 CHECK(ed25519_pubkey->arr_len == 32);
33164 memcpy(ed25519_pubkey_ref.data, ed25519_pubkey->elems, 32); FREE(ed25519_pubkey);
33165 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
33166 *ret_copy = NetAddress_onion_v3(ed25519_pubkey_ref, checksum, version, port);
33167 uint64_t ret_ref = tag_ptr(ret_copy, true);
33171 uint64_t __attribute__((export_name("TS_NetAddress_hostname"))) TS_NetAddress_hostname(uint64_t hostname, int16_t port) {
33172 LDKHostname hostname_conv;
33173 hostname_conv.inner = untag_ptr(hostname);
33174 hostname_conv.is_owned = ptr_is_owned(hostname);
33175 CHECK_INNER_FIELD_ACCESS_OR_NULL(hostname_conv);
33176 hostname_conv = Hostname_clone(&hostname_conv);
33177 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
33178 *ret_copy = NetAddress_hostname(hostname_conv, port);
33179 uint64_t ret_ref = tag_ptr(ret_copy, true);
33183 jboolean __attribute__((export_name("TS_NetAddress_eq"))) TS_NetAddress_eq(uint64_t a, uint64_t b) {
33184 LDKNetAddress* a_conv = (LDKNetAddress*)untag_ptr(a);
33185 LDKNetAddress* b_conv = (LDKNetAddress*)untag_ptr(b);
33186 jboolean ret_conv = NetAddress_eq(a_conv, b_conv);
33190 int8_tArray __attribute__((export_name("TS_NetAddress_write"))) TS_NetAddress_write(uint64_t obj) {
33191 LDKNetAddress* obj_conv = (LDKNetAddress*)untag_ptr(obj);
33192 LDKCVec_u8Z ret_var = NetAddress_write(obj_conv);
33193 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
33194 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
33195 CVec_u8Z_free(ret_var);
33199 uint64_t __attribute__((export_name("TS_NetAddress_read"))) TS_NetAddress_read(int8_tArray ser) {
33200 LDKu8slice ser_ref;
33201 ser_ref.datalen = ser->arr_len;
33202 ser_ref.data = ser->elems;
33203 LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
33204 *ret_conv = NetAddress_read(ser_ref);
33206 return tag_ptr(ret_conv, true);
33209 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_free"))) TS_UnsignedNodeAnnouncement_free(uint64_t this_obj) {
33210 LDKUnsignedNodeAnnouncement this_obj_conv;
33211 this_obj_conv.inner = untag_ptr(this_obj);
33212 this_obj_conv.is_owned = ptr_is_owned(this_obj);
33213 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
33214 UnsignedNodeAnnouncement_free(this_obj_conv);
33217 uint64_t __attribute__((export_name("TS_UnsignedNodeAnnouncement_get_features"))) TS_UnsignedNodeAnnouncement_get_features(uint64_t this_ptr) {
33218 LDKUnsignedNodeAnnouncement this_ptr_conv;
33219 this_ptr_conv.inner = untag_ptr(this_ptr);
33220 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33221 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33222 this_ptr_conv.is_owned = false;
33223 LDKNodeFeatures ret_var = UnsignedNodeAnnouncement_get_features(&this_ptr_conv);
33224 uint64_t ret_ref = 0;
33225 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33226 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33230 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_set_features"))) TS_UnsignedNodeAnnouncement_set_features(uint64_t this_ptr, uint64_t val) {
33231 LDKUnsignedNodeAnnouncement this_ptr_conv;
33232 this_ptr_conv.inner = untag_ptr(this_ptr);
33233 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33234 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33235 this_ptr_conv.is_owned = false;
33236 LDKNodeFeatures val_conv;
33237 val_conv.inner = untag_ptr(val);
33238 val_conv.is_owned = ptr_is_owned(val);
33239 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
33240 val_conv = NodeFeatures_clone(&val_conv);
33241 UnsignedNodeAnnouncement_set_features(&this_ptr_conv, val_conv);
33244 int32_t __attribute__((export_name("TS_UnsignedNodeAnnouncement_get_timestamp"))) TS_UnsignedNodeAnnouncement_get_timestamp(uint64_t this_ptr) {
33245 LDKUnsignedNodeAnnouncement this_ptr_conv;
33246 this_ptr_conv.inner = untag_ptr(this_ptr);
33247 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33248 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33249 this_ptr_conv.is_owned = false;
33250 int32_t ret_conv = UnsignedNodeAnnouncement_get_timestamp(&this_ptr_conv);
33254 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_set_timestamp"))) TS_UnsignedNodeAnnouncement_set_timestamp(uint64_t this_ptr, int32_t val) {
33255 LDKUnsignedNodeAnnouncement this_ptr_conv;
33256 this_ptr_conv.inner = untag_ptr(this_ptr);
33257 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33258 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33259 this_ptr_conv.is_owned = false;
33260 UnsignedNodeAnnouncement_set_timestamp(&this_ptr_conv, val);
33263 int8_tArray __attribute__((export_name("TS_UnsignedNodeAnnouncement_get_node_id"))) TS_UnsignedNodeAnnouncement_get_node_id(uint64_t this_ptr) {
33264 LDKUnsignedNodeAnnouncement this_ptr_conv;
33265 this_ptr_conv.inner = untag_ptr(this_ptr);
33266 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33267 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33268 this_ptr_conv.is_owned = false;
33269 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
33270 memcpy(ret_arr->elems, UnsignedNodeAnnouncement_get_node_id(&this_ptr_conv).compressed_form, 33);
33274 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_set_node_id"))) TS_UnsignedNodeAnnouncement_set_node_id(uint64_t this_ptr, int8_tArray val) {
33275 LDKUnsignedNodeAnnouncement this_ptr_conv;
33276 this_ptr_conv.inner = untag_ptr(this_ptr);
33277 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33278 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33279 this_ptr_conv.is_owned = false;
33280 LDKPublicKey val_ref;
33281 CHECK(val->arr_len == 33);
33282 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
33283 UnsignedNodeAnnouncement_set_node_id(&this_ptr_conv, val_ref);
33286 int8_tArray __attribute__((export_name("TS_UnsignedNodeAnnouncement_get_rgb"))) TS_UnsignedNodeAnnouncement_get_rgb(uint64_t this_ptr) {
33287 LDKUnsignedNodeAnnouncement this_ptr_conv;
33288 this_ptr_conv.inner = untag_ptr(this_ptr);
33289 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33290 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33291 this_ptr_conv.is_owned = false;
33292 int8_tArray ret_arr = init_int8_tArray(3, __LINE__);
33293 memcpy(ret_arr->elems, *UnsignedNodeAnnouncement_get_rgb(&this_ptr_conv), 3);
33297 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_set_rgb"))) TS_UnsignedNodeAnnouncement_set_rgb(uint64_t this_ptr, int8_tArray val) {
33298 LDKUnsignedNodeAnnouncement this_ptr_conv;
33299 this_ptr_conv.inner = untag_ptr(this_ptr);
33300 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33301 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33302 this_ptr_conv.is_owned = false;
33303 LDKThreeBytes val_ref;
33304 CHECK(val->arr_len == 3);
33305 memcpy(val_ref.data, val->elems, 3); FREE(val);
33306 UnsignedNodeAnnouncement_set_rgb(&this_ptr_conv, val_ref);
33309 int8_tArray __attribute__((export_name("TS_UnsignedNodeAnnouncement_get_alias"))) TS_UnsignedNodeAnnouncement_get_alias(uint64_t this_ptr) {
33310 LDKUnsignedNodeAnnouncement this_ptr_conv;
33311 this_ptr_conv.inner = untag_ptr(this_ptr);
33312 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33313 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33314 this_ptr_conv.is_owned = false;
33315 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
33316 memcpy(ret_arr->elems, *UnsignedNodeAnnouncement_get_alias(&this_ptr_conv), 32);
33320 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_set_alias"))) TS_UnsignedNodeAnnouncement_set_alias(uint64_t this_ptr, int8_tArray val) {
33321 LDKUnsignedNodeAnnouncement this_ptr_conv;
33322 this_ptr_conv.inner = untag_ptr(this_ptr);
33323 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33324 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33325 this_ptr_conv.is_owned = false;
33326 LDKThirtyTwoBytes val_ref;
33327 CHECK(val->arr_len == 32);
33328 memcpy(val_ref.data, val->elems, 32); FREE(val);
33329 UnsignedNodeAnnouncement_set_alias(&this_ptr_conv, val_ref);
33332 uint64_tArray __attribute__((export_name("TS_UnsignedNodeAnnouncement_get_addresses"))) TS_UnsignedNodeAnnouncement_get_addresses(uint64_t this_ptr) {
33333 LDKUnsignedNodeAnnouncement this_ptr_conv;
33334 this_ptr_conv.inner = untag_ptr(this_ptr);
33335 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33336 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33337 this_ptr_conv.is_owned = false;
33338 LDKCVec_NetAddressZ ret_var = UnsignedNodeAnnouncement_get_addresses(&this_ptr_conv);
33339 uint64_tArray ret_arr = NULL;
33340 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
33341 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
33342 for (size_t m = 0; m < ret_var.datalen; m++) {
33343 LDKNetAddress *ret_conv_12_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
33344 *ret_conv_12_copy = ret_var.data[m];
33345 uint64_t ret_conv_12_ref = tag_ptr(ret_conv_12_copy, true);
33346 ret_arr_ptr[m] = ret_conv_12_ref;
33349 FREE(ret_var.data);
33353 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_set_addresses"))) TS_UnsignedNodeAnnouncement_set_addresses(uint64_t this_ptr, uint64_tArray val) {
33354 LDKUnsignedNodeAnnouncement this_ptr_conv;
33355 this_ptr_conv.inner = untag_ptr(this_ptr);
33356 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33357 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33358 this_ptr_conv.is_owned = false;
33359 LDKCVec_NetAddressZ val_constr;
33360 val_constr.datalen = val->arr_len;
33361 if (val_constr.datalen > 0)
33362 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
33364 val_constr.data = NULL;
33365 uint64_t* val_vals = val->elems;
33366 for (size_t m = 0; m < val_constr.datalen; m++) {
33367 uint64_t val_conv_12 = val_vals[m];
33368 void* val_conv_12_ptr = untag_ptr(val_conv_12);
33369 CHECK_ACCESS(val_conv_12_ptr);
33370 LDKNetAddress val_conv_12_conv = *(LDKNetAddress*)(val_conv_12_ptr);
33371 val_conv_12_conv = NetAddress_clone((LDKNetAddress*)untag_ptr(val_conv_12));
33372 val_constr.data[m] = val_conv_12_conv;
33375 UnsignedNodeAnnouncement_set_addresses(&this_ptr_conv, val_constr);
33378 static inline uint64_t UnsignedNodeAnnouncement_clone_ptr(LDKUnsignedNodeAnnouncement *NONNULL_PTR arg) {
33379 LDKUnsignedNodeAnnouncement ret_var = UnsignedNodeAnnouncement_clone(arg);
33380 uint64_t ret_ref = 0;
33381 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33382 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33385 int64_t __attribute__((export_name("TS_UnsignedNodeAnnouncement_clone_ptr"))) TS_UnsignedNodeAnnouncement_clone_ptr(uint64_t arg) {
33386 LDKUnsignedNodeAnnouncement arg_conv;
33387 arg_conv.inner = untag_ptr(arg);
33388 arg_conv.is_owned = ptr_is_owned(arg);
33389 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
33390 arg_conv.is_owned = false;
33391 int64_t ret_conv = UnsignedNodeAnnouncement_clone_ptr(&arg_conv);
33395 uint64_t __attribute__((export_name("TS_UnsignedNodeAnnouncement_clone"))) TS_UnsignedNodeAnnouncement_clone(uint64_t orig) {
33396 LDKUnsignedNodeAnnouncement orig_conv;
33397 orig_conv.inner = untag_ptr(orig);
33398 orig_conv.is_owned = ptr_is_owned(orig);
33399 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
33400 orig_conv.is_owned = false;
33401 LDKUnsignedNodeAnnouncement ret_var = UnsignedNodeAnnouncement_clone(&orig_conv);
33402 uint64_t ret_ref = 0;
33403 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33404 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33408 jboolean __attribute__((export_name("TS_UnsignedNodeAnnouncement_eq"))) TS_UnsignedNodeAnnouncement_eq(uint64_t a, uint64_t b) {
33409 LDKUnsignedNodeAnnouncement a_conv;
33410 a_conv.inner = untag_ptr(a);
33411 a_conv.is_owned = ptr_is_owned(a);
33412 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
33413 a_conv.is_owned = false;
33414 LDKUnsignedNodeAnnouncement b_conv;
33415 b_conv.inner = untag_ptr(b);
33416 b_conv.is_owned = ptr_is_owned(b);
33417 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
33418 b_conv.is_owned = false;
33419 jboolean ret_conv = UnsignedNodeAnnouncement_eq(&a_conv, &b_conv);
33423 void __attribute__((export_name("TS_NodeAnnouncement_free"))) TS_NodeAnnouncement_free(uint64_t this_obj) {
33424 LDKNodeAnnouncement this_obj_conv;
33425 this_obj_conv.inner = untag_ptr(this_obj);
33426 this_obj_conv.is_owned = ptr_is_owned(this_obj);
33427 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
33428 NodeAnnouncement_free(this_obj_conv);
33431 int8_tArray __attribute__((export_name("TS_NodeAnnouncement_get_signature"))) TS_NodeAnnouncement_get_signature(uint64_t this_ptr) {
33432 LDKNodeAnnouncement this_ptr_conv;
33433 this_ptr_conv.inner = untag_ptr(this_ptr);
33434 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33435 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33436 this_ptr_conv.is_owned = false;
33437 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
33438 memcpy(ret_arr->elems, NodeAnnouncement_get_signature(&this_ptr_conv).compact_form, 64);
33442 void __attribute__((export_name("TS_NodeAnnouncement_set_signature"))) TS_NodeAnnouncement_set_signature(uint64_t this_ptr, int8_tArray val) {
33443 LDKNodeAnnouncement this_ptr_conv;
33444 this_ptr_conv.inner = untag_ptr(this_ptr);
33445 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33446 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33447 this_ptr_conv.is_owned = false;
33448 LDKSignature val_ref;
33449 CHECK(val->arr_len == 64);
33450 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
33451 NodeAnnouncement_set_signature(&this_ptr_conv, val_ref);
33454 uint64_t __attribute__((export_name("TS_NodeAnnouncement_get_contents"))) TS_NodeAnnouncement_get_contents(uint64_t this_ptr) {
33455 LDKNodeAnnouncement this_ptr_conv;
33456 this_ptr_conv.inner = untag_ptr(this_ptr);
33457 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33458 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33459 this_ptr_conv.is_owned = false;
33460 LDKUnsignedNodeAnnouncement ret_var = NodeAnnouncement_get_contents(&this_ptr_conv);
33461 uint64_t ret_ref = 0;
33462 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33463 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33467 void __attribute__((export_name("TS_NodeAnnouncement_set_contents"))) TS_NodeAnnouncement_set_contents(uint64_t this_ptr, uint64_t val) {
33468 LDKNodeAnnouncement this_ptr_conv;
33469 this_ptr_conv.inner = untag_ptr(this_ptr);
33470 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33471 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33472 this_ptr_conv.is_owned = false;
33473 LDKUnsignedNodeAnnouncement val_conv;
33474 val_conv.inner = untag_ptr(val);
33475 val_conv.is_owned = ptr_is_owned(val);
33476 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
33477 val_conv = UnsignedNodeAnnouncement_clone(&val_conv);
33478 NodeAnnouncement_set_contents(&this_ptr_conv, val_conv);
33481 uint64_t __attribute__((export_name("TS_NodeAnnouncement_new"))) TS_NodeAnnouncement_new(int8_tArray signature_arg, uint64_t contents_arg) {
33482 LDKSignature signature_arg_ref;
33483 CHECK(signature_arg->arr_len == 64);
33484 memcpy(signature_arg_ref.compact_form, signature_arg->elems, 64); FREE(signature_arg);
33485 LDKUnsignedNodeAnnouncement contents_arg_conv;
33486 contents_arg_conv.inner = untag_ptr(contents_arg);
33487 contents_arg_conv.is_owned = ptr_is_owned(contents_arg);
33488 CHECK_INNER_FIELD_ACCESS_OR_NULL(contents_arg_conv);
33489 contents_arg_conv = UnsignedNodeAnnouncement_clone(&contents_arg_conv);
33490 LDKNodeAnnouncement ret_var = NodeAnnouncement_new(signature_arg_ref, contents_arg_conv);
33491 uint64_t ret_ref = 0;
33492 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33493 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33497 static inline uint64_t NodeAnnouncement_clone_ptr(LDKNodeAnnouncement *NONNULL_PTR arg) {
33498 LDKNodeAnnouncement ret_var = NodeAnnouncement_clone(arg);
33499 uint64_t ret_ref = 0;
33500 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33501 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33504 int64_t __attribute__((export_name("TS_NodeAnnouncement_clone_ptr"))) TS_NodeAnnouncement_clone_ptr(uint64_t arg) {
33505 LDKNodeAnnouncement arg_conv;
33506 arg_conv.inner = untag_ptr(arg);
33507 arg_conv.is_owned = ptr_is_owned(arg);
33508 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
33509 arg_conv.is_owned = false;
33510 int64_t ret_conv = NodeAnnouncement_clone_ptr(&arg_conv);
33514 uint64_t __attribute__((export_name("TS_NodeAnnouncement_clone"))) TS_NodeAnnouncement_clone(uint64_t orig) {
33515 LDKNodeAnnouncement orig_conv;
33516 orig_conv.inner = untag_ptr(orig);
33517 orig_conv.is_owned = ptr_is_owned(orig);
33518 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
33519 orig_conv.is_owned = false;
33520 LDKNodeAnnouncement ret_var = NodeAnnouncement_clone(&orig_conv);
33521 uint64_t ret_ref = 0;
33522 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33523 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33527 jboolean __attribute__((export_name("TS_NodeAnnouncement_eq"))) TS_NodeAnnouncement_eq(uint64_t a, uint64_t b) {
33528 LDKNodeAnnouncement a_conv;
33529 a_conv.inner = untag_ptr(a);
33530 a_conv.is_owned = ptr_is_owned(a);
33531 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
33532 a_conv.is_owned = false;
33533 LDKNodeAnnouncement b_conv;
33534 b_conv.inner = untag_ptr(b);
33535 b_conv.is_owned = ptr_is_owned(b);
33536 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
33537 b_conv.is_owned = false;
33538 jboolean ret_conv = NodeAnnouncement_eq(&a_conv, &b_conv);
33542 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_free"))) TS_UnsignedChannelAnnouncement_free(uint64_t this_obj) {
33543 LDKUnsignedChannelAnnouncement this_obj_conv;
33544 this_obj_conv.inner = untag_ptr(this_obj);
33545 this_obj_conv.is_owned = ptr_is_owned(this_obj);
33546 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
33547 UnsignedChannelAnnouncement_free(this_obj_conv);
33550 uint64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_features"))) TS_UnsignedChannelAnnouncement_get_features(uint64_t this_ptr) {
33551 LDKUnsignedChannelAnnouncement this_ptr_conv;
33552 this_ptr_conv.inner = untag_ptr(this_ptr);
33553 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33554 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33555 this_ptr_conv.is_owned = false;
33556 LDKChannelFeatures ret_var = UnsignedChannelAnnouncement_get_features(&this_ptr_conv);
33557 uint64_t ret_ref = 0;
33558 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33559 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33563 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_features"))) TS_UnsignedChannelAnnouncement_set_features(uint64_t this_ptr, uint64_t val) {
33564 LDKUnsignedChannelAnnouncement this_ptr_conv;
33565 this_ptr_conv.inner = untag_ptr(this_ptr);
33566 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33567 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33568 this_ptr_conv.is_owned = false;
33569 LDKChannelFeatures val_conv;
33570 val_conv.inner = untag_ptr(val);
33571 val_conv.is_owned = ptr_is_owned(val);
33572 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
33573 val_conv = ChannelFeatures_clone(&val_conv);
33574 UnsignedChannelAnnouncement_set_features(&this_ptr_conv, val_conv);
33577 int8_tArray __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_chain_hash"))) TS_UnsignedChannelAnnouncement_get_chain_hash(uint64_t this_ptr) {
33578 LDKUnsignedChannelAnnouncement this_ptr_conv;
33579 this_ptr_conv.inner = untag_ptr(this_ptr);
33580 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33581 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33582 this_ptr_conv.is_owned = false;
33583 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
33584 memcpy(ret_arr->elems, *UnsignedChannelAnnouncement_get_chain_hash(&this_ptr_conv), 32);
33588 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_chain_hash"))) TS_UnsignedChannelAnnouncement_set_chain_hash(uint64_t this_ptr, int8_tArray val) {
33589 LDKUnsignedChannelAnnouncement this_ptr_conv;
33590 this_ptr_conv.inner = untag_ptr(this_ptr);
33591 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33592 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33593 this_ptr_conv.is_owned = false;
33594 LDKThirtyTwoBytes val_ref;
33595 CHECK(val->arr_len == 32);
33596 memcpy(val_ref.data, val->elems, 32); FREE(val);
33597 UnsignedChannelAnnouncement_set_chain_hash(&this_ptr_conv, val_ref);
33600 int64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_short_channel_id"))) TS_UnsignedChannelAnnouncement_get_short_channel_id(uint64_t this_ptr) {
33601 LDKUnsignedChannelAnnouncement this_ptr_conv;
33602 this_ptr_conv.inner = untag_ptr(this_ptr);
33603 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33604 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33605 this_ptr_conv.is_owned = false;
33606 int64_t ret_conv = UnsignedChannelAnnouncement_get_short_channel_id(&this_ptr_conv);
33610 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_short_channel_id"))) TS_UnsignedChannelAnnouncement_set_short_channel_id(uint64_t this_ptr, int64_t val) {
33611 LDKUnsignedChannelAnnouncement this_ptr_conv;
33612 this_ptr_conv.inner = untag_ptr(this_ptr);
33613 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33614 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33615 this_ptr_conv.is_owned = false;
33616 UnsignedChannelAnnouncement_set_short_channel_id(&this_ptr_conv, val);
33619 int8_tArray __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_node_id_1"))) TS_UnsignedChannelAnnouncement_get_node_id_1(uint64_t this_ptr) {
33620 LDKUnsignedChannelAnnouncement this_ptr_conv;
33621 this_ptr_conv.inner = untag_ptr(this_ptr);
33622 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33623 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33624 this_ptr_conv.is_owned = false;
33625 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
33626 memcpy(ret_arr->elems, UnsignedChannelAnnouncement_get_node_id_1(&this_ptr_conv).compressed_form, 33);
33630 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_node_id_1"))) TS_UnsignedChannelAnnouncement_set_node_id_1(uint64_t this_ptr, int8_tArray val) {
33631 LDKUnsignedChannelAnnouncement this_ptr_conv;
33632 this_ptr_conv.inner = untag_ptr(this_ptr);
33633 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33634 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33635 this_ptr_conv.is_owned = false;
33636 LDKPublicKey val_ref;
33637 CHECK(val->arr_len == 33);
33638 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
33639 UnsignedChannelAnnouncement_set_node_id_1(&this_ptr_conv, val_ref);
33642 int8_tArray __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_node_id_2"))) TS_UnsignedChannelAnnouncement_get_node_id_2(uint64_t this_ptr) {
33643 LDKUnsignedChannelAnnouncement this_ptr_conv;
33644 this_ptr_conv.inner = untag_ptr(this_ptr);
33645 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33646 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33647 this_ptr_conv.is_owned = false;
33648 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
33649 memcpy(ret_arr->elems, UnsignedChannelAnnouncement_get_node_id_2(&this_ptr_conv).compressed_form, 33);
33653 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_node_id_2"))) TS_UnsignedChannelAnnouncement_set_node_id_2(uint64_t this_ptr, int8_tArray val) {
33654 LDKUnsignedChannelAnnouncement this_ptr_conv;
33655 this_ptr_conv.inner = untag_ptr(this_ptr);
33656 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33657 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33658 this_ptr_conv.is_owned = false;
33659 LDKPublicKey val_ref;
33660 CHECK(val->arr_len == 33);
33661 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
33662 UnsignedChannelAnnouncement_set_node_id_2(&this_ptr_conv, val_ref);
33665 int8_tArray __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_bitcoin_key_1"))) TS_UnsignedChannelAnnouncement_get_bitcoin_key_1(uint64_t this_ptr) {
33666 LDKUnsignedChannelAnnouncement this_ptr_conv;
33667 this_ptr_conv.inner = untag_ptr(this_ptr);
33668 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33669 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33670 this_ptr_conv.is_owned = false;
33671 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
33672 memcpy(ret_arr->elems, UnsignedChannelAnnouncement_get_bitcoin_key_1(&this_ptr_conv).compressed_form, 33);
33676 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_bitcoin_key_1"))) TS_UnsignedChannelAnnouncement_set_bitcoin_key_1(uint64_t this_ptr, int8_tArray val) {
33677 LDKUnsignedChannelAnnouncement this_ptr_conv;
33678 this_ptr_conv.inner = untag_ptr(this_ptr);
33679 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33680 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33681 this_ptr_conv.is_owned = false;
33682 LDKPublicKey val_ref;
33683 CHECK(val->arr_len == 33);
33684 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
33685 UnsignedChannelAnnouncement_set_bitcoin_key_1(&this_ptr_conv, val_ref);
33688 int8_tArray __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_bitcoin_key_2"))) TS_UnsignedChannelAnnouncement_get_bitcoin_key_2(uint64_t this_ptr) {
33689 LDKUnsignedChannelAnnouncement this_ptr_conv;
33690 this_ptr_conv.inner = untag_ptr(this_ptr);
33691 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33692 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33693 this_ptr_conv.is_owned = false;
33694 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
33695 memcpy(ret_arr->elems, UnsignedChannelAnnouncement_get_bitcoin_key_2(&this_ptr_conv).compressed_form, 33);
33699 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_bitcoin_key_2"))) TS_UnsignedChannelAnnouncement_set_bitcoin_key_2(uint64_t this_ptr, int8_tArray val) {
33700 LDKUnsignedChannelAnnouncement this_ptr_conv;
33701 this_ptr_conv.inner = untag_ptr(this_ptr);
33702 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33703 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33704 this_ptr_conv.is_owned = false;
33705 LDKPublicKey val_ref;
33706 CHECK(val->arr_len == 33);
33707 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
33708 UnsignedChannelAnnouncement_set_bitcoin_key_2(&this_ptr_conv, val_ref);
33711 static inline uint64_t UnsignedChannelAnnouncement_clone_ptr(LDKUnsignedChannelAnnouncement *NONNULL_PTR arg) {
33712 LDKUnsignedChannelAnnouncement ret_var = UnsignedChannelAnnouncement_clone(arg);
33713 uint64_t ret_ref = 0;
33714 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33715 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33718 int64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_clone_ptr"))) TS_UnsignedChannelAnnouncement_clone_ptr(uint64_t arg) {
33719 LDKUnsignedChannelAnnouncement arg_conv;
33720 arg_conv.inner = untag_ptr(arg);
33721 arg_conv.is_owned = ptr_is_owned(arg);
33722 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
33723 arg_conv.is_owned = false;
33724 int64_t ret_conv = UnsignedChannelAnnouncement_clone_ptr(&arg_conv);
33728 uint64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_clone"))) TS_UnsignedChannelAnnouncement_clone(uint64_t orig) {
33729 LDKUnsignedChannelAnnouncement orig_conv;
33730 orig_conv.inner = untag_ptr(orig);
33731 orig_conv.is_owned = ptr_is_owned(orig);
33732 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
33733 orig_conv.is_owned = false;
33734 LDKUnsignedChannelAnnouncement ret_var = UnsignedChannelAnnouncement_clone(&orig_conv);
33735 uint64_t ret_ref = 0;
33736 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33737 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33741 jboolean __attribute__((export_name("TS_UnsignedChannelAnnouncement_eq"))) TS_UnsignedChannelAnnouncement_eq(uint64_t a, uint64_t b) {
33742 LDKUnsignedChannelAnnouncement a_conv;
33743 a_conv.inner = untag_ptr(a);
33744 a_conv.is_owned = ptr_is_owned(a);
33745 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
33746 a_conv.is_owned = false;
33747 LDKUnsignedChannelAnnouncement b_conv;
33748 b_conv.inner = untag_ptr(b);
33749 b_conv.is_owned = ptr_is_owned(b);
33750 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
33751 b_conv.is_owned = false;
33752 jboolean ret_conv = UnsignedChannelAnnouncement_eq(&a_conv, &b_conv);
33756 void __attribute__((export_name("TS_ChannelAnnouncement_free"))) TS_ChannelAnnouncement_free(uint64_t this_obj) {
33757 LDKChannelAnnouncement this_obj_conv;
33758 this_obj_conv.inner = untag_ptr(this_obj);
33759 this_obj_conv.is_owned = ptr_is_owned(this_obj);
33760 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
33761 ChannelAnnouncement_free(this_obj_conv);
33764 int8_tArray __attribute__((export_name("TS_ChannelAnnouncement_get_node_signature_1"))) TS_ChannelAnnouncement_get_node_signature_1(uint64_t this_ptr) {
33765 LDKChannelAnnouncement this_ptr_conv;
33766 this_ptr_conv.inner = untag_ptr(this_ptr);
33767 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33768 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33769 this_ptr_conv.is_owned = false;
33770 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
33771 memcpy(ret_arr->elems, ChannelAnnouncement_get_node_signature_1(&this_ptr_conv).compact_form, 64);
33775 void __attribute__((export_name("TS_ChannelAnnouncement_set_node_signature_1"))) TS_ChannelAnnouncement_set_node_signature_1(uint64_t this_ptr, int8_tArray val) {
33776 LDKChannelAnnouncement this_ptr_conv;
33777 this_ptr_conv.inner = untag_ptr(this_ptr);
33778 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33779 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33780 this_ptr_conv.is_owned = false;
33781 LDKSignature val_ref;
33782 CHECK(val->arr_len == 64);
33783 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
33784 ChannelAnnouncement_set_node_signature_1(&this_ptr_conv, val_ref);
33787 int8_tArray __attribute__((export_name("TS_ChannelAnnouncement_get_node_signature_2"))) TS_ChannelAnnouncement_get_node_signature_2(uint64_t this_ptr) {
33788 LDKChannelAnnouncement this_ptr_conv;
33789 this_ptr_conv.inner = untag_ptr(this_ptr);
33790 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33791 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33792 this_ptr_conv.is_owned = false;
33793 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
33794 memcpy(ret_arr->elems, ChannelAnnouncement_get_node_signature_2(&this_ptr_conv).compact_form, 64);
33798 void __attribute__((export_name("TS_ChannelAnnouncement_set_node_signature_2"))) TS_ChannelAnnouncement_set_node_signature_2(uint64_t this_ptr, int8_tArray val) {
33799 LDKChannelAnnouncement this_ptr_conv;
33800 this_ptr_conv.inner = untag_ptr(this_ptr);
33801 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33802 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33803 this_ptr_conv.is_owned = false;
33804 LDKSignature val_ref;
33805 CHECK(val->arr_len == 64);
33806 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
33807 ChannelAnnouncement_set_node_signature_2(&this_ptr_conv, val_ref);
33810 int8_tArray __attribute__((export_name("TS_ChannelAnnouncement_get_bitcoin_signature_1"))) TS_ChannelAnnouncement_get_bitcoin_signature_1(uint64_t this_ptr) {
33811 LDKChannelAnnouncement this_ptr_conv;
33812 this_ptr_conv.inner = untag_ptr(this_ptr);
33813 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33814 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33815 this_ptr_conv.is_owned = false;
33816 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
33817 memcpy(ret_arr->elems, ChannelAnnouncement_get_bitcoin_signature_1(&this_ptr_conv).compact_form, 64);
33821 void __attribute__((export_name("TS_ChannelAnnouncement_set_bitcoin_signature_1"))) TS_ChannelAnnouncement_set_bitcoin_signature_1(uint64_t this_ptr, int8_tArray val) {
33822 LDKChannelAnnouncement this_ptr_conv;
33823 this_ptr_conv.inner = untag_ptr(this_ptr);
33824 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33825 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33826 this_ptr_conv.is_owned = false;
33827 LDKSignature val_ref;
33828 CHECK(val->arr_len == 64);
33829 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
33830 ChannelAnnouncement_set_bitcoin_signature_1(&this_ptr_conv, val_ref);
33833 int8_tArray __attribute__((export_name("TS_ChannelAnnouncement_get_bitcoin_signature_2"))) TS_ChannelAnnouncement_get_bitcoin_signature_2(uint64_t this_ptr) {
33834 LDKChannelAnnouncement this_ptr_conv;
33835 this_ptr_conv.inner = untag_ptr(this_ptr);
33836 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33837 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33838 this_ptr_conv.is_owned = false;
33839 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
33840 memcpy(ret_arr->elems, ChannelAnnouncement_get_bitcoin_signature_2(&this_ptr_conv).compact_form, 64);
33844 void __attribute__((export_name("TS_ChannelAnnouncement_set_bitcoin_signature_2"))) TS_ChannelAnnouncement_set_bitcoin_signature_2(uint64_t this_ptr, int8_tArray val) {
33845 LDKChannelAnnouncement this_ptr_conv;
33846 this_ptr_conv.inner = untag_ptr(this_ptr);
33847 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33848 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33849 this_ptr_conv.is_owned = false;
33850 LDKSignature val_ref;
33851 CHECK(val->arr_len == 64);
33852 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
33853 ChannelAnnouncement_set_bitcoin_signature_2(&this_ptr_conv, val_ref);
33856 uint64_t __attribute__((export_name("TS_ChannelAnnouncement_get_contents"))) TS_ChannelAnnouncement_get_contents(uint64_t this_ptr) {
33857 LDKChannelAnnouncement this_ptr_conv;
33858 this_ptr_conv.inner = untag_ptr(this_ptr);
33859 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33860 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33861 this_ptr_conv.is_owned = false;
33862 LDKUnsignedChannelAnnouncement ret_var = ChannelAnnouncement_get_contents(&this_ptr_conv);
33863 uint64_t ret_ref = 0;
33864 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33865 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33869 void __attribute__((export_name("TS_ChannelAnnouncement_set_contents"))) TS_ChannelAnnouncement_set_contents(uint64_t this_ptr, uint64_t val) {
33870 LDKChannelAnnouncement this_ptr_conv;
33871 this_ptr_conv.inner = untag_ptr(this_ptr);
33872 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33873 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33874 this_ptr_conv.is_owned = false;
33875 LDKUnsignedChannelAnnouncement val_conv;
33876 val_conv.inner = untag_ptr(val);
33877 val_conv.is_owned = ptr_is_owned(val);
33878 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
33879 val_conv = UnsignedChannelAnnouncement_clone(&val_conv);
33880 ChannelAnnouncement_set_contents(&this_ptr_conv, val_conv);
33883 uint64_t __attribute__((export_name("TS_ChannelAnnouncement_new"))) TS_ChannelAnnouncement_new(int8_tArray node_signature_1_arg, int8_tArray node_signature_2_arg, int8_tArray bitcoin_signature_1_arg, int8_tArray bitcoin_signature_2_arg, uint64_t contents_arg) {
33884 LDKSignature node_signature_1_arg_ref;
33885 CHECK(node_signature_1_arg->arr_len == 64);
33886 memcpy(node_signature_1_arg_ref.compact_form, node_signature_1_arg->elems, 64); FREE(node_signature_1_arg);
33887 LDKSignature node_signature_2_arg_ref;
33888 CHECK(node_signature_2_arg->arr_len == 64);
33889 memcpy(node_signature_2_arg_ref.compact_form, node_signature_2_arg->elems, 64); FREE(node_signature_2_arg);
33890 LDKSignature bitcoin_signature_1_arg_ref;
33891 CHECK(bitcoin_signature_1_arg->arr_len == 64);
33892 memcpy(bitcoin_signature_1_arg_ref.compact_form, bitcoin_signature_1_arg->elems, 64); FREE(bitcoin_signature_1_arg);
33893 LDKSignature bitcoin_signature_2_arg_ref;
33894 CHECK(bitcoin_signature_2_arg->arr_len == 64);
33895 memcpy(bitcoin_signature_2_arg_ref.compact_form, bitcoin_signature_2_arg->elems, 64); FREE(bitcoin_signature_2_arg);
33896 LDKUnsignedChannelAnnouncement contents_arg_conv;
33897 contents_arg_conv.inner = untag_ptr(contents_arg);
33898 contents_arg_conv.is_owned = ptr_is_owned(contents_arg);
33899 CHECK_INNER_FIELD_ACCESS_OR_NULL(contents_arg_conv);
33900 contents_arg_conv = UnsignedChannelAnnouncement_clone(&contents_arg_conv);
33901 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);
33902 uint64_t ret_ref = 0;
33903 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33904 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33908 static inline uint64_t ChannelAnnouncement_clone_ptr(LDKChannelAnnouncement *NONNULL_PTR arg) {
33909 LDKChannelAnnouncement ret_var = ChannelAnnouncement_clone(arg);
33910 uint64_t ret_ref = 0;
33911 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33912 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33915 int64_t __attribute__((export_name("TS_ChannelAnnouncement_clone_ptr"))) TS_ChannelAnnouncement_clone_ptr(uint64_t arg) {
33916 LDKChannelAnnouncement arg_conv;
33917 arg_conv.inner = untag_ptr(arg);
33918 arg_conv.is_owned = ptr_is_owned(arg);
33919 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
33920 arg_conv.is_owned = false;
33921 int64_t ret_conv = ChannelAnnouncement_clone_ptr(&arg_conv);
33925 uint64_t __attribute__((export_name("TS_ChannelAnnouncement_clone"))) TS_ChannelAnnouncement_clone(uint64_t orig) {
33926 LDKChannelAnnouncement orig_conv;
33927 orig_conv.inner = untag_ptr(orig);
33928 orig_conv.is_owned = ptr_is_owned(orig);
33929 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
33930 orig_conv.is_owned = false;
33931 LDKChannelAnnouncement ret_var = ChannelAnnouncement_clone(&orig_conv);
33932 uint64_t ret_ref = 0;
33933 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33934 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33938 jboolean __attribute__((export_name("TS_ChannelAnnouncement_eq"))) TS_ChannelAnnouncement_eq(uint64_t a, uint64_t b) {
33939 LDKChannelAnnouncement a_conv;
33940 a_conv.inner = untag_ptr(a);
33941 a_conv.is_owned = ptr_is_owned(a);
33942 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
33943 a_conv.is_owned = false;
33944 LDKChannelAnnouncement b_conv;
33945 b_conv.inner = untag_ptr(b);
33946 b_conv.is_owned = ptr_is_owned(b);
33947 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
33948 b_conv.is_owned = false;
33949 jboolean ret_conv = ChannelAnnouncement_eq(&a_conv, &b_conv);
33953 void __attribute__((export_name("TS_UnsignedChannelUpdate_free"))) TS_UnsignedChannelUpdate_free(uint64_t this_obj) {
33954 LDKUnsignedChannelUpdate this_obj_conv;
33955 this_obj_conv.inner = untag_ptr(this_obj);
33956 this_obj_conv.is_owned = ptr_is_owned(this_obj);
33957 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
33958 UnsignedChannelUpdate_free(this_obj_conv);
33961 int8_tArray __attribute__((export_name("TS_UnsignedChannelUpdate_get_chain_hash"))) TS_UnsignedChannelUpdate_get_chain_hash(uint64_t this_ptr) {
33962 LDKUnsignedChannelUpdate this_ptr_conv;
33963 this_ptr_conv.inner = untag_ptr(this_ptr);
33964 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33965 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33966 this_ptr_conv.is_owned = false;
33967 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
33968 memcpy(ret_arr->elems, *UnsignedChannelUpdate_get_chain_hash(&this_ptr_conv), 32);
33972 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_chain_hash"))) TS_UnsignedChannelUpdate_set_chain_hash(uint64_t this_ptr, int8_tArray val) {
33973 LDKUnsignedChannelUpdate this_ptr_conv;
33974 this_ptr_conv.inner = untag_ptr(this_ptr);
33975 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33976 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33977 this_ptr_conv.is_owned = false;
33978 LDKThirtyTwoBytes val_ref;
33979 CHECK(val->arr_len == 32);
33980 memcpy(val_ref.data, val->elems, 32); FREE(val);
33981 UnsignedChannelUpdate_set_chain_hash(&this_ptr_conv, val_ref);
33984 int64_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_short_channel_id"))) TS_UnsignedChannelUpdate_get_short_channel_id(uint64_t this_ptr) {
33985 LDKUnsignedChannelUpdate this_ptr_conv;
33986 this_ptr_conv.inner = untag_ptr(this_ptr);
33987 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33988 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33989 this_ptr_conv.is_owned = false;
33990 int64_t ret_conv = UnsignedChannelUpdate_get_short_channel_id(&this_ptr_conv);
33994 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_short_channel_id"))) TS_UnsignedChannelUpdate_set_short_channel_id(uint64_t this_ptr, int64_t val) {
33995 LDKUnsignedChannelUpdate this_ptr_conv;
33996 this_ptr_conv.inner = untag_ptr(this_ptr);
33997 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33998 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33999 this_ptr_conv.is_owned = false;
34000 UnsignedChannelUpdate_set_short_channel_id(&this_ptr_conv, val);
34003 int32_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_timestamp"))) TS_UnsignedChannelUpdate_get_timestamp(uint64_t this_ptr) {
34004 LDKUnsignedChannelUpdate this_ptr_conv;
34005 this_ptr_conv.inner = untag_ptr(this_ptr);
34006 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34007 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34008 this_ptr_conv.is_owned = false;
34009 int32_t ret_conv = UnsignedChannelUpdate_get_timestamp(&this_ptr_conv);
34013 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_timestamp"))) TS_UnsignedChannelUpdate_set_timestamp(uint64_t this_ptr, int32_t val) {
34014 LDKUnsignedChannelUpdate this_ptr_conv;
34015 this_ptr_conv.inner = untag_ptr(this_ptr);
34016 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34017 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34018 this_ptr_conv.is_owned = false;
34019 UnsignedChannelUpdate_set_timestamp(&this_ptr_conv, val);
34022 int8_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_flags"))) TS_UnsignedChannelUpdate_get_flags(uint64_t this_ptr) {
34023 LDKUnsignedChannelUpdate this_ptr_conv;
34024 this_ptr_conv.inner = untag_ptr(this_ptr);
34025 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34026 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34027 this_ptr_conv.is_owned = false;
34028 int8_t ret_conv = UnsignedChannelUpdate_get_flags(&this_ptr_conv);
34032 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_flags"))) TS_UnsignedChannelUpdate_set_flags(uint64_t this_ptr, int8_t val) {
34033 LDKUnsignedChannelUpdate this_ptr_conv;
34034 this_ptr_conv.inner = untag_ptr(this_ptr);
34035 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34036 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34037 this_ptr_conv.is_owned = false;
34038 UnsignedChannelUpdate_set_flags(&this_ptr_conv, val);
34041 int16_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_cltv_expiry_delta"))) TS_UnsignedChannelUpdate_get_cltv_expiry_delta(uint64_t this_ptr) {
34042 LDKUnsignedChannelUpdate this_ptr_conv;
34043 this_ptr_conv.inner = untag_ptr(this_ptr);
34044 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34045 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34046 this_ptr_conv.is_owned = false;
34047 int16_t ret_conv = UnsignedChannelUpdate_get_cltv_expiry_delta(&this_ptr_conv);
34051 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_cltv_expiry_delta"))) TS_UnsignedChannelUpdate_set_cltv_expiry_delta(uint64_t this_ptr, int16_t val) {
34052 LDKUnsignedChannelUpdate this_ptr_conv;
34053 this_ptr_conv.inner = untag_ptr(this_ptr);
34054 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34055 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34056 this_ptr_conv.is_owned = false;
34057 UnsignedChannelUpdate_set_cltv_expiry_delta(&this_ptr_conv, val);
34060 int64_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_htlc_minimum_msat"))) TS_UnsignedChannelUpdate_get_htlc_minimum_msat(uint64_t this_ptr) {
34061 LDKUnsignedChannelUpdate this_ptr_conv;
34062 this_ptr_conv.inner = untag_ptr(this_ptr);
34063 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34064 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34065 this_ptr_conv.is_owned = false;
34066 int64_t ret_conv = UnsignedChannelUpdate_get_htlc_minimum_msat(&this_ptr_conv);
34070 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_htlc_minimum_msat"))) TS_UnsignedChannelUpdate_set_htlc_minimum_msat(uint64_t this_ptr, int64_t val) {
34071 LDKUnsignedChannelUpdate this_ptr_conv;
34072 this_ptr_conv.inner = untag_ptr(this_ptr);
34073 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34074 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34075 this_ptr_conv.is_owned = false;
34076 UnsignedChannelUpdate_set_htlc_minimum_msat(&this_ptr_conv, val);
34079 int64_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_htlc_maximum_msat"))) TS_UnsignedChannelUpdate_get_htlc_maximum_msat(uint64_t this_ptr) {
34080 LDKUnsignedChannelUpdate this_ptr_conv;
34081 this_ptr_conv.inner = untag_ptr(this_ptr);
34082 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34083 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34084 this_ptr_conv.is_owned = false;
34085 int64_t ret_conv = UnsignedChannelUpdate_get_htlc_maximum_msat(&this_ptr_conv);
34089 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_htlc_maximum_msat"))) TS_UnsignedChannelUpdate_set_htlc_maximum_msat(uint64_t this_ptr, int64_t val) {
34090 LDKUnsignedChannelUpdate this_ptr_conv;
34091 this_ptr_conv.inner = untag_ptr(this_ptr);
34092 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34093 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34094 this_ptr_conv.is_owned = false;
34095 UnsignedChannelUpdate_set_htlc_maximum_msat(&this_ptr_conv, val);
34098 int32_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_fee_base_msat"))) TS_UnsignedChannelUpdate_get_fee_base_msat(uint64_t this_ptr) {
34099 LDKUnsignedChannelUpdate this_ptr_conv;
34100 this_ptr_conv.inner = untag_ptr(this_ptr);
34101 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34102 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34103 this_ptr_conv.is_owned = false;
34104 int32_t ret_conv = UnsignedChannelUpdate_get_fee_base_msat(&this_ptr_conv);
34108 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_fee_base_msat"))) TS_UnsignedChannelUpdate_set_fee_base_msat(uint64_t this_ptr, int32_t val) {
34109 LDKUnsignedChannelUpdate this_ptr_conv;
34110 this_ptr_conv.inner = untag_ptr(this_ptr);
34111 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34112 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34113 this_ptr_conv.is_owned = false;
34114 UnsignedChannelUpdate_set_fee_base_msat(&this_ptr_conv, val);
34117 int32_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_fee_proportional_millionths"))) TS_UnsignedChannelUpdate_get_fee_proportional_millionths(uint64_t this_ptr) {
34118 LDKUnsignedChannelUpdate this_ptr_conv;
34119 this_ptr_conv.inner = untag_ptr(this_ptr);
34120 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34121 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34122 this_ptr_conv.is_owned = false;
34123 int32_t ret_conv = UnsignedChannelUpdate_get_fee_proportional_millionths(&this_ptr_conv);
34127 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_fee_proportional_millionths"))) TS_UnsignedChannelUpdate_set_fee_proportional_millionths(uint64_t this_ptr, int32_t val) {
34128 LDKUnsignedChannelUpdate this_ptr_conv;
34129 this_ptr_conv.inner = untag_ptr(this_ptr);
34130 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34131 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34132 this_ptr_conv.is_owned = false;
34133 UnsignedChannelUpdate_set_fee_proportional_millionths(&this_ptr_conv, val);
34136 int8_tArray __attribute__((export_name("TS_UnsignedChannelUpdate_get_excess_data"))) TS_UnsignedChannelUpdate_get_excess_data(uint64_t this_ptr) {
34137 LDKUnsignedChannelUpdate this_ptr_conv;
34138 this_ptr_conv.inner = untag_ptr(this_ptr);
34139 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34140 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34141 this_ptr_conv.is_owned = false;
34142 LDKCVec_u8Z ret_var = UnsignedChannelUpdate_get_excess_data(&this_ptr_conv);
34143 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
34144 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
34145 CVec_u8Z_free(ret_var);
34149 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_excess_data"))) TS_UnsignedChannelUpdate_set_excess_data(uint64_t this_ptr, int8_tArray val) {
34150 LDKUnsignedChannelUpdate this_ptr_conv;
34151 this_ptr_conv.inner = untag_ptr(this_ptr);
34152 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34153 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34154 this_ptr_conv.is_owned = false;
34155 LDKCVec_u8Z val_ref;
34156 val_ref.datalen = val->arr_len;
34157 val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
34158 memcpy(val_ref.data, val->elems, val_ref.datalen); FREE(val);
34159 UnsignedChannelUpdate_set_excess_data(&this_ptr_conv, val_ref);
34162 uint64_t __attribute__((export_name("TS_UnsignedChannelUpdate_new"))) TS_UnsignedChannelUpdate_new(int8_tArray chain_hash_arg, int64_t short_channel_id_arg, int32_t timestamp_arg, int8_t flags_arg, int16_t cltv_expiry_delta_arg, int64_t htlc_minimum_msat_arg, int64_t htlc_maximum_msat_arg, int32_t fee_base_msat_arg, int32_t fee_proportional_millionths_arg, int8_tArray excess_data_arg) {
34163 LDKThirtyTwoBytes chain_hash_arg_ref;
34164 CHECK(chain_hash_arg->arr_len == 32);
34165 memcpy(chain_hash_arg_ref.data, chain_hash_arg->elems, 32); FREE(chain_hash_arg);
34166 LDKCVec_u8Z excess_data_arg_ref;
34167 excess_data_arg_ref.datalen = excess_data_arg->arr_len;
34168 excess_data_arg_ref.data = MALLOC(excess_data_arg_ref.datalen, "LDKCVec_u8Z Bytes");
34169 memcpy(excess_data_arg_ref.data, excess_data_arg->elems, excess_data_arg_ref.datalen); FREE(excess_data_arg);
34170 LDKUnsignedChannelUpdate ret_var = UnsignedChannelUpdate_new(chain_hash_arg_ref, short_channel_id_arg, timestamp_arg, flags_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg, htlc_maximum_msat_arg, fee_base_msat_arg, fee_proportional_millionths_arg, excess_data_arg_ref);
34171 uint64_t ret_ref = 0;
34172 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34173 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34177 static inline uint64_t UnsignedChannelUpdate_clone_ptr(LDKUnsignedChannelUpdate *NONNULL_PTR arg) {
34178 LDKUnsignedChannelUpdate ret_var = UnsignedChannelUpdate_clone(arg);
34179 uint64_t ret_ref = 0;
34180 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34181 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34184 int64_t __attribute__((export_name("TS_UnsignedChannelUpdate_clone_ptr"))) TS_UnsignedChannelUpdate_clone_ptr(uint64_t arg) {
34185 LDKUnsignedChannelUpdate arg_conv;
34186 arg_conv.inner = untag_ptr(arg);
34187 arg_conv.is_owned = ptr_is_owned(arg);
34188 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
34189 arg_conv.is_owned = false;
34190 int64_t ret_conv = UnsignedChannelUpdate_clone_ptr(&arg_conv);
34194 uint64_t __attribute__((export_name("TS_UnsignedChannelUpdate_clone"))) TS_UnsignedChannelUpdate_clone(uint64_t orig) {
34195 LDKUnsignedChannelUpdate orig_conv;
34196 orig_conv.inner = untag_ptr(orig);
34197 orig_conv.is_owned = ptr_is_owned(orig);
34198 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
34199 orig_conv.is_owned = false;
34200 LDKUnsignedChannelUpdate ret_var = UnsignedChannelUpdate_clone(&orig_conv);
34201 uint64_t ret_ref = 0;
34202 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34203 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34207 jboolean __attribute__((export_name("TS_UnsignedChannelUpdate_eq"))) TS_UnsignedChannelUpdate_eq(uint64_t a, uint64_t b) {
34208 LDKUnsignedChannelUpdate a_conv;
34209 a_conv.inner = untag_ptr(a);
34210 a_conv.is_owned = ptr_is_owned(a);
34211 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
34212 a_conv.is_owned = false;
34213 LDKUnsignedChannelUpdate b_conv;
34214 b_conv.inner = untag_ptr(b);
34215 b_conv.is_owned = ptr_is_owned(b);
34216 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
34217 b_conv.is_owned = false;
34218 jboolean ret_conv = UnsignedChannelUpdate_eq(&a_conv, &b_conv);
34222 void __attribute__((export_name("TS_ChannelUpdate_free"))) TS_ChannelUpdate_free(uint64_t this_obj) {
34223 LDKChannelUpdate this_obj_conv;
34224 this_obj_conv.inner = untag_ptr(this_obj);
34225 this_obj_conv.is_owned = ptr_is_owned(this_obj);
34226 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
34227 ChannelUpdate_free(this_obj_conv);
34230 int8_tArray __attribute__((export_name("TS_ChannelUpdate_get_signature"))) TS_ChannelUpdate_get_signature(uint64_t this_ptr) {
34231 LDKChannelUpdate this_ptr_conv;
34232 this_ptr_conv.inner = untag_ptr(this_ptr);
34233 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34234 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34235 this_ptr_conv.is_owned = false;
34236 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
34237 memcpy(ret_arr->elems, ChannelUpdate_get_signature(&this_ptr_conv).compact_form, 64);
34241 void __attribute__((export_name("TS_ChannelUpdate_set_signature"))) TS_ChannelUpdate_set_signature(uint64_t this_ptr, int8_tArray val) {
34242 LDKChannelUpdate this_ptr_conv;
34243 this_ptr_conv.inner = untag_ptr(this_ptr);
34244 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34245 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34246 this_ptr_conv.is_owned = false;
34247 LDKSignature val_ref;
34248 CHECK(val->arr_len == 64);
34249 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
34250 ChannelUpdate_set_signature(&this_ptr_conv, val_ref);
34253 uint64_t __attribute__((export_name("TS_ChannelUpdate_get_contents"))) TS_ChannelUpdate_get_contents(uint64_t this_ptr) {
34254 LDKChannelUpdate this_ptr_conv;
34255 this_ptr_conv.inner = untag_ptr(this_ptr);
34256 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34257 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34258 this_ptr_conv.is_owned = false;
34259 LDKUnsignedChannelUpdate ret_var = ChannelUpdate_get_contents(&this_ptr_conv);
34260 uint64_t ret_ref = 0;
34261 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34262 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34266 void __attribute__((export_name("TS_ChannelUpdate_set_contents"))) TS_ChannelUpdate_set_contents(uint64_t this_ptr, uint64_t val) {
34267 LDKChannelUpdate this_ptr_conv;
34268 this_ptr_conv.inner = untag_ptr(this_ptr);
34269 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34270 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34271 this_ptr_conv.is_owned = false;
34272 LDKUnsignedChannelUpdate val_conv;
34273 val_conv.inner = untag_ptr(val);
34274 val_conv.is_owned = ptr_is_owned(val);
34275 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
34276 val_conv = UnsignedChannelUpdate_clone(&val_conv);
34277 ChannelUpdate_set_contents(&this_ptr_conv, val_conv);
34280 uint64_t __attribute__((export_name("TS_ChannelUpdate_new"))) TS_ChannelUpdate_new(int8_tArray signature_arg, uint64_t contents_arg) {
34281 LDKSignature signature_arg_ref;
34282 CHECK(signature_arg->arr_len == 64);
34283 memcpy(signature_arg_ref.compact_form, signature_arg->elems, 64); FREE(signature_arg);
34284 LDKUnsignedChannelUpdate contents_arg_conv;
34285 contents_arg_conv.inner = untag_ptr(contents_arg);
34286 contents_arg_conv.is_owned = ptr_is_owned(contents_arg);
34287 CHECK_INNER_FIELD_ACCESS_OR_NULL(contents_arg_conv);
34288 contents_arg_conv = UnsignedChannelUpdate_clone(&contents_arg_conv);
34289 LDKChannelUpdate ret_var = ChannelUpdate_new(signature_arg_ref, contents_arg_conv);
34290 uint64_t ret_ref = 0;
34291 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34292 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34296 static inline uint64_t ChannelUpdate_clone_ptr(LDKChannelUpdate *NONNULL_PTR arg) {
34297 LDKChannelUpdate ret_var = ChannelUpdate_clone(arg);
34298 uint64_t ret_ref = 0;
34299 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34300 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34303 int64_t __attribute__((export_name("TS_ChannelUpdate_clone_ptr"))) TS_ChannelUpdate_clone_ptr(uint64_t arg) {
34304 LDKChannelUpdate arg_conv;
34305 arg_conv.inner = untag_ptr(arg);
34306 arg_conv.is_owned = ptr_is_owned(arg);
34307 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
34308 arg_conv.is_owned = false;
34309 int64_t ret_conv = ChannelUpdate_clone_ptr(&arg_conv);
34313 uint64_t __attribute__((export_name("TS_ChannelUpdate_clone"))) TS_ChannelUpdate_clone(uint64_t orig) {
34314 LDKChannelUpdate orig_conv;
34315 orig_conv.inner = untag_ptr(orig);
34316 orig_conv.is_owned = ptr_is_owned(orig);
34317 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
34318 orig_conv.is_owned = false;
34319 LDKChannelUpdate ret_var = ChannelUpdate_clone(&orig_conv);
34320 uint64_t ret_ref = 0;
34321 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34322 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34326 jboolean __attribute__((export_name("TS_ChannelUpdate_eq"))) TS_ChannelUpdate_eq(uint64_t a, uint64_t b) {
34327 LDKChannelUpdate a_conv;
34328 a_conv.inner = untag_ptr(a);
34329 a_conv.is_owned = ptr_is_owned(a);
34330 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
34331 a_conv.is_owned = false;
34332 LDKChannelUpdate b_conv;
34333 b_conv.inner = untag_ptr(b);
34334 b_conv.is_owned = ptr_is_owned(b);
34335 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
34336 b_conv.is_owned = false;
34337 jboolean ret_conv = ChannelUpdate_eq(&a_conv, &b_conv);
34341 void __attribute__((export_name("TS_QueryChannelRange_free"))) TS_QueryChannelRange_free(uint64_t this_obj) {
34342 LDKQueryChannelRange this_obj_conv;
34343 this_obj_conv.inner = untag_ptr(this_obj);
34344 this_obj_conv.is_owned = ptr_is_owned(this_obj);
34345 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
34346 QueryChannelRange_free(this_obj_conv);
34349 int8_tArray __attribute__((export_name("TS_QueryChannelRange_get_chain_hash"))) TS_QueryChannelRange_get_chain_hash(uint64_t this_ptr) {
34350 LDKQueryChannelRange this_ptr_conv;
34351 this_ptr_conv.inner = untag_ptr(this_ptr);
34352 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34353 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34354 this_ptr_conv.is_owned = false;
34355 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
34356 memcpy(ret_arr->elems, *QueryChannelRange_get_chain_hash(&this_ptr_conv), 32);
34360 void __attribute__((export_name("TS_QueryChannelRange_set_chain_hash"))) TS_QueryChannelRange_set_chain_hash(uint64_t this_ptr, int8_tArray val) {
34361 LDKQueryChannelRange this_ptr_conv;
34362 this_ptr_conv.inner = untag_ptr(this_ptr);
34363 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34364 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34365 this_ptr_conv.is_owned = false;
34366 LDKThirtyTwoBytes val_ref;
34367 CHECK(val->arr_len == 32);
34368 memcpy(val_ref.data, val->elems, 32); FREE(val);
34369 QueryChannelRange_set_chain_hash(&this_ptr_conv, val_ref);
34372 int32_t __attribute__((export_name("TS_QueryChannelRange_get_first_blocknum"))) TS_QueryChannelRange_get_first_blocknum(uint64_t this_ptr) {
34373 LDKQueryChannelRange this_ptr_conv;
34374 this_ptr_conv.inner = untag_ptr(this_ptr);
34375 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34376 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34377 this_ptr_conv.is_owned = false;
34378 int32_t ret_conv = QueryChannelRange_get_first_blocknum(&this_ptr_conv);
34382 void __attribute__((export_name("TS_QueryChannelRange_set_first_blocknum"))) TS_QueryChannelRange_set_first_blocknum(uint64_t this_ptr, int32_t val) {
34383 LDKQueryChannelRange this_ptr_conv;
34384 this_ptr_conv.inner = untag_ptr(this_ptr);
34385 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34386 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34387 this_ptr_conv.is_owned = false;
34388 QueryChannelRange_set_first_blocknum(&this_ptr_conv, val);
34391 int32_t __attribute__((export_name("TS_QueryChannelRange_get_number_of_blocks"))) TS_QueryChannelRange_get_number_of_blocks(uint64_t this_ptr) {
34392 LDKQueryChannelRange this_ptr_conv;
34393 this_ptr_conv.inner = untag_ptr(this_ptr);
34394 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34395 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34396 this_ptr_conv.is_owned = false;
34397 int32_t ret_conv = QueryChannelRange_get_number_of_blocks(&this_ptr_conv);
34401 void __attribute__((export_name("TS_QueryChannelRange_set_number_of_blocks"))) TS_QueryChannelRange_set_number_of_blocks(uint64_t this_ptr, int32_t val) {
34402 LDKQueryChannelRange this_ptr_conv;
34403 this_ptr_conv.inner = untag_ptr(this_ptr);
34404 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34405 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34406 this_ptr_conv.is_owned = false;
34407 QueryChannelRange_set_number_of_blocks(&this_ptr_conv, val);
34410 uint64_t __attribute__((export_name("TS_QueryChannelRange_new"))) TS_QueryChannelRange_new(int8_tArray chain_hash_arg, int32_t first_blocknum_arg, int32_t number_of_blocks_arg) {
34411 LDKThirtyTwoBytes chain_hash_arg_ref;
34412 CHECK(chain_hash_arg->arr_len == 32);
34413 memcpy(chain_hash_arg_ref.data, chain_hash_arg->elems, 32); FREE(chain_hash_arg);
34414 LDKQueryChannelRange ret_var = QueryChannelRange_new(chain_hash_arg_ref, first_blocknum_arg, number_of_blocks_arg);
34415 uint64_t ret_ref = 0;
34416 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34417 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34421 static inline uint64_t QueryChannelRange_clone_ptr(LDKQueryChannelRange *NONNULL_PTR arg) {
34422 LDKQueryChannelRange ret_var = QueryChannelRange_clone(arg);
34423 uint64_t ret_ref = 0;
34424 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34425 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34428 int64_t __attribute__((export_name("TS_QueryChannelRange_clone_ptr"))) TS_QueryChannelRange_clone_ptr(uint64_t arg) {
34429 LDKQueryChannelRange arg_conv;
34430 arg_conv.inner = untag_ptr(arg);
34431 arg_conv.is_owned = ptr_is_owned(arg);
34432 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
34433 arg_conv.is_owned = false;
34434 int64_t ret_conv = QueryChannelRange_clone_ptr(&arg_conv);
34438 uint64_t __attribute__((export_name("TS_QueryChannelRange_clone"))) TS_QueryChannelRange_clone(uint64_t orig) {
34439 LDKQueryChannelRange orig_conv;
34440 orig_conv.inner = untag_ptr(orig);
34441 orig_conv.is_owned = ptr_is_owned(orig);
34442 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
34443 orig_conv.is_owned = false;
34444 LDKQueryChannelRange ret_var = QueryChannelRange_clone(&orig_conv);
34445 uint64_t ret_ref = 0;
34446 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34447 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34451 jboolean __attribute__((export_name("TS_QueryChannelRange_eq"))) TS_QueryChannelRange_eq(uint64_t a, uint64_t b) {
34452 LDKQueryChannelRange a_conv;
34453 a_conv.inner = untag_ptr(a);
34454 a_conv.is_owned = ptr_is_owned(a);
34455 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
34456 a_conv.is_owned = false;
34457 LDKQueryChannelRange b_conv;
34458 b_conv.inner = untag_ptr(b);
34459 b_conv.is_owned = ptr_is_owned(b);
34460 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
34461 b_conv.is_owned = false;
34462 jboolean ret_conv = QueryChannelRange_eq(&a_conv, &b_conv);
34466 void __attribute__((export_name("TS_ReplyChannelRange_free"))) TS_ReplyChannelRange_free(uint64_t this_obj) {
34467 LDKReplyChannelRange this_obj_conv;
34468 this_obj_conv.inner = untag_ptr(this_obj);
34469 this_obj_conv.is_owned = ptr_is_owned(this_obj);
34470 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
34471 ReplyChannelRange_free(this_obj_conv);
34474 int8_tArray __attribute__((export_name("TS_ReplyChannelRange_get_chain_hash"))) TS_ReplyChannelRange_get_chain_hash(uint64_t this_ptr) {
34475 LDKReplyChannelRange this_ptr_conv;
34476 this_ptr_conv.inner = untag_ptr(this_ptr);
34477 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34478 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34479 this_ptr_conv.is_owned = false;
34480 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
34481 memcpy(ret_arr->elems, *ReplyChannelRange_get_chain_hash(&this_ptr_conv), 32);
34485 void __attribute__((export_name("TS_ReplyChannelRange_set_chain_hash"))) TS_ReplyChannelRange_set_chain_hash(uint64_t this_ptr, int8_tArray val) {
34486 LDKReplyChannelRange this_ptr_conv;
34487 this_ptr_conv.inner = untag_ptr(this_ptr);
34488 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34489 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34490 this_ptr_conv.is_owned = false;
34491 LDKThirtyTwoBytes val_ref;
34492 CHECK(val->arr_len == 32);
34493 memcpy(val_ref.data, val->elems, 32); FREE(val);
34494 ReplyChannelRange_set_chain_hash(&this_ptr_conv, val_ref);
34497 int32_t __attribute__((export_name("TS_ReplyChannelRange_get_first_blocknum"))) TS_ReplyChannelRange_get_first_blocknum(uint64_t this_ptr) {
34498 LDKReplyChannelRange this_ptr_conv;
34499 this_ptr_conv.inner = untag_ptr(this_ptr);
34500 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34501 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34502 this_ptr_conv.is_owned = false;
34503 int32_t ret_conv = ReplyChannelRange_get_first_blocknum(&this_ptr_conv);
34507 void __attribute__((export_name("TS_ReplyChannelRange_set_first_blocknum"))) TS_ReplyChannelRange_set_first_blocknum(uint64_t this_ptr, int32_t val) {
34508 LDKReplyChannelRange this_ptr_conv;
34509 this_ptr_conv.inner = untag_ptr(this_ptr);
34510 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34511 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34512 this_ptr_conv.is_owned = false;
34513 ReplyChannelRange_set_first_blocknum(&this_ptr_conv, val);
34516 int32_t __attribute__((export_name("TS_ReplyChannelRange_get_number_of_blocks"))) TS_ReplyChannelRange_get_number_of_blocks(uint64_t this_ptr) {
34517 LDKReplyChannelRange this_ptr_conv;
34518 this_ptr_conv.inner = untag_ptr(this_ptr);
34519 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34520 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34521 this_ptr_conv.is_owned = false;
34522 int32_t ret_conv = ReplyChannelRange_get_number_of_blocks(&this_ptr_conv);
34526 void __attribute__((export_name("TS_ReplyChannelRange_set_number_of_blocks"))) TS_ReplyChannelRange_set_number_of_blocks(uint64_t this_ptr, int32_t val) {
34527 LDKReplyChannelRange this_ptr_conv;
34528 this_ptr_conv.inner = untag_ptr(this_ptr);
34529 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34530 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34531 this_ptr_conv.is_owned = false;
34532 ReplyChannelRange_set_number_of_blocks(&this_ptr_conv, val);
34535 jboolean __attribute__((export_name("TS_ReplyChannelRange_get_sync_complete"))) TS_ReplyChannelRange_get_sync_complete(uint64_t this_ptr) {
34536 LDKReplyChannelRange this_ptr_conv;
34537 this_ptr_conv.inner = untag_ptr(this_ptr);
34538 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34539 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34540 this_ptr_conv.is_owned = false;
34541 jboolean ret_conv = ReplyChannelRange_get_sync_complete(&this_ptr_conv);
34545 void __attribute__((export_name("TS_ReplyChannelRange_set_sync_complete"))) TS_ReplyChannelRange_set_sync_complete(uint64_t this_ptr, jboolean val) {
34546 LDKReplyChannelRange this_ptr_conv;
34547 this_ptr_conv.inner = untag_ptr(this_ptr);
34548 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34549 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34550 this_ptr_conv.is_owned = false;
34551 ReplyChannelRange_set_sync_complete(&this_ptr_conv, val);
34554 int64_tArray __attribute__((export_name("TS_ReplyChannelRange_get_short_channel_ids"))) TS_ReplyChannelRange_get_short_channel_ids(uint64_t this_ptr) {
34555 LDKReplyChannelRange this_ptr_conv;
34556 this_ptr_conv.inner = untag_ptr(this_ptr);
34557 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34558 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34559 this_ptr_conv.is_owned = false;
34560 LDKCVec_u64Z ret_var = ReplyChannelRange_get_short_channel_ids(&this_ptr_conv);
34561 int64_tArray ret_arr = NULL;
34562 ret_arr = init_int64_tArray(ret_var.datalen, __LINE__);
34563 int64_t *ret_arr_ptr = (int64_t*)(((uint8_t*)ret_arr) + 8);
34564 for (size_t i = 0; i < ret_var.datalen; i++) {
34565 int64_t ret_conv_8_conv = ret_var.data[i];
34566 ret_arr_ptr[i] = ret_conv_8_conv;
34569 FREE(ret_var.data);
34573 void __attribute__((export_name("TS_ReplyChannelRange_set_short_channel_ids"))) TS_ReplyChannelRange_set_short_channel_ids(uint64_t this_ptr, int64_tArray val) {
34574 LDKReplyChannelRange this_ptr_conv;
34575 this_ptr_conv.inner = untag_ptr(this_ptr);
34576 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34577 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34578 this_ptr_conv.is_owned = false;
34579 LDKCVec_u64Z val_constr;
34580 val_constr.datalen = val->arr_len;
34581 if (val_constr.datalen > 0)
34582 val_constr.data = MALLOC(val_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
34584 val_constr.data = NULL;
34585 int64_t* val_vals = val->elems;
34586 for (size_t i = 0; i < val_constr.datalen; i++) {
34587 int64_t val_conv_8 = val_vals[i];
34588 val_constr.data[i] = val_conv_8;
34591 ReplyChannelRange_set_short_channel_ids(&this_ptr_conv, val_constr);
34594 uint64_t __attribute__((export_name("TS_ReplyChannelRange_new"))) TS_ReplyChannelRange_new(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) {
34595 LDKThirtyTwoBytes chain_hash_arg_ref;
34596 CHECK(chain_hash_arg->arr_len == 32);
34597 memcpy(chain_hash_arg_ref.data, chain_hash_arg->elems, 32); FREE(chain_hash_arg);
34598 LDKCVec_u64Z short_channel_ids_arg_constr;
34599 short_channel_ids_arg_constr.datalen = short_channel_ids_arg->arr_len;
34600 if (short_channel_ids_arg_constr.datalen > 0)
34601 short_channel_ids_arg_constr.data = MALLOC(short_channel_ids_arg_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
34603 short_channel_ids_arg_constr.data = NULL;
34604 int64_t* short_channel_ids_arg_vals = short_channel_ids_arg->elems;
34605 for (size_t i = 0; i < short_channel_ids_arg_constr.datalen; i++) {
34606 int64_t short_channel_ids_arg_conv_8 = short_channel_ids_arg_vals[i];
34607 short_channel_ids_arg_constr.data[i] = short_channel_ids_arg_conv_8;
34609 FREE(short_channel_ids_arg);
34610 LDKReplyChannelRange ret_var = ReplyChannelRange_new(chain_hash_arg_ref, first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg_constr);
34611 uint64_t ret_ref = 0;
34612 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34613 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34617 static inline uint64_t ReplyChannelRange_clone_ptr(LDKReplyChannelRange *NONNULL_PTR arg) {
34618 LDKReplyChannelRange ret_var = ReplyChannelRange_clone(arg);
34619 uint64_t ret_ref = 0;
34620 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34621 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34624 int64_t __attribute__((export_name("TS_ReplyChannelRange_clone_ptr"))) TS_ReplyChannelRange_clone_ptr(uint64_t arg) {
34625 LDKReplyChannelRange arg_conv;
34626 arg_conv.inner = untag_ptr(arg);
34627 arg_conv.is_owned = ptr_is_owned(arg);
34628 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
34629 arg_conv.is_owned = false;
34630 int64_t ret_conv = ReplyChannelRange_clone_ptr(&arg_conv);
34634 uint64_t __attribute__((export_name("TS_ReplyChannelRange_clone"))) TS_ReplyChannelRange_clone(uint64_t orig) {
34635 LDKReplyChannelRange orig_conv;
34636 orig_conv.inner = untag_ptr(orig);
34637 orig_conv.is_owned = ptr_is_owned(orig);
34638 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
34639 orig_conv.is_owned = false;
34640 LDKReplyChannelRange ret_var = ReplyChannelRange_clone(&orig_conv);
34641 uint64_t ret_ref = 0;
34642 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34643 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34647 jboolean __attribute__((export_name("TS_ReplyChannelRange_eq"))) TS_ReplyChannelRange_eq(uint64_t a, uint64_t b) {
34648 LDKReplyChannelRange a_conv;
34649 a_conv.inner = untag_ptr(a);
34650 a_conv.is_owned = ptr_is_owned(a);
34651 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
34652 a_conv.is_owned = false;
34653 LDKReplyChannelRange b_conv;
34654 b_conv.inner = untag_ptr(b);
34655 b_conv.is_owned = ptr_is_owned(b);
34656 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
34657 b_conv.is_owned = false;
34658 jboolean ret_conv = ReplyChannelRange_eq(&a_conv, &b_conv);
34662 void __attribute__((export_name("TS_QueryShortChannelIds_free"))) TS_QueryShortChannelIds_free(uint64_t this_obj) {
34663 LDKQueryShortChannelIds this_obj_conv;
34664 this_obj_conv.inner = untag_ptr(this_obj);
34665 this_obj_conv.is_owned = ptr_is_owned(this_obj);
34666 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
34667 QueryShortChannelIds_free(this_obj_conv);
34670 int8_tArray __attribute__((export_name("TS_QueryShortChannelIds_get_chain_hash"))) TS_QueryShortChannelIds_get_chain_hash(uint64_t this_ptr) {
34671 LDKQueryShortChannelIds this_ptr_conv;
34672 this_ptr_conv.inner = untag_ptr(this_ptr);
34673 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34674 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34675 this_ptr_conv.is_owned = false;
34676 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
34677 memcpy(ret_arr->elems, *QueryShortChannelIds_get_chain_hash(&this_ptr_conv), 32);
34681 void __attribute__((export_name("TS_QueryShortChannelIds_set_chain_hash"))) TS_QueryShortChannelIds_set_chain_hash(uint64_t this_ptr, int8_tArray val) {
34682 LDKQueryShortChannelIds this_ptr_conv;
34683 this_ptr_conv.inner = untag_ptr(this_ptr);
34684 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34685 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34686 this_ptr_conv.is_owned = false;
34687 LDKThirtyTwoBytes val_ref;
34688 CHECK(val->arr_len == 32);
34689 memcpy(val_ref.data, val->elems, 32); FREE(val);
34690 QueryShortChannelIds_set_chain_hash(&this_ptr_conv, val_ref);
34693 int64_tArray __attribute__((export_name("TS_QueryShortChannelIds_get_short_channel_ids"))) TS_QueryShortChannelIds_get_short_channel_ids(uint64_t this_ptr) {
34694 LDKQueryShortChannelIds this_ptr_conv;
34695 this_ptr_conv.inner = untag_ptr(this_ptr);
34696 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34697 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34698 this_ptr_conv.is_owned = false;
34699 LDKCVec_u64Z ret_var = QueryShortChannelIds_get_short_channel_ids(&this_ptr_conv);
34700 int64_tArray ret_arr = NULL;
34701 ret_arr = init_int64_tArray(ret_var.datalen, __LINE__);
34702 int64_t *ret_arr_ptr = (int64_t*)(((uint8_t*)ret_arr) + 8);
34703 for (size_t i = 0; i < ret_var.datalen; i++) {
34704 int64_t ret_conv_8_conv = ret_var.data[i];
34705 ret_arr_ptr[i] = ret_conv_8_conv;
34708 FREE(ret_var.data);
34712 void __attribute__((export_name("TS_QueryShortChannelIds_set_short_channel_ids"))) TS_QueryShortChannelIds_set_short_channel_ids(uint64_t this_ptr, int64_tArray val) {
34713 LDKQueryShortChannelIds this_ptr_conv;
34714 this_ptr_conv.inner = untag_ptr(this_ptr);
34715 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34716 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34717 this_ptr_conv.is_owned = false;
34718 LDKCVec_u64Z val_constr;
34719 val_constr.datalen = val->arr_len;
34720 if (val_constr.datalen > 0)
34721 val_constr.data = MALLOC(val_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
34723 val_constr.data = NULL;
34724 int64_t* val_vals = val->elems;
34725 for (size_t i = 0; i < val_constr.datalen; i++) {
34726 int64_t val_conv_8 = val_vals[i];
34727 val_constr.data[i] = val_conv_8;
34730 QueryShortChannelIds_set_short_channel_ids(&this_ptr_conv, val_constr);
34733 uint64_t __attribute__((export_name("TS_QueryShortChannelIds_new"))) TS_QueryShortChannelIds_new(int8_tArray chain_hash_arg, int64_tArray short_channel_ids_arg) {
34734 LDKThirtyTwoBytes chain_hash_arg_ref;
34735 CHECK(chain_hash_arg->arr_len == 32);
34736 memcpy(chain_hash_arg_ref.data, chain_hash_arg->elems, 32); FREE(chain_hash_arg);
34737 LDKCVec_u64Z short_channel_ids_arg_constr;
34738 short_channel_ids_arg_constr.datalen = short_channel_ids_arg->arr_len;
34739 if (short_channel_ids_arg_constr.datalen > 0)
34740 short_channel_ids_arg_constr.data = MALLOC(short_channel_ids_arg_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
34742 short_channel_ids_arg_constr.data = NULL;
34743 int64_t* short_channel_ids_arg_vals = short_channel_ids_arg->elems;
34744 for (size_t i = 0; i < short_channel_ids_arg_constr.datalen; i++) {
34745 int64_t short_channel_ids_arg_conv_8 = short_channel_ids_arg_vals[i];
34746 short_channel_ids_arg_constr.data[i] = short_channel_ids_arg_conv_8;
34748 FREE(short_channel_ids_arg);
34749 LDKQueryShortChannelIds ret_var = QueryShortChannelIds_new(chain_hash_arg_ref, short_channel_ids_arg_constr);
34750 uint64_t ret_ref = 0;
34751 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34752 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34756 static inline uint64_t QueryShortChannelIds_clone_ptr(LDKQueryShortChannelIds *NONNULL_PTR arg) {
34757 LDKQueryShortChannelIds ret_var = QueryShortChannelIds_clone(arg);
34758 uint64_t ret_ref = 0;
34759 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34760 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34763 int64_t __attribute__((export_name("TS_QueryShortChannelIds_clone_ptr"))) TS_QueryShortChannelIds_clone_ptr(uint64_t arg) {
34764 LDKQueryShortChannelIds arg_conv;
34765 arg_conv.inner = untag_ptr(arg);
34766 arg_conv.is_owned = ptr_is_owned(arg);
34767 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
34768 arg_conv.is_owned = false;
34769 int64_t ret_conv = QueryShortChannelIds_clone_ptr(&arg_conv);
34773 uint64_t __attribute__((export_name("TS_QueryShortChannelIds_clone"))) TS_QueryShortChannelIds_clone(uint64_t orig) {
34774 LDKQueryShortChannelIds orig_conv;
34775 orig_conv.inner = untag_ptr(orig);
34776 orig_conv.is_owned = ptr_is_owned(orig);
34777 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
34778 orig_conv.is_owned = false;
34779 LDKQueryShortChannelIds ret_var = QueryShortChannelIds_clone(&orig_conv);
34780 uint64_t ret_ref = 0;
34781 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34782 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34786 jboolean __attribute__((export_name("TS_QueryShortChannelIds_eq"))) TS_QueryShortChannelIds_eq(uint64_t a, uint64_t b) {
34787 LDKQueryShortChannelIds a_conv;
34788 a_conv.inner = untag_ptr(a);
34789 a_conv.is_owned = ptr_is_owned(a);
34790 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
34791 a_conv.is_owned = false;
34792 LDKQueryShortChannelIds b_conv;
34793 b_conv.inner = untag_ptr(b);
34794 b_conv.is_owned = ptr_is_owned(b);
34795 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
34796 b_conv.is_owned = false;
34797 jboolean ret_conv = QueryShortChannelIds_eq(&a_conv, &b_conv);
34801 void __attribute__((export_name("TS_ReplyShortChannelIdsEnd_free"))) TS_ReplyShortChannelIdsEnd_free(uint64_t this_obj) {
34802 LDKReplyShortChannelIdsEnd this_obj_conv;
34803 this_obj_conv.inner = untag_ptr(this_obj);
34804 this_obj_conv.is_owned = ptr_is_owned(this_obj);
34805 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
34806 ReplyShortChannelIdsEnd_free(this_obj_conv);
34809 int8_tArray __attribute__((export_name("TS_ReplyShortChannelIdsEnd_get_chain_hash"))) TS_ReplyShortChannelIdsEnd_get_chain_hash(uint64_t this_ptr) {
34810 LDKReplyShortChannelIdsEnd this_ptr_conv;
34811 this_ptr_conv.inner = untag_ptr(this_ptr);
34812 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34813 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34814 this_ptr_conv.is_owned = false;
34815 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
34816 memcpy(ret_arr->elems, *ReplyShortChannelIdsEnd_get_chain_hash(&this_ptr_conv), 32);
34820 void __attribute__((export_name("TS_ReplyShortChannelIdsEnd_set_chain_hash"))) TS_ReplyShortChannelIdsEnd_set_chain_hash(uint64_t this_ptr, int8_tArray val) {
34821 LDKReplyShortChannelIdsEnd this_ptr_conv;
34822 this_ptr_conv.inner = untag_ptr(this_ptr);
34823 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34824 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34825 this_ptr_conv.is_owned = false;
34826 LDKThirtyTwoBytes val_ref;
34827 CHECK(val->arr_len == 32);
34828 memcpy(val_ref.data, val->elems, 32); FREE(val);
34829 ReplyShortChannelIdsEnd_set_chain_hash(&this_ptr_conv, val_ref);
34832 jboolean __attribute__((export_name("TS_ReplyShortChannelIdsEnd_get_full_information"))) TS_ReplyShortChannelIdsEnd_get_full_information(uint64_t this_ptr) {
34833 LDKReplyShortChannelIdsEnd this_ptr_conv;
34834 this_ptr_conv.inner = untag_ptr(this_ptr);
34835 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34836 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34837 this_ptr_conv.is_owned = false;
34838 jboolean ret_conv = ReplyShortChannelIdsEnd_get_full_information(&this_ptr_conv);
34842 void __attribute__((export_name("TS_ReplyShortChannelIdsEnd_set_full_information"))) TS_ReplyShortChannelIdsEnd_set_full_information(uint64_t this_ptr, jboolean val) {
34843 LDKReplyShortChannelIdsEnd this_ptr_conv;
34844 this_ptr_conv.inner = untag_ptr(this_ptr);
34845 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34846 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34847 this_ptr_conv.is_owned = false;
34848 ReplyShortChannelIdsEnd_set_full_information(&this_ptr_conv, val);
34851 uint64_t __attribute__((export_name("TS_ReplyShortChannelIdsEnd_new"))) TS_ReplyShortChannelIdsEnd_new(int8_tArray chain_hash_arg, jboolean full_information_arg) {
34852 LDKThirtyTwoBytes chain_hash_arg_ref;
34853 CHECK(chain_hash_arg->arr_len == 32);
34854 memcpy(chain_hash_arg_ref.data, chain_hash_arg->elems, 32); FREE(chain_hash_arg);
34855 LDKReplyShortChannelIdsEnd ret_var = ReplyShortChannelIdsEnd_new(chain_hash_arg_ref, full_information_arg);
34856 uint64_t ret_ref = 0;
34857 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34858 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34862 static inline uint64_t ReplyShortChannelIdsEnd_clone_ptr(LDKReplyShortChannelIdsEnd *NONNULL_PTR arg) {
34863 LDKReplyShortChannelIdsEnd ret_var = ReplyShortChannelIdsEnd_clone(arg);
34864 uint64_t ret_ref = 0;
34865 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34866 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34869 int64_t __attribute__((export_name("TS_ReplyShortChannelIdsEnd_clone_ptr"))) TS_ReplyShortChannelIdsEnd_clone_ptr(uint64_t arg) {
34870 LDKReplyShortChannelIdsEnd arg_conv;
34871 arg_conv.inner = untag_ptr(arg);
34872 arg_conv.is_owned = ptr_is_owned(arg);
34873 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
34874 arg_conv.is_owned = false;
34875 int64_t ret_conv = ReplyShortChannelIdsEnd_clone_ptr(&arg_conv);
34879 uint64_t __attribute__((export_name("TS_ReplyShortChannelIdsEnd_clone"))) TS_ReplyShortChannelIdsEnd_clone(uint64_t orig) {
34880 LDKReplyShortChannelIdsEnd orig_conv;
34881 orig_conv.inner = untag_ptr(orig);
34882 orig_conv.is_owned = ptr_is_owned(orig);
34883 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
34884 orig_conv.is_owned = false;
34885 LDKReplyShortChannelIdsEnd ret_var = ReplyShortChannelIdsEnd_clone(&orig_conv);
34886 uint64_t ret_ref = 0;
34887 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34888 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34892 jboolean __attribute__((export_name("TS_ReplyShortChannelIdsEnd_eq"))) TS_ReplyShortChannelIdsEnd_eq(uint64_t a, uint64_t b) {
34893 LDKReplyShortChannelIdsEnd a_conv;
34894 a_conv.inner = untag_ptr(a);
34895 a_conv.is_owned = ptr_is_owned(a);
34896 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
34897 a_conv.is_owned = false;
34898 LDKReplyShortChannelIdsEnd b_conv;
34899 b_conv.inner = untag_ptr(b);
34900 b_conv.is_owned = ptr_is_owned(b);
34901 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
34902 b_conv.is_owned = false;
34903 jboolean ret_conv = ReplyShortChannelIdsEnd_eq(&a_conv, &b_conv);
34907 void __attribute__((export_name("TS_GossipTimestampFilter_free"))) TS_GossipTimestampFilter_free(uint64_t this_obj) {
34908 LDKGossipTimestampFilter this_obj_conv;
34909 this_obj_conv.inner = untag_ptr(this_obj);
34910 this_obj_conv.is_owned = ptr_is_owned(this_obj);
34911 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
34912 GossipTimestampFilter_free(this_obj_conv);
34915 int8_tArray __attribute__((export_name("TS_GossipTimestampFilter_get_chain_hash"))) TS_GossipTimestampFilter_get_chain_hash(uint64_t this_ptr) {
34916 LDKGossipTimestampFilter this_ptr_conv;
34917 this_ptr_conv.inner = untag_ptr(this_ptr);
34918 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34919 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34920 this_ptr_conv.is_owned = false;
34921 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
34922 memcpy(ret_arr->elems, *GossipTimestampFilter_get_chain_hash(&this_ptr_conv), 32);
34926 void __attribute__((export_name("TS_GossipTimestampFilter_set_chain_hash"))) TS_GossipTimestampFilter_set_chain_hash(uint64_t this_ptr, int8_tArray val) {
34927 LDKGossipTimestampFilter this_ptr_conv;
34928 this_ptr_conv.inner = untag_ptr(this_ptr);
34929 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34930 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34931 this_ptr_conv.is_owned = false;
34932 LDKThirtyTwoBytes val_ref;
34933 CHECK(val->arr_len == 32);
34934 memcpy(val_ref.data, val->elems, 32); FREE(val);
34935 GossipTimestampFilter_set_chain_hash(&this_ptr_conv, val_ref);
34938 int32_t __attribute__((export_name("TS_GossipTimestampFilter_get_first_timestamp"))) TS_GossipTimestampFilter_get_first_timestamp(uint64_t this_ptr) {
34939 LDKGossipTimestampFilter this_ptr_conv;
34940 this_ptr_conv.inner = untag_ptr(this_ptr);
34941 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34942 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34943 this_ptr_conv.is_owned = false;
34944 int32_t ret_conv = GossipTimestampFilter_get_first_timestamp(&this_ptr_conv);
34948 void __attribute__((export_name("TS_GossipTimestampFilter_set_first_timestamp"))) TS_GossipTimestampFilter_set_first_timestamp(uint64_t this_ptr, int32_t val) {
34949 LDKGossipTimestampFilter this_ptr_conv;
34950 this_ptr_conv.inner = untag_ptr(this_ptr);
34951 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34952 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34953 this_ptr_conv.is_owned = false;
34954 GossipTimestampFilter_set_first_timestamp(&this_ptr_conv, val);
34957 int32_t __attribute__((export_name("TS_GossipTimestampFilter_get_timestamp_range"))) TS_GossipTimestampFilter_get_timestamp_range(uint64_t this_ptr) {
34958 LDKGossipTimestampFilter this_ptr_conv;
34959 this_ptr_conv.inner = untag_ptr(this_ptr);
34960 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34961 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34962 this_ptr_conv.is_owned = false;
34963 int32_t ret_conv = GossipTimestampFilter_get_timestamp_range(&this_ptr_conv);
34967 void __attribute__((export_name("TS_GossipTimestampFilter_set_timestamp_range"))) TS_GossipTimestampFilter_set_timestamp_range(uint64_t this_ptr, int32_t val) {
34968 LDKGossipTimestampFilter this_ptr_conv;
34969 this_ptr_conv.inner = untag_ptr(this_ptr);
34970 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34971 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34972 this_ptr_conv.is_owned = false;
34973 GossipTimestampFilter_set_timestamp_range(&this_ptr_conv, val);
34976 uint64_t __attribute__((export_name("TS_GossipTimestampFilter_new"))) TS_GossipTimestampFilter_new(int8_tArray chain_hash_arg, int32_t first_timestamp_arg, int32_t timestamp_range_arg) {
34977 LDKThirtyTwoBytes chain_hash_arg_ref;
34978 CHECK(chain_hash_arg->arr_len == 32);
34979 memcpy(chain_hash_arg_ref.data, chain_hash_arg->elems, 32); FREE(chain_hash_arg);
34980 LDKGossipTimestampFilter ret_var = GossipTimestampFilter_new(chain_hash_arg_ref, first_timestamp_arg, timestamp_range_arg);
34981 uint64_t ret_ref = 0;
34982 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34983 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34987 static inline uint64_t GossipTimestampFilter_clone_ptr(LDKGossipTimestampFilter *NONNULL_PTR arg) {
34988 LDKGossipTimestampFilter ret_var = GossipTimestampFilter_clone(arg);
34989 uint64_t ret_ref = 0;
34990 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34991 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34994 int64_t __attribute__((export_name("TS_GossipTimestampFilter_clone_ptr"))) TS_GossipTimestampFilter_clone_ptr(uint64_t arg) {
34995 LDKGossipTimestampFilter arg_conv;
34996 arg_conv.inner = untag_ptr(arg);
34997 arg_conv.is_owned = ptr_is_owned(arg);
34998 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
34999 arg_conv.is_owned = false;
35000 int64_t ret_conv = GossipTimestampFilter_clone_ptr(&arg_conv);
35004 uint64_t __attribute__((export_name("TS_GossipTimestampFilter_clone"))) TS_GossipTimestampFilter_clone(uint64_t orig) {
35005 LDKGossipTimestampFilter orig_conv;
35006 orig_conv.inner = untag_ptr(orig);
35007 orig_conv.is_owned = ptr_is_owned(orig);
35008 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
35009 orig_conv.is_owned = false;
35010 LDKGossipTimestampFilter ret_var = GossipTimestampFilter_clone(&orig_conv);
35011 uint64_t ret_ref = 0;
35012 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35013 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35017 jboolean __attribute__((export_name("TS_GossipTimestampFilter_eq"))) TS_GossipTimestampFilter_eq(uint64_t a, uint64_t b) {
35018 LDKGossipTimestampFilter a_conv;
35019 a_conv.inner = untag_ptr(a);
35020 a_conv.is_owned = ptr_is_owned(a);
35021 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
35022 a_conv.is_owned = false;
35023 LDKGossipTimestampFilter b_conv;
35024 b_conv.inner = untag_ptr(b);
35025 b_conv.is_owned = ptr_is_owned(b);
35026 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
35027 b_conv.is_owned = false;
35028 jboolean ret_conv = GossipTimestampFilter_eq(&a_conv, &b_conv);
35032 void __attribute__((export_name("TS_ErrorAction_free"))) TS_ErrorAction_free(uint64_t this_ptr) {
35033 if (!ptr_is_owned(this_ptr)) return;
35034 void* this_ptr_ptr = untag_ptr(this_ptr);
35035 CHECK_ACCESS(this_ptr_ptr);
35036 LDKErrorAction this_ptr_conv = *(LDKErrorAction*)(this_ptr_ptr);
35037 FREE(untag_ptr(this_ptr));
35038 ErrorAction_free(this_ptr_conv);
35041 static inline uint64_t ErrorAction_clone_ptr(LDKErrorAction *NONNULL_PTR arg) {
35042 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
35043 *ret_copy = ErrorAction_clone(arg);
35044 uint64_t ret_ref = tag_ptr(ret_copy, true);
35047 int64_t __attribute__((export_name("TS_ErrorAction_clone_ptr"))) TS_ErrorAction_clone_ptr(uint64_t arg) {
35048 LDKErrorAction* arg_conv = (LDKErrorAction*)untag_ptr(arg);
35049 int64_t ret_conv = ErrorAction_clone_ptr(arg_conv);
35053 uint64_t __attribute__((export_name("TS_ErrorAction_clone"))) TS_ErrorAction_clone(uint64_t orig) {
35054 LDKErrorAction* orig_conv = (LDKErrorAction*)untag_ptr(orig);
35055 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
35056 *ret_copy = ErrorAction_clone(orig_conv);
35057 uint64_t ret_ref = tag_ptr(ret_copy, true);
35061 uint64_t __attribute__((export_name("TS_ErrorAction_disconnect_peer"))) TS_ErrorAction_disconnect_peer(uint64_t msg) {
35062 LDKErrorMessage msg_conv;
35063 msg_conv.inner = untag_ptr(msg);
35064 msg_conv.is_owned = ptr_is_owned(msg);
35065 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
35066 msg_conv = ErrorMessage_clone(&msg_conv);
35067 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
35068 *ret_copy = ErrorAction_disconnect_peer(msg_conv);
35069 uint64_t ret_ref = tag_ptr(ret_copy, true);
35073 uint64_t __attribute__((export_name("TS_ErrorAction_ignore_error"))) TS_ErrorAction_ignore_error() {
35074 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
35075 *ret_copy = ErrorAction_ignore_error();
35076 uint64_t ret_ref = tag_ptr(ret_copy, true);
35080 uint64_t __attribute__((export_name("TS_ErrorAction_ignore_and_log"))) TS_ErrorAction_ignore_and_log(uint32_t a) {
35081 LDKLevel a_conv = LDKLevel_from_js(a);
35082 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
35083 *ret_copy = ErrorAction_ignore_and_log(a_conv);
35084 uint64_t ret_ref = tag_ptr(ret_copy, true);
35088 uint64_t __attribute__((export_name("TS_ErrorAction_ignore_duplicate_gossip"))) TS_ErrorAction_ignore_duplicate_gossip() {
35089 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
35090 *ret_copy = ErrorAction_ignore_duplicate_gossip();
35091 uint64_t ret_ref = tag_ptr(ret_copy, true);
35095 uint64_t __attribute__((export_name("TS_ErrorAction_send_error_message"))) TS_ErrorAction_send_error_message(uint64_t msg) {
35096 LDKErrorMessage msg_conv;
35097 msg_conv.inner = untag_ptr(msg);
35098 msg_conv.is_owned = ptr_is_owned(msg);
35099 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
35100 msg_conv = ErrorMessage_clone(&msg_conv);
35101 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
35102 *ret_copy = ErrorAction_send_error_message(msg_conv);
35103 uint64_t ret_ref = tag_ptr(ret_copy, true);
35107 uint64_t __attribute__((export_name("TS_ErrorAction_send_warning_message"))) TS_ErrorAction_send_warning_message(uint64_t msg, uint32_t log_level) {
35108 LDKWarningMessage msg_conv;
35109 msg_conv.inner = untag_ptr(msg);
35110 msg_conv.is_owned = ptr_is_owned(msg);
35111 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
35112 msg_conv = WarningMessage_clone(&msg_conv);
35113 LDKLevel log_level_conv = LDKLevel_from_js(log_level);
35114 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
35115 *ret_copy = ErrorAction_send_warning_message(msg_conv, log_level_conv);
35116 uint64_t ret_ref = tag_ptr(ret_copy, true);
35120 void __attribute__((export_name("TS_LightningError_free"))) TS_LightningError_free(uint64_t this_obj) {
35121 LDKLightningError this_obj_conv;
35122 this_obj_conv.inner = untag_ptr(this_obj);
35123 this_obj_conv.is_owned = ptr_is_owned(this_obj);
35124 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
35125 LightningError_free(this_obj_conv);
35128 jstring __attribute__((export_name("TS_LightningError_get_err"))) TS_LightningError_get_err(uint64_t this_ptr) {
35129 LDKLightningError this_ptr_conv;
35130 this_ptr_conv.inner = untag_ptr(this_ptr);
35131 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35132 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35133 this_ptr_conv.is_owned = false;
35134 LDKStr ret_str = LightningError_get_err(&this_ptr_conv);
35135 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
35140 void __attribute__((export_name("TS_LightningError_set_err"))) TS_LightningError_set_err(uint64_t this_ptr, jstring val) {
35141 LDKLightningError this_ptr_conv;
35142 this_ptr_conv.inner = untag_ptr(this_ptr);
35143 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35144 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35145 this_ptr_conv.is_owned = false;
35146 LDKStr val_conv = str_ref_to_owned_c(val);
35147 LightningError_set_err(&this_ptr_conv, val_conv);
35150 uint64_t __attribute__((export_name("TS_LightningError_get_action"))) TS_LightningError_get_action(uint64_t this_ptr) {
35151 LDKLightningError this_ptr_conv;
35152 this_ptr_conv.inner = untag_ptr(this_ptr);
35153 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35154 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35155 this_ptr_conv.is_owned = false;
35156 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
35157 *ret_copy = LightningError_get_action(&this_ptr_conv);
35158 uint64_t ret_ref = tag_ptr(ret_copy, true);
35162 void __attribute__((export_name("TS_LightningError_set_action"))) TS_LightningError_set_action(uint64_t this_ptr, uint64_t val) {
35163 LDKLightningError this_ptr_conv;
35164 this_ptr_conv.inner = untag_ptr(this_ptr);
35165 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35166 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35167 this_ptr_conv.is_owned = false;
35168 void* val_ptr = untag_ptr(val);
35169 CHECK_ACCESS(val_ptr);
35170 LDKErrorAction val_conv = *(LDKErrorAction*)(val_ptr);
35171 val_conv = ErrorAction_clone((LDKErrorAction*)untag_ptr(val));
35172 LightningError_set_action(&this_ptr_conv, val_conv);
35175 uint64_t __attribute__((export_name("TS_LightningError_new"))) TS_LightningError_new(jstring err_arg, uint64_t action_arg) {
35176 LDKStr err_arg_conv = str_ref_to_owned_c(err_arg);
35177 void* action_arg_ptr = untag_ptr(action_arg);
35178 CHECK_ACCESS(action_arg_ptr);
35179 LDKErrorAction action_arg_conv = *(LDKErrorAction*)(action_arg_ptr);
35180 action_arg_conv = ErrorAction_clone((LDKErrorAction*)untag_ptr(action_arg));
35181 LDKLightningError ret_var = LightningError_new(err_arg_conv, action_arg_conv);
35182 uint64_t ret_ref = 0;
35183 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35184 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35188 static inline uint64_t LightningError_clone_ptr(LDKLightningError *NONNULL_PTR arg) {
35189 LDKLightningError ret_var = LightningError_clone(arg);
35190 uint64_t ret_ref = 0;
35191 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35192 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35195 int64_t __attribute__((export_name("TS_LightningError_clone_ptr"))) TS_LightningError_clone_ptr(uint64_t arg) {
35196 LDKLightningError arg_conv;
35197 arg_conv.inner = untag_ptr(arg);
35198 arg_conv.is_owned = ptr_is_owned(arg);
35199 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
35200 arg_conv.is_owned = false;
35201 int64_t ret_conv = LightningError_clone_ptr(&arg_conv);
35205 uint64_t __attribute__((export_name("TS_LightningError_clone"))) TS_LightningError_clone(uint64_t orig) {
35206 LDKLightningError orig_conv;
35207 orig_conv.inner = untag_ptr(orig);
35208 orig_conv.is_owned = ptr_is_owned(orig);
35209 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
35210 orig_conv.is_owned = false;
35211 LDKLightningError ret_var = LightningError_clone(&orig_conv);
35212 uint64_t ret_ref = 0;
35213 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35214 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35218 void __attribute__((export_name("TS_CommitmentUpdate_free"))) TS_CommitmentUpdate_free(uint64_t this_obj) {
35219 LDKCommitmentUpdate this_obj_conv;
35220 this_obj_conv.inner = untag_ptr(this_obj);
35221 this_obj_conv.is_owned = ptr_is_owned(this_obj);
35222 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
35223 CommitmentUpdate_free(this_obj_conv);
35226 uint64_tArray __attribute__((export_name("TS_CommitmentUpdate_get_update_add_htlcs"))) TS_CommitmentUpdate_get_update_add_htlcs(uint64_t this_ptr) {
35227 LDKCommitmentUpdate this_ptr_conv;
35228 this_ptr_conv.inner = untag_ptr(this_ptr);
35229 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35230 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35231 this_ptr_conv.is_owned = false;
35232 LDKCVec_UpdateAddHTLCZ ret_var = CommitmentUpdate_get_update_add_htlcs(&this_ptr_conv);
35233 uint64_tArray ret_arr = NULL;
35234 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
35235 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
35236 for (size_t p = 0; p < ret_var.datalen; p++) {
35237 LDKUpdateAddHTLC ret_conv_15_var = ret_var.data[p];
35238 uint64_t ret_conv_15_ref = 0;
35239 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_15_var);
35240 ret_conv_15_ref = tag_ptr(ret_conv_15_var.inner, ret_conv_15_var.is_owned);
35241 ret_arr_ptr[p] = ret_conv_15_ref;
35244 FREE(ret_var.data);
35248 void __attribute__((export_name("TS_CommitmentUpdate_set_update_add_htlcs"))) TS_CommitmentUpdate_set_update_add_htlcs(uint64_t this_ptr, uint64_tArray val) {
35249 LDKCommitmentUpdate this_ptr_conv;
35250 this_ptr_conv.inner = untag_ptr(this_ptr);
35251 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35252 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35253 this_ptr_conv.is_owned = false;
35254 LDKCVec_UpdateAddHTLCZ val_constr;
35255 val_constr.datalen = val->arr_len;
35256 if (val_constr.datalen > 0)
35257 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKUpdateAddHTLC), "LDKCVec_UpdateAddHTLCZ Elements");
35259 val_constr.data = NULL;
35260 uint64_t* val_vals = val->elems;
35261 for (size_t p = 0; p < val_constr.datalen; p++) {
35262 uint64_t val_conv_15 = val_vals[p];
35263 LDKUpdateAddHTLC val_conv_15_conv;
35264 val_conv_15_conv.inner = untag_ptr(val_conv_15);
35265 val_conv_15_conv.is_owned = ptr_is_owned(val_conv_15);
35266 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_15_conv);
35267 val_conv_15_conv = UpdateAddHTLC_clone(&val_conv_15_conv);
35268 val_constr.data[p] = val_conv_15_conv;
35271 CommitmentUpdate_set_update_add_htlcs(&this_ptr_conv, val_constr);
35274 uint64_tArray __attribute__((export_name("TS_CommitmentUpdate_get_update_fulfill_htlcs"))) TS_CommitmentUpdate_get_update_fulfill_htlcs(uint64_t this_ptr) {
35275 LDKCommitmentUpdate this_ptr_conv;
35276 this_ptr_conv.inner = untag_ptr(this_ptr);
35277 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35278 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35279 this_ptr_conv.is_owned = false;
35280 LDKCVec_UpdateFulfillHTLCZ ret_var = CommitmentUpdate_get_update_fulfill_htlcs(&this_ptr_conv);
35281 uint64_tArray ret_arr = NULL;
35282 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
35283 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
35284 for (size_t t = 0; t < ret_var.datalen; t++) {
35285 LDKUpdateFulfillHTLC ret_conv_19_var = ret_var.data[t];
35286 uint64_t ret_conv_19_ref = 0;
35287 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_19_var);
35288 ret_conv_19_ref = tag_ptr(ret_conv_19_var.inner, ret_conv_19_var.is_owned);
35289 ret_arr_ptr[t] = ret_conv_19_ref;
35292 FREE(ret_var.data);
35296 void __attribute__((export_name("TS_CommitmentUpdate_set_update_fulfill_htlcs"))) TS_CommitmentUpdate_set_update_fulfill_htlcs(uint64_t this_ptr, uint64_tArray val) {
35297 LDKCommitmentUpdate this_ptr_conv;
35298 this_ptr_conv.inner = untag_ptr(this_ptr);
35299 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35300 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35301 this_ptr_conv.is_owned = false;
35302 LDKCVec_UpdateFulfillHTLCZ val_constr;
35303 val_constr.datalen = val->arr_len;
35304 if (val_constr.datalen > 0)
35305 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKUpdateFulfillHTLC), "LDKCVec_UpdateFulfillHTLCZ Elements");
35307 val_constr.data = NULL;
35308 uint64_t* val_vals = val->elems;
35309 for (size_t t = 0; t < val_constr.datalen; t++) {
35310 uint64_t val_conv_19 = val_vals[t];
35311 LDKUpdateFulfillHTLC val_conv_19_conv;
35312 val_conv_19_conv.inner = untag_ptr(val_conv_19);
35313 val_conv_19_conv.is_owned = ptr_is_owned(val_conv_19);
35314 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_19_conv);
35315 val_conv_19_conv = UpdateFulfillHTLC_clone(&val_conv_19_conv);
35316 val_constr.data[t] = val_conv_19_conv;
35319 CommitmentUpdate_set_update_fulfill_htlcs(&this_ptr_conv, val_constr);
35322 uint64_tArray __attribute__((export_name("TS_CommitmentUpdate_get_update_fail_htlcs"))) TS_CommitmentUpdate_get_update_fail_htlcs(uint64_t this_ptr) {
35323 LDKCommitmentUpdate this_ptr_conv;
35324 this_ptr_conv.inner = untag_ptr(this_ptr);
35325 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35326 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35327 this_ptr_conv.is_owned = false;
35328 LDKCVec_UpdateFailHTLCZ ret_var = CommitmentUpdate_get_update_fail_htlcs(&this_ptr_conv);
35329 uint64_tArray ret_arr = NULL;
35330 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
35331 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
35332 for (size_t q = 0; q < ret_var.datalen; q++) {
35333 LDKUpdateFailHTLC ret_conv_16_var = ret_var.data[q];
35334 uint64_t ret_conv_16_ref = 0;
35335 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
35336 ret_conv_16_ref = tag_ptr(ret_conv_16_var.inner, ret_conv_16_var.is_owned);
35337 ret_arr_ptr[q] = ret_conv_16_ref;
35340 FREE(ret_var.data);
35344 void __attribute__((export_name("TS_CommitmentUpdate_set_update_fail_htlcs"))) TS_CommitmentUpdate_set_update_fail_htlcs(uint64_t this_ptr, uint64_tArray val) {
35345 LDKCommitmentUpdate this_ptr_conv;
35346 this_ptr_conv.inner = untag_ptr(this_ptr);
35347 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35348 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35349 this_ptr_conv.is_owned = false;
35350 LDKCVec_UpdateFailHTLCZ val_constr;
35351 val_constr.datalen = val->arr_len;
35352 if (val_constr.datalen > 0)
35353 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKUpdateFailHTLC), "LDKCVec_UpdateFailHTLCZ Elements");
35355 val_constr.data = NULL;
35356 uint64_t* val_vals = val->elems;
35357 for (size_t q = 0; q < val_constr.datalen; q++) {
35358 uint64_t val_conv_16 = val_vals[q];
35359 LDKUpdateFailHTLC val_conv_16_conv;
35360 val_conv_16_conv.inner = untag_ptr(val_conv_16);
35361 val_conv_16_conv.is_owned = ptr_is_owned(val_conv_16);
35362 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_16_conv);
35363 val_conv_16_conv = UpdateFailHTLC_clone(&val_conv_16_conv);
35364 val_constr.data[q] = val_conv_16_conv;
35367 CommitmentUpdate_set_update_fail_htlcs(&this_ptr_conv, val_constr);
35370 uint64_tArray __attribute__((export_name("TS_CommitmentUpdate_get_update_fail_malformed_htlcs"))) TS_CommitmentUpdate_get_update_fail_malformed_htlcs(uint64_t this_ptr) {
35371 LDKCommitmentUpdate this_ptr_conv;
35372 this_ptr_conv.inner = untag_ptr(this_ptr);
35373 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35374 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35375 this_ptr_conv.is_owned = false;
35376 LDKCVec_UpdateFailMalformedHTLCZ ret_var = CommitmentUpdate_get_update_fail_malformed_htlcs(&this_ptr_conv);
35377 uint64_tArray ret_arr = NULL;
35378 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
35379 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
35380 for (size_t z = 0; z < ret_var.datalen; z++) {
35381 LDKUpdateFailMalformedHTLC ret_conv_25_var = ret_var.data[z];
35382 uint64_t ret_conv_25_ref = 0;
35383 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_25_var);
35384 ret_conv_25_ref = tag_ptr(ret_conv_25_var.inner, ret_conv_25_var.is_owned);
35385 ret_arr_ptr[z] = ret_conv_25_ref;
35388 FREE(ret_var.data);
35392 void __attribute__((export_name("TS_CommitmentUpdate_set_update_fail_malformed_htlcs"))) TS_CommitmentUpdate_set_update_fail_malformed_htlcs(uint64_t this_ptr, uint64_tArray val) {
35393 LDKCommitmentUpdate this_ptr_conv;
35394 this_ptr_conv.inner = untag_ptr(this_ptr);
35395 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35396 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35397 this_ptr_conv.is_owned = false;
35398 LDKCVec_UpdateFailMalformedHTLCZ val_constr;
35399 val_constr.datalen = val->arr_len;
35400 if (val_constr.datalen > 0)
35401 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKUpdateFailMalformedHTLC), "LDKCVec_UpdateFailMalformedHTLCZ Elements");
35403 val_constr.data = NULL;
35404 uint64_t* val_vals = val->elems;
35405 for (size_t z = 0; z < val_constr.datalen; z++) {
35406 uint64_t val_conv_25 = val_vals[z];
35407 LDKUpdateFailMalformedHTLC val_conv_25_conv;
35408 val_conv_25_conv.inner = untag_ptr(val_conv_25);
35409 val_conv_25_conv.is_owned = ptr_is_owned(val_conv_25);
35410 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_25_conv);
35411 val_conv_25_conv = UpdateFailMalformedHTLC_clone(&val_conv_25_conv);
35412 val_constr.data[z] = val_conv_25_conv;
35415 CommitmentUpdate_set_update_fail_malformed_htlcs(&this_ptr_conv, val_constr);
35418 uint64_t __attribute__((export_name("TS_CommitmentUpdate_get_update_fee"))) TS_CommitmentUpdate_get_update_fee(uint64_t this_ptr) {
35419 LDKCommitmentUpdate this_ptr_conv;
35420 this_ptr_conv.inner = untag_ptr(this_ptr);
35421 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35422 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35423 this_ptr_conv.is_owned = false;
35424 LDKUpdateFee ret_var = CommitmentUpdate_get_update_fee(&this_ptr_conv);
35425 uint64_t ret_ref = 0;
35426 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35427 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35431 void __attribute__((export_name("TS_CommitmentUpdate_set_update_fee"))) TS_CommitmentUpdate_set_update_fee(uint64_t this_ptr, uint64_t val) {
35432 LDKCommitmentUpdate this_ptr_conv;
35433 this_ptr_conv.inner = untag_ptr(this_ptr);
35434 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35435 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35436 this_ptr_conv.is_owned = false;
35437 LDKUpdateFee val_conv;
35438 val_conv.inner = untag_ptr(val);
35439 val_conv.is_owned = ptr_is_owned(val);
35440 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
35441 val_conv = UpdateFee_clone(&val_conv);
35442 CommitmentUpdate_set_update_fee(&this_ptr_conv, val_conv);
35445 uint64_t __attribute__((export_name("TS_CommitmentUpdate_get_commitment_signed"))) TS_CommitmentUpdate_get_commitment_signed(uint64_t this_ptr) {
35446 LDKCommitmentUpdate this_ptr_conv;
35447 this_ptr_conv.inner = untag_ptr(this_ptr);
35448 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35449 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35450 this_ptr_conv.is_owned = false;
35451 LDKCommitmentSigned ret_var = CommitmentUpdate_get_commitment_signed(&this_ptr_conv);
35452 uint64_t ret_ref = 0;
35453 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35454 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35458 void __attribute__((export_name("TS_CommitmentUpdate_set_commitment_signed"))) TS_CommitmentUpdate_set_commitment_signed(uint64_t this_ptr, uint64_t val) {
35459 LDKCommitmentUpdate this_ptr_conv;
35460 this_ptr_conv.inner = untag_ptr(this_ptr);
35461 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35462 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35463 this_ptr_conv.is_owned = false;
35464 LDKCommitmentSigned val_conv;
35465 val_conv.inner = untag_ptr(val);
35466 val_conv.is_owned = ptr_is_owned(val);
35467 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
35468 val_conv = CommitmentSigned_clone(&val_conv);
35469 CommitmentUpdate_set_commitment_signed(&this_ptr_conv, val_conv);
35472 uint64_t __attribute__((export_name("TS_CommitmentUpdate_new"))) TS_CommitmentUpdate_new(uint64_tArray update_add_htlcs_arg, uint64_tArray update_fulfill_htlcs_arg, uint64_tArray update_fail_htlcs_arg, uint64_tArray update_fail_malformed_htlcs_arg, uint64_t update_fee_arg, uint64_t commitment_signed_arg) {
35473 LDKCVec_UpdateAddHTLCZ update_add_htlcs_arg_constr;
35474 update_add_htlcs_arg_constr.datalen = update_add_htlcs_arg->arr_len;
35475 if (update_add_htlcs_arg_constr.datalen > 0)
35476 update_add_htlcs_arg_constr.data = MALLOC(update_add_htlcs_arg_constr.datalen * sizeof(LDKUpdateAddHTLC), "LDKCVec_UpdateAddHTLCZ Elements");
35478 update_add_htlcs_arg_constr.data = NULL;
35479 uint64_t* update_add_htlcs_arg_vals = update_add_htlcs_arg->elems;
35480 for (size_t p = 0; p < update_add_htlcs_arg_constr.datalen; p++) {
35481 uint64_t update_add_htlcs_arg_conv_15 = update_add_htlcs_arg_vals[p];
35482 LDKUpdateAddHTLC update_add_htlcs_arg_conv_15_conv;
35483 update_add_htlcs_arg_conv_15_conv.inner = untag_ptr(update_add_htlcs_arg_conv_15);
35484 update_add_htlcs_arg_conv_15_conv.is_owned = ptr_is_owned(update_add_htlcs_arg_conv_15);
35485 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_add_htlcs_arg_conv_15_conv);
35486 update_add_htlcs_arg_conv_15_conv = UpdateAddHTLC_clone(&update_add_htlcs_arg_conv_15_conv);
35487 update_add_htlcs_arg_constr.data[p] = update_add_htlcs_arg_conv_15_conv;
35489 FREE(update_add_htlcs_arg);
35490 LDKCVec_UpdateFulfillHTLCZ update_fulfill_htlcs_arg_constr;
35491 update_fulfill_htlcs_arg_constr.datalen = update_fulfill_htlcs_arg->arr_len;
35492 if (update_fulfill_htlcs_arg_constr.datalen > 0)
35493 update_fulfill_htlcs_arg_constr.data = MALLOC(update_fulfill_htlcs_arg_constr.datalen * sizeof(LDKUpdateFulfillHTLC), "LDKCVec_UpdateFulfillHTLCZ Elements");
35495 update_fulfill_htlcs_arg_constr.data = NULL;
35496 uint64_t* update_fulfill_htlcs_arg_vals = update_fulfill_htlcs_arg->elems;
35497 for (size_t t = 0; t < update_fulfill_htlcs_arg_constr.datalen; t++) {
35498 uint64_t update_fulfill_htlcs_arg_conv_19 = update_fulfill_htlcs_arg_vals[t];
35499 LDKUpdateFulfillHTLC update_fulfill_htlcs_arg_conv_19_conv;
35500 update_fulfill_htlcs_arg_conv_19_conv.inner = untag_ptr(update_fulfill_htlcs_arg_conv_19);
35501 update_fulfill_htlcs_arg_conv_19_conv.is_owned = ptr_is_owned(update_fulfill_htlcs_arg_conv_19);
35502 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fulfill_htlcs_arg_conv_19_conv);
35503 update_fulfill_htlcs_arg_conv_19_conv = UpdateFulfillHTLC_clone(&update_fulfill_htlcs_arg_conv_19_conv);
35504 update_fulfill_htlcs_arg_constr.data[t] = update_fulfill_htlcs_arg_conv_19_conv;
35506 FREE(update_fulfill_htlcs_arg);
35507 LDKCVec_UpdateFailHTLCZ update_fail_htlcs_arg_constr;
35508 update_fail_htlcs_arg_constr.datalen = update_fail_htlcs_arg->arr_len;
35509 if (update_fail_htlcs_arg_constr.datalen > 0)
35510 update_fail_htlcs_arg_constr.data = MALLOC(update_fail_htlcs_arg_constr.datalen * sizeof(LDKUpdateFailHTLC), "LDKCVec_UpdateFailHTLCZ Elements");
35512 update_fail_htlcs_arg_constr.data = NULL;
35513 uint64_t* update_fail_htlcs_arg_vals = update_fail_htlcs_arg->elems;
35514 for (size_t q = 0; q < update_fail_htlcs_arg_constr.datalen; q++) {
35515 uint64_t update_fail_htlcs_arg_conv_16 = update_fail_htlcs_arg_vals[q];
35516 LDKUpdateFailHTLC update_fail_htlcs_arg_conv_16_conv;
35517 update_fail_htlcs_arg_conv_16_conv.inner = untag_ptr(update_fail_htlcs_arg_conv_16);
35518 update_fail_htlcs_arg_conv_16_conv.is_owned = ptr_is_owned(update_fail_htlcs_arg_conv_16);
35519 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fail_htlcs_arg_conv_16_conv);
35520 update_fail_htlcs_arg_conv_16_conv = UpdateFailHTLC_clone(&update_fail_htlcs_arg_conv_16_conv);
35521 update_fail_htlcs_arg_constr.data[q] = update_fail_htlcs_arg_conv_16_conv;
35523 FREE(update_fail_htlcs_arg);
35524 LDKCVec_UpdateFailMalformedHTLCZ update_fail_malformed_htlcs_arg_constr;
35525 update_fail_malformed_htlcs_arg_constr.datalen = update_fail_malformed_htlcs_arg->arr_len;
35526 if (update_fail_malformed_htlcs_arg_constr.datalen > 0)
35527 update_fail_malformed_htlcs_arg_constr.data = MALLOC(update_fail_malformed_htlcs_arg_constr.datalen * sizeof(LDKUpdateFailMalformedHTLC), "LDKCVec_UpdateFailMalformedHTLCZ Elements");
35529 update_fail_malformed_htlcs_arg_constr.data = NULL;
35530 uint64_t* update_fail_malformed_htlcs_arg_vals = update_fail_malformed_htlcs_arg->elems;
35531 for (size_t z = 0; z < update_fail_malformed_htlcs_arg_constr.datalen; z++) {
35532 uint64_t update_fail_malformed_htlcs_arg_conv_25 = update_fail_malformed_htlcs_arg_vals[z];
35533 LDKUpdateFailMalformedHTLC update_fail_malformed_htlcs_arg_conv_25_conv;
35534 update_fail_malformed_htlcs_arg_conv_25_conv.inner = untag_ptr(update_fail_malformed_htlcs_arg_conv_25);
35535 update_fail_malformed_htlcs_arg_conv_25_conv.is_owned = ptr_is_owned(update_fail_malformed_htlcs_arg_conv_25);
35536 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fail_malformed_htlcs_arg_conv_25_conv);
35537 update_fail_malformed_htlcs_arg_conv_25_conv = UpdateFailMalformedHTLC_clone(&update_fail_malformed_htlcs_arg_conv_25_conv);
35538 update_fail_malformed_htlcs_arg_constr.data[z] = update_fail_malformed_htlcs_arg_conv_25_conv;
35540 FREE(update_fail_malformed_htlcs_arg);
35541 LDKUpdateFee update_fee_arg_conv;
35542 update_fee_arg_conv.inner = untag_ptr(update_fee_arg);
35543 update_fee_arg_conv.is_owned = ptr_is_owned(update_fee_arg);
35544 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fee_arg_conv);
35545 update_fee_arg_conv = UpdateFee_clone(&update_fee_arg_conv);
35546 LDKCommitmentSigned commitment_signed_arg_conv;
35547 commitment_signed_arg_conv.inner = untag_ptr(commitment_signed_arg);
35548 commitment_signed_arg_conv.is_owned = ptr_is_owned(commitment_signed_arg);
35549 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_signed_arg_conv);
35550 commitment_signed_arg_conv = CommitmentSigned_clone(&commitment_signed_arg_conv);
35551 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);
35552 uint64_t ret_ref = 0;
35553 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35554 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35558 static inline uint64_t CommitmentUpdate_clone_ptr(LDKCommitmentUpdate *NONNULL_PTR arg) {
35559 LDKCommitmentUpdate ret_var = CommitmentUpdate_clone(arg);
35560 uint64_t ret_ref = 0;
35561 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35562 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35565 int64_t __attribute__((export_name("TS_CommitmentUpdate_clone_ptr"))) TS_CommitmentUpdate_clone_ptr(uint64_t arg) {
35566 LDKCommitmentUpdate arg_conv;
35567 arg_conv.inner = untag_ptr(arg);
35568 arg_conv.is_owned = ptr_is_owned(arg);
35569 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
35570 arg_conv.is_owned = false;
35571 int64_t ret_conv = CommitmentUpdate_clone_ptr(&arg_conv);
35575 uint64_t __attribute__((export_name("TS_CommitmentUpdate_clone"))) TS_CommitmentUpdate_clone(uint64_t orig) {
35576 LDKCommitmentUpdate orig_conv;
35577 orig_conv.inner = untag_ptr(orig);
35578 orig_conv.is_owned = ptr_is_owned(orig);
35579 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
35580 orig_conv.is_owned = false;
35581 LDKCommitmentUpdate ret_var = CommitmentUpdate_clone(&orig_conv);
35582 uint64_t ret_ref = 0;
35583 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35584 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35588 jboolean __attribute__((export_name("TS_CommitmentUpdate_eq"))) TS_CommitmentUpdate_eq(uint64_t a, uint64_t b) {
35589 LDKCommitmentUpdate a_conv;
35590 a_conv.inner = untag_ptr(a);
35591 a_conv.is_owned = ptr_is_owned(a);
35592 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
35593 a_conv.is_owned = false;
35594 LDKCommitmentUpdate b_conv;
35595 b_conv.inner = untag_ptr(b);
35596 b_conv.is_owned = ptr_is_owned(b);
35597 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
35598 b_conv.is_owned = false;
35599 jboolean ret_conv = CommitmentUpdate_eq(&a_conv, &b_conv);
35603 void __attribute__((export_name("TS_ChannelMessageHandler_free"))) TS_ChannelMessageHandler_free(uint64_t this_ptr) {
35604 if (!ptr_is_owned(this_ptr)) return;
35605 void* this_ptr_ptr = untag_ptr(this_ptr);
35606 CHECK_ACCESS(this_ptr_ptr);
35607 LDKChannelMessageHandler this_ptr_conv = *(LDKChannelMessageHandler*)(this_ptr_ptr);
35608 FREE(untag_ptr(this_ptr));
35609 ChannelMessageHandler_free(this_ptr_conv);
35612 void __attribute__((export_name("TS_RoutingMessageHandler_free"))) TS_RoutingMessageHandler_free(uint64_t this_ptr) {
35613 if (!ptr_is_owned(this_ptr)) return;
35614 void* this_ptr_ptr = untag_ptr(this_ptr);
35615 CHECK_ACCESS(this_ptr_ptr);
35616 LDKRoutingMessageHandler this_ptr_conv = *(LDKRoutingMessageHandler*)(this_ptr_ptr);
35617 FREE(untag_ptr(this_ptr));
35618 RoutingMessageHandler_free(this_ptr_conv);
35621 void __attribute__((export_name("TS_OnionMessageHandler_free"))) TS_OnionMessageHandler_free(uint64_t this_ptr) {
35622 if (!ptr_is_owned(this_ptr)) return;
35623 void* this_ptr_ptr = untag_ptr(this_ptr);
35624 CHECK_ACCESS(this_ptr_ptr);
35625 LDKOnionMessageHandler this_ptr_conv = *(LDKOnionMessageHandler*)(this_ptr_ptr);
35626 FREE(untag_ptr(this_ptr));
35627 OnionMessageHandler_free(this_ptr_conv);
35630 int8_tArray __attribute__((export_name("TS_AcceptChannel_write"))) TS_AcceptChannel_write(uint64_t obj) {
35631 LDKAcceptChannel obj_conv;
35632 obj_conv.inner = untag_ptr(obj);
35633 obj_conv.is_owned = ptr_is_owned(obj);
35634 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
35635 obj_conv.is_owned = false;
35636 LDKCVec_u8Z ret_var = AcceptChannel_write(&obj_conv);
35637 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
35638 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
35639 CVec_u8Z_free(ret_var);
35643 uint64_t __attribute__((export_name("TS_AcceptChannel_read"))) TS_AcceptChannel_read(int8_tArray ser) {
35644 LDKu8slice ser_ref;
35645 ser_ref.datalen = ser->arr_len;
35646 ser_ref.data = ser->elems;
35647 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
35648 *ret_conv = AcceptChannel_read(ser_ref);
35650 return tag_ptr(ret_conv, true);
35653 int8_tArray __attribute__((export_name("TS_AnnouncementSignatures_write"))) TS_AnnouncementSignatures_write(uint64_t obj) {
35654 LDKAnnouncementSignatures obj_conv;
35655 obj_conv.inner = untag_ptr(obj);
35656 obj_conv.is_owned = ptr_is_owned(obj);
35657 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
35658 obj_conv.is_owned = false;
35659 LDKCVec_u8Z ret_var = AnnouncementSignatures_write(&obj_conv);
35660 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
35661 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
35662 CVec_u8Z_free(ret_var);
35666 uint64_t __attribute__((export_name("TS_AnnouncementSignatures_read"))) TS_AnnouncementSignatures_read(int8_tArray ser) {
35667 LDKu8slice ser_ref;
35668 ser_ref.datalen = ser->arr_len;
35669 ser_ref.data = ser->elems;
35670 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
35671 *ret_conv = AnnouncementSignatures_read(ser_ref);
35673 return tag_ptr(ret_conv, true);
35676 int8_tArray __attribute__((export_name("TS_ChannelReestablish_write"))) TS_ChannelReestablish_write(uint64_t obj) {
35677 LDKChannelReestablish obj_conv;
35678 obj_conv.inner = untag_ptr(obj);
35679 obj_conv.is_owned = ptr_is_owned(obj);
35680 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
35681 obj_conv.is_owned = false;
35682 LDKCVec_u8Z ret_var = ChannelReestablish_write(&obj_conv);
35683 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
35684 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
35685 CVec_u8Z_free(ret_var);
35689 uint64_t __attribute__((export_name("TS_ChannelReestablish_read"))) TS_ChannelReestablish_read(int8_tArray ser) {
35690 LDKu8slice ser_ref;
35691 ser_ref.datalen = ser->arr_len;
35692 ser_ref.data = ser->elems;
35693 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
35694 *ret_conv = ChannelReestablish_read(ser_ref);
35696 return tag_ptr(ret_conv, true);
35699 int8_tArray __attribute__((export_name("TS_ClosingSigned_write"))) TS_ClosingSigned_write(uint64_t obj) {
35700 LDKClosingSigned obj_conv;
35701 obj_conv.inner = untag_ptr(obj);
35702 obj_conv.is_owned = ptr_is_owned(obj);
35703 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
35704 obj_conv.is_owned = false;
35705 LDKCVec_u8Z ret_var = ClosingSigned_write(&obj_conv);
35706 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
35707 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
35708 CVec_u8Z_free(ret_var);
35712 uint64_t __attribute__((export_name("TS_ClosingSigned_read"))) TS_ClosingSigned_read(int8_tArray ser) {
35713 LDKu8slice ser_ref;
35714 ser_ref.datalen = ser->arr_len;
35715 ser_ref.data = ser->elems;
35716 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
35717 *ret_conv = ClosingSigned_read(ser_ref);
35719 return tag_ptr(ret_conv, true);
35722 int8_tArray __attribute__((export_name("TS_ClosingSignedFeeRange_write"))) TS_ClosingSignedFeeRange_write(uint64_t obj) {
35723 LDKClosingSignedFeeRange obj_conv;
35724 obj_conv.inner = untag_ptr(obj);
35725 obj_conv.is_owned = ptr_is_owned(obj);
35726 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
35727 obj_conv.is_owned = false;
35728 LDKCVec_u8Z ret_var = ClosingSignedFeeRange_write(&obj_conv);
35729 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
35730 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
35731 CVec_u8Z_free(ret_var);
35735 uint64_t __attribute__((export_name("TS_ClosingSignedFeeRange_read"))) TS_ClosingSignedFeeRange_read(int8_tArray ser) {
35736 LDKu8slice ser_ref;
35737 ser_ref.datalen = ser->arr_len;
35738 ser_ref.data = ser->elems;
35739 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
35740 *ret_conv = ClosingSignedFeeRange_read(ser_ref);
35742 return tag_ptr(ret_conv, true);
35745 int8_tArray __attribute__((export_name("TS_CommitmentSigned_write"))) TS_CommitmentSigned_write(uint64_t obj) {
35746 LDKCommitmentSigned obj_conv;
35747 obj_conv.inner = untag_ptr(obj);
35748 obj_conv.is_owned = ptr_is_owned(obj);
35749 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
35750 obj_conv.is_owned = false;
35751 LDKCVec_u8Z ret_var = CommitmentSigned_write(&obj_conv);
35752 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
35753 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
35754 CVec_u8Z_free(ret_var);
35758 uint64_t __attribute__((export_name("TS_CommitmentSigned_read"))) TS_CommitmentSigned_read(int8_tArray ser) {
35759 LDKu8slice ser_ref;
35760 ser_ref.datalen = ser->arr_len;
35761 ser_ref.data = ser->elems;
35762 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
35763 *ret_conv = CommitmentSigned_read(ser_ref);
35765 return tag_ptr(ret_conv, true);
35768 int8_tArray __attribute__((export_name("TS_FundingCreated_write"))) TS_FundingCreated_write(uint64_t obj) {
35769 LDKFundingCreated obj_conv;
35770 obj_conv.inner = untag_ptr(obj);
35771 obj_conv.is_owned = ptr_is_owned(obj);
35772 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
35773 obj_conv.is_owned = false;
35774 LDKCVec_u8Z ret_var = FundingCreated_write(&obj_conv);
35775 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
35776 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
35777 CVec_u8Z_free(ret_var);
35781 uint64_t __attribute__((export_name("TS_FundingCreated_read"))) TS_FundingCreated_read(int8_tArray ser) {
35782 LDKu8slice ser_ref;
35783 ser_ref.datalen = ser->arr_len;
35784 ser_ref.data = ser->elems;
35785 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
35786 *ret_conv = FundingCreated_read(ser_ref);
35788 return tag_ptr(ret_conv, true);
35791 int8_tArray __attribute__((export_name("TS_FundingSigned_write"))) TS_FundingSigned_write(uint64_t obj) {
35792 LDKFundingSigned obj_conv;
35793 obj_conv.inner = untag_ptr(obj);
35794 obj_conv.is_owned = ptr_is_owned(obj);
35795 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
35796 obj_conv.is_owned = false;
35797 LDKCVec_u8Z ret_var = FundingSigned_write(&obj_conv);
35798 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
35799 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
35800 CVec_u8Z_free(ret_var);
35804 uint64_t __attribute__((export_name("TS_FundingSigned_read"))) TS_FundingSigned_read(int8_tArray ser) {
35805 LDKu8slice ser_ref;
35806 ser_ref.datalen = ser->arr_len;
35807 ser_ref.data = ser->elems;
35808 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
35809 *ret_conv = FundingSigned_read(ser_ref);
35811 return tag_ptr(ret_conv, true);
35814 int8_tArray __attribute__((export_name("TS_ChannelReady_write"))) TS_ChannelReady_write(uint64_t obj) {
35815 LDKChannelReady obj_conv;
35816 obj_conv.inner = untag_ptr(obj);
35817 obj_conv.is_owned = ptr_is_owned(obj);
35818 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
35819 obj_conv.is_owned = false;
35820 LDKCVec_u8Z ret_var = ChannelReady_write(&obj_conv);
35821 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
35822 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
35823 CVec_u8Z_free(ret_var);
35827 uint64_t __attribute__((export_name("TS_ChannelReady_read"))) TS_ChannelReady_read(int8_tArray ser) {
35828 LDKu8slice ser_ref;
35829 ser_ref.datalen = ser->arr_len;
35830 ser_ref.data = ser->elems;
35831 LDKCResult_ChannelReadyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReadyDecodeErrorZ), "LDKCResult_ChannelReadyDecodeErrorZ");
35832 *ret_conv = ChannelReady_read(ser_ref);
35834 return tag_ptr(ret_conv, true);
35837 int8_tArray __attribute__((export_name("TS_Init_write"))) TS_Init_write(uint64_t obj) {
35839 obj_conv.inner = untag_ptr(obj);
35840 obj_conv.is_owned = ptr_is_owned(obj);
35841 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
35842 obj_conv.is_owned = false;
35843 LDKCVec_u8Z ret_var = Init_write(&obj_conv);
35844 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
35845 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
35846 CVec_u8Z_free(ret_var);
35850 uint64_t __attribute__((export_name("TS_Init_read"))) TS_Init_read(int8_tArray ser) {
35851 LDKu8slice ser_ref;
35852 ser_ref.datalen = ser->arr_len;
35853 ser_ref.data = ser->elems;
35854 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
35855 *ret_conv = Init_read(ser_ref);
35857 return tag_ptr(ret_conv, true);
35860 int8_tArray __attribute__((export_name("TS_OpenChannel_write"))) TS_OpenChannel_write(uint64_t obj) {
35861 LDKOpenChannel obj_conv;
35862 obj_conv.inner = untag_ptr(obj);
35863 obj_conv.is_owned = ptr_is_owned(obj);
35864 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
35865 obj_conv.is_owned = false;
35866 LDKCVec_u8Z ret_var = OpenChannel_write(&obj_conv);
35867 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
35868 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
35869 CVec_u8Z_free(ret_var);
35873 uint64_t __attribute__((export_name("TS_OpenChannel_read"))) TS_OpenChannel_read(int8_tArray ser) {
35874 LDKu8slice ser_ref;
35875 ser_ref.datalen = ser->arr_len;
35876 ser_ref.data = ser->elems;
35877 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
35878 *ret_conv = OpenChannel_read(ser_ref);
35880 return tag_ptr(ret_conv, true);
35883 int8_tArray __attribute__((export_name("TS_RevokeAndACK_write"))) TS_RevokeAndACK_write(uint64_t obj) {
35884 LDKRevokeAndACK obj_conv;
35885 obj_conv.inner = untag_ptr(obj);
35886 obj_conv.is_owned = ptr_is_owned(obj);
35887 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
35888 obj_conv.is_owned = false;
35889 LDKCVec_u8Z ret_var = RevokeAndACK_write(&obj_conv);
35890 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
35891 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
35892 CVec_u8Z_free(ret_var);
35896 uint64_t __attribute__((export_name("TS_RevokeAndACK_read"))) TS_RevokeAndACK_read(int8_tArray ser) {
35897 LDKu8slice ser_ref;
35898 ser_ref.datalen = ser->arr_len;
35899 ser_ref.data = ser->elems;
35900 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
35901 *ret_conv = RevokeAndACK_read(ser_ref);
35903 return tag_ptr(ret_conv, true);
35906 int8_tArray __attribute__((export_name("TS_Shutdown_write"))) TS_Shutdown_write(uint64_t obj) {
35907 LDKShutdown obj_conv;
35908 obj_conv.inner = untag_ptr(obj);
35909 obj_conv.is_owned = ptr_is_owned(obj);
35910 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
35911 obj_conv.is_owned = false;
35912 LDKCVec_u8Z ret_var = Shutdown_write(&obj_conv);
35913 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
35914 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
35915 CVec_u8Z_free(ret_var);
35919 uint64_t __attribute__((export_name("TS_Shutdown_read"))) TS_Shutdown_read(int8_tArray ser) {
35920 LDKu8slice ser_ref;
35921 ser_ref.datalen = ser->arr_len;
35922 ser_ref.data = ser->elems;
35923 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
35924 *ret_conv = Shutdown_read(ser_ref);
35926 return tag_ptr(ret_conv, true);
35929 int8_tArray __attribute__((export_name("TS_UpdateFailHTLC_write"))) TS_UpdateFailHTLC_write(uint64_t obj) {
35930 LDKUpdateFailHTLC obj_conv;
35931 obj_conv.inner = untag_ptr(obj);
35932 obj_conv.is_owned = ptr_is_owned(obj);
35933 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
35934 obj_conv.is_owned = false;
35935 LDKCVec_u8Z ret_var = UpdateFailHTLC_write(&obj_conv);
35936 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
35937 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
35938 CVec_u8Z_free(ret_var);
35942 uint64_t __attribute__((export_name("TS_UpdateFailHTLC_read"))) TS_UpdateFailHTLC_read(int8_tArray ser) {
35943 LDKu8slice ser_ref;
35944 ser_ref.datalen = ser->arr_len;
35945 ser_ref.data = ser->elems;
35946 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
35947 *ret_conv = UpdateFailHTLC_read(ser_ref);
35949 return tag_ptr(ret_conv, true);
35952 int8_tArray __attribute__((export_name("TS_UpdateFailMalformedHTLC_write"))) TS_UpdateFailMalformedHTLC_write(uint64_t obj) {
35953 LDKUpdateFailMalformedHTLC obj_conv;
35954 obj_conv.inner = untag_ptr(obj);
35955 obj_conv.is_owned = ptr_is_owned(obj);
35956 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
35957 obj_conv.is_owned = false;
35958 LDKCVec_u8Z ret_var = UpdateFailMalformedHTLC_write(&obj_conv);
35959 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
35960 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
35961 CVec_u8Z_free(ret_var);
35965 uint64_t __attribute__((export_name("TS_UpdateFailMalformedHTLC_read"))) TS_UpdateFailMalformedHTLC_read(int8_tArray ser) {
35966 LDKu8slice ser_ref;
35967 ser_ref.datalen = ser->arr_len;
35968 ser_ref.data = ser->elems;
35969 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
35970 *ret_conv = UpdateFailMalformedHTLC_read(ser_ref);
35972 return tag_ptr(ret_conv, true);
35975 int8_tArray __attribute__((export_name("TS_UpdateFee_write"))) TS_UpdateFee_write(uint64_t obj) {
35976 LDKUpdateFee obj_conv;
35977 obj_conv.inner = untag_ptr(obj);
35978 obj_conv.is_owned = ptr_is_owned(obj);
35979 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
35980 obj_conv.is_owned = false;
35981 LDKCVec_u8Z ret_var = UpdateFee_write(&obj_conv);
35982 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
35983 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
35984 CVec_u8Z_free(ret_var);
35988 uint64_t __attribute__((export_name("TS_UpdateFee_read"))) TS_UpdateFee_read(int8_tArray ser) {
35989 LDKu8slice ser_ref;
35990 ser_ref.datalen = ser->arr_len;
35991 ser_ref.data = ser->elems;
35992 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
35993 *ret_conv = UpdateFee_read(ser_ref);
35995 return tag_ptr(ret_conv, true);
35998 int8_tArray __attribute__((export_name("TS_UpdateFulfillHTLC_write"))) TS_UpdateFulfillHTLC_write(uint64_t obj) {
35999 LDKUpdateFulfillHTLC obj_conv;
36000 obj_conv.inner = untag_ptr(obj);
36001 obj_conv.is_owned = ptr_is_owned(obj);
36002 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36003 obj_conv.is_owned = false;
36004 LDKCVec_u8Z ret_var = UpdateFulfillHTLC_write(&obj_conv);
36005 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36006 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36007 CVec_u8Z_free(ret_var);
36011 uint64_t __attribute__((export_name("TS_UpdateFulfillHTLC_read"))) TS_UpdateFulfillHTLC_read(int8_tArray ser) {
36012 LDKu8slice ser_ref;
36013 ser_ref.datalen = ser->arr_len;
36014 ser_ref.data = ser->elems;
36015 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
36016 *ret_conv = UpdateFulfillHTLC_read(ser_ref);
36018 return tag_ptr(ret_conv, true);
36021 int8_tArray __attribute__((export_name("TS_UpdateAddHTLC_write"))) TS_UpdateAddHTLC_write(uint64_t obj) {
36022 LDKUpdateAddHTLC obj_conv;
36023 obj_conv.inner = untag_ptr(obj);
36024 obj_conv.is_owned = ptr_is_owned(obj);
36025 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36026 obj_conv.is_owned = false;
36027 LDKCVec_u8Z ret_var = UpdateAddHTLC_write(&obj_conv);
36028 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36029 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36030 CVec_u8Z_free(ret_var);
36034 uint64_t __attribute__((export_name("TS_UpdateAddHTLC_read"))) TS_UpdateAddHTLC_read(int8_tArray ser) {
36035 LDKu8slice ser_ref;
36036 ser_ref.datalen = ser->arr_len;
36037 ser_ref.data = ser->elems;
36038 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
36039 *ret_conv = UpdateAddHTLC_read(ser_ref);
36041 return tag_ptr(ret_conv, true);
36044 uint64_t __attribute__((export_name("TS_OnionMessage_read"))) TS_OnionMessage_read(int8_tArray ser) {
36045 LDKu8slice ser_ref;
36046 ser_ref.datalen = ser->arr_len;
36047 ser_ref.data = ser->elems;
36048 LDKCResult_OnionMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OnionMessageDecodeErrorZ), "LDKCResult_OnionMessageDecodeErrorZ");
36049 *ret_conv = OnionMessage_read(ser_ref);
36051 return tag_ptr(ret_conv, true);
36054 int8_tArray __attribute__((export_name("TS_OnionMessage_write"))) TS_OnionMessage_write(uint64_t obj) {
36055 LDKOnionMessage obj_conv;
36056 obj_conv.inner = untag_ptr(obj);
36057 obj_conv.is_owned = ptr_is_owned(obj);
36058 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36059 obj_conv.is_owned = false;
36060 LDKCVec_u8Z ret_var = OnionMessage_write(&obj_conv);
36061 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36062 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36063 CVec_u8Z_free(ret_var);
36067 int8_tArray __attribute__((export_name("TS_Ping_write"))) TS_Ping_write(uint64_t obj) {
36069 obj_conv.inner = untag_ptr(obj);
36070 obj_conv.is_owned = ptr_is_owned(obj);
36071 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36072 obj_conv.is_owned = false;
36073 LDKCVec_u8Z ret_var = Ping_write(&obj_conv);
36074 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36075 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36076 CVec_u8Z_free(ret_var);
36080 uint64_t __attribute__((export_name("TS_Ping_read"))) TS_Ping_read(int8_tArray ser) {
36081 LDKu8slice ser_ref;
36082 ser_ref.datalen = ser->arr_len;
36083 ser_ref.data = ser->elems;
36084 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
36085 *ret_conv = Ping_read(ser_ref);
36087 return tag_ptr(ret_conv, true);
36090 int8_tArray __attribute__((export_name("TS_Pong_write"))) TS_Pong_write(uint64_t obj) {
36092 obj_conv.inner = untag_ptr(obj);
36093 obj_conv.is_owned = ptr_is_owned(obj);
36094 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36095 obj_conv.is_owned = false;
36096 LDKCVec_u8Z ret_var = Pong_write(&obj_conv);
36097 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36098 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36099 CVec_u8Z_free(ret_var);
36103 uint64_t __attribute__((export_name("TS_Pong_read"))) TS_Pong_read(int8_tArray ser) {
36104 LDKu8slice ser_ref;
36105 ser_ref.datalen = ser->arr_len;
36106 ser_ref.data = ser->elems;
36107 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
36108 *ret_conv = Pong_read(ser_ref);
36110 return tag_ptr(ret_conv, true);
36113 int8_tArray __attribute__((export_name("TS_UnsignedChannelAnnouncement_write"))) TS_UnsignedChannelAnnouncement_write(uint64_t obj) {
36114 LDKUnsignedChannelAnnouncement obj_conv;
36115 obj_conv.inner = untag_ptr(obj);
36116 obj_conv.is_owned = ptr_is_owned(obj);
36117 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36118 obj_conv.is_owned = false;
36119 LDKCVec_u8Z ret_var = UnsignedChannelAnnouncement_write(&obj_conv);
36120 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36121 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36122 CVec_u8Z_free(ret_var);
36126 uint64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_read"))) TS_UnsignedChannelAnnouncement_read(int8_tArray ser) {
36127 LDKu8slice ser_ref;
36128 ser_ref.datalen = ser->arr_len;
36129 ser_ref.data = ser->elems;
36130 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
36131 *ret_conv = UnsignedChannelAnnouncement_read(ser_ref);
36133 return tag_ptr(ret_conv, true);
36136 int8_tArray __attribute__((export_name("TS_ChannelAnnouncement_write"))) TS_ChannelAnnouncement_write(uint64_t obj) {
36137 LDKChannelAnnouncement obj_conv;
36138 obj_conv.inner = untag_ptr(obj);
36139 obj_conv.is_owned = ptr_is_owned(obj);
36140 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36141 obj_conv.is_owned = false;
36142 LDKCVec_u8Z ret_var = ChannelAnnouncement_write(&obj_conv);
36143 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36144 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36145 CVec_u8Z_free(ret_var);
36149 uint64_t __attribute__((export_name("TS_ChannelAnnouncement_read"))) TS_ChannelAnnouncement_read(int8_tArray ser) {
36150 LDKu8slice ser_ref;
36151 ser_ref.datalen = ser->arr_len;
36152 ser_ref.data = ser->elems;
36153 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
36154 *ret_conv = ChannelAnnouncement_read(ser_ref);
36156 return tag_ptr(ret_conv, true);
36159 int8_tArray __attribute__((export_name("TS_UnsignedChannelUpdate_write"))) TS_UnsignedChannelUpdate_write(uint64_t obj) {
36160 LDKUnsignedChannelUpdate obj_conv;
36161 obj_conv.inner = untag_ptr(obj);
36162 obj_conv.is_owned = ptr_is_owned(obj);
36163 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36164 obj_conv.is_owned = false;
36165 LDKCVec_u8Z ret_var = UnsignedChannelUpdate_write(&obj_conv);
36166 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36167 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36168 CVec_u8Z_free(ret_var);
36172 uint64_t __attribute__((export_name("TS_UnsignedChannelUpdate_read"))) TS_UnsignedChannelUpdate_read(int8_tArray ser) {
36173 LDKu8slice ser_ref;
36174 ser_ref.datalen = ser->arr_len;
36175 ser_ref.data = ser->elems;
36176 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
36177 *ret_conv = UnsignedChannelUpdate_read(ser_ref);
36179 return tag_ptr(ret_conv, true);
36182 int8_tArray __attribute__((export_name("TS_ChannelUpdate_write"))) TS_ChannelUpdate_write(uint64_t obj) {
36183 LDKChannelUpdate obj_conv;
36184 obj_conv.inner = untag_ptr(obj);
36185 obj_conv.is_owned = ptr_is_owned(obj);
36186 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36187 obj_conv.is_owned = false;
36188 LDKCVec_u8Z ret_var = ChannelUpdate_write(&obj_conv);
36189 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36190 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36191 CVec_u8Z_free(ret_var);
36195 uint64_t __attribute__((export_name("TS_ChannelUpdate_read"))) TS_ChannelUpdate_read(int8_tArray ser) {
36196 LDKu8slice ser_ref;
36197 ser_ref.datalen = ser->arr_len;
36198 ser_ref.data = ser->elems;
36199 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
36200 *ret_conv = ChannelUpdate_read(ser_ref);
36202 return tag_ptr(ret_conv, true);
36205 int8_tArray __attribute__((export_name("TS_ErrorMessage_write"))) TS_ErrorMessage_write(uint64_t obj) {
36206 LDKErrorMessage obj_conv;
36207 obj_conv.inner = untag_ptr(obj);
36208 obj_conv.is_owned = ptr_is_owned(obj);
36209 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36210 obj_conv.is_owned = false;
36211 LDKCVec_u8Z ret_var = ErrorMessage_write(&obj_conv);
36212 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36213 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36214 CVec_u8Z_free(ret_var);
36218 uint64_t __attribute__((export_name("TS_ErrorMessage_read"))) TS_ErrorMessage_read(int8_tArray ser) {
36219 LDKu8slice ser_ref;
36220 ser_ref.datalen = ser->arr_len;
36221 ser_ref.data = ser->elems;
36222 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
36223 *ret_conv = ErrorMessage_read(ser_ref);
36225 return tag_ptr(ret_conv, true);
36228 int8_tArray __attribute__((export_name("TS_WarningMessage_write"))) TS_WarningMessage_write(uint64_t obj) {
36229 LDKWarningMessage obj_conv;
36230 obj_conv.inner = untag_ptr(obj);
36231 obj_conv.is_owned = ptr_is_owned(obj);
36232 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36233 obj_conv.is_owned = false;
36234 LDKCVec_u8Z ret_var = WarningMessage_write(&obj_conv);
36235 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36236 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36237 CVec_u8Z_free(ret_var);
36241 uint64_t __attribute__((export_name("TS_WarningMessage_read"))) TS_WarningMessage_read(int8_tArray ser) {
36242 LDKu8slice ser_ref;
36243 ser_ref.datalen = ser->arr_len;
36244 ser_ref.data = ser->elems;
36245 LDKCResult_WarningMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WarningMessageDecodeErrorZ), "LDKCResult_WarningMessageDecodeErrorZ");
36246 *ret_conv = WarningMessage_read(ser_ref);
36248 return tag_ptr(ret_conv, true);
36251 int8_tArray __attribute__((export_name("TS_UnsignedNodeAnnouncement_write"))) TS_UnsignedNodeAnnouncement_write(uint64_t obj) {
36252 LDKUnsignedNodeAnnouncement obj_conv;
36253 obj_conv.inner = untag_ptr(obj);
36254 obj_conv.is_owned = ptr_is_owned(obj);
36255 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36256 obj_conv.is_owned = false;
36257 LDKCVec_u8Z ret_var = UnsignedNodeAnnouncement_write(&obj_conv);
36258 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36259 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36260 CVec_u8Z_free(ret_var);
36264 uint64_t __attribute__((export_name("TS_UnsignedNodeAnnouncement_read"))) TS_UnsignedNodeAnnouncement_read(int8_tArray ser) {
36265 LDKu8slice ser_ref;
36266 ser_ref.datalen = ser->arr_len;
36267 ser_ref.data = ser->elems;
36268 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
36269 *ret_conv = UnsignedNodeAnnouncement_read(ser_ref);
36271 return tag_ptr(ret_conv, true);
36274 int8_tArray __attribute__((export_name("TS_NodeAnnouncement_write"))) TS_NodeAnnouncement_write(uint64_t obj) {
36275 LDKNodeAnnouncement obj_conv;
36276 obj_conv.inner = untag_ptr(obj);
36277 obj_conv.is_owned = ptr_is_owned(obj);
36278 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36279 obj_conv.is_owned = false;
36280 LDKCVec_u8Z ret_var = NodeAnnouncement_write(&obj_conv);
36281 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36282 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36283 CVec_u8Z_free(ret_var);
36287 uint64_t __attribute__((export_name("TS_NodeAnnouncement_read"))) TS_NodeAnnouncement_read(int8_tArray ser) {
36288 LDKu8slice ser_ref;
36289 ser_ref.datalen = ser->arr_len;
36290 ser_ref.data = ser->elems;
36291 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
36292 *ret_conv = NodeAnnouncement_read(ser_ref);
36294 return tag_ptr(ret_conv, true);
36297 uint64_t __attribute__((export_name("TS_QueryShortChannelIds_read"))) TS_QueryShortChannelIds_read(int8_tArray ser) {
36298 LDKu8slice ser_ref;
36299 ser_ref.datalen = ser->arr_len;
36300 ser_ref.data = ser->elems;
36301 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
36302 *ret_conv = QueryShortChannelIds_read(ser_ref);
36304 return tag_ptr(ret_conv, true);
36307 int8_tArray __attribute__((export_name("TS_QueryShortChannelIds_write"))) TS_QueryShortChannelIds_write(uint64_t obj) {
36308 LDKQueryShortChannelIds obj_conv;
36309 obj_conv.inner = untag_ptr(obj);
36310 obj_conv.is_owned = ptr_is_owned(obj);
36311 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36312 obj_conv.is_owned = false;
36313 LDKCVec_u8Z ret_var = QueryShortChannelIds_write(&obj_conv);
36314 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36315 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36316 CVec_u8Z_free(ret_var);
36320 int8_tArray __attribute__((export_name("TS_ReplyShortChannelIdsEnd_write"))) TS_ReplyShortChannelIdsEnd_write(uint64_t obj) {
36321 LDKReplyShortChannelIdsEnd obj_conv;
36322 obj_conv.inner = untag_ptr(obj);
36323 obj_conv.is_owned = ptr_is_owned(obj);
36324 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36325 obj_conv.is_owned = false;
36326 LDKCVec_u8Z ret_var = ReplyShortChannelIdsEnd_write(&obj_conv);
36327 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36328 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36329 CVec_u8Z_free(ret_var);
36333 uint64_t __attribute__((export_name("TS_ReplyShortChannelIdsEnd_read"))) TS_ReplyShortChannelIdsEnd_read(int8_tArray ser) {
36334 LDKu8slice ser_ref;
36335 ser_ref.datalen = ser->arr_len;
36336 ser_ref.data = ser->elems;
36337 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
36338 *ret_conv = ReplyShortChannelIdsEnd_read(ser_ref);
36340 return tag_ptr(ret_conv, true);
36343 int32_t __attribute__((export_name("TS_QueryChannelRange_end_blocknum"))) TS_QueryChannelRange_end_blocknum(uint64_t this_arg) {
36344 LDKQueryChannelRange this_arg_conv;
36345 this_arg_conv.inner = untag_ptr(this_arg);
36346 this_arg_conv.is_owned = ptr_is_owned(this_arg);
36347 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36348 this_arg_conv.is_owned = false;
36349 int32_t ret_conv = QueryChannelRange_end_blocknum(&this_arg_conv);
36353 int8_tArray __attribute__((export_name("TS_QueryChannelRange_write"))) TS_QueryChannelRange_write(uint64_t obj) {
36354 LDKQueryChannelRange obj_conv;
36355 obj_conv.inner = untag_ptr(obj);
36356 obj_conv.is_owned = ptr_is_owned(obj);
36357 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36358 obj_conv.is_owned = false;
36359 LDKCVec_u8Z ret_var = QueryChannelRange_write(&obj_conv);
36360 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36361 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36362 CVec_u8Z_free(ret_var);
36366 uint64_t __attribute__((export_name("TS_QueryChannelRange_read"))) TS_QueryChannelRange_read(int8_tArray ser) {
36367 LDKu8slice ser_ref;
36368 ser_ref.datalen = ser->arr_len;
36369 ser_ref.data = ser->elems;
36370 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
36371 *ret_conv = QueryChannelRange_read(ser_ref);
36373 return tag_ptr(ret_conv, true);
36376 uint64_t __attribute__((export_name("TS_ReplyChannelRange_read"))) TS_ReplyChannelRange_read(int8_tArray ser) {
36377 LDKu8slice ser_ref;
36378 ser_ref.datalen = ser->arr_len;
36379 ser_ref.data = ser->elems;
36380 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
36381 *ret_conv = ReplyChannelRange_read(ser_ref);
36383 return tag_ptr(ret_conv, true);
36386 int8_tArray __attribute__((export_name("TS_ReplyChannelRange_write"))) TS_ReplyChannelRange_write(uint64_t obj) {
36387 LDKReplyChannelRange obj_conv;
36388 obj_conv.inner = untag_ptr(obj);
36389 obj_conv.is_owned = ptr_is_owned(obj);
36390 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36391 obj_conv.is_owned = false;
36392 LDKCVec_u8Z ret_var = ReplyChannelRange_write(&obj_conv);
36393 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36394 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36395 CVec_u8Z_free(ret_var);
36399 int8_tArray __attribute__((export_name("TS_GossipTimestampFilter_write"))) TS_GossipTimestampFilter_write(uint64_t obj) {
36400 LDKGossipTimestampFilter obj_conv;
36401 obj_conv.inner = untag_ptr(obj);
36402 obj_conv.is_owned = ptr_is_owned(obj);
36403 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36404 obj_conv.is_owned = false;
36405 LDKCVec_u8Z ret_var = GossipTimestampFilter_write(&obj_conv);
36406 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36407 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36408 CVec_u8Z_free(ret_var);
36412 uint64_t __attribute__((export_name("TS_GossipTimestampFilter_read"))) TS_GossipTimestampFilter_read(int8_tArray ser) {
36413 LDKu8slice ser_ref;
36414 ser_ref.datalen = ser->arr_len;
36415 ser_ref.data = ser->elems;
36416 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
36417 *ret_conv = GossipTimestampFilter_read(ser_ref);
36419 return tag_ptr(ret_conv, true);
36422 void __attribute__((export_name("TS_CustomMessageHandler_free"))) TS_CustomMessageHandler_free(uint64_t this_ptr) {
36423 if (!ptr_is_owned(this_ptr)) return;
36424 void* this_ptr_ptr = untag_ptr(this_ptr);
36425 CHECK_ACCESS(this_ptr_ptr);
36426 LDKCustomMessageHandler this_ptr_conv = *(LDKCustomMessageHandler*)(this_ptr_ptr);
36427 FREE(untag_ptr(this_ptr));
36428 CustomMessageHandler_free(this_ptr_conv);
36431 void __attribute__((export_name("TS_IgnoringMessageHandler_free"))) TS_IgnoringMessageHandler_free(uint64_t this_obj) {
36432 LDKIgnoringMessageHandler this_obj_conv;
36433 this_obj_conv.inner = untag_ptr(this_obj);
36434 this_obj_conv.is_owned = ptr_is_owned(this_obj);
36435 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
36436 IgnoringMessageHandler_free(this_obj_conv);
36439 uint64_t __attribute__((export_name("TS_IgnoringMessageHandler_new"))) TS_IgnoringMessageHandler_new() {
36440 LDKIgnoringMessageHandler ret_var = IgnoringMessageHandler_new();
36441 uint64_t ret_ref = 0;
36442 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36443 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36447 uint64_t __attribute__((export_name("TS_IgnoringMessageHandler_as_MessageSendEventsProvider"))) TS_IgnoringMessageHandler_as_MessageSendEventsProvider(uint64_t this_arg) {
36448 LDKIgnoringMessageHandler this_arg_conv;
36449 this_arg_conv.inner = untag_ptr(this_arg);
36450 this_arg_conv.is_owned = ptr_is_owned(this_arg);
36451 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36452 this_arg_conv.is_owned = false;
36453 LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
36454 *ret_ret = IgnoringMessageHandler_as_MessageSendEventsProvider(&this_arg_conv);
36455 return tag_ptr(ret_ret, true);
36458 uint64_t __attribute__((export_name("TS_IgnoringMessageHandler_as_RoutingMessageHandler"))) TS_IgnoringMessageHandler_as_RoutingMessageHandler(uint64_t this_arg) {
36459 LDKIgnoringMessageHandler this_arg_conv;
36460 this_arg_conv.inner = untag_ptr(this_arg);
36461 this_arg_conv.is_owned = ptr_is_owned(this_arg);
36462 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36463 this_arg_conv.is_owned = false;
36464 LDKRoutingMessageHandler* ret_ret = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
36465 *ret_ret = IgnoringMessageHandler_as_RoutingMessageHandler(&this_arg_conv);
36466 return tag_ptr(ret_ret, true);
36469 uint64_t __attribute__((export_name("TS_IgnoringMessageHandler_as_OnionMessageProvider"))) TS_IgnoringMessageHandler_as_OnionMessageProvider(uint64_t this_arg) {
36470 LDKIgnoringMessageHandler this_arg_conv;
36471 this_arg_conv.inner = untag_ptr(this_arg);
36472 this_arg_conv.is_owned = ptr_is_owned(this_arg);
36473 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36474 this_arg_conv.is_owned = false;
36475 LDKOnionMessageProvider* ret_ret = MALLOC(sizeof(LDKOnionMessageProvider), "LDKOnionMessageProvider");
36476 *ret_ret = IgnoringMessageHandler_as_OnionMessageProvider(&this_arg_conv);
36477 return tag_ptr(ret_ret, true);
36480 uint64_t __attribute__((export_name("TS_IgnoringMessageHandler_as_OnionMessageHandler"))) TS_IgnoringMessageHandler_as_OnionMessageHandler(uint64_t this_arg) {
36481 LDKIgnoringMessageHandler this_arg_conv;
36482 this_arg_conv.inner = untag_ptr(this_arg);
36483 this_arg_conv.is_owned = ptr_is_owned(this_arg);
36484 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36485 this_arg_conv.is_owned = false;
36486 LDKOnionMessageHandler* ret_ret = MALLOC(sizeof(LDKOnionMessageHandler), "LDKOnionMessageHandler");
36487 *ret_ret = IgnoringMessageHandler_as_OnionMessageHandler(&this_arg_conv);
36488 return tag_ptr(ret_ret, true);
36491 uint64_t __attribute__((export_name("TS_IgnoringMessageHandler_as_CustomOnionMessageHandler"))) TS_IgnoringMessageHandler_as_CustomOnionMessageHandler(uint64_t this_arg) {
36492 LDKIgnoringMessageHandler this_arg_conv;
36493 this_arg_conv.inner = untag_ptr(this_arg);
36494 this_arg_conv.is_owned = ptr_is_owned(this_arg);
36495 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36496 this_arg_conv.is_owned = false;
36497 LDKCustomOnionMessageHandler* ret_ret = MALLOC(sizeof(LDKCustomOnionMessageHandler), "LDKCustomOnionMessageHandler");
36498 *ret_ret = IgnoringMessageHandler_as_CustomOnionMessageHandler(&this_arg_conv);
36499 return tag_ptr(ret_ret, true);
36502 uint64_t __attribute__((export_name("TS_IgnoringMessageHandler_as_CustomMessageReader"))) TS_IgnoringMessageHandler_as_CustomMessageReader(uint64_t this_arg) {
36503 LDKIgnoringMessageHandler this_arg_conv;
36504 this_arg_conv.inner = untag_ptr(this_arg);
36505 this_arg_conv.is_owned = ptr_is_owned(this_arg);
36506 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36507 this_arg_conv.is_owned = false;
36508 LDKCustomMessageReader* ret_ret = MALLOC(sizeof(LDKCustomMessageReader), "LDKCustomMessageReader");
36509 *ret_ret = IgnoringMessageHandler_as_CustomMessageReader(&this_arg_conv);
36510 return tag_ptr(ret_ret, true);
36513 uint64_t __attribute__((export_name("TS_IgnoringMessageHandler_as_CustomMessageHandler"))) TS_IgnoringMessageHandler_as_CustomMessageHandler(uint64_t this_arg) {
36514 LDKIgnoringMessageHandler this_arg_conv;
36515 this_arg_conv.inner = untag_ptr(this_arg);
36516 this_arg_conv.is_owned = ptr_is_owned(this_arg);
36517 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36518 this_arg_conv.is_owned = false;
36519 LDKCustomMessageHandler* ret_ret = MALLOC(sizeof(LDKCustomMessageHandler), "LDKCustomMessageHandler");
36520 *ret_ret = IgnoringMessageHandler_as_CustomMessageHandler(&this_arg_conv);
36521 return tag_ptr(ret_ret, true);
36524 void __attribute__((export_name("TS_ErroringMessageHandler_free"))) TS_ErroringMessageHandler_free(uint64_t this_obj) {
36525 LDKErroringMessageHandler this_obj_conv;
36526 this_obj_conv.inner = untag_ptr(this_obj);
36527 this_obj_conv.is_owned = ptr_is_owned(this_obj);
36528 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
36529 ErroringMessageHandler_free(this_obj_conv);
36532 uint64_t __attribute__((export_name("TS_ErroringMessageHandler_new"))) TS_ErroringMessageHandler_new() {
36533 LDKErroringMessageHandler ret_var = ErroringMessageHandler_new();
36534 uint64_t ret_ref = 0;
36535 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36536 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36540 uint64_t __attribute__((export_name("TS_ErroringMessageHandler_as_MessageSendEventsProvider"))) TS_ErroringMessageHandler_as_MessageSendEventsProvider(uint64_t this_arg) {
36541 LDKErroringMessageHandler this_arg_conv;
36542 this_arg_conv.inner = untag_ptr(this_arg);
36543 this_arg_conv.is_owned = ptr_is_owned(this_arg);
36544 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36545 this_arg_conv.is_owned = false;
36546 LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
36547 *ret_ret = ErroringMessageHandler_as_MessageSendEventsProvider(&this_arg_conv);
36548 return tag_ptr(ret_ret, true);
36551 uint64_t __attribute__((export_name("TS_ErroringMessageHandler_as_ChannelMessageHandler"))) TS_ErroringMessageHandler_as_ChannelMessageHandler(uint64_t this_arg) {
36552 LDKErroringMessageHandler this_arg_conv;
36553 this_arg_conv.inner = untag_ptr(this_arg);
36554 this_arg_conv.is_owned = ptr_is_owned(this_arg);
36555 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36556 this_arg_conv.is_owned = false;
36557 LDKChannelMessageHandler* ret_ret = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
36558 *ret_ret = ErroringMessageHandler_as_ChannelMessageHandler(&this_arg_conv);
36559 return tag_ptr(ret_ret, true);
36562 void __attribute__((export_name("TS_MessageHandler_free"))) TS_MessageHandler_free(uint64_t this_obj) {
36563 LDKMessageHandler this_obj_conv;
36564 this_obj_conv.inner = untag_ptr(this_obj);
36565 this_obj_conv.is_owned = ptr_is_owned(this_obj);
36566 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
36567 MessageHandler_free(this_obj_conv);
36570 uint64_t __attribute__((export_name("TS_MessageHandler_get_chan_handler"))) TS_MessageHandler_get_chan_handler(uint64_t this_ptr) {
36571 LDKMessageHandler this_ptr_conv;
36572 this_ptr_conv.inner = untag_ptr(this_ptr);
36573 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36574 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36575 this_ptr_conv.is_owned = false;
36576 // WARNING: This object doesn't live past this scope, needs clone!
36577 uint64_t ret_ret = tag_ptr(MessageHandler_get_chan_handler(&this_ptr_conv), false);
36581 void __attribute__((export_name("TS_MessageHandler_set_chan_handler"))) TS_MessageHandler_set_chan_handler(uint64_t this_ptr, uint64_t val) {
36582 LDKMessageHandler this_ptr_conv;
36583 this_ptr_conv.inner = untag_ptr(this_ptr);
36584 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36585 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36586 this_ptr_conv.is_owned = false;
36587 void* val_ptr = untag_ptr(val);
36588 CHECK_ACCESS(val_ptr);
36589 LDKChannelMessageHandler val_conv = *(LDKChannelMessageHandler*)(val_ptr);
36590 if (val_conv.free == LDKChannelMessageHandler_JCalls_free) {
36591 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
36592 LDKChannelMessageHandler_JCalls_cloned(&val_conv);
36594 MessageHandler_set_chan_handler(&this_ptr_conv, val_conv);
36597 uint64_t __attribute__((export_name("TS_MessageHandler_get_route_handler"))) TS_MessageHandler_get_route_handler(uint64_t this_ptr) {
36598 LDKMessageHandler this_ptr_conv;
36599 this_ptr_conv.inner = untag_ptr(this_ptr);
36600 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36601 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36602 this_ptr_conv.is_owned = false;
36603 // WARNING: This object doesn't live past this scope, needs clone!
36604 uint64_t ret_ret = tag_ptr(MessageHandler_get_route_handler(&this_ptr_conv), false);
36608 void __attribute__((export_name("TS_MessageHandler_set_route_handler"))) TS_MessageHandler_set_route_handler(uint64_t this_ptr, uint64_t val) {
36609 LDKMessageHandler this_ptr_conv;
36610 this_ptr_conv.inner = untag_ptr(this_ptr);
36611 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36612 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36613 this_ptr_conv.is_owned = false;
36614 void* val_ptr = untag_ptr(val);
36615 CHECK_ACCESS(val_ptr);
36616 LDKRoutingMessageHandler val_conv = *(LDKRoutingMessageHandler*)(val_ptr);
36617 if (val_conv.free == LDKRoutingMessageHandler_JCalls_free) {
36618 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
36619 LDKRoutingMessageHandler_JCalls_cloned(&val_conv);
36621 MessageHandler_set_route_handler(&this_ptr_conv, val_conv);
36624 uint64_t __attribute__((export_name("TS_MessageHandler_get_onion_message_handler"))) TS_MessageHandler_get_onion_message_handler(uint64_t this_ptr) {
36625 LDKMessageHandler this_ptr_conv;
36626 this_ptr_conv.inner = untag_ptr(this_ptr);
36627 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36628 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36629 this_ptr_conv.is_owned = false;
36630 // WARNING: This object doesn't live past this scope, needs clone!
36631 uint64_t ret_ret = tag_ptr(MessageHandler_get_onion_message_handler(&this_ptr_conv), false);
36635 void __attribute__((export_name("TS_MessageHandler_set_onion_message_handler"))) TS_MessageHandler_set_onion_message_handler(uint64_t this_ptr, uint64_t val) {
36636 LDKMessageHandler this_ptr_conv;
36637 this_ptr_conv.inner = untag_ptr(this_ptr);
36638 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36639 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36640 this_ptr_conv.is_owned = false;
36641 void* val_ptr = untag_ptr(val);
36642 CHECK_ACCESS(val_ptr);
36643 LDKOnionMessageHandler val_conv = *(LDKOnionMessageHandler*)(val_ptr);
36644 if (val_conv.free == LDKOnionMessageHandler_JCalls_free) {
36645 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
36646 LDKOnionMessageHandler_JCalls_cloned(&val_conv);
36648 MessageHandler_set_onion_message_handler(&this_ptr_conv, val_conv);
36651 uint64_t __attribute__((export_name("TS_MessageHandler_new"))) TS_MessageHandler_new(uint64_t chan_handler_arg, uint64_t route_handler_arg, uint64_t onion_message_handler_arg) {
36652 void* chan_handler_arg_ptr = untag_ptr(chan_handler_arg);
36653 CHECK_ACCESS(chan_handler_arg_ptr);
36654 LDKChannelMessageHandler chan_handler_arg_conv = *(LDKChannelMessageHandler*)(chan_handler_arg_ptr);
36655 if (chan_handler_arg_conv.free == LDKChannelMessageHandler_JCalls_free) {
36656 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
36657 LDKChannelMessageHandler_JCalls_cloned(&chan_handler_arg_conv);
36659 void* route_handler_arg_ptr = untag_ptr(route_handler_arg);
36660 CHECK_ACCESS(route_handler_arg_ptr);
36661 LDKRoutingMessageHandler route_handler_arg_conv = *(LDKRoutingMessageHandler*)(route_handler_arg_ptr);
36662 if (route_handler_arg_conv.free == LDKRoutingMessageHandler_JCalls_free) {
36663 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
36664 LDKRoutingMessageHandler_JCalls_cloned(&route_handler_arg_conv);
36666 void* onion_message_handler_arg_ptr = untag_ptr(onion_message_handler_arg);
36667 CHECK_ACCESS(onion_message_handler_arg_ptr);
36668 LDKOnionMessageHandler onion_message_handler_arg_conv = *(LDKOnionMessageHandler*)(onion_message_handler_arg_ptr);
36669 if (onion_message_handler_arg_conv.free == LDKOnionMessageHandler_JCalls_free) {
36670 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
36671 LDKOnionMessageHandler_JCalls_cloned(&onion_message_handler_arg_conv);
36673 LDKMessageHandler ret_var = MessageHandler_new(chan_handler_arg_conv, route_handler_arg_conv, onion_message_handler_arg_conv);
36674 uint64_t ret_ref = 0;
36675 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36676 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36680 static inline uint64_t SocketDescriptor_clone_ptr(LDKSocketDescriptor *NONNULL_PTR arg) {
36681 LDKSocketDescriptor* ret_ret = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
36682 *ret_ret = SocketDescriptor_clone(arg);
36683 return tag_ptr(ret_ret, true);
36685 int64_t __attribute__((export_name("TS_SocketDescriptor_clone_ptr"))) TS_SocketDescriptor_clone_ptr(uint64_t arg) {
36686 void* arg_ptr = untag_ptr(arg);
36687 if (ptr_is_owned(arg)) { CHECK_ACCESS(arg_ptr); }
36688 LDKSocketDescriptor* arg_conv = (LDKSocketDescriptor*)arg_ptr;
36689 int64_t ret_conv = SocketDescriptor_clone_ptr(arg_conv);
36693 uint64_t __attribute__((export_name("TS_SocketDescriptor_clone"))) TS_SocketDescriptor_clone(uint64_t orig) {
36694 void* orig_ptr = untag_ptr(orig);
36695 if (ptr_is_owned(orig)) { CHECK_ACCESS(orig_ptr); }
36696 LDKSocketDescriptor* orig_conv = (LDKSocketDescriptor*)orig_ptr;
36697 LDKSocketDescriptor* ret_ret = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
36698 *ret_ret = SocketDescriptor_clone(orig_conv);
36699 return tag_ptr(ret_ret, true);
36702 void __attribute__((export_name("TS_SocketDescriptor_free"))) TS_SocketDescriptor_free(uint64_t this_ptr) {
36703 if (!ptr_is_owned(this_ptr)) return;
36704 void* this_ptr_ptr = untag_ptr(this_ptr);
36705 CHECK_ACCESS(this_ptr_ptr);
36706 LDKSocketDescriptor this_ptr_conv = *(LDKSocketDescriptor*)(this_ptr_ptr);
36707 FREE(untag_ptr(this_ptr));
36708 SocketDescriptor_free(this_ptr_conv);
36711 void __attribute__((export_name("TS_PeerHandleError_free"))) TS_PeerHandleError_free(uint64_t this_obj) {
36712 LDKPeerHandleError this_obj_conv;
36713 this_obj_conv.inner = untag_ptr(this_obj);
36714 this_obj_conv.is_owned = ptr_is_owned(this_obj);
36715 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
36716 PeerHandleError_free(this_obj_conv);
36719 jboolean __attribute__((export_name("TS_PeerHandleError_get_no_connection_possible"))) TS_PeerHandleError_get_no_connection_possible(uint64_t this_ptr) {
36720 LDKPeerHandleError this_ptr_conv;
36721 this_ptr_conv.inner = untag_ptr(this_ptr);
36722 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36723 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36724 this_ptr_conv.is_owned = false;
36725 jboolean ret_conv = PeerHandleError_get_no_connection_possible(&this_ptr_conv);
36729 void __attribute__((export_name("TS_PeerHandleError_set_no_connection_possible"))) TS_PeerHandleError_set_no_connection_possible(uint64_t this_ptr, jboolean val) {
36730 LDKPeerHandleError this_ptr_conv;
36731 this_ptr_conv.inner = untag_ptr(this_ptr);
36732 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36733 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36734 this_ptr_conv.is_owned = false;
36735 PeerHandleError_set_no_connection_possible(&this_ptr_conv, val);
36738 uint64_t __attribute__((export_name("TS_PeerHandleError_new"))) TS_PeerHandleError_new(jboolean no_connection_possible_arg) {
36739 LDKPeerHandleError ret_var = PeerHandleError_new(no_connection_possible_arg);
36740 uint64_t ret_ref = 0;
36741 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36742 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36746 static inline uint64_t PeerHandleError_clone_ptr(LDKPeerHandleError *NONNULL_PTR arg) {
36747 LDKPeerHandleError ret_var = PeerHandleError_clone(arg);
36748 uint64_t ret_ref = 0;
36749 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36750 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36753 int64_t __attribute__((export_name("TS_PeerHandleError_clone_ptr"))) TS_PeerHandleError_clone_ptr(uint64_t arg) {
36754 LDKPeerHandleError arg_conv;
36755 arg_conv.inner = untag_ptr(arg);
36756 arg_conv.is_owned = ptr_is_owned(arg);
36757 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
36758 arg_conv.is_owned = false;
36759 int64_t ret_conv = PeerHandleError_clone_ptr(&arg_conv);
36763 uint64_t __attribute__((export_name("TS_PeerHandleError_clone"))) TS_PeerHandleError_clone(uint64_t orig) {
36764 LDKPeerHandleError orig_conv;
36765 orig_conv.inner = untag_ptr(orig);
36766 orig_conv.is_owned = ptr_is_owned(orig);
36767 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
36768 orig_conv.is_owned = false;
36769 LDKPeerHandleError ret_var = PeerHandleError_clone(&orig_conv);
36770 uint64_t ret_ref = 0;
36771 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36772 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36776 void __attribute__((export_name("TS_PeerManager_free"))) TS_PeerManager_free(uint64_t this_obj) {
36777 LDKPeerManager this_obj_conv;
36778 this_obj_conv.inner = untag_ptr(this_obj);
36779 this_obj_conv.is_owned = ptr_is_owned(this_obj);
36780 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
36781 PeerManager_free(this_obj_conv);
36784 uint64_t __attribute__((export_name("TS_PeerManager_new"))) TS_PeerManager_new(uint64_t message_handler, int8_tArray our_node_secret, int32_t current_time, int8_tArray ephemeral_random_data, uint64_t logger, uint64_t custom_message_handler) {
36785 LDKMessageHandler message_handler_conv;
36786 message_handler_conv.inner = untag_ptr(message_handler);
36787 message_handler_conv.is_owned = ptr_is_owned(message_handler);
36788 CHECK_INNER_FIELD_ACCESS_OR_NULL(message_handler_conv);
36789 // WARNING: we need a move here but no clone is available for LDKMessageHandler
36791 LDKSecretKey our_node_secret_ref;
36792 CHECK(our_node_secret->arr_len == 32);
36793 memcpy(our_node_secret_ref.bytes, our_node_secret->elems, 32); FREE(our_node_secret);
36794 unsigned char ephemeral_random_data_arr[32];
36795 CHECK(ephemeral_random_data->arr_len == 32);
36796 memcpy(ephemeral_random_data_arr, ephemeral_random_data->elems, 32); FREE(ephemeral_random_data);
36797 unsigned char (*ephemeral_random_data_ref)[32] = &ephemeral_random_data_arr;
36798 void* logger_ptr = untag_ptr(logger);
36799 CHECK_ACCESS(logger_ptr);
36800 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
36801 if (logger_conv.free == LDKLogger_JCalls_free) {
36802 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
36803 LDKLogger_JCalls_cloned(&logger_conv);
36805 void* custom_message_handler_ptr = untag_ptr(custom_message_handler);
36806 CHECK_ACCESS(custom_message_handler_ptr);
36807 LDKCustomMessageHandler custom_message_handler_conv = *(LDKCustomMessageHandler*)(custom_message_handler_ptr);
36808 if (custom_message_handler_conv.free == LDKCustomMessageHandler_JCalls_free) {
36809 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
36810 LDKCustomMessageHandler_JCalls_cloned(&custom_message_handler_conv);
36812 LDKPeerManager ret_var = PeerManager_new(message_handler_conv, our_node_secret_ref, current_time, ephemeral_random_data_ref, logger_conv, custom_message_handler_conv);
36813 uint64_t ret_ref = 0;
36814 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36815 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36819 ptrArray __attribute__((export_name("TS_PeerManager_get_peer_node_ids"))) TS_PeerManager_get_peer_node_ids(uint64_t this_arg) {
36820 LDKPeerManager this_arg_conv;
36821 this_arg_conv.inner = untag_ptr(this_arg);
36822 this_arg_conv.is_owned = ptr_is_owned(this_arg);
36823 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36824 this_arg_conv.is_owned = false;
36825 LDKCVec_PublicKeyZ ret_var = PeerManager_get_peer_node_ids(&this_arg_conv);
36826 ptrArray ret_arr = NULL;
36827 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
36828 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 8);
36829 for (size_t m = 0; m < ret_var.datalen; m++) {
36830 int8_tArray ret_conv_12_arr = init_int8_tArray(33, __LINE__);
36831 memcpy(ret_conv_12_arr->elems, ret_var.data[m].compressed_form, 33);
36832 ret_arr_ptr[m] = ret_conv_12_arr;
36835 FREE(ret_var.data);
36839 uint64_t __attribute__((export_name("TS_PeerManager_new_outbound_connection"))) TS_PeerManager_new_outbound_connection(uint64_t this_arg, int8_tArray their_node_id, uint64_t descriptor, uint64_t remote_network_address) {
36840 LDKPeerManager this_arg_conv;
36841 this_arg_conv.inner = untag_ptr(this_arg);
36842 this_arg_conv.is_owned = ptr_is_owned(this_arg);
36843 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36844 this_arg_conv.is_owned = false;
36845 LDKPublicKey their_node_id_ref;
36846 CHECK(their_node_id->arr_len == 33);
36847 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
36848 void* descriptor_ptr = untag_ptr(descriptor);
36849 CHECK_ACCESS(descriptor_ptr);
36850 LDKSocketDescriptor descriptor_conv = *(LDKSocketDescriptor*)(descriptor_ptr);
36851 if (descriptor_conv.free == LDKSocketDescriptor_JCalls_free) {
36852 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
36853 LDKSocketDescriptor_JCalls_cloned(&descriptor_conv);
36855 void* remote_network_address_ptr = untag_ptr(remote_network_address);
36856 CHECK_ACCESS(remote_network_address_ptr);
36857 LDKCOption_NetAddressZ remote_network_address_conv = *(LDKCOption_NetAddressZ*)(remote_network_address_ptr);
36858 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
36859 *ret_conv = PeerManager_new_outbound_connection(&this_arg_conv, their_node_id_ref, descriptor_conv, remote_network_address_conv);
36860 return tag_ptr(ret_conv, true);
36863 uint64_t __attribute__((export_name("TS_PeerManager_new_inbound_connection"))) TS_PeerManager_new_inbound_connection(uint64_t this_arg, uint64_t descriptor, uint64_t remote_network_address) {
36864 LDKPeerManager this_arg_conv;
36865 this_arg_conv.inner = untag_ptr(this_arg);
36866 this_arg_conv.is_owned = ptr_is_owned(this_arg);
36867 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36868 this_arg_conv.is_owned = false;
36869 void* descriptor_ptr = untag_ptr(descriptor);
36870 CHECK_ACCESS(descriptor_ptr);
36871 LDKSocketDescriptor descriptor_conv = *(LDKSocketDescriptor*)(descriptor_ptr);
36872 if (descriptor_conv.free == LDKSocketDescriptor_JCalls_free) {
36873 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
36874 LDKSocketDescriptor_JCalls_cloned(&descriptor_conv);
36876 void* remote_network_address_ptr = untag_ptr(remote_network_address);
36877 CHECK_ACCESS(remote_network_address_ptr);
36878 LDKCOption_NetAddressZ remote_network_address_conv = *(LDKCOption_NetAddressZ*)(remote_network_address_ptr);
36879 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
36880 *ret_conv = PeerManager_new_inbound_connection(&this_arg_conv, descriptor_conv, remote_network_address_conv);
36881 return tag_ptr(ret_conv, true);
36884 uint64_t __attribute__((export_name("TS_PeerManager_write_buffer_space_avail"))) TS_PeerManager_write_buffer_space_avail(uint64_t this_arg, uint64_t descriptor) {
36885 LDKPeerManager this_arg_conv;
36886 this_arg_conv.inner = untag_ptr(this_arg);
36887 this_arg_conv.is_owned = ptr_is_owned(this_arg);
36888 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36889 this_arg_conv.is_owned = false;
36890 void* descriptor_ptr = untag_ptr(descriptor);
36891 if (ptr_is_owned(descriptor)) { CHECK_ACCESS(descriptor_ptr); }
36892 LDKSocketDescriptor* descriptor_conv = (LDKSocketDescriptor*)descriptor_ptr;
36893 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
36894 *ret_conv = PeerManager_write_buffer_space_avail(&this_arg_conv, descriptor_conv);
36895 return tag_ptr(ret_conv, true);
36898 uint64_t __attribute__((export_name("TS_PeerManager_read_event"))) TS_PeerManager_read_event(uint64_t this_arg, uint64_t peer_descriptor, int8_tArray data) {
36899 LDKPeerManager this_arg_conv;
36900 this_arg_conv.inner = untag_ptr(this_arg);
36901 this_arg_conv.is_owned = ptr_is_owned(this_arg);
36902 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36903 this_arg_conv.is_owned = false;
36904 void* peer_descriptor_ptr = untag_ptr(peer_descriptor);
36905 if (ptr_is_owned(peer_descriptor)) { CHECK_ACCESS(peer_descriptor_ptr); }
36906 LDKSocketDescriptor* peer_descriptor_conv = (LDKSocketDescriptor*)peer_descriptor_ptr;
36907 LDKu8slice data_ref;
36908 data_ref.datalen = data->arr_len;
36909 data_ref.data = data->elems;
36910 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
36911 *ret_conv = PeerManager_read_event(&this_arg_conv, peer_descriptor_conv, data_ref);
36913 return tag_ptr(ret_conv, true);
36916 void __attribute__((export_name("TS_PeerManager_process_events"))) TS_PeerManager_process_events(uint64_t this_arg) {
36917 LDKPeerManager this_arg_conv;
36918 this_arg_conv.inner = untag_ptr(this_arg);
36919 this_arg_conv.is_owned = ptr_is_owned(this_arg);
36920 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36921 this_arg_conv.is_owned = false;
36922 PeerManager_process_events(&this_arg_conv);
36925 void __attribute__((export_name("TS_PeerManager_socket_disconnected"))) TS_PeerManager_socket_disconnected(uint64_t this_arg, uint64_t descriptor) {
36926 LDKPeerManager this_arg_conv;
36927 this_arg_conv.inner = untag_ptr(this_arg);
36928 this_arg_conv.is_owned = ptr_is_owned(this_arg);
36929 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36930 this_arg_conv.is_owned = false;
36931 void* descriptor_ptr = untag_ptr(descriptor);
36932 if (ptr_is_owned(descriptor)) { CHECK_ACCESS(descriptor_ptr); }
36933 LDKSocketDescriptor* descriptor_conv = (LDKSocketDescriptor*)descriptor_ptr;
36934 PeerManager_socket_disconnected(&this_arg_conv, descriptor_conv);
36937 void __attribute__((export_name("TS_PeerManager_disconnect_by_node_id"))) TS_PeerManager_disconnect_by_node_id(uint64_t this_arg, int8_tArray node_id, jboolean no_connection_possible) {
36938 LDKPeerManager this_arg_conv;
36939 this_arg_conv.inner = untag_ptr(this_arg);
36940 this_arg_conv.is_owned = ptr_is_owned(this_arg);
36941 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36942 this_arg_conv.is_owned = false;
36943 LDKPublicKey node_id_ref;
36944 CHECK(node_id->arr_len == 33);
36945 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
36946 PeerManager_disconnect_by_node_id(&this_arg_conv, node_id_ref, no_connection_possible);
36949 void __attribute__((export_name("TS_PeerManager_disconnect_all_peers"))) TS_PeerManager_disconnect_all_peers(uint64_t this_arg) {
36950 LDKPeerManager this_arg_conv;
36951 this_arg_conv.inner = untag_ptr(this_arg);
36952 this_arg_conv.is_owned = ptr_is_owned(this_arg);
36953 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36954 this_arg_conv.is_owned = false;
36955 PeerManager_disconnect_all_peers(&this_arg_conv);
36958 void __attribute__((export_name("TS_PeerManager_timer_tick_occurred"))) TS_PeerManager_timer_tick_occurred(uint64_t this_arg) {
36959 LDKPeerManager this_arg_conv;
36960 this_arg_conv.inner = untag_ptr(this_arg);
36961 this_arg_conv.is_owned = ptr_is_owned(this_arg);
36962 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36963 this_arg_conv.is_owned = false;
36964 PeerManager_timer_tick_occurred(&this_arg_conv);
36967 void __attribute__((export_name("TS_PeerManager_broadcast_node_announcement"))) TS_PeerManager_broadcast_node_announcement(uint64_t this_arg, int8_tArray rgb, int8_tArray alias, uint64_tArray addresses) {
36968 LDKPeerManager this_arg_conv;
36969 this_arg_conv.inner = untag_ptr(this_arg);
36970 this_arg_conv.is_owned = ptr_is_owned(this_arg);
36971 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36972 this_arg_conv.is_owned = false;
36973 LDKThreeBytes rgb_ref;
36974 CHECK(rgb->arr_len == 3);
36975 memcpy(rgb_ref.data, rgb->elems, 3); FREE(rgb);
36976 LDKThirtyTwoBytes alias_ref;
36977 CHECK(alias->arr_len == 32);
36978 memcpy(alias_ref.data, alias->elems, 32); FREE(alias);
36979 LDKCVec_NetAddressZ addresses_constr;
36980 addresses_constr.datalen = addresses->arr_len;
36981 if (addresses_constr.datalen > 0)
36982 addresses_constr.data = MALLOC(addresses_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
36984 addresses_constr.data = NULL;
36985 uint64_t* addresses_vals = addresses->elems;
36986 for (size_t m = 0; m < addresses_constr.datalen; m++) {
36987 uint64_t addresses_conv_12 = addresses_vals[m];
36988 void* addresses_conv_12_ptr = untag_ptr(addresses_conv_12);
36989 CHECK_ACCESS(addresses_conv_12_ptr);
36990 LDKNetAddress addresses_conv_12_conv = *(LDKNetAddress*)(addresses_conv_12_ptr);
36991 addresses_constr.data[m] = addresses_conv_12_conv;
36994 PeerManager_broadcast_node_announcement(&this_arg_conv, rgb_ref, alias_ref, addresses_constr);
36997 int64_t __attribute__((export_name("TS_htlc_success_tx_weight"))) TS_htlc_success_tx_weight(jboolean opt_anchors) {
36998 int64_t ret_conv = htlc_success_tx_weight(opt_anchors);
37002 int64_t __attribute__((export_name("TS_htlc_timeout_tx_weight"))) TS_htlc_timeout_tx_weight(jboolean opt_anchors) {
37003 int64_t ret_conv = htlc_timeout_tx_weight(opt_anchors);
37007 uint32_t __attribute__((export_name("TS_HTLCClaim_clone"))) TS_HTLCClaim_clone(uint64_t orig) {
37008 LDKHTLCClaim* orig_conv = (LDKHTLCClaim*)untag_ptr(orig);
37009 uint32_t ret_conv = LDKHTLCClaim_to_js(HTLCClaim_clone(orig_conv));
37013 uint32_t __attribute__((export_name("TS_HTLCClaim_offered_timeout"))) TS_HTLCClaim_offered_timeout() {
37014 uint32_t ret_conv = LDKHTLCClaim_to_js(HTLCClaim_offered_timeout());
37018 uint32_t __attribute__((export_name("TS_HTLCClaim_offered_preimage"))) TS_HTLCClaim_offered_preimage() {
37019 uint32_t ret_conv = LDKHTLCClaim_to_js(HTLCClaim_offered_preimage());
37023 uint32_t __attribute__((export_name("TS_HTLCClaim_accepted_timeout"))) TS_HTLCClaim_accepted_timeout() {
37024 uint32_t ret_conv = LDKHTLCClaim_to_js(HTLCClaim_accepted_timeout());
37028 uint32_t __attribute__((export_name("TS_HTLCClaim_accepted_preimage"))) TS_HTLCClaim_accepted_preimage() {
37029 uint32_t ret_conv = LDKHTLCClaim_to_js(HTLCClaim_accepted_preimage());
37033 uint32_t __attribute__((export_name("TS_HTLCClaim_revocation"))) TS_HTLCClaim_revocation() {
37034 uint32_t ret_conv = LDKHTLCClaim_to_js(HTLCClaim_revocation());
37038 jboolean __attribute__((export_name("TS_HTLCClaim_eq"))) TS_HTLCClaim_eq(uint64_t a, uint64_t b) {
37039 LDKHTLCClaim* a_conv = (LDKHTLCClaim*)untag_ptr(a);
37040 LDKHTLCClaim* b_conv = (LDKHTLCClaim*)untag_ptr(b);
37041 jboolean ret_conv = HTLCClaim_eq(a_conv, b_conv);
37045 uint64_t __attribute__((export_name("TS_HTLCClaim_from_witness"))) TS_HTLCClaim_from_witness(int8_tArray witness) {
37046 LDKWitness witness_ref;
37047 witness_ref.datalen = witness->arr_len;
37048 witness_ref.data = MALLOC(witness_ref.datalen, "LDKWitness Bytes");
37049 memcpy(witness_ref.data, witness->elems, witness_ref.datalen); FREE(witness);
37050 witness_ref.data_is_owned = true;
37051 LDKCOption_HTLCClaimZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCClaimZ), "LDKCOption_HTLCClaimZ");
37052 *ret_copy = HTLCClaim_from_witness(witness_ref);
37053 uint64_t ret_ref = tag_ptr(ret_copy, true);
37057 int8_tArray __attribute__((export_name("TS_build_commitment_secret"))) TS_build_commitment_secret(int8_tArray commitment_seed, int64_t idx) {
37058 unsigned char commitment_seed_arr[32];
37059 CHECK(commitment_seed->arr_len == 32);
37060 memcpy(commitment_seed_arr, commitment_seed->elems, 32); FREE(commitment_seed);
37061 unsigned char (*commitment_seed_ref)[32] = &commitment_seed_arr;
37062 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
37063 memcpy(ret_arr->elems, build_commitment_secret(commitment_seed_ref, idx).data, 32);
37067 int8_tArray __attribute__((export_name("TS_build_closing_transaction"))) TS_build_closing_transaction(int64_t to_holder_value_sat, int64_t to_counterparty_value_sat, int8_tArray to_holder_script, int8_tArray to_counterparty_script, uint64_t funding_outpoint) {
37068 LDKCVec_u8Z to_holder_script_ref;
37069 to_holder_script_ref.datalen = to_holder_script->arr_len;
37070 to_holder_script_ref.data = MALLOC(to_holder_script_ref.datalen, "LDKCVec_u8Z Bytes");
37071 memcpy(to_holder_script_ref.data, to_holder_script->elems, to_holder_script_ref.datalen); FREE(to_holder_script);
37072 LDKCVec_u8Z to_counterparty_script_ref;
37073 to_counterparty_script_ref.datalen = to_counterparty_script->arr_len;
37074 to_counterparty_script_ref.data = MALLOC(to_counterparty_script_ref.datalen, "LDKCVec_u8Z Bytes");
37075 memcpy(to_counterparty_script_ref.data, to_counterparty_script->elems, to_counterparty_script_ref.datalen); FREE(to_counterparty_script);
37076 LDKOutPoint funding_outpoint_conv;
37077 funding_outpoint_conv.inner = untag_ptr(funding_outpoint);
37078 funding_outpoint_conv.is_owned = ptr_is_owned(funding_outpoint);
37079 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_conv);
37080 funding_outpoint_conv = OutPoint_clone(&funding_outpoint_conv);
37081 LDKTransaction ret_var = build_closing_transaction(to_holder_value_sat, to_counterparty_value_sat, to_holder_script_ref, to_counterparty_script_ref, funding_outpoint_conv);
37082 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
37083 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
37084 Transaction_free(ret_var);
37088 void __attribute__((export_name("TS_CounterpartyCommitmentSecrets_free"))) TS_CounterpartyCommitmentSecrets_free(uint64_t this_obj) {
37089 LDKCounterpartyCommitmentSecrets this_obj_conv;
37090 this_obj_conv.inner = untag_ptr(this_obj);
37091 this_obj_conv.is_owned = ptr_is_owned(this_obj);
37092 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
37093 CounterpartyCommitmentSecrets_free(this_obj_conv);
37096 static inline uint64_t CounterpartyCommitmentSecrets_clone_ptr(LDKCounterpartyCommitmentSecrets *NONNULL_PTR arg) {
37097 LDKCounterpartyCommitmentSecrets ret_var = CounterpartyCommitmentSecrets_clone(arg);
37098 uint64_t ret_ref = 0;
37099 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37100 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37103 int64_t __attribute__((export_name("TS_CounterpartyCommitmentSecrets_clone_ptr"))) TS_CounterpartyCommitmentSecrets_clone_ptr(uint64_t arg) {
37104 LDKCounterpartyCommitmentSecrets arg_conv;
37105 arg_conv.inner = untag_ptr(arg);
37106 arg_conv.is_owned = ptr_is_owned(arg);
37107 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
37108 arg_conv.is_owned = false;
37109 int64_t ret_conv = CounterpartyCommitmentSecrets_clone_ptr(&arg_conv);
37113 uint64_t __attribute__((export_name("TS_CounterpartyCommitmentSecrets_clone"))) TS_CounterpartyCommitmentSecrets_clone(uint64_t orig) {
37114 LDKCounterpartyCommitmentSecrets orig_conv;
37115 orig_conv.inner = untag_ptr(orig);
37116 orig_conv.is_owned = ptr_is_owned(orig);
37117 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
37118 orig_conv.is_owned = false;
37119 LDKCounterpartyCommitmentSecrets ret_var = CounterpartyCommitmentSecrets_clone(&orig_conv);
37120 uint64_t ret_ref = 0;
37121 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37122 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37126 uint64_t __attribute__((export_name("TS_CounterpartyCommitmentSecrets_new"))) TS_CounterpartyCommitmentSecrets_new() {
37127 LDKCounterpartyCommitmentSecrets ret_var = CounterpartyCommitmentSecrets_new();
37128 uint64_t ret_ref = 0;
37129 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37130 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37134 int64_t __attribute__((export_name("TS_CounterpartyCommitmentSecrets_get_min_seen_secret"))) TS_CounterpartyCommitmentSecrets_get_min_seen_secret(uint64_t this_arg) {
37135 LDKCounterpartyCommitmentSecrets this_arg_conv;
37136 this_arg_conv.inner = untag_ptr(this_arg);
37137 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37138 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37139 this_arg_conv.is_owned = false;
37140 int64_t ret_conv = CounterpartyCommitmentSecrets_get_min_seen_secret(&this_arg_conv);
37144 uint64_t __attribute__((export_name("TS_CounterpartyCommitmentSecrets_provide_secret"))) TS_CounterpartyCommitmentSecrets_provide_secret(uint64_t this_arg, int64_t idx, int8_tArray secret) {
37145 LDKCounterpartyCommitmentSecrets this_arg_conv;
37146 this_arg_conv.inner = untag_ptr(this_arg);
37147 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37148 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37149 this_arg_conv.is_owned = false;
37150 LDKThirtyTwoBytes secret_ref;
37151 CHECK(secret->arr_len == 32);
37152 memcpy(secret_ref.data, secret->elems, 32); FREE(secret);
37153 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
37154 *ret_conv = CounterpartyCommitmentSecrets_provide_secret(&this_arg_conv, idx, secret_ref);
37155 return tag_ptr(ret_conv, true);
37158 int8_tArray __attribute__((export_name("TS_CounterpartyCommitmentSecrets_get_secret"))) TS_CounterpartyCommitmentSecrets_get_secret(uint64_t this_arg, int64_t idx) {
37159 LDKCounterpartyCommitmentSecrets this_arg_conv;
37160 this_arg_conv.inner = untag_ptr(this_arg);
37161 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37162 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37163 this_arg_conv.is_owned = false;
37164 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
37165 memcpy(ret_arr->elems, CounterpartyCommitmentSecrets_get_secret(&this_arg_conv, idx).data, 32);
37169 int8_tArray __attribute__((export_name("TS_CounterpartyCommitmentSecrets_write"))) TS_CounterpartyCommitmentSecrets_write(uint64_t obj) {
37170 LDKCounterpartyCommitmentSecrets obj_conv;
37171 obj_conv.inner = untag_ptr(obj);
37172 obj_conv.is_owned = ptr_is_owned(obj);
37173 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
37174 obj_conv.is_owned = false;
37175 LDKCVec_u8Z ret_var = CounterpartyCommitmentSecrets_write(&obj_conv);
37176 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
37177 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
37178 CVec_u8Z_free(ret_var);
37182 uint64_t __attribute__((export_name("TS_CounterpartyCommitmentSecrets_read"))) TS_CounterpartyCommitmentSecrets_read(int8_tArray ser) {
37183 LDKu8slice ser_ref;
37184 ser_ref.datalen = ser->arr_len;
37185 ser_ref.data = ser->elems;
37186 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ), "LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ");
37187 *ret_conv = CounterpartyCommitmentSecrets_read(ser_ref);
37189 return tag_ptr(ret_conv, true);
37192 int8_tArray __attribute__((export_name("TS_derive_private_key"))) TS_derive_private_key(int8_tArray per_commitment_point, int8_tArray base_secret) {
37193 LDKPublicKey per_commitment_point_ref;
37194 CHECK(per_commitment_point->arr_len == 33);
37195 memcpy(per_commitment_point_ref.compressed_form, per_commitment_point->elems, 33); FREE(per_commitment_point);
37196 unsigned char base_secret_arr[32];
37197 CHECK(base_secret->arr_len == 32);
37198 memcpy(base_secret_arr, base_secret->elems, 32); FREE(base_secret);
37199 unsigned char (*base_secret_ref)[32] = &base_secret_arr;
37200 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
37201 memcpy(ret_arr->elems, derive_private_key(per_commitment_point_ref, base_secret_ref).bytes, 32);
37205 int8_tArray __attribute__((export_name("TS_derive_public_key"))) TS_derive_public_key(int8_tArray per_commitment_point, int8_tArray base_point) {
37206 LDKPublicKey per_commitment_point_ref;
37207 CHECK(per_commitment_point->arr_len == 33);
37208 memcpy(per_commitment_point_ref.compressed_form, per_commitment_point->elems, 33); FREE(per_commitment_point);
37209 LDKPublicKey base_point_ref;
37210 CHECK(base_point->arr_len == 33);
37211 memcpy(base_point_ref.compressed_form, base_point->elems, 33); FREE(base_point);
37212 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
37213 memcpy(ret_arr->elems, derive_public_key(per_commitment_point_ref, base_point_ref).compressed_form, 33);
37217 int8_tArray __attribute__((export_name("TS_derive_private_revocation_key"))) TS_derive_private_revocation_key(int8_tArray per_commitment_secret, int8_tArray countersignatory_revocation_base_secret) {
37218 unsigned char per_commitment_secret_arr[32];
37219 CHECK(per_commitment_secret->arr_len == 32);
37220 memcpy(per_commitment_secret_arr, per_commitment_secret->elems, 32); FREE(per_commitment_secret);
37221 unsigned char (*per_commitment_secret_ref)[32] = &per_commitment_secret_arr;
37222 unsigned char countersignatory_revocation_base_secret_arr[32];
37223 CHECK(countersignatory_revocation_base_secret->arr_len == 32);
37224 memcpy(countersignatory_revocation_base_secret_arr, countersignatory_revocation_base_secret->elems, 32); FREE(countersignatory_revocation_base_secret);
37225 unsigned char (*countersignatory_revocation_base_secret_ref)[32] = &countersignatory_revocation_base_secret_arr;
37226 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
37227 memcpy(ret_arr->elems, derive_private_revocation_key(per_commitment_secret_ref, countersignatory_revocation_base_secret_ref).bytes, 32);
37231 int8_tArray __attribute__((export_name("TS_derive_public_revocation_key"))) TS_derive_public_revocation_key(int8_tArray per_commitment_point, int8_tArray countersignatory_revocation_base_point) {
37232 LDKPublicKey per_commitment_point_ref;
37233 CHECK(per_commitment_point->arr_len == 33);
37234 memcpy(per_commitment_point_ref.compressed_form, per_commitment_point->elems, 33); FREE(per_commitment_point);
37235 LDKPublicKey countersignatory_revocation_base_point_ref;
37236 CHECK(countersignatory_revocation_base_point->arr_len == 33);
37237 memcpy(countersignatory_revocation_base_point_ref.compressed_form, countersignatory_revocation_base_point->elems, 33); FREE(countersignatory_revocation_base_point);
37238 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
37239 memcpy(ret_arr->elems, derive_public_revocation_key(per_commitment_point_ref, countersignatory_revocation_base_point_ref).compressed_form, 33);
37243 void __attribute__((export_name("TS_TxCreationKeys_free"))) TS_TxCreationKeys_free(uint64_t this_obj) {
37244 LDKTxCreationKeys this_obj_conv;
37245 this_obj_conv.inner = untag_ptr(this_obj);
37246 this_obj_conv.is_owned = ptr_is_owned(this_obj);
37247 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
37248 TxCreationKeys_free(this_obj_conv);
37251 int8_tArray __attribute__((export_name("TS_TxCreationKeys_get_per_commitment_point"))) TS_TxCreationKeys_get_per_commitment_point(uint64_t this_ptr) {
37252 LDKTxCreationKeys this_ptr_conv;
37253 this_ptr_conv.inner = untag_ptr(this_ptr);
37254 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37255 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37256 this_ptr_conv.is_owned = false;
37257 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
37258 memcpy(ret_arr->elems, TxCreationKeys_get_per_commitment_point(&this_ptr_conv).compressed_form, 33);
37262 void __attribute__((export_name("TS_TxCreationKeys_set_per_commitment_point"))) TS_TxCreationKeys_set_per_commitment_point(uint64_t this_ptr, int8_tArray val) {
37263 LDKTxCreationKeys this_ptr_conv;
37264 this_ptr_conv.inner = untag_ptr(this_ptr);
37265 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37266 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37267 this_ptr_conv.is_owned = false;
37268 LDKPublicKey val_ref;
37269 CHECK(val->arr_len == 33);
37270 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
37271 TxCreationKeys_set_per_commitment_point(&this_ptr_conv, val_ref);
37274 int8_tArray __attribute__((export_name("TS_TxCreationKeys_get_revocation_key"))) TS_TxCreationKeys_get_revocation_key(uint64_t this_ptr) {
37275 LDKTxCreationKeys this_ptr_conv;
37276 this_ptr_conv.inner = untag_ptr(this_ptr);
37277 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37278 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37279 this_ptr_conv.is_owned = false;
37280 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
37281 memcpy(ret_arr->elems, TxCreationKeys_get_revocation_key(&this_ptr_conv).compressed_form, 33);
37285 void __attribute__((export_name("TS_TxCreationKeys_set_revocation_key"))) TS_TxCreationKeys_set_revocation_key(uint64_t this_ptr, int8_tArray val) {
37286 LDKTxCreationKeys this_ptr_conv;
37287 this_ptr_conv.inner = untag_ptr(this_ptr);
37288 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37289 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37290 this_ptr_conv.is_owned = false;
37291 LDKPublicKey val_ref;
37292 CHECK(val->arr_len == 33);
37293 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
37294 TxCreationKeys_set_revocation_key(&this_ptr_conv, val_ref);
37297 int8_tArray __attribute__((export_name("TS_TxCreationKeys_get_broadcaster_htlc_key"))) TS_TxCreationKeys_get_broadcaster_htlc_key(uint64_t this_ptr) {
37298 LDKTxCreationKeys this_ptr_conv;
37299 this_ptr_conv.inner = untag_ptr(this_ptr);
37300 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37301 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37302 this_ptr_conv.is_owned = false;
37303 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
37304 memcpy(ret_arr->elems, TxCreationKeys_get_broadcaster_htlc_key(&this_ptr_conv).compressed_form, 33);
37308 void __attribute__((export_name("TS_TxCreationKeys_set_broadcaster_htlc_key"))) TS_TxCreationKeys_set_broadcaster_htlc_key(uint64_t this_ptr, int8_tArray val) {
37309 LDKTxCreationKeys this_ptr_conv;
37310 this_ptr_conv.inner = untag_ptr(this_ptr);
37311 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37312 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37313 this_ptr_conv.is_owned = false;
37314 LDKPublicKey val_ref;
37315 CHECK(val->arr_len == 33);
37316 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
37317 TxCreationKeys_set_broadcaster_htlc_key(&this_ptr_conv, val_ref);
37320 int8_tArray __attribute__((export_name("TS_TxCreationKeys_get_countersignatory_htlc_key"))) TS_TxCreationKeys_get_countersignatory_htlc_key(uint64_t this_ptr) {
37321 LDKTxCreationKeys this_ptr_conv;
37322 this_ptr_conv.inner = untag_ptr(this_ptr);
37323 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37324 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37325 this_ptr_conv.is_owned = false;
37326 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
37327 memcpy(ret_arr->elems, TxCreationKeys_get_countersignatory_htlc_key(&this_ptr_conv).compressed_form, 33);
37331 void __attribute__((export_name("TS_TxCreationKeys_set_countersignatory_htlc_key"))) TS_TxCreationKeys_set_countersignatory_htlc_key(uint64_t this_ptr, int8_tArray val) {
37332 LDKTxCreationKeys this_ptr_conv;
37333 this_ptr_conv.inner = untag_ptr(this_ptr);
37334 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37335 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37336 this_ptr_conv.is_owned = false;
37337 LDKPublicKey val_ref;
37338 CHECK(val->arr_len == 33);
37339 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
37340 TxCreationKeys_set_countersignatory_htlc_key(&this_ptr_conv, val_ref);
37343 int8_tArray __attribute__((export_name("TS_TxCreationKeys_get_broadcaster_delayed_payment_key"))) TS_TxCreationKeys_get_broadcaster_delayed_payment_key(uint64_t this_ptr) {
37344 LDKTxCreationKeys this_ptr_conv;
37345 this_ptr_conv.inner = untag_ptr(this_ptr);
37346 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37347 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37348 this_ptr_conv.is_owned = false;
37349 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
37350 memcpy(ret_arr->elems, TxCreationKeys_get_broadcaster_delayed_payment_key(&this_ptr_conv).compressed_form, 33);
37354 void __attribute__((export_name("TS_TxCreationKeys_set_broadcaster_delayed_payment_key"))) TS_TxCreationKeys_set_broadcaster_delayed_payment_key(uint64_t this_ptr, int8_tArray val) {
37355 LDKTxCreationKeys this_ptr_conv;
37356 this_ptr_conv.inner = untag_ptr(this_ptr);
37357 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37358 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37359 this_ptr_conv.is_owned = false;
37360 LDKPublicKey val_ref;
37361 CHECK(val->arr_len == 33);
37362 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
37363 TxCreationKeys_set_broadcaster_delayed_payment_key(&this_ptr_conv, val_ref);
37366 uint64_t __attribute__((export_name("TS_TxCreationKeys_new"))) TS_TxCreationKeys_new(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) {
37367 LDKPublicKey per_commitment_point_arg_ref;
37368 CHECK(per_commitment_point_arg->arr_len == 33);
37369 memcpy(per_commitment_point_arg_ref.compressed_form, per_commitment_point_arg->elems, 33); FREE(per_commitment_point_arg);
37370 LDKPublicKey revocation_key_arg_ref;
37371 CHECK(revocation_key_arg->arr_len == 33);
37372 memcpy(revocation_key_arg_ref.compressed_form, revocation_key_arg->elems, 33); FREE(revocation_key_arg);
37373 LDKPublicKey broadcaster_htlc_key_arg_ref;
37374 CHECK(broadcaster_htlc_key_arg->arr_len == 33);
37375 memcpy(broadcaster_htlc_key_arg_ref.compressed_form, broadcaster_htlc_key_arg->elems, 33); FREE(broadcaster_htlc_key_arg);
37376 LDKPublicKey countersignatory_htlc_key_arg_ref;
37377 CHECK(countersignatory_htlc_key_arg->arr_len == 33);
37378 memcpy(countersignatory_htlc_key_arg_ref.compressed_form, countersignatory_htlc_key_arg->elems, 33); FREE(countersignatory_htlc_key_arg);
37379 LDKPublicKey broadcaster_delayed_payment_key_arg_ref;
37380 CHECK(broadcaster_delayed_payment_key_arg->arr_len == 33);
37381 memcpy(broadcaster_delayed_payment_key_arg_ref.compressed_form, broadcaster_delayed_payment_key_arg->elems, 33); FREE(broadcaster_delayed_payment_key_arg);
37382 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);
37383 uint64_t ret_ref = 0;
37384 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37385 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37389 jboolean __attribute__((export_name("TS_TxCreationKeys_eq"))) TS_TxCreationKeys_eq(uint64_t a, uint64_t b) {
37390 LDKTxCreationKeys a_conv;
37391 a_conv.inner = untag_ptr(a);
37392 a_conv.is_owned = ptr_is_owned(a);
37393 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
37394 a_conv.is_owned = false;
37395 LDKTxCreationKeys b_conv;
37396 b_conv.inner = untag_ptr(b);
37397 b_conv.is_owned = ptr_is_owned(b);
37398 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
37399 b_conv.is_owned = false;
37400 jboolean ret_conv = TxCreationKeys_eq(&a_conv, &b_conv);
37404 static inline uint64_t TxCreationKeys_clone_ptr(LDKTxCreationKeys *NONNULL_PTR arg) {
37405 LDKTxCreationKeys ret_var = TxCreationKeys_clone(arg);
37406 uint64_t ret_ref = 0;
37407 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37408 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37411 int64_t __attribute__((export_name("TS_TxCreationKeys_clone_ptr"))) TS_TxCreationKeys_clone_ptr(uint64_t arg) {
37412 LDKTxCreationKeys arg_conv;
37413 arg_conv.inner = untag_ptr(arg);
37414 arg_conv.is_owned = ptr_is_owned(arg);
37415 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
37416 arg_conv.is_owned = false;
37417 int64_t ret_conv = TxCreationKeys_clone_ptr(&arg_conv);
37421 uint64_t __attribute__((export_name("TS_TxCreationKeys_clone"))) TS_TxCreationKeys_clone(uint64_t orig) {
37422 LDKTxCreationKeys orig_conv;
37423 orig_conv.inner = untag_ptr(orig);
37424 orig_conv.is_owned = ptr_is_owned(orig);
37425 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
37426 orig_conv.is_owned = false;
37427 LDKTxCreationKeys ret_var = TxCreationKeys_clone(&orig_conv);
37428 uint64_t ret_ref = 0;
37429 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37430 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37434 int8_tArray __attribute__((export_name("TS_TxCreationKeys_write"))) TS_TxCreationKeys_write(uint64_t obj) {
37435 LDKTxCreationKeys obj_conv;
37436 obj_conv.inner = untag_ptr(obj);
37437 obj_conv.is_owned = ptr_is_owned(obj);
37438 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
37439 obj_conv.is_owned = false;
37440 LDKCVec_u8Z ret_var = TxCreationKeys_write(&obj_conv);
37441 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
37442 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
37443 CVec_u8Z_free(ret_var);
37447 uint64_t __attribute__((export_name("TS_TxCreationKeys_read"))) TS_TxCreationKeys_read(int8_tArray ser) {
37448 LDKu8slice ser_ref;
37449 ser_ref.datalen = ser->arr_len;
37450 ser_ref.data = ser->elems;
37451 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
37452 *ret_conv = TxCreationKeys_read(ser_ref);
37454 return tag_ptr(ret_conv, true);
37457 void __attribute__((export_name("TS_ChannelPublicKeys_free"))) TS_ChannelPublicKeys_free(uint64_t this_obj) {
37458 LDKChannelPublicKeys this_obj_conv;
37459 this_obj_conv.inner = untag_ptr(this_obj);
37460 this_obj_conv.is_owned = ptr_is_owned(this_obj);
37461 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
37462 ChannelPublicKeys_free(this_obj_conv);
37465 int8_tArray __attribute__((export_name("TS_ChannelPublicKeys_get_funding_pubkey"))) TS_ChannelPublicKeys_get_funding_pubkey(uint64_t this_ptr) {
37466 LDKChannelPublicKeys this_ptr_conv;
37467 this_ptr_conv.inner = untag_ptr(this_ptr);
37468 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37469 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37470 this_ptr_conv.is_owned = false;
37471 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
37472 memcpy(ret_arr->elems, ChannelPublicKeys_get_funding_pubkey(&this_ptr_conv).compressed_form, 33);
37476 void __attribute__((export_name("TS_ChannelPublicKeys_set_funding_pubkey"))) TS_ChannelPublicKeys_set_funding_pubkey(uint64_t this_ptr, int8_tArray val) {
37477 LDKChannelPublicKeys this_ptr_conv;
37478 this_ptr_conv.inner = untag_ptr(this_ptr);
37479 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37480 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37481 this_ptr_conv.is_owned = false;
37482 LDKPublicKey val_ref;
37483 CHECK(val->arr_len == 33);
37484 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
37485 ChannelPublicKeys_set_funding_pubkey(&this_ptr_conv, val_ref);
37488 int8_tArray __attribute__((export_name("TS_ChannelPublicKeys_get_revocation_basepoint"))) TS_ChannelPublicKeys_get_revocation_basepoint(uint64_t this_ptr) {
37489 LDKChannelPublicKeys this_ptr_conv;
37490 this_ptr_conv.inner = untag_ptr(this_ptr);
37491 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37492 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37493 this_ptr_conv.is_owned = false;
37494 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
37495 memcpy(ret_arr->elems, ChannelPublicKeys_get_revocation_basepoint(&this_ptr_conv).compressed_form, 33);
37499 void __attribute__((export_name("TS_ChannelPublicKeys_set_revocation_basepoint"))) TS_ChannelPublicKeys_set_revocation_basepoint(uint64_t this_ptr, int8_tArray val) {
37500 LDKChannelPublicKeys this_ptr_conv;
37501 this_ptr_conv.inner = untag_ptr(this_ptr);
37502 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37503 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37504 this_ptr_conv.is_owned = false;
37505 LDKPublicKey val_ref;
37506 CHECK(val->arr_len == 33);
37507 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
37508 ChannelPublicKeys_set_revocation_basepoint(&this_ptr_conv, val_ref);
37511 int8_tArray __attribute__((export_name("TS_ChannelPublicKeys_get_payment_point"))) TS_ChannelPublicKeys_get_payment_point(uint64_t this_ptr) {
37512 LDKChannelPublicKeys this_ptr_conv;
37513 this_ptr_conv.inner = untag_ptr(this_ptr);
37514 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37515 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37516 this_ptr_conv.is_owned = false;
37517 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
37518 memcpy(ret_arr->elems, ChannelPublicKeys_get_payment_point(&this_ptr_conv).compressed_form, 33);
37522 void __attribute__((export_name("TS_ChannelPublicKeys_set_payment_point"))) TS_ChannelPublicKeys_set_payment_point(uint64_t this_ptr, int8_tArray val) {
37523 LDKChannelPublicKeys this_ptr_conv;
37524 this_ptr_conv.inner = untag_ptr(this_ptr);
37525 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37526 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37527 this_ptr_conv.is_owned = false;
37528 LDKPublicKey val_ref;
37529 CHECK(val->arr_len == 33);
37530 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
37531 ChannelPublicKeys_set_payment_point(&this_ptr_conv, val_ref);
37534 int8_tArray __attribute__((export_name("TS_ChannelPublicKeys_get_delayed_payment_basepoint"))) TS_ChannelPublicKeys_get_delayed_payment_basepoint(uint64_t this_ptr) {
37535 LDKChannelPublicKeys this_ptr_conv;
37536 this_ptr_conv.inner = untag_ptr(this_ptr);
37537 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37538 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37539 this_ptr_conv.is_owned = false;
37540 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
37541 memcpy(ret_arr->elems, ChannelPublicKeys_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form, 33);
37545 void __attribute__((export_name("TS_ChannelPublicKeys_set_delayed_payment_basepoint"))) TS_ChannelPublicKeys_set_delayed_payment_basepoint(uint64_t this_ptr, int8_tArray val) {
37546 LDKChannelPublicKeys this_ptr_conv;
37547 this_ptr_conv.inner = untag_ptr(this_ptr);
37548 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37549 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37550 this_ptr_conv.is_owned = false;
37551 LDKPublicKey val_ref;
37552 CHECK(val->arr_len == 33);
37553 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
37554 ChannelPublicKeys_set_delayed_payment_basepoint(&this_ptr_conv, val_ref);
37557 int8_tArray __attribute__((export_name("TS_ChannelPublicKeys_get_htlc_basepoint"))) TS_ChannelPublicKeys_get_htlc_basepoint(uint64_t this_ptr) {
37558 LDKChannelPublicKeys this_ptr_conv;
37559 this_ptr_conv.inner = untag_ptr(this_ptr);
37560 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37561 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37562 this_ptr_conv.is_owned = false;
37563 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
37564 memcpy(ret_arr->elems, ChannelPublicKeys_get_htlc_basepoint(&this_ptr_conv).compressed_form, 33);
37568 void __attribute__((export_name("TS_ChannelPublicKeys_set_htlc_basepoint"))) TS_ChannelPublicKeys_set_htlc_basepoint(uint64_t this_ptr, int8_tArray val) {
37569 LDKChannelPublicKeys this_ptr_conv;
37570 this_ptr_conv.inner = untag_ptr(this_ptr);
37571 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37572 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37573 this_ptr_conv.is_owned = false;
37574 LDKPublicKey val_ref;
37575 CHECK(val->arr_len == 33);
37576 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
37577 ChannelPublicKeys_set_htlc_basepoint(&this_ptr_conv, val_ref);
37580 uint64_t __attribute__((export_name("TS_ChannelPublicKeys_new"))) TS_ChannelPublicKeys_new(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) {
37581 LDKPublicKey funding_pubkey_arg_ref;
37582 CHECK(funding_pubkey_arg->arr_len == 33);
37583 memcpy(funding_pubkey_arg_ref.compressed_form, funding_pubkey_arg->elems, 33); FREE(funding_pubkey_arg);
37584 LDKPublicKey revocation_basepoint_arg_ref;
37585 CHECK(revocation_basepoint_arg->arr_len == 33);
37586 memcpy(revocation_basepoint_arg_ref.compressed_form, revocation_basepoint_arg->elems, 33); FREE(revocation_basepoint_arg);
37587 LDKPublicKey payment_point_arg_ref;
37588 CHECK(payment_point_arg->arr_len == 33);
37589 memcpy(payment_point_arg_ref.compressed_form, payment_point_arg->elems, 33); FREE(payment_point_arg);
37590 LDKPublicKey delayed_payment_basepoint_arg_ref;
37591 CHECK(delayed_payment_basepoint_arg->arr_len == 33);
37592 memcpy(delayed_payment_basepoint_arg_ref.compressed_form, delayed_payment_basepoint_arg->elems, 33); FREE(delayed_payment_basepoint_arg);
37593 LDKPublicKey htlc_basepoint_arg_ref;
37594 CHECK(htlc_basepoint_arg->arr_len == 33);
37595 memcpy(htlc_basepoint_arg_ref.compressed_form, htlc_basepoint_arg->elems, 33); FREE(htlc_basepoint_arg);
37596 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);
37597 uint64_t ret_ref = 0;
37598 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37599 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37603 static inline uint64_t ChannelPublicKeys_clone_ptr(LDKChannelPublicKeys *NONNULL_PTR arg) {
37604 LDKChannelPublicKeys ret_var = ChannelPublicKeys_clone(arg);
37605 uint64_t ret_ref = 0;
37606 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37607 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37610 int64_t __attribute__((export_name("TS_ChannelPublicKeys_clone_ptr"))) TS_ChannelPublicKeys_clone_ptr(uint64_t arg) {
37611 LDKChannelPublicKeys arg_conv;
37612 arg_conv.inner = untag_ptr(arg);
37613 arg_conv.is_owned = ptr_is_owned(arg);
37614 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
37615 arg_conv.is_owned = false;
37616 int64_t ret_conv = ChannelPublicKeys_clone_ptr(&arg_conv);
37620 uint64_t __attribute__((export_name("TS_ChannelPublicKeys_clone"))) TS_ChannelPublicKeys_clone(uint64_t orig) {
37621 LDKChannelPublicKeys orig_conv;
37622 orig_conv.inner = untag_ptr(orig);
37623 orig_conv.is_owned = ptr_is_owned(orig);
37624 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
37625 orig_conv.is_owned = false;
37626 LDKChannelPublicKeys ret_var = ChannelPublicKeys_clone(&orig_conv);
37627 uint64_t ret_ref = 0;
37628 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37629 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37633 jboolean __attribute__((export_name("TS_ChannelPublicKeys_eq"))) TS_ChannelPublicKeys_eq(uint64_t a, uint64_t b) {
37634 LDKChannelPublicKeys a_conv;
37635 a_conv.inner = untag_ptr(a);
37636 a_conv.is_owned = ptr_is_owned(a);
37637 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
37638 a_conv.is_owned = false;
37639 LDKChannelPublicKeys b_conv;
37640 b_conv.inner = untag_ptr(b);
37641 b_conv.is_owned = ptr_is_owned(b);
37642 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
37643 b_conv.is_owned = false;
37644 jboolean ret_conv = ChannelPublicKeys_eq(&a_conv, &b_conv);
37648 int8_tArray __attribute__((export_name("TS_ChannelPublicKeys_write"))) TS_ChannelPublicKeys_write(uint64_t obj) {
37649 LDKChannelPublicKeys obj_conv;
37650 obj_conv.inner = untag_ptr(obj);
37651 obj_conv.is_owned = ptr_is_owned(obj);
37652 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
37653 obj_conv.is_owned = false;
37654 LDKCVec_u8Z ret_var = ChannelPublicKeys_write(&obj_conv);
37655 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
37656 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
37657 CVec_u8Z_free(ret_var);
37661 uint64_t __attribute__((export_name("TS_ChannelPublicKeys_read"))) TS_ChannelPublicKeys_read(int8_tArray ser) {
37662 LDKu8slice ser_ref;
37663 ser_ref.datalen = ser->arr_len;
37664 ser_ref.data = ser->elems;
37665 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
37666 *ret_conv = ChannelPublicKeys_read(ser_ref);
37668 return tag_ptr(ret_conv, true);
37671 uint64_t __attribute__((export_name("TS_TxCreationKeys_derive_new"))) TS_TxCreationKeys_derive_new(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) {
37672 LDKPublicKey per_commitment_point_ref;
37673 CHECK(per_commitment_point->arr_len == 33);
37674 memcpy(per_commitment_point_ref.compressed_form, per_commitment_point->elems, 33); FREE(per_commitment_point);
37675 LDKPublicKey broadcaster_delayed_payment_base_ref;
37676 CHECK(broadcaster_delayed_payment_base->arr_len == 33);
37677 memcpy(broadcaster_delayed_payment_base_ref.compressed_form, broadcaster_delayed_payment_base->elems, 33); FREE(broadcaster_delayed_payment_base);
37678 LDKPublicKey broadcaster_htlc_base_ref;
37679 CHECK(broadcaster_htlc_base->arr_len == 33);
37680 memcpy(broadcaster_htlc_base_ref.compressed_form, broadcaster_htlc_base->elems, 33); FREE(broadcaster_htlc_base);
37681 LDKPublicKey countersignatory_revocation_base_ref;
37682 CHECK(countersignatory_revocation_base->arr_len == 33);
37683 memcpy(countersignatory_revocation_base_ref.compressed_form, countersignatory_revocation_base->elems, 33); FREE(countersignatory_revocation_base);
37684 LDKPublicKey countersignatory_htlc_base_ref;
37685 CHECK(countersignatory_htlc_base->arr_len == 33);
37686 memcpy(countersignatory_htlc_base_ref.compressed_form, countersignatory_htlc_base->elems, 33); FREE(countersignatory_htlc_base);
37687 LDKTxCreationKeys ret_var = TxCreationKeys_derive_new(per_commitment_point_ref, broadcaster_delayed_payment_base_ref, broadcaster_htlc_base_ref, countersignatory_revocation_base_ref, countersignatory_htlc_base_ref);
37688 uint64_t ret_ref = 0;
37689 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37690 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37694 uint64_t __attribute__((export_name("TS_TxCreationKeys_from_channel_static_keys"))) TS_TxCreationKeys_from_channel_static_keys(int8_tArray per_commitment_point, uint64_t broadcaster_keys, uint64_t countersignatory_keys) {
37695 LDKPublicKey per_commitment_point_ref;
37696 CHECK(per_commitment_point->arr_len == 33);
37697 memcpy(per_commitment_point_ref.compressed_form, per_commitment_point->elems, 33); FREE(per_commitment_point);
37698 LDKChannelPublicKeys broadcaster_keys_conv;
37699 broadcaster_keys_conv.inner = untag_ptr(broadcaster_keys);
37700 broadcaster_keys_conv.is_owned = ptr_is_owned(broadcaster_keys);
37701 CHECK_INNER_FIELD_ACCESS_OR_NULL(broadcaster_keys_conv);
37702 broadcaster_keys_conv.is_owned = false;
37703 LDKChannelPublicKeys countersignatory_keys_conv;
37704 countersignatory_keys_conv.inner = untag_ptr(countersignatory_keys);
37705 countersignatory_keys_conv.is_owned = ptr_is_owned(countersignatory_keys);
37706 CHECK_INNER_FIELD_ACCESS_OR_NULL(countersignatory_keys_conv);
37707 countersignatory_keys_conv.is_owned = false;
37708 LDKTxCreationKeys ret_var = TxCreationKeys_from_channel_static_keys(per_commitment_point_ref, &broadcaster_keys_conv, &countersignatory_keys_conv);
37709 uint64_t ret_ref = 0;
37710 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37711 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37715 int8_tArray __attribute__((export_name("TS_get_revokeable_redeemscript"))) TS_get_revokeable_redeemscript(int8_tArray revocation_key, int16_t contest_delay, int8_tArray broadcaster_delayed_payment_key) {
37716 LDKPublicKey revocation_key_ref;
37717 CHECK(revocation_key->arr_len == 33);
37718 memcpy(revocation_key_ref.compressed_form, revocation_key->elems, 33); FREE(revocation_key);
37719 LDKPublicKey broadcaster_delayed_payment_key_ref;
37720 CHECK(broadcaster_delayed_payment_key->arr_len == 33);
37721 memcpy(broadcaster_delayed_payment_key_ref.compressed_form, broadcaster_delayed_payment_key->elems, 33); FREE(broadcaster_delayed_payment_key);
37722 LDKCVec_u8Z ret_var = get_revokeable_redeemscript(revocation_key_ref, contest_delay, broadcaster_delayed_payment_key_ref);
37723 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
37724 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
37725 CVec_u8Z_free(ret_var);
37729 void __attribute__((export_name("TS_HTLCOutputInCommitment_free"))) TS_HTLCOutputInCommitment_free(uint64_t this_obj) {
37730 LDKHTLCOutputInCommitment this_obj_conv;
37731 this_obj_conv.inner = untag_ptr(this_obj);
37732 this_obj_conv.is_owned = ptr_is_owned(this_obj);
37733 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
37734 HTLCOutputInCommitment_free(this_obj_conv);
37737 jboolean __attribute__((export_name("TS_HTLCOutputInCommitment_get_offered"))) TS_HTLCOutputInCommitment_get_offered(uint64_t this_ptr) {
37738 LDKHTLCOutputInCommitment this_ptr_conv;
37739 this_ptr_conv.inner = untag_ptr(this_ptr);
37740 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37741 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37742 this_ptr_conv.is_owned = false;
37743 jboolean ret_conv = HTLCOutputInCommitment_get_offered(&this_ptr_conv);
37747 void __attribute__((export_name("TS_HTLCOutputInCommitment_set_offered"))) TS_HTLCOutputInCommitment_set_offered(uint64_t this_ptr, jboolean val) {
37748 LDKHTLCOutputInCommitment this_ptr_conv;
37749 this_ptr_conv.inner = untag_ptr(this_ptr);
37750 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37751 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37752 this_ptr_conv.is_owned = false;
37753 HTLCOutputInCommitment_set_offered(&this_ptr_conv, val);
37756 int64_t __attribute__((export_name("TS_HTLCOutputInCommitment_get_amount_msat"))) TS_HTLCOutputInCommitment_get_amount_msat(uint64_t this_ptr) {
37757 LDKHTLCOutputInCommitment this_ptr_conv;
37758 this_ptr_conv.inner = untag_ptr(this_ptr);
37759 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37760 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37761 this_ptr_conv.is_owned = false;
37762 int64_t ret_conv = HTLCOutputInCommitment_get_amount_msat(&this_ptr_conv);
37766 void __attribute__((export_name("TS_HTLCOutputInCommitment_set_amount_msat"))) TS_HTLCOutputInCommitment_set_amount_msat(uint64_t this_ptr, int64_t val) {
37767 LDKHTLCOutputInCommitment this_ptr_conv;
37768 this_ptr_conv.inner = untag_ptr(this_ptr);
37769 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37770 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37771 this_ptr_conv.is_owned = false;
37772 HTLCOutputInCommitment_set_amount_msat(&this_ptr_conv, val);
37775 int32_t __attribute__((export_name("TS_HTLCOutputInCommitment_get_cltv_expiry"))) TS_HTLCOutputInCommitment_get_cltv_expiry(uint64_t this_ptr) {
37776 LDKHTLCOutputInCommitment this_ptr_conv;
37777 this_ptr_conv.inner = untag_ptr(this_ptr);
37778 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37779 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37780 this_ptr_conv.is_owned = false;
37781 int32_t ret_conv = HTLCOutputInCommitment_get_cltv_expiry(&this_ptr_conv);
37785 void __attribute__((export_name("TS_HTLCOutputInCommitment_set_cltv_expiry"))) TS_HTLCOutputInCommitment_set_cltv_expiry(uint64_t this_ptr, int32_t val) {
37786 LDKHTLCOutputInCommitment this_ptr_conv;
37787 this_ptr_conv.inner = untag_ptr(this_ptr);
37788 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37789 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37790 this_ptr_conv.is_owned = false;
37791 HTLCOutputInCommitment_set_cltv_expiry(&this_ptr_conv, val);
37794 int8_tArray __attribute__((export_name("TS_HTLCOutputInCommitment_get_payment_hash"))) TS_HTLCOutputInCommitment_get_payment_hash(uint64_t this_ptr) {
37795 LDKHTLCOutputInCommitment this_ptr_conv;
37796 this_ptr_conv.inner = untag_ptr(this_ptr);
37797 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37798 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37799 this_ptr_conv.is_owned = false;
37800 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
37801 memcpy(ret_arr->elems, *HTLCOutputInCommitment_get_payment_hash(&this_ptr_conv), 32);
37805 void __attribute__((export_name("TS_HTLCOutputInCommitment_set_payment_hash"))) TS_HTLCOutputInCommitment_set_payment_hash(uint64_t this_ptr, int8_tArray val) {
37806 LDKHTLCOutputInCommitment this_ptr_conv;
37807 this_ptr_conv.inner = untag_ptr(this_ptr);
37808 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37809 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37810 this_ptr_conv.is_owned = false;
37811 LDKThirtyTwoBytes val_ref;
37812 CHECK(val->arr_len == 32);
37813 memcpy(val_ref.data, val->elems, 32); FREE(val);
37814 HTLCOutputInCommitment_set_payment_hash(&this_ptr_conv, val_ref);
37817 uint64_t __attribute__((export_name("TS_HTLCOutputInCommitment_get_transaction_output_index"))) TS_HTLCOutputInCommitment_get_transaction_output_index(uint64_t this_ptr) {
37818 LDKHTLCOutputInCommitment this_ptr_conv;
37819 this_ptr_conv.inner = untag_ptr(this_ptr);
37820 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37821 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37822 this_ptr_conv.is_owned = false;
37823 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
37824 *ret_copy = HTLCOutputInCommitment_get_transaction_output_index(&this_ptr_conv);
37825 uint64_t ret_ref = tag_ptr(ret_copy, true);
37829 void __attribute__((export_name("TS_HTLCOutputInCommitment_set_transaction_output_index"))) TS_HTLCOutputInCommitment_set_transaction_output_index(uint64_t this_ptr, uint64_t val) {
37830 LDKHTLCOutputInCommitment this_ptr_conv;
37831 this_ptr_conv.inner = untag_ptr(this_ptr);
37832 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37833 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37834 this_ptr_conv.is_owned = false;
37835 void* val_ptr = untag_ptr(val);
37836 CHECK_ACCESS(val_ptr);
37837 LDKCOption_u32Z val_conv = *(LDKCOption_u32Z*)(val_ptr);
37838 val_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(val));
37839 HTLCOutputInCommitment_set_transaction_output_index(&this_ptr_conv, val_conv);
37842 uint64_t __attribute__((export_name("TS_HTLCOutputInCommitment_new"))) TS_HTLCOutputInCommitment_new(jboolean offered_arg, int64_t amount_msat_arg, int32_t cltv_expiry_arg, int8_tArray payment_hash_arg, uint64_t transaction_output_index_arg) {
37843 LDKThirtyTwoBytes payment_hash_arg_ref;
37844 CHECK(payment_hash_arg->arr_len == 32);
37845 memcpy(payment_hash_arg_ref.data, payment_hash_arg->elems, 32); FREE(payment_hash_arg);
37846 void* transaction_output_index_arg_ptr = untag_ptr(transaction_output_index_arg);
37847 CHECK_ACCESS(transaction_output_index_arg_ptr);
37848 LDKCOption_u32Z transaction_output_index_arg_conv = *(LDKCOption_u32Z*)(transaction_output_index_arg_ptr);
37849 transaction_output_index_arg_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(transaction_output_index_arg));
37850 LDKHTLCOutputInCommitment ret_var = HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, payment_hash_arg_ref, transaction_output_index_arg_conv);
37851 uint64_t ret_ref = 0;
37852 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37853 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37857 static inline uint64_t HTLCOutputInCommitment_clone_ptr(LDKHTLCOutputInCommitment *NONNULL_PTR arg) {
37858 LDKHTLCOutputInCommitment ret_var = HTLCOutputInCommitment_clone(arg);
37859 uint64_t ret_ref = 0;
37860 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37861 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37864 int64_t __attribute__((export_name("TS_HTLCOutputInCommitment_clone_ptr"))) TS_HTLCOutputInCommitment_clone_ptr(uint64_t arg) {
37865 LDKHTLCOutputInCommitment arg_conv;
37866 arg_conv.inner = untag_ptr(arg);
37867 arg_conv.is_owned = ptr_is_owned(arg);
37868 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
37869 arg_conv.is_owned = false;
37870 int64_t ret_conv = HTLCOutputInCommitment_clone_ptr(&arg_conv);
37874 uint64_t __attribute__((export_name("TS_HTLCOutputInCommitment_clone"))) TS_HTLCOutputInCommitment_clone(uint64_t orig) {
37875 LDKHTLCOutputInCommitment orig_conv;
37876 orig_conv.inner = untag_ptr(orig);
37877 orig_conv.is_owned = ptr_is_owned(orig);
37878 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
37879 orig_conv.is_owned = false;
37880 LDKHTLCOutputInCommitment ret_var = HTLCOutputInCommitment_clone(&orig_conv);
37881 uint64_t ret_ref = 0;
37882 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37883 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37887 jboolean __attribute__((export_name("TS_HTLCOutputInCommitment_eq"))) TS_HTLCOutputInCommitment_eq(uint64_t a, uint64_t b) {
37888 LDKHTLCOutputInCommitment a_conv;
37889 a_conv.inner = untag_ptr(a);
37890 a_conv.is_owned = ptr_is_owned(a);
37891 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
37892 a_conv.is_owned = false;
37893 LDKHTLCOutputInCommitment b_conv;
37894 b_conv.inner = untag_ptr(b);
37895 b_conv.is_owned = ptr_is_owned(b);
37896 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
37897 b_conv.is_owned = false;
37898 jboolean ret_conv = HTLCOutputInCommitment_eq(&a_conv, &b_conv);
37902 int8_tArray __attribute__((export_name("TS_HTLCOutputInCommitment_write"))) TS_HTLCOutputInCommitment_write(uint64_t obj) {
37903 LDKHTLCOutputInCommitment obj_conv;
37904 obj_conv.inner = untag_ptr(obj);
37905 obj_conv.is_owned = ptr_is_owned(obj);
37906 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
37907 obj_conv.is_owned = false;
37908 LDKCVec_u8Z ret_var = HTLCOutputInCommitment_write(&obj_conv);
37909 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
37910 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
37911 CVec_u8Z_free(ret_var);
37915 uint64_t __attribute__((export_name("TS_HTLCOutputInCommitment_read"))) TS_HTLCOutputInCommitment_read(int8_tArray ser) {
37916 LDKu8slice ser_ref;
37917 ser_ref.datalen = ser->arr_len;
37918 ser_ref.data = ser->elems;
37919 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
37920 *ret_conv = HTLCOutputInCommitment_read(ser_ref);
37922 return tag_ptr(ret_conv, true);
37925 int8_tArray __attribute__((export_name("TS_get_htlc_redeemscript"))) TS_get_htlc_redeemscript(uint64_t htlc, jboolean opt_anchors, uint64_t keys) {
37926 LDKHTLCOutputInCommitment htlc_conv;
37927 htlc_conv.inner = untag_ptr(htlc);
37928 htlc_conv.is_owned = ptr_is_owned(htlc);
37929 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
37930 htlc_conv.is_owned = false;
37931 LDKTxCreationKeys keys_conv;
37932 keys_conv.inner = untag_ptr(keys);
37933 keys_conv.is_owned = ptr_is_owned(keys);
37934 CHECK_INNER_FIELD_ACCESS_OR_NULL(keys_conv);
37935 keys_conv.is_owned = false;
37936 LDKCVec_u8Z ret_var = get_htlc_redeemscript(&htlc_conv, opt_anchors, &keys_conv);
37937 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
37938 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
37939 CVec_u8Z_free(ret_var);
37943 int8_tArray __attribute__((export_name("TS_make_funding_redeemscript"))) TS_make_funding_redeemscript(int8_tArray broadcaster, int8_tArray countersignatory) {
37944 LDKPublicKey broadcaster_ref;
37945 CHECK(broadcaster->arr_len == 33);
37946 memcpy(broadcaster_ref.compressed_form, broadcaster->elems, 33); FREE(broadcaster);
37947 LDKPublicKey countersignatory_ref;
37948 CHECK(countersignatory->arr_len == 33);
37949 memcpy(countersignatory_ref.compressed_form, countersignatory->elems, 33); FREE(countersignatory);
37950 LDKCVec_u8Z ret_var = make_funding_redeemscript(broadcaster_ref, countersignatory_ref);
37951 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
37952 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
37953 CVec_u8Z_free(ret_var);
37957 int8_tArray __attribute__((export_name("TS_build_htlc_transaction"))) TS_build_htlc_transaction(int8_tArray commitment_txid, int32_t feerate_per_kw, int16_t contest_delay, uint64_t htlc, jboolean opt_anchors, jboolean use_non_zero_fee_anchors, int8_tArray broadcaster_delayed_payment_key, int8_tArray revocation_key) {
37958 unsigned char commitment_txid_arr[32];
37959 CHECK(commitment_txid->arr_len == 32);
37960 memcpy(commitment_txid_arr, commitment_txid->elems, 32); FREE(commitment_txid);
37961 unsigned char (*commitment_txid_ref)[32] = &commitment_txid_arr;
37962 LDKHTLCOutputInCommitment htlc_conv;
37963 htlc_conv.inner = untag_ptr(htlc);
37964 htlc_conv.is_owned = ptr_is_owned(htlc);
37965 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
37966 htlc_conv.is_owned = false;
37967 LDKPublicKey broadcaster_delayed_payment_key_ref;
37968 CHECK(broadcaster_delayed_payment_key->arr_len == 33);
37969 memcpy(broadcaster_delayed_payment_key_ref.compressed_form, broadcaster_delayed_payment_key->elems, 33); FREE(broadcaster_delayed_payment_key);
37970 LDKPublicKey revocation_key_ref;
37971 CHECK(revocation_key->arr_len == 33);
37972 memcpy(revocation_key_ref.compressed_form, revocation_key->elems, 33); FREE(revocation_key);
37973 LDKTransaction ret_var = build_htlc_transaction(commitment_txid_ref, feerate_per_kw, contest_delay, &htlc_conv, opt_anchors, use_non_zero_fee_anchors, broadcaster_delayed_payment_key_ref, revocation_key_ref);
37974 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
37975 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
37976 Transaction_free(ret_var);
37980 int8_tArray __attribute__((export_name("TS_build_htlc_input_witness"))) TS_build_htlc_input_witness(int8_tArray local_sig, int8_tArray remote_sig, int8_tArray preimage, int8_tArray redeem_script, jboolean opt_anchors) {
37981 LDKSignature local_sig_ref;
37982 CHECK(local_sig->arr_len == 64);
37983 memcpy(local_sig_ref.compact_form, local_sig->elems, 64); FREE(local_sig);
37984 LDKSignature remote_sig_ref;
37985 CHECK(remote_sig->arr_len == 64);
37986 memcpy(remote_sig_ref.compact_form, remote_sig->elems, 64); FREE(remote_sig);
37987 LDKThirtyTwoBytes preimage_ref;
37988 CHECK(preimage->arr_len == 32);
37989 memcpy(preimage_ref.data, preimage->elems, 32); FREE(preimage);
37990 LDKu8slice redeem_script_ref;
37991 redeem_script_ref.datalen = redeem_script->arr_len;
37992 redeem_script_ref.data = redeem_script->elems;
37993 LDKWitness ret_var = build_htlc_input_witness(local_sig_ref, remote_sig_ref, preimage_ref, redeem_script_ref, opt_anchors);
37994 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
37995 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
37996 Witness_free(ret_var);
37997 FREE(redeem_script);
38001 int8_tArray __attribute__((export_name("TS_get_to_countersignatory_with_anchors_redeemscript"))) TS_get_to_countersignatory_with_anchors_redeemscript(int8_tArray payment_point) {
38002 LDKPublicKey payment_point_ref;
38003 CHECK(payment_point->arr_len == 33);
38004 memcpy(payment_point_ref.compressed_form, payment_point->elems, 33); FREE(payment_point);
38005 LDKCVec_u8Z ret_var = get_to_countersignatory_with_anchors_redeemscript(payment_point_ref);
38006 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38007 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38008 CVec_u8Z_free(ret_var);
38012 int8_tArray __attribute__((export_name("TS_get_anchor_redeemscript"))) TS_get_anchor_redeemscript(int8_tArray funding_pubkey) {
38013 LDKPublicKey funding_pubkey_ref;
38014 CHECK(funding_pubkey->arr_len == 33);
38015 memcpy(funding_pubkey_ref.compressed_form, funding_pubkey->elems, 33); FREE(funding_pubkey);
38016 LDKCVec_u8Z ret_var = get_anchor_redeemscript(funding_pubkey_ref);
38017 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38018 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38019 CVec_u8Z_free(ret_var);
38023 int8_tArray __attribute__((export_name("TS_build_anchor_input_witness"))) TS_build_anchor_input_witness(int8_tArray funding_key, int8_tArray funding_sig) {
38024 LDKPublicKey funding_key_ref;
38025 CHECK(funding_key->arr_len == 33);
38026 memcpy(funding_key_ref.compressed_form, funding_key->elems, 33); FREE(funding_key);
38027 LDKSignature funding_sig_ref;
38028 CHECK(funding_sig->arr_len == 64);
38029 memcpy(funding_sig_ref.compact_form, funding_sig->elems, 64); FREE(funding_sig);
38030 LDKWitness ret_var = build_anchor_input_witness(funding_key_ref, funding_sig_ref);
38031 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38032 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38033 Witness_free(ret_var);
38037 void __attribute__((export_name("TS_ChannelTransactionParameters_free"))) TS_ChannelTransactionParameters_free(uint64_t this_obj) {
38038 LDKChannelTransactionParameters this_obj_conv;
38039 this_obj_conv.inner = untag_ptr(this_obj);
38040 this_obj_conv.is_owned = ptr_is_owned(this_obj);
38041 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
38042 ChannelTransactionParameters_free(this_obj_conv);
38045 uint64_t __attribute__((export_name("TS_ChannelTransactionParameters_get_holder_pubkeys"))) TS_ChannelTransactionParameters_get_holder_pubkeys(uint64_t this_ptr) {
38046 LDKChannelTransactionParameters this_ptr_conv;
38047 this_ptr_conv.inner = untag_ptr(this_ptr);
38048 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38049 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38050 this_ptr_conv.is_owned = false;
38051 LDKChannelPublicKeys ret_var = ChannelTransactionParameters_get_holder_pubkeys(&this_ptr_conv);
38052 uint64_t ret_ref = 0;
38053 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38054 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38058 void __attribute__((export_name("TS_ChannelTransactionParameters_set_holder_pubkeys"))) TS_ChannelTransactionParameters_set_holder_pubkeys(uint64_t this_ptr, uint64_t val) {
38059 LDKChannelTransactionParameters this_ptr_conv;
38060 this_ptr_conv.inner = untag_ptr(this_ptr);
38061 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38062 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38063 this_ptr_conv.is_owned = false;
38064 LDKChannelPublicKeys val_conv;
38065 val_conv.inner = untag_ptr(val);
38066 val_conv.is_owned = ptr_is_owned(val);
38067 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
38068 val_conv = ChannelPublicKeys_clone(&val_conv);
38069 ChannelTransactionParameters_set_holder_pubkeys(&this_ptr_conv, val_conv);
38072 int16_t __attribute__((export_name("TS_ChannelTransactionParameters_get_holder_selected_contest_delay"))) TS_ChannelTransactionParameters_get_holder_selected_contest_delay(uint64_t this_ptr) {
38073 LDKChannelTransactionParameters this_ptr_conv;
38074 this_ptr_conv.inner = untag_ptr(this_ptr);
38075 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38076 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38077 this_ptr_conv.is_owned = false;
38078 int16_t ret_conv = ChannelTransactionParameters_get_holder_selected_contest_delay(&this_ptr_conv);
38082 void __attribute__((export_name("TS_ChannelTransactionParameters_set_holder_selected_contest_delay"))) TS_ChannelTransactionParameters_set_holder_selected_contest_delay(uint64_t this_ptr, int16_t val) {
38083 LDKChannelTransactionParameters this_ptr_conv;
38084 this_ptr_conv.inner = untag_ptr(this_ptr);
38085 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38086 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38087 this_ptr_conv.is_owned = false;
38088 ChannelTransactionParameters_set_holder_selected_contest_delay(&this_ptr_conv, val);
38091 jboolean __attribute__((export_name("TS_ChannelTransactionParameters_get_is_outbound_from_holder"))) TS_ChannelTransactionParameters_get_is_outbound_from_holder(uint64_t this_ptr) {
38092 LDKChannelTransactionParameters this_ptr_conv;
38093 this_ptr_conv.inner = untag_ptr(this_ptr);
38094 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38095 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38096 this_ptr_conv.is_owned = false;
38097 jboolean ret_conv = ChannelTransactionParameters_get_is_outbound_from_holder(&this_ptr_conv);
38101 void __attribute__((export_name("TS_ChannelTransactionParameters_set_is_outbound_from_holder"))) TS_ChannelTransactionParameters_set_is_outbound_from_holder(uint64_t this_ptr, jboolean val) {
38102 LDKChannelTransactionParameters this_ptr_conv;
38103 this_ptr_conv.inner = untag_ptr(this_ptr);
38104 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38105 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38106 this_ptr_conv.is_owned = false;
38107 ChannelTransactionParameters_set_is_outbound_from_holder(&this_ptr_conv, val);
38110 uint64_t __attribute__((export_name("TS_ChannelTransactionParameters_get_counterparty_parameters"))) TS_ChannelTransactionParameters_get_counterparty_parameters(uint64_t this_ptr) {
38111 LDKChannelTransactionParameters this_ptr_conv;
38112 this_ptr_conv.inner = untag_ptr(this_ptr);
38113 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38114 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38115 this_ptr_conv.is_owned = false;
38116 LDKCounterpartyChannelTransactionParameters ret_var = ChannelTransactionParameters_get_counterparty_parameters(&this_ptr_conv);
38117 uint64_t ret_ref = 0;
38118 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38119 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38123 void __attribute__((export_name("TS_ChannelTransactionParameters_set_counterparty_parameters"))) TS_ChannelTransactionParameters_set_counterparty_parameters(uint64_t this_ptr, uint64_t val) {
38124 LDKChannelTransactionParameters this_ptr_conv;
38125 this_ptr_conv.inner = untag_ptr(this_ptr);
38126 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38127 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38128 this_ptr_conv.is_owned = false;
38129 LDKCounterpartyChannelTransactionParameters val_conv;
38130 val_conv.inner = untag_ptr(val);
38131 val_conv.is_owned = ptr_is_owned(val);
38132 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
38133 val_conv = CounterpartyChannelTransactionParameters_clone(&val_conv);
38134 ChannelTransactionParameters_set_counterparty_parameters(&this_ptr_conv, val_conv);
38137 uint64_t __attribute__((export_name("TS_ChannelTransactionParameters_get_funding_outpoint"))) TS_ChannelTransactionParameters_get_funding_outpoint(uint64_t this_ptr) {
38138 LDKChannelTransactionParameters this_ptr_conv;
38139 this_ptr_conv.inner = untag_ptr(this_ptr);
38140 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38141 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38142 this_ptr_conv.is_owned = false;
38143 LDKOutPoint ret_var = ChannelTransactionParameters_get_funding_outpoint(&this_ptr_conv);
38144 uint64_t ret_ref = 0;
38145 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38146 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38150 void __attribute__((export_name("TS_ChannelTransactionParameters_set_funding_outpoint"))) TS_ChannelTransactionParameters_set_funding_outpoint(uint64_t this_ptr, uint64_t val) {
38151 LDKChannelTransactionParameters this_ptr_conv;
38152 this_ptr_conv.inner = untag_ptr(this_ptr);
38153 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38154 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38155 this_ptr_conv.is_owned = false;
38156 LDKOutPoint val_conv;
38157 val_conv.inner = untag_ptr(val);
38158 val_conv.is_owned = ptr_is_owned(val);
38159 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
38160 val_conv = OutPoint_clone(&val_conv);
38161 ChannelTransactionParameters_set_funding_outpoint(&this_ptr_conv, val_conv);
38164 uint32_t __attribute__((export_name("TS_ChannelTransactionParameters_get_opt_anchors"))) TS_ChannelTransactionParameters_get_opt_anchors(uint64_t this_ptr) {
38165 LDKChannelTransactionParameters this_ptr_conv;
38166 this_ptr_conv.inner = untag_ptr(this_ptr);
38167 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38168 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38169 this_ptr_conv.is_owned = false;
38170 uint32_t ret_conv = LDKCOption_NoneZ_to_js(ChannelTransactionParameters_get_opt_anchors(&this_ptr_conv));
38174 void __attribute__((export_name("TS_ChannelTransactionParameters_set_opt_anchors"))) TS_ChannelTransactionParameters_set_opt_anchors(uint64_t this_ptr, uint32_t val) {
38175 LDKChannelTransactionParameters this_ptr_conv;
38176 this_ptr_conv.inner = untag_ptr(this_ptr);
38177 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38178 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38179 this_ptr_conv.is_owned = false;
38180 LDKCOption_NoneZ val_conv = LDKCOption_NoneZ_from_js(val);
38181 ChannelTransactionParameters_set_opt_anchors(&this_ptr_conv, val_conv);
38184 uint32_t __attribute__((export_name("TS_ChannelTransactionParameters_get_opt_non_zero_fee_anchors"))) TS_ChannelTransactionParameters_get_opt_non_zero_fee_anchors(uint64_t this_ptr) {
38185 LDKChannelTransactionParameters this_ptr_conv;
38186 this_ptr_conv.inner = untag_ptr(this_ptr);
38187 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38188 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38189 this_ptr_conv.is_owned = false;
38190 uint32_t ret_conv = LDKCOption_NoneZ_to_js(ChannelTransactionParameters_get_opt_non_zero_fee_anchors(&this_ptr_conv));
38194 void __attribute__((export_name("TS_ChannelTransactionParameters_set_opt_non_zero_fee_anchors"))) TS_ChannelTransactionParameters_set_opt_non_zero_fee_anchors(uint64_t this_ptr, uint32_t val) {
38195 LDKChannelTransactionParameters this_ptr_conv;
38196 this_ptr_conv.inner = untag_ptr(this_ptr);
38197 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38198 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38199 this_ptr_conv.is_owned = false;
38200 LDKCOption_NoneZ val_conv = LDKCOption_NoneZ_from_js(val);
38201 ChannelTransactionParameters_set_opt_non_zero_fee_anchors(&this_ptr_conv, val_conv);
38204 uint64_t __attribute__((export_name("TS_ChannelTransactionParameters_new"))) TS_ChannelTransactionParameters_new(uint64_t holder_pubkeys_arg, int16_t holder_selected_contest_delay_arg, jboolean is_outbound_from_holder_arg, uint64_t counterparty_parameters_arg, uint64_t funding_outpoint_arg, uint32_t opt_anchors_arg, uint32_t opt_non_zero_fee_anchors_arg) {
38205 LDKChannelPublicKeys holder_pubkeys_arg_conv;
38206 holder_pubkeys_arg_conv.inner = untag_ptr(holder_pubkeys_arg);
38207 holder_pubkeys_arg_conv.is_owned = ptr_is_owned(holder_pubkeys_arg);
38208 CHECK_INNER_FIELD_ACCESS_OR_NULL(holder_pubkeys_arg_conv);
38209 holder_pubkeys_arg_conv = ChannelPublicKeys_clone(&holder_pubkeys_arg_conv);
38210 LDKCounterpartyChannelTransactionParameters counterparty_parameters_arg_conv;
38211 counterparty_parameters_arg_conv.inner = untag_ptr(counterparty_parameters_arg);
38212 counterparty_parameters_arg_conv.is_owned = ptr_is_owned(counterparty_parameters_arg);
38213 CHECK_INNER_FIELD_ACCESS_OR_NULL(counterparty_parameters_arg_conv);
38214 counterparty_parameters_arg_conv = CounterpartyChannelTransactionParameters_clone(&counterparty_parameters_arg_conv);
38215 LDKOutPoint funding_outpoint_arg_conv;
38216 funding_outpoint_arg_conv.inner = untag_ptr(funding_outpoint_arg);
38217 funding_outpoint_arg_conv.is_owned = ptr_is_owned(funding_outpoint_arg);
38218 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_arg_conv);
38219 funding_outpoint_arg_conv = OutPoint_clone(&funding_outpoint_arg_conv);
38220 LDKCOption_NoneZ opt_anchors_arg_conv = LDKCOption_NoneZ_from_js(opt_anchors_arg);
38221 LDKCOption_NoneZ opt_non_zero_fee_anchors_arg_conv = LDKCOption_NoneZ_from_js(opt_non_zero_fee_anchors_arg);
38222 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, opt_anchors_arg_conv, opt_non_zero_fee_anchors_arg_conv);
38223 uint64_t ret_ref = 0;
38224 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38225 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38229 static inline uint64_t ChannelTransactionParameters_clone_ptr(LDKChannelTransactionParameters *NONNULL_PTR arg) {
38230 LDKChannelTransactionParameters ret_var = ChannelTransactionParameters_clone(arg);
38231 uint64_t ret_ref = 0;
38232 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38233 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38236 int64_t __attribute__((export_name("TS_ChannelTransactionParameters_clone_ptr"))) TS_ChannelTransactionParameters_clone_ptr(uint64_t arg) {
38237 LDKChannelTransactionParameters arg_conv;
38238 arg_conv.inner = untag_ptr(arg);
38239 arg_conv.is_owned = ptr_is_owned(arg);
38240 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
38241 arg_conv.is_owned = false;
38242 int64_t ret_conv = ChannelTransactionParameters_clone_ptr(&arg_conv);
38246 uint64_t __attribute__((export_name("TS_ChannelTransactionParameters_clone"))) TS_ChannelTransactionParameters_clone(uint64_t orig) {
38247 LDKChannelTransactionParameters orig_conv;
38248 orig_conv.inner = untag_ptr(orig);
38249 orig_conv.is_owned = ptr_is_owned(orig);
38250 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
38251 orig_conv.is_owned = false;
38252 LDKChannelTransactionParameters ret_var = ChannelTransactionParameters_clone(&orig_conv);
38253 uint64_t ret_ref = 0;
38254 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38255 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38259 void __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_free"))) TS_CounterpartyChannelTransactionParameters_free(uint64_t this_obj) {
38260 LDKCounterpartyChannelTransactionParameters this_obj_conv;
38261 this_obj_conv.inner = untag_ptr(this_obj);
38262 this_obj_conv.is_owned = ptr_is_owned(this_obj);
38263 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
38264 CounterpartyChannelTransactionParameters_free(this_obj_conv);
38267 uint64_t __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_get_pubkeys"))) TS_CounterpartyChannelTransactionParameters_get_pubkeys(uint64_t this_ptr) {
38268 LDKCounterpartyChannelTransactionParameters this_ptr_conv;
38269 this_ptr_conv.inner = untag_ptr(this_ptr);
38270 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38271 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38272 this_ptr_conv.is_owned = false;
38273 LDKChannelPublicKeys ret_var = CounterpartyChannelTransactionParameters_get_pubkeys(&this_ptr_conv);
38274 uint64_t ret_ref = 0;
38275 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38276 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38280 void __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_set_pubkeys"))) TS_CounterpartyChannelTransactionParameters_set_pubkeys(uint64_t this_ptr, uint64_t val) {
38281 LDKCounterpartyChannelTransactionParameters this_ptr_conv;
38282 this_ptr_conv.inner = untag_ptr(this_ptr);
38283 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38284 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38285 this_ptr_conv.is_owned = false;
38286 LDKChannelPublicKeys val_conv;
38287 val_conv.inner = untag_ptr(val);
38288 val_conv.is_owned = ptr_is_owned(val);
38289 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
38290 val_conv = ChannelPublicKeys_clone(&val_conv);
38291 CounterpartyChannelTransactionParameters_set_pubkeys(&this_ptr_conv, val_conv);
38294 int16_t __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_get_selected_contest_delay"))) TS_CounterpartyChannelTransactionParameters_get_selected_contest_delay(uint64_t this_ptr) {
38295 LDKCounterpartyChannelTransactionParameters this_ptr_conv;
38296 this_ptr_conv.inner = untag_ptr(this_ptr);
38297 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38298 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38299 this_ptr_conv.is_owned = false;
38300 int16_t ret_conv = CounterpartyChannelTransactionParameters_get_selected_contest_delay(&this_ptr_conv);
38304 void __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_set_selected_contest_delay"))) TS_CounterpartyChannelTransactionParameters_set_selected_contest_delay(uint64_t this_ptr, int16_t val) {
38305 LDKCounterpartyChannelTransactionParameters this_ptr_conv;
38306 this_ptr_conv.inner = untag_ptr(this_ptr);
38307 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38308 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38309 this_ptr_conv.is_owned = false;
38310 CounterpartyChannelTransactionParameters_set_selected_contest_delay(&this_ptr_conv, val);
38313 uint64_t __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_new"))) TS_CounterpartyChannelTransactionParameters_new(uint64_t pubkeys_arg, int16_t selected_contest_delay_arg) {
38314 LDKChannelPublicKeys pubkeys_arg_conv;
38315 pubkeys_arg_conv.inner = untag_ptr(pubkeys_arg);
38316 pubkeys_arg_conv.is_owned = ptr_is_owned(pubkeys_arg);
38317 CHECK_INNER_FIELD_ACCESS_OR_NULL(pubkeys_arg_conv);
38318 pubkeys_arg_conv = ChannelPublicKeys_clone(&pubkeys_arg_conv);
38319 LDKCounterpartyChannelTransactionParameters ret_var = CounterpartyChannelTransactionParameters_new(pubkeys_arg_conv, selected_contest_delay_arg);
38320 uint64_t ret_ref = 0;
38321 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38322 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38326 static inline uint64_t CounterpartyChannelTransactionParameters_clone_ptr(LDKCounterpartyChannelTransactionParameters *NONNULL_PTR arg) {
38327 LDKCounterpartyChannelTransactionParameters ret_var = CounterpartyChannelTransactionParameters_clone(arg);
38328 uint64_t ret_ref = 0;
38329 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38330 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38333 int64_t __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_clone_ptr"))) TS_CounterpartyChannelTransactionParameters_clone_ptr(uint64_t arg) {
38334 LDKCounterpartyChannelTransactionParameters arg_conv;
38335 arg_conv.inner = untag_ptr(arg);
38336 arg_conv.is_owned = ptr_is_owned(arg);
38337 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
38338 arg_conv.is_owned = false;
38339 int64_t ret_conv = CounterpartyChannelTransactionParameters_clone_ptr(&arg_conv);
38343 uint64_t __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_clone"))) TS_CounterpartyChannelTransactionParameters_clone(uint64_t orig) {
38344 LDKCounterpartyChannelTransactionParameters orig_conv;
38345 orig_conv.inner = untag_ptr(orig);
38346 orig_conv.is_owned = ptr_is_owned(orig);
38347 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
38348 orig_conv.is_owned = false;
38349 LDKCounterpartyChannelTransactionParameters ret_var = CounterpartyChannelTransactionParameters_clone(&orig_conv);
38350 uint64_t ret_ref = 0;
38351 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38352 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38356 jboolean __attribute__((export_name("TS_ChannelTransactionParameters_is_populated"))) TS_ChannelTransactionParameters_is_populated(uint64_t this_arg) {
38357 LDKChannelTransactionParameters this_arg_conv;
38358 this_arg_conv.inner = untag_ptr(this_arg);
38359 this_arg_conv.is_owned = ptr_is_owned(this_arg);
38360 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38361 this_arg_conv.is_owned = false;
38362 jboolean ret_conv = ChannelTransactionParameters_is_populated(&this_arg_conv);
38366 uint64_t __attribute__((export_name("TS_ChannelTransactionParameters_as_holder_broadcastable"))) TS_ChannelTransactionParameters_as_holder_broadcastable(uint64_t this_arg) {
38367 LDKChannelTransactionParameters this_arg_conv;
38368 this_arg_conv.inner = untag_ptr(this_arg);
38369 this_arg_conv.is_owned = ptr_is_owned(this_arg);
38370 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38371 this_arg_conv.is_owned = false;
38372 LDKDirectedChannelTransactionParameters ret_var = ChannelTransactionParameters_as_holder_broadcastable(&this_arg_conv);
38373 uint64_t ret_ref = 0;
38374 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38375 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38379 uint64_t __attribute__((export_name("TS_ChannelTransactionParameters_as_counterparty_broadcastable"))) TS_ChannelTransactionParameters_as_counterparty_broadcastable(uint64_t this_arg) {
38380 LDKChannelTransactionParameters this_arg_conv;
38381 this_arg_conv.inner = untag_ptr(this_arg);
38382 this_arg_conv.is_owned = ptr_is_owned(this_arg);
38383 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38384 this_arg_conv.is_owned = false;
38385 LDKDirectedChannelTransactionParameters ret_var = ChannelTransactionParameters_as_counterparty_broadcastable(&this_arg_conv);
38386 uint64_t ret_ref = 0;
38387 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38388 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38392 int8_tArray __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_write"))) TS_CounterpartyChannelTransactionParameters_write(uint64_t obj) {
38393 LDKCounterpartyChannelTransactionParameters obj_conv;
38394 obj_conv.inner = untag_ptr(obj);
38395 obj_conv.is_owned = ptr_is_owned(obj);
38396 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
38397 obj_conv.is_owned = false;
38398 LDKCVec_u8Z ret_var = CounterpartyChannelTransactionParameters_write(&obj_conv);
38399 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38400 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38401 CVec_u8Z_free(ret_var);
38405 uint64_t __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_read"))) TS_CounterpartyChannelTransactionParameters_read(int8_tArray ser) {
38406 LDKu8slice ser_ref;
38407 ser_ref.datalen = ser->arr_len;
38408 ser_ref.data = ser->elems;
38409 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
38410 *ret_conv = CounterpartyChannelTransactionParameters_read(ser_ref);
38412 return tag_ptr(ret_conv, true);
38415 int8_tArray __attribute__((export_name("TS_ChannelTransactionParameters_write"))) TS_ChannelTransactionParameters_write(uint64_t obj) {
38416 LDKChannelTransactionParameters obj_conv;
38417 obj_conv.inner = untag_ptr(obj);
38418 obj_conv.is_owned = ptr_is_owned(obj);
38419 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
38420 obj_conv.is_owned = false;
38421 LDKCVec_u8Z ret_var = ChannelTransactionParameters_write(&obj_conv);
38422 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38423 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38424 CVec_u8Z_free(ret_var);
38428 uint64_t __attribute__((export_name("TS_ChannelTransactionParameters_read"))) TS_ChannelTransactionParameters_read(int8_tArray ser) {
38429 LDKu8slice ser_ref;
38430 ser_ref.datalen = ser->arr_len;
38431 ser_ref.data = ser->elems;
38432 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
38433 *ret_conv = ChannelTransactionParameters_read(ser_ref);
38435 return tag_ptr(ret_conv, true);
38438 void __attribute__((export_name("TS_DirectedChannelTransactionParameters_free"))) TS_DirectedChannelTransactionParameters_free(uint64_t this_obj) {
38439 LDKDirectedChannelTransactionParameters this_obj_conv;
38440 this_obj_conv.inner = untag_ptr(this_obj);
38441 this_obj_conv.is_owned = ptr_is_owned(this_obj);
38442 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
38443 DirectedChannelTransactionParameters_free(this_obj_conv);
38446 uint64_t __attribute__((export_name("TS_DirectedChannelTransactionParameters_broadcaster_pubkeys"))) TS_DirectedChannelTransactionParameters_broadcaster_pubkeys(uint64_t this_arg) {
38447 LDKDirectedChannelTransactionParameters this_arg_conv;
38448 this_arg_conv.inner = untag_ptr(this_arg);
38449 this_arg_conv.is_owned = ptr_is_owned(this_arg);
38450 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38451 this_arg_conv.is_owned = false;
38452 LDKChannelPublicKeys ret_var = DirectedChannelTransactionParameters_broadcaster_pubkeys(&this_arg_conv);
38453 uint64_t ret_ref = 0;
38454 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38455 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38459 uint64_t __attribute__((export_name("TS_DirectedChannelTransactionParameters_countersignatory_pubkeys"))) TS_DirectedChannelTransactionParameters_countersignatory_pubkeys(uint64_t this_arg) {
38460 LDKDirectedChannelTransactionParameters this_arg_conv;
38461 this_arg_conv.inner = untag_ptr(this_arg);
38462 this_arg_conv.is_owned = ptr_is_owned(this_arg);
38463 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38464 this_arg_conv.is_owned = false;
38465 LDKChannelPublicKeys ret_var = DirectedChannelTransactionParameters_countersignatory_pubkeys(&this_arg_conv);
38466 uint64_t ret_ref = 0;
38467 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38468 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38472 int16_t __attribute__((export_name("TS_DirectedChannelTransactionParameters_contest_delay"))) TS_DirectedChannelTransactionParameters_contest_delay(uint64_t this_arg) {
38473 LDKDirectedChannelTransactionParameters this_arg_conv;
38474 this_arg_conv.inner = untag_ptr(this_arg);
38475 this_arg_conv.is_owned = ptr_is_owned(this_arg);
38476 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38477 this_arg_conv.is_owned = false;
38478 int16_t ret_conv = DirectedChannelTransactionParameters_contest_delay(&this_arg_conv);
38482 jboolean __attribute__((export_name("TS_DirectedChannelTransactionParameters_is_outbound"))) TS_DirectedChannelTransactionParameters_is_outbound(uint64_t this_arg) {
38483 LDKDirectedChannelTransactionParameters this_arg_conv;
38484 this_arg_conv.inner = untag_ptr(this_arg);
38485 this_arg_conv.is_owned = ptr_is_owned(this_arg);
38486 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38487 this_arg_conv.is_owned = false;
38488 jboolean ret_conv = DirectedChannelTransactionParameters_is_outbound(&this_arg_conv);
38492 uint64_t __attribute__((export_name("TS_DirectedChannelTransactionParameters_funding_outpoint"))) TS_DirectedChannelTransactionParameters_funding_outpoint(uint64_t this_arg) {
38493 LDKDirectedChannelTransactionParameters this_arg_conv;
38494 this_arg_conv.inner = untag_ptr(this_arg);
38495 this_arg_conv.is_owned = ptr_is_owned(this_arg);
38496 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38497 this_arg_conv.is_owned = false;
38498 LDKOutPoint ret_var = DirectedChannelTransactionParameters_funding_outpoint(&this_arg_conv);
38499 uint64_t ret_ref = 0;
38500 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38501 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38505 jboolean __attribute__((export_name("TS_DirectedChannelTransactionParameters_opt_anchors"))) TS_DirectedChannelTransactionParameters_opt_anchors(uint64_t this_arg) {
38506 LDKDirectedChannelTransactionParameters this_arg_conv;
38507 this_arg_conv.inner = untag_ptr(this_arg);
38508 this_arg_conv.is_owned = ptr_is_owned(this_arg);
38509 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38510 this_arg_conv.is_owned = false;
38511 jboolean ret_conv = DirectedChannelTransactionParameters_opt_anchors(&this_arg_conv);
38515 void __attribute__((export_name("TS_HolderCommitmentTransaction_free"))) TS_HolderCommitmentTransaction_free(uint64_t this_obj) {
38516 LDKHolderCommitmentTransaction this_obj_conv;
38517 this_obj_conv.inner = untag_ptr(this_obj);
38518 this_obj_conv.is_owned = ptr_is_owned(this_obj);
38519 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
38520 HolderCommitmentTransaction_free(this_obj_conv);
38523 int8_tArray __attribute__((export_name("TS_HolderCommitmentTransaction_get_counterparty_sig"))) TS_HolderCommitmentTransaction_get_counterparty_sig(uint64_t this_ptr) {
38524 LDKHolderCommitmentTransaction this_ptr_conv;
38525 this_ptr_conv.inner = untag_ptr(this_ptr);
38526 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38527 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38528 this_ptr_conv.is_owned = false;
38529 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
38530 memcpy(ret_arr->elems, HolderCommitmentTransaction_get_counterparty_sig(&this_ptr_conv).compact_form, 64);
38534 void __attribute__((export_name("TS_HolderCommitmentTransaction_set_counterparty_sig"))) TS_HolderCommitmentTransaction_set_counterparty_sig(uint64_t this_ptr, int8_tArray val) {
38535 LDKHolderCommitmentTransaction this_ptr_conv;
38536 this_ptr_conv.inner = untag_ptr(this_ptr);
38537 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38538 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38539 this_ptr_conv.is_owned = false;
38540 LDKSignature val_ref;
38541 CHECK(val->arr_len == 64);
38542 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
38543 HolderCommitmentTransaction_set_counterparty_sig(&this_ptr_conv, val_ref);
38546 ptrArray __attribute__((export_name("TS_HolderCommitmentTransaction_get_counterparty_htlc_sigs"))) TS_HolderCommitmentTransaction_get_counterparty_htlc_sigs(uint64_t this_ptr) {
38547 LDKHolderCommitmentTransaction this_ptr_conv;
38548 this_ptr_conv.inner = untag_ptr(this_ptr);
38549 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38550 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38551 this_ptr_conv.is_owned = false;
38552 LDKCVec_SignatureZ ret_var = HolderCommitmentTransaction_get_counterparty_htlc_sigs(&this_ptr_conv);
38553 ptrArray ret_arr = NULL;
38554 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
38555 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 8);
38556 for (size_t m = 0; m < ret_var.datalen; m++) {
38557 int8_tArray ret_conv_12_arr = init_int8_tArray(64, __LINE__);
38558 memcpy(ret_conv_12_arr->elems, ret_var.data[m].compact_form, 64);
38559 ret_arr_ptr[m] = ret_conv_12_arr;
38562 FREE(ret_var.data);
38566 void __attribute__((export_name("TS_HolderCommitmentTransaction_set_counterparty_htlc_sigs"))) TS_HolderCommitmentTransaction_set_counterparty_htlc_sigs(uint64_t this_ptr, ptrArray val) {
38567 LDKHolderCommitmentTransaction this_ptr_conv;
38568 this_ptr_conv.inner = untag_ptr(this_ptr);
38569 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38570 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38571 this_ptr_conv.is_owned = false;
38572 LDKCVec_SignatureZ val_constr;
38573 val_constr.datalen = val->arr_len;
38574 if (val_constr.datalen > 0)
38575 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
38577 val_constr.data = NULL;
38578 int8_tArray* val_vals = (void*) val->elems;
38579 for (size_t m = 0; m < val_constr.datalen; m++) {
38580 int8_tArray val_conv_12 = val_vals[m];
38581 LDKSignature val_conv_12_ref;
38582 CHECK(val_conv_12->arr_len == 64);
38583 memcpy(val_conv_12_ref.compact_form, val_conv_12->elems, 64); FREE(val_conv_12);
38584 val_constr.data[m] = val_conv_12_ref;
38587 HolderCommitmentTransaction_set_counterparty_htlc_sigs(&this_ptr_conv, val_constr);
38590 static inline uint64_t HolderCommitmentTransaction_clone_ptr(LDKHolderCommitmentTransaction *NONNULL_PTR arg) {
38591 LDKHolderCommitmentTransaction ret_var = HolderCommitmentTransaction_clone(arg);
38592 uint64_t ret_ref = 0;
38593 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38594 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38597 int64_t __attribute__((export_name("TS_HolderCommitmentTransaction_clone_ptr"))) TS_HolderCommitmentTransaction_clone_ptr(uint64_t arg) {
38598 LDKHolderCommitmentTransaction arg_conv;
38599 arg_conv.inner = untag_ptr(arg);
38600 arg_conv.is_owned = ptr_is_owned(arg);
38601 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
38602 arg_conv.is_owned = false;
38603 int64_t ret_conv = HolderCommitmentTransaction_clone_ptr(&arg_conv);
38607 uint64_t __attribute__((export_name("TS_HolderCommitmentTransaction_clone"))) TS_HolderCommitmentTransaction_clone(uint64_t orig) {
38608 LDKHolderCommitmentTransaction orig_conv;
38609 orig_conv.inner = untag_ptr(orig);
38610 orig_conv.is_owned = ptr_is_owned(orig);
38611 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
38612 orig_conv.is_owned = false;
38613 LDKHolderCommitmentTransaction ret_var = HolderCommitmentTransaction_clone(&orig_conv);
38614 uint64_t ret_ref = 0;
38615 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38616 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38620 int8_tArray __attribute__((export_name("TS_HolderCommitmentTransaction_write"))) TS_HolderCommitmentTransaction_write(uint64_t obj) {
38621 LDKHolderCommitmentTransaction obj_conv;
38622 obj_conv.inner = untag_ptr(obj);
38623 obj_conv.is_owned = ptr_is_owned(obj);
38624 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
38625 obj_conv.is_owned = false;
38626 LDKCVec_u8Z ret_var = HolderCommitmentTransaction_write(&obj_conv);
38627 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38628 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38629 CVec_u8Z_free(ret_var);
38633 uint64_t __attribute__((export_name("TS_HolderCommitmentTransaction_read"))) TS_HolderCommitmentTransaction_read(int8_tArray ser) {
38634 LDKu8slice ser_ref;
38635 ser_ref.datalen = ser->arr_len;
38636 ser_ref.data = ser->elems;
38637 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
38638 *ret_conv = HolderCommitmentTransaction_read(ser_ref);
38640 return tag_ptr(ret_conv, true);
38643 uint64_t __attribute__((export_name("TS_HolderCommitmentTransaction_new"))) TS_HolderCommitmentTransaction_new(uint64_t commitment_tx, int8_tArray counterparty_sig, ptrArray counterparty_htlc_sigs, int8_tArray holder_funding_key, int8_tArray counterparty_funding_key) {
38644 LDKCommitmentTransaction commitment_tx_conv;
38645 commitment_tx_conv.inner = untag_ptr(commitment_tx);
38646 commitment_tx_conv.is_owned = ptr_is_owned(commitment_tx);
38647 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_conv);
38648 commitment_tx_conv = CommitmentTransaction_clone(&commitment_tx_conv);
38649 LDKSignature counterparty_sig_ref;
38650 CHECK(counterparty_sig->arr_len == 64);
38651 memcpy(counterparty_sig_ref.compact_form, counterparty_sig->elems, 64); FREE(counterparty_sig);
38652 LDKCVec_SignatureZ counterparty_htlc_sigs_constr;
38653 counterparty_htlc_sigs_constr.datalen = counterparty_htlc_sigs->arr_len;
38654 if (counterparty_htlc_sigs_constr.datalen > 0)
38655 counterparty_htlc_sigs_constr.data = MALLOC(counterparty_htlc_sigs_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
38657 counterparty_htlc_sigs_constr.data = NULL;
38658 int8_tArray* counterparty_htlc_sigs_vals = (void*) counterparty_htlc_sigs->elems;
38659 for (size_t m = 0; m < counterparty_htlc_sigs_constr.datalen; m++) {
38660 int8_tArray counterparty_htlc_sigs_conv_12 = counterparty_htlc_sigs_vals[m];
38661 LDKSignature counterparty_htlc_sigs_conv_12_ref;
38662 CHECK(counterparty_htlc_sigs_conv_12->arr_len == 64);
38663 memcpy(counterparty_htlc_sigs_conv_12_ref.compact_form, counterparty_htlc_sigs_conv_12->elems, 64); FREE(counterparty_htlc_sigs_conv_12);
38664 counterparty_htlc_sigs_constr.data[m] = counterparty_htlc_sigs_conv_12_ref;
38666 FREE(counterparty_htlc_sigs);
38667 LDKPublicKey holder_funding_key_ref;
38668 CHECK(holder_funding_key->arr_len == 33);
38669 memcpy(holder_funding_key_ref.compressed_form, holder_funding_key->elems, 33); FREE(holder_funding_key);
38670 LDKPublicKey counterparty_funding_key_ref;
38671 CHECK(counterparty_funding_key->arr_len == 33);
38672 memcpy(counterparty_funding_key_ref.compressed_form, counterparty_funding_key->elems, 33); FREE(counterparty_funding_key);
38673 LDKHolderCommitmentTransaction ret_var = HolderCommitmentTransaction_new(commitment_tx_conv, counterparty_sig_ref, counterparty_htlc_sigs_constr, holder_funding_key_ref, counterparty_funding_key_ref);
38674 uint64_t ret_ref = 0;
38675 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38676 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38680 void __attribute__((export_name("TS_BuiltCommitmentTransaction_free"))) TS_BuiltCommitmentTransaction_free(uint64_t this_obj) {
38681 LDKBuiltCommitmentTransaction this_obj_conv;
38682 this_obj_conv.inner = untag_ptr(this_obj);
38683 this_obj_conv.is_owned = ptr_is_owned(this_obj);
38684 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
38685 BuiltCommitmentTransaction_free(this_obj_conv);
38688 int8_tArray __attribute__((export_name("TS_BuiltCommitmentTransaction_get_transaction"))) TS_BuiltCommitmentTransaction_get_transaction(uint64_t this_ptr) {
38689 LDKBuiltCommitmentTransaction this_ptr_conv;
38690 this_ptr_conv.inner = untag_ptr(this_ptr);
38691 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38692 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38693 this_ptr_conv.is_owned = false;
38694 LDKTransaction ret_var = BuiltCommitmentTransaction_get_transaction(&this_ptr_conv);
38695 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38696 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38697 Transaction_free(ret_var);
38701 void __attribute__((export_name("TS_BuiltCommitmentTransaction_set_transaction"))) TS_BuiltCommitmentTransaction_set_transaction(uint64_t this_ptr, int8_tArray val) {
38702 LDKBuiltCommitmentTransaction this_ptr_conv;
38703 this_ptr_conv.inner = untag_ptr(this_ptr);
38704 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38705 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38706 this_ptr_conv.is_owned = false;
38707 LDKTransaction val_ref;
38708 val_ref.datalen = val->arr_len;
38709 val_ref.data = MALLOC(val_ref.datalen, "LDKTransaction Bytes");
38710 memcpy(val_ref.data, val->elems, val_ref.datalen); FREE(val);
38711 val_ref.data_is_owned = true;
38712 BuiltCommitmentTransaction_set_transaction(&this_ptr_conv, val_ref);
38715 int8_tArray __attribute__((export_name("TS_BuiltCommitmentTransaction_get_txid"))) TS_BuiltCommitmentTransaction_get_txid(uint64_t this_ptr) {
38716 LDKBuiltCommitmentTransaction this_ptr_conv;
38717 this_ptr_conv.inner = untag_ptr(this_ptr);
38718 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38719 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38720 this_ptr_conv.is_owned = false;
38721 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
38722 memcpy(ret_arr->elems, *BuiltCommitmentTransaction_get_txid(&this_ptr_conv), 32);
38726 void __attribute__((export_name("TS_BuiltCommitmentTransaction_set_txid"))) TS_BuiltCommitmentTransaction_set_txid(uint64_t this_ptr, int8_tArray val) {
38727 LDKBuiltCommitmentTransaction this_ptr_conv;
38728 this_ptr_conv.inner = untag_ptr(this_ptr);
38729 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38730 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38731 this_ptr_conv.is_owned = false;
38732 LDKThirtyTwoBytes val_ref;
38733 CHECK(val->arr_len == 32);
38734 memcpy(val_ref.data, val->elems, 32); FREE(val);
38735 BuiltCommitmentTransaction_set_txid(&this_ptr_conv, val_ref);
38738 uint64_t __attribute__((export_name("TS_BuiltCommitmentTransaction_new"))) TS_BuiltCommitmentTransaction_new(int8_tArray transaction_arg, int8_tArray txid_arg) {
38739 LDKTransaction transaction_arg_ref;
38740 transaction_arg_ref.datalen = transaction_arg->arr_len;
38741 transaction_arg_ref.data = MALLOC(transaction_arg_ref.datalen, "LDKTransaction Bytes");
38742 memcpy(transaction_arg_ref.data, transaction_arg->elems, transaction_arg_ref.datalen); FREE(transaction_arg);
38743 transaction_arg_ref.data_is_owned = true;
38744 LDKThirtyTwoBytes txid_arg_ref;
38745 CHECK(txid_arg->arr_len == 32);
38746 memcpy(txid_arg_ref.data, txid_arg->elems, 32); FREE(txid_arg);
38747 LDKBuiltCommitmentTransaction ret_var = BuiltCommitmentTransaction_new(transaction_arg_ref, txid_arg_ref);
38748 uint64_t ret_ref = 0;
38749 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38750 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38754 static inline uint64_t BuiltCommitmentTransaction_clone_ptr(LDKBuiltCommitmentTransaction *NONNULL_PTR arg) {
38755 LDKBuiltCommitmentTransaction ret_var = BuiltCommitmentTransaction_clone(arg);
38756 uint64_t ret_ref = 0;
38757 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38758 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38761 int64_t __attribute__((export_name("TS_BuiltCommitmentTransaction_clone_ptr"))) TS_BuiltCommitmentTransaction_clone_ptr(uint64_t arg) {
38762 LDKBuiltCommitmentTransaction arg_conv;
38763 arg_conv.inner = untag_ptr(arg);
38764 arg_conv.is_owned = ptr_is_owned(arg);
38765 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
38766 arg_conv.is_owned = false;
38767 int64_t ret_conv = BuiltCommitmentTransaction_clone_ptr(&arg_conv);
38771 uint64_t __attribute__((export_name("TS_BuiltCommitmentTransaction_clone"))) TS_BuiltCommitmentTransaction_clone(uint64_t orig) {
38772 LDKBuiltCommitmentTransaction orig_conv;
38773 orig_conv.inner = untag_ptr(orig);
38774 orig_conv.is_owned = ptr_is_owned(orig);
38775 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
38776 orig_conv.is_owned = false;
38777 LDKBuiltCommitmentTransaction ret_var = BuiltCommitmentTransaction_clone(&orig_conv);
38778 uint64_t ret_ref = 0;
38779 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38780 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38784 int8_tArray __attribute__((export_name("TS_BuiltCommitmentTransaction_write"))) TS_BuiltCommitmentTransaction_write(uint64_t obj) {
38785 LDKBuiltCommitmentTransaction obj_conv;
38786 obj_conv.inner = untag_ptr(obj);
38787 obj_conv.is_owned = ptr_is_owned(obj);
38788 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
38789 obj_conv.is_owned = false;
38790 LDKCVec_u8Z ret_var = BuiltCommitmentTransaction_write(&obj_conv);
38791 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38792 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38793 CVec_u8Z_free(ret_var);
38797 uint64_t __attribute__((export_name("TS_BuiltCommitmentTransaction_read"))) TS_BuiltCommitmentTransaction_read(int8_tArray ser) {
38798 LDKu8slice ser_ref;
38799 ser_ref.datalen = ser->arr_len;
38800 ser_ref.data = ser->elems;
38801 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
38802 *ret_conv = BuiltCommitmentTransaction_read(ser_ref);
38804 return tag_ptr(ret_conv, true);
38807 int8_tArray __attribute__((export_name("TS_BuiltCommitmentTransaction_get_sighash_all"))) TS_BuiltCommitmentTransaction_get_sighash_all(uint64_t this_arg, int8_tArray funding_redeemscript, int64_t channel_value_satoshis) {
38808 LDKBuiltCommitmentTransaction this_arg_conv;
38809 this_arg_conv.inner = untag_ptr(this_arg);
38810 this_arg_conv.is_owned = ptr_is_owned(this_arg);
38811 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38812 this_arg_conv.is_owned = false;
38813 LDKu8slice funding_redeemscript_ref;
38814 funding_redeemscript_ref.datalen = funding_redeemscript->arr_len;
38815 funding_redeemscript_ref.data = funding_redeemscript->elems;
38816 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
38817 memcpy(ret_arr->elems, BuiltCommitmentTransaction_get_sighash_all(&this_arg_conv, funding_redeemscript_ref, channel_value_satoshis).data, 32);
38818 FREE(funding_redeemscript);
38822 int8_tArray __attribute__((export_name("TS_BuiltCommitmentTransaction_sign"))) TS_BuiltCommitmentTransaction_sign(uint64_t this_arg, int8_tArray funding_key, int8_tArray funding_redeemscript, int64_t channel_value_satoshis) {
38823 LDKBuiltCommitmentTransaction this_arg_conv;
38824 this_arg_conv.inner = untag_ptr(this_arg);
38825 this_arg_conv.is_owned = ptr_is_owned(this_arg);
38826 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38827 this_arg_conv.is_owned = false;
38828 unsigned char funding_key_arr[32];
38829 CHECK(funding_key->arr_len == 32);
38830 memcpy(funding_key_arr, funding_key->elems, 32); FREE(funding_key);
38831 unsigned char (*funding_key_ref)[32] = &funding_key_arr;
38832 LDKu8slice funding_redeemscript_ref;
38833 funding_redeemscript_ref.datalen = funding_redeemscript->arr_len;
38834 funding_redeemscript_ref.data = funding_redeemscript->elems;
38835 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
38836 memcpy(ret_arr->elems, BuiltCommitmentTransaction_sign(&this_arg_conv, funding_key_ref, funding_redeemscript_ref, channel_value_satoshis).compact_form, 64);
38837 FREE(funding_redeemscript);
38841 void __attribute__((export_name("TS_ClosingTransaction_free"))) TS_ClosingTransaction_free(uint64_t this_obj) {
38842 LDKClosingTransaction this_obj_conv;
38843 this_obj_conv.inner = untag_ptr(this_obj);
38844 this_obj_conv.is_owned = ptr_is_owned(this_obj);
38845 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
38846 ClosingTransaction_free(this_obj_conv);
38849 static inline uint64_t ClosingTransaction_clone_ptr(LDKClosingTransaction *NONNULL_PTR arg) {
38850 LDKClosingTransaction ret_var = ClosingTransaction_clone(arg);
38851 uint64_t ret_ref = 0;
38852 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38853 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38856 int64_t __attribute__((export_name("TS_ClosingTransaction_clone_ptr"))) TS_ClosingTransaction_clone_ptr(uint64_t arg) {
38857 LDKClosingTransaction arg_conv;
38858 arg_conv.inner = untag_ptr(arg);
38859 arg_conv.is_owned = ptr_is_owned(arg);
38860 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
38861 arg_conv.is_owned = false;
38862 int64_t ret_conv = ClosingTransaction_clone_ptr(&arg_conv);
38866 uint64_t __attribute__((export_name("TS_ClosingTransaction_clone"))) TS_ClosingTransaction_clone(uint64_t orig) {
38867 LDKClosingTransaction orig_conv;
38868 orig_conv.inner = untag_ptr(orig);
38869 orig_conv.is_owned = ptr_is_owned(orig);
38870 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
38871 orig_conv.is_owned = false;
38872 LDKClosingTransaction ret_var = ClosingTransaction_clone(&orig_conv);
38873 uint64_t ret_ref = 0;
38874 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38875 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38879 int64_t __attribute__((export_name("TS_ClosingTransaction_hash"))) TS_ClosingTransaction_hash(uint64_t o) {
38880 LDKClosingTransaction o_conv;
38881 o_conv.inner = untag_ptr(o);
38882 o_conv.is_owned = ptr_is_owned(o);
38883 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
38884 o_conv.is_owned = false;
38885 int64_t ret_conv = ClosingTransaction_hash(&o_conv);
38889 jboolean __attribute__((export_name("TS_ClosingTransaction_eq"))) TS_ClosingTransaction_eq(uint64_t a, uint64_t b) {
38890 LDKClosingTransaction a_conv;
38891 a_conv.inner = untag_ptr(a);
38892 a_conv.is_owned = ptr_is_owned(a);
38893 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
38894 a_conv.is_owned = false;
38895 LDKClosingTransaction b_conv;
38896 b_conv.inner = untag_ptr(b);
38897 b_conv.is_owned = ptr_is_owned(b);
38898 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
38899 b_conv.is_owned = false;
38900 jboolean ret_conv = ClosingTransaction_eq(&a_conv, &b_conv);
38904 uint64_t __attribute__((export_name("TS_ClosingTransaction_new"))) TS_ClosingTransaction_new(int64_t to_holder_value_sat, int64_t to_counterparty_value_sat, int8_tArray to_holder_script, int8_tArray to_counterparty_script, uint64_t funding_outpoint) {
38905 LDKCVec_u8Z to_holder_script_ref;
38906 to_holder_script_ref.datalen = to_holder_script->arr_len;
38907 to_holder_script_ref.data = MALLOC(to_holder_script_ref.datalen, "LDKCVec_u8Z Bytes");
38908 memcpy(to_holder_script_ref.data, to_holder_script->elems, to_holder_script_ref.datalen); FREE(to_holder_script);
38909 LDKCVec_u8Z to_counterparty_script_ref;
38910 to_counterparty_script_ref.datalen = to_counterparty_script->arr_len;
38911 to_counterparty_script_ref.data = MALLOC(to_counterparty_script_ref.datalen, "LDKCVec_u8Z Bytes");
38912 memcpy(to_counterparty_script_ref.data, to_counterparty_script->elems, to_counterparty_script_ref.datalen); FREE(to_counterparty_script);
38913 LDKOutPoint funding_outpoint_conv;
38914 funding_outpoint_conv.inner = untag_ptr(funding_outpoint);
38915 funding_outpoint_conv.is_owned = ptr_is_owned(funding_outpoint);
38916 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_conv);
38917 funding_outpoint_conv = OutPoint_clone(&funding_outpoint_conv);
38918 LDKClosingTransaction ret_var = ClosingTransaction_new(to_holder_value_sat, to_counterparty_value_sat, to_holder_script_ref, to_counterparty_script_ref, funding_outpoint_conv);
38919 uint64_t ret_ref = 0;
38920 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38921 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38925 uint64_t __attribute__((export_name("TS_ClosingTransaction_trust"))) TS_ClosingTransaction_trust(uint64_t this_arg) {
38926 LDKClosingTransaction this_arg_conv;
38927 this_arg_conv.inner = untag_ptr(this_arg);
38928 this_arg_conv.is_owned = ptr_is_owned(this_arg);
38929 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38930 this_arg_conv.is_owned = false;
38931 LDKTrustedClosingTransaction ret_var = ClosingTransaction_trust(&this_arg_conv);
38932 uint64_t ret_ref = 0;
38933 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38934 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38938 uint64_t __attribute__((export_name("TS_ClosingTransaction_verify"))) TS_ClosingTransaction_verify(uint64_t this_arg, uint64_t funding_outpoint) {
38939 LDKClosingTransaction this_arg_conv;
38940 this_arg_conv.inner = untag_ptr(this_arg);
38941 this_arg_conv.is_owned = ptr_is_owned(this_arg);
38942 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38943 this_arg_conv.is_owned = false;
38944 LDKOutPoint funding_outpoint_conv;
38945 funding_outpoint_conv.inner = untag_ptr(funding_outpoint);
38946 funding_outpoint_conv.is_owned = ptr_is_owned(funding_outpoint);
38947 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_conv);
38948 funding_outpoint_conv = OutPoint_clone(&funding_outpoint_conv);
38949 LDKCResult_TrustedClosingTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedClosingTransactionNoneZ), "LDKCResult_TrustedClosingTransactionNoneZ");
38950 *ret_conv = ClosingTransaction_verify(&this_arg_conv, funding_outpoint_conv);
38951 return tag_ptr(ret_conv, true);
38954 int64_t __attribute__((export_name("TS_ClosingTransaction_to_holder_value_sat"))) TS_ClosingTransaction_to_holder_value_sat(uint64_t this_arg) {
38955 LDKClosingTransaction this_arg_conv;
38956 this_arg_conv.inner = untag_ptr(this_arg);
38957 this_arg_conv.is_owned = ptr_is_owned(this_arg);
38958 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38959 this_arg_conv.is_owned = false;
38960 int64_t ret_conv = ClosingTransaction_to_holder_value_sat(&this_arg_conv);
38964 int64_t __attribute__((export_name("TS_ClosingTransaction_to_counterparty_value_sat"))) TS_ClosingTransaction_to_counterparty_value_sat(uint64_t this_arg) {
38965 LDKClosingTransaction this_arg_conv;
38966 this_arg_conv.inner = untag_ptr(this_arg);
38967 this_arg_conv.is_owned = ptr_is_owned(this_arg);
38968 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38969 this_arg_conv.is_owned = false;
38970 int64_t ret_conv = ClosingTransaction_to_counterparty_value_sat(&this_arg_conv);
38974 int8_tArray __attribute__((export_name("TS_ClosingTransaction_to_holder_script"))) TS_ClosingTransaction_to_holder_script(uint64_t this_arg) {
38975 LDKClosingTransaction this_arg_conv;
38976 this_arg_conv.inner = untag_ptr(this_arg);
38977 this_arg_conv.is_owned = ptr_is_owned(this_arg);
38978 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38979 this_arg_conv.is_owned = false;
38980 LDKu8slice ret_var = ClosingTransaction_to_holder_script(&this_arg_conv);
38981 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38982 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38986 int8_tArray __attribute__((export_name("TS_ClosingTransaction_to_counterparty_script"))) TS_ClosingTransaction_to_counterparty_script(uint64_t this_arg) {
38987 LDKClosingTransaction this_arg_conv;
38988 this_arg_conv.inner = untag_ptr(this_arg);
38989 this_arg_conv.is_owned = ptr_is_owned(this_arg);
38990 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38991 this_arg_conv.is_owned = false;
38992 LDKu8slice ret_var = ClosingTransaction_to_counterparty_script(&this_arg_conv);
38993 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38994 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38998 void __attribute__((export_name("TS_TrustedClosingTransaction_free"))) TS_TrustedClosingTransaction_free(uint64_t this_obj) {
38999 LDKTrustedClosingTransaction this_obj_conv;
39000 this_obj_conv.inner = untag_ptr(this_obj);
39001 this_obj_conv.is_owned = ptr_is_owned(this_obj);
39002 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39003 TrustedClosingTransaction_free(this_obj_conv);
39006 int8_tArray __attribute__((export_name("TS_TrustedClosingTransaction_built_transaction"))) TS_TrustedClosingTransaction_built_transaction(uint64_t this_arg) {
39007 LDKTrustedClosingTransaction this_arg_conv;
39008 this_arg_conv.inner = untag_ptr(this_arg);
39009 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39010 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39011 this_arg_conv.is_owned = false;
39012 LDKTransaction ret_var = TrustedClosingTransaction_built_transaction(&this_arg_conv);
39013 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39014 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39015 Transaction_free(ret_var);
39019 int8_tArray __attribute__((export_name("TS_TrustedClosingTransaction_get_sighash_all"))) TS_TrustedClosingTransaction_get_sighash_all(uint64_t this_arg, int8_tArray funding_redeemscript, int64_t channel_value_satoshis) {
39020 LDKTrustedClosingTransaction this_arg_conv;
39021 this_arg_conv.inner = untag_ptr(this_arg);
39022 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39023 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39024 this_arg_conv.is_owned = false;
39025 LDKu8slice funding_redeemscript_ref;
39026 funding_redeemscript_ref.datalen = funding_redeemscript->arr_len;
39027 funding_redeemscript_ref.data = funding_redeemscript->elems;
39028 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
39029 memcpy(ret_arr->elems, TrustedClosingTransaction_get_sighash_all(&this_arg_conv, funding_redeemscript_ref, channel_value_satoshis).data, 32);
39030 FREE(funding_redeemscript);
39034 int8_tArray __attribute__((export_name("TS_TrustedClosingTransaction_sign"))) TS_TrustedClosingTransaction_sign(uint64_t this_arg, int8_tArray funding_key, int8_tArray funding_redeemscript, int64_t channel_value_satoshis) {
39035 LDKTrustedClosingTransaction this_arg_conv;
39036 this_arg_conv.inner = untag_ptr(this_arg);
39037 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39038 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39039 this_arg_conv.is_owned = false;
39040 unsigned char funding_key_arr[32];
39041 CHECK(funding_key->arr_len == 32);
39042 memcpy(funding_key_arr, funding_key->elems, 32); FREE(funding_key);
39043 unsigned char (*funding_key_ref)[32] = &funding_key_arr;
39044 LDKu8slice funding_redeemscript_ref;
39045 funding_redeemscript_ref.datalen = funding_redeemscript->arr_len;
39046 funding_redeemscript_ref.data = funding_redeemscript->elems;
39047 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
39048 memcpy(ret_arr->elems, TrustedClosingTransaction_sign(&this_arg_conv, funding_key_ref, funding_redeemscript_ref, channel_value_satoshis).compact_form, 64);
39049 FREE(funding_redeemscript);
39053 void __attribute__((export_name("TS_CommitmentTransaction_free"))) TS_CommitmentTransaction_free(uint64_t this_obj) {
39054 LDKCommitmentTransaction this_obj_conv;
39055 this_obj_conv.inner = untag_ptr(this_obj);
39056 this_obj_conv.is_owned = ptr_is_owned(this_obj);
39057 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39058 CommitmentTransaction_free(this_obj_conv);
39061 static inline uint64_t CommitmentTransaction_clone_ptr(LDKCommitmentTransaction *NONNULL_PTR arg) {
39062 LDKCommitmentTransaction ret_var = CommitmentTransaction_clone(arg);
39063 uint64_t ret_ref = 0;
39064 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39065 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39068 int64_t __attribute__((export_name("TS_CommitmentTransaction_clone_ptr"))) TS_CommitmentTransaction_clone_ptr(uint64_t arg) {
39069 LDKCommitmentTransaction arg_conv;
39070 arg_conv.inner = untag_ptr(arg);
39071 arg_conv.is_owned = ptr_is_owned(arg);
39072 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
39073 arg_conv.is_owned = false;
39074 int64_t ret_conv = CommitmentTransaction_clone_ptr(&arg_conv);
39078 uint64_t __attribute__((export_name("TS_CommitmentTransaction_clone"))) TS_CommitmentTransaction_clone(uint64_t orig) {
39079 LDKCommitmentTransaction orig_conv;
39080 orig_conv.inner = untag_ptr(orig);
39081 orig_conv.is_owned = ptr_is_owned(orig);
39082 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
39083 orig_conv.is_owned = false;
39084 LDKCommitmentTransaction ret_var = CommitmentTransaction_clone(&orig_conv);
39085 uint64_t ret_ref = 0;
39086 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39087 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39091 int8_tArray __attribute__((export_name("TS_CommitmentTransaction_write"))) TS_CommitmentTransaction_write(uint64_t obj) {
39092 LDKCommitmentTransaction obj_conv;
39093 obj_conv.inner = untag_ptr(obj);
39094 obj_conv.is_owned = ptr_is_owned(obj);
39095 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
39096 obj_conv.is_owned = false;
39097 LDKCVec_u8Z ret_var = CommitmentTransaction_write(&obj_conv);
39098 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39099 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39100 CVec_u8Z_free(ret_var);
39104 uint64_t __attribute__((export_name("TS_CommitmentTransaction_read"))) TS_CommitmentTransaction_read(int8_tArray ser) {
39105 LDKu8slice ser_ref;
39106 ser_ref.datalen = ser->arr_len;
39107 ser_ref.data = ser->elems;
39108 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
39109 *ret_conv = CommitmentTransaction_read(ser_ref);
39111 return tag_ptr(ret_conv, true);
39114 int64_t __attribute__((export_name("TS_CommitmentTransaction_commitment_number"))) TS_CommitmentTransaction_commitment_number(uint64_t this_arg) {
39115 LDKCommitmentTransaction this_arg_conv;
39116 this_arg_conv.inner = untag_ptr(this_arg);
39117 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39118 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39119 this_arg_conv.is_owned = false;
39120 int64_t ret_conv = CommitmentTransaction_commitment_number(&this_arg_conv);
39124 int64_t __attribute__((export_name("TS_CommitmentTransaction_to_broadcaster_value_sat"))) TS_CommitmentTransaction_to_broadcaster_value_sat(uint64_t this_arg) {
39125 LDKCommitmentTransaction this_arg_conv;
39126 this_arg_conv.inner = untag_ptr(this_arg);
39127 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39128 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39129 this_arg_conv.is_owned = false;
39130 int64_t ret_conv = CommitmentTransaction_to_broadcaster_value_sat(&this_arg_conv);
39134 int64_t __attribute__((export_name("TS_CommitmentTransaction_to_countersignatory_value_sat"))) TS_CommitmentTransaction_to_countersignatory_value_sat(uint64_t this_arg) {
39135 LDKCommitmentTransaction this_arg_conv;
39136 this_arg_conv.inner = untag_ptr(this_arg);
39137 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39138 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39139 this_arg_conv.is_owned = false;
39140 int64_t ret_conv = CommitmentTransaction_to_countersignatory_value_sat(&this_arg_conv);
39144 int32_t __attribute__((export_name("TS_CommitmentTransaction_feerate_per_kw"))) TS_CommitmentTransaction_feerate_per_kw(uint64_t this_arg) {
39145 LDKCommitmentTransaction this_arg_conv;
39146 this_arg_conv.inner = untag_ptr(this_arg);
39147 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39148 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39149 this_arg_conv.is_owned = false;
39150 int32_t ret_conv = CommitmentTransaction_feerate_per_kw(&this_arg_conv);
39154 uint64_t __attribute__((export_name("TS_CommitmentTransaction_trust"))) TS_CommitmentTransaction_trust(uint64_t this_arg) {
39155 LDKCommitmentTransaction this_arg_conv;
39156 this_arg_conv.inner = untag_ptr(this_arg);
39157 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39158 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39159 this_arg_conv.is_owned = false;
39160 LDKTrustedCommitmentTransaction ret_var = CommitmentTransaction_trust(&this_arg_conv);
39161 uint64_t ret_ref = 0;
39162 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39163 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39167 uint64_t __attribute__((export_name("TS_CommitmentTransaction_verify"))) TS_CommitmentTransaction_verify(uint64_t this_arg, uint64_t channel_parameters, uint64_t broadcaster_keys, uint64_t countersignatory_keys) {
39168 LDKCommitmentTransaction this_arg_conv;
39169 this_arg_conv.inner = untag_ptr(this_arg);
39170 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39171 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39172 this_arg_conv.is_owned = false;
39173 LDKDirectedChannelTransactionParameters channel_parameters_conv;
39174 channel_parameters_conv.inner = untag_ptr(channel_parameters);
39175 channel_parameters_conv.is_owned = ptr_is_owned(channel_parameters);
39176 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_conv);
39177 channel_parameters_conv.is_owned = false;
39178 LDKChannelPublicKeys broadcaster_keys_conv;
39179 broadcaster_keys_conv.inner = untag_ptr(broadcaster_keys);
39180 broadcaster_keys_conv.is_owned = ptr_is_owned(broadcaster_keys);
39181 CHECK_INNER_FIELD_ACCESS_OR_NULL(broadcaster_keys_conv);
39182 broadcaster_keys_conv.is_owned = false;
39183 LDKChannelPublicKeys countersignatory_keys_conv;
39184 countersignatory_keys_conv.inner = untag_ptr(countersignatory_keys);
39185 countersignatory_keys_conv.is_owned = ptr_is_owned(countersignatory_keys);
39186 CHECK_INNER_FIELD_ACCESS_OR_NULL(countersignatory_keys_conv);
39187 countersignatory_keys_conv.is_owned = false;
39188 LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
39189 *ret_conv = CommitmentTransaction_verify(&this_arg_conv, &channel_parameters_conv, &broadcaster_keys_conv, &countersignatory_keys_conv);
39190 return tag_ptr(ret_conv, true);
39193 void __attribute__((export_name("TS_TrustedCommitmentTransaction_free"))) TS_TrustedCommitmentTransaction_free(uint64_t this_obj) {
39194 LDKTrustedCommitmentTransaction this_obj_conv;
39195 this_obj_conv.inner = untag_ptr(this_obj);
39196 this_obj_conv.is_owned = ptr_is_owned(this_obj);
39197 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39198 TrustedCommitmentTransaction_free(this_obj_conv);
39201 int8_tArray __attribute__((export_name("TS_TrustedCommitmentTransaction_txid"))) TS_TrustedCommitmentTransaction_txid(uint64_t this_arg) {
39202 LDKTrustedCommitmentTransaction this_arg_conv;
39203 this_arg_conv.inner = untag_ptr(this_arg);
39204 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39205 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39206 this_arg_conv.is_owned = false;
39207 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
39208 memcpy(ret_arr->elems, TrustedCommitmentTransaction_txid(&this_arg_conv).data, 32);
39212 uint64_t __attribute__((export_name("TS_TrustedCommitmentTransaction_built_transaction"))) TS_TrustedCommitmentTransaction_built_transaction(uint64_t this_arg) {
39213 LDKTrustedCommitmentTransaction this_arg_conv;
39214 this_arg_conv.inner = untag_ptr(this_arg);
39215 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39216 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39217 this_arg_conv.is_owned = false;
39218 LDKBuiltCommitmentTransaction ret_var = TrustedCommitmentTransaction_built_transaction(&this_arg_conv);
39219 uint64_t ret_ref = 0;
39220 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39221 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39225 uint64_t __attribute__((export_name("TS_TrustedCommitmentTransaction_keys"))) TS_TrustedCommitmentTransaction_keys(uint64_t this_arg) {
39226 LDKTrustedCommitmentTransaction this_arg_conv;
39227 this_arg_conv.inner = untag_ptr(this_arg);
39228 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39229 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39230 this_arg_conv.is_owned = false;
39231 LDKTxCreationKeys ret_var = TrustedCommitmentTransaction_keys(&this_arg_conv);
39232 uint64_t ret_ref = 0;
39233 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39234 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39238 jboolean __attribute__((export_name("TS_TrustedCommitmentTransaction_opt_anchors"))) TS_TrustedCommitmentTransaction_opt_anchors(uint64_t this_arg) {
39239 LDKTrustedCommitmentTransaction this_arg_conv;
39240 this_arg_conv.inner = untag_ptr(this_arg);
39241 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39242 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39243 this_arg_conv.is_owned = false;
39244 jboolean ret_conv = TrustedCommitmentTransaction_opt_anchors(&this_arg_conv);
39248 uint64_t __attribute__((export_name("TS_TrustedCommitmentTransaction_get_htlc_sigs"))) TS_TrustedCommitmentTransaction_get_htlc_sigs(uint64_t this_arg, int8_tArray htlc_base_key, uint64_t channel_parameters) {
39249 LDKTrustedCommitmentTransaction this_arg_conv;
39250 this_arg_conv.inner = untag_ptr(this_arg);
39251 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39252 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39253 this_arg_conv.is_owned = false;
39254 unsigned char htlc_base_key_arr[32];
39255 CHECK(htlc_base_key->arr_len == 32);
39256 memcpy(htlc_base_key_arr, htlc_base_key->elems, 32); FREE(htlc_base_key);
39257 unsigned char (*htlc_base_key_ref)[32] = &htlc_base_key_arr;
39258 LDKDirectedChannelTransactionParameters channel_parameters_conv;
39259 channel_parameters_conv.inner = untag_ptr(channel_parameters);
39260 channel_parameters_conv.is_owned = ptr_is_owned(channel_parameters);
39261 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_conv);
39262 channel_parameters_conv.is_owned = false;
39263 LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
39264 *ret_conv = TrustedCommitmentTransaction_get_htlc_sigs(&this_arg_conv, htlc_base_key_ref, &channel_parameters_conv);
39265 return tag_ptr(ret_conv, true);
39268 int64_t __attribute__((export_name("TS_get_commitment_transaction_number_obscure_factor"))) TS_get_commitment_transaction_number_obscure_factor(int8_tArray broadcaster_payment_basepoint, int8_tArray countersignatory_payment_basepoint, jboolean outbound_from_broadcaster) {
39269 LDKPublicKey broadcaster_payment_basepoint_ref;
39270 CHECK(broadcaster_payment_basepoint->arr_len == 33);
39271 memcpy(broadcaster_payment_basepoint_ref.compressed_form, broadcaster_payment_basepoint->elems, 33); FREE(broadcaster_payment_basepoint);
39272 LDKPublicKey countersignatory_payment_basepoint_ref;
39273 CHECK(countersignatory_payment_basepoint->arr_len == 33);
39274 memcpy(countersignatory_payment_basepoint_ref.compressed_form, countersignatory_payment_basepoint->elems, 33); FREE(countersignatory_payment_basepoint);
39275 int64_t ret_conv = get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint_ref, countersignatory_payment_basepoint_ref, outbound_from_broadcaster);
39279 jboolean __attribute__((export_name("TS_InitFeatures_eq"))) TS_InitFeatures_eq(uint64_t a, uint64_t b) {
39280 LDKInitFeatures a_conv;
39281 a_conv.inner = untag_ptr(a);
39282 a_conv.is_owned = ptr_is_owned(a);
39283 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
39284 a_conv.is_owned = false;
39285 LDKInitFeatures b_conv;
39286 b_conv.inner = untag_ptr(b);
39287 b_conv.is_owned = ptr_is_owned(b);
39288 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
39289 b_conv.is_owned = false;
39290 jboolean ret_conv = InitFeatures_eq(&a_conv, &b_conv);
39294 jboolean __attribute__((export_name("TS_NodeFeatures_eq"))) TS_NodeFeatures_eq(uint64_t a, uint64_t b) {
39295 LDKNodeFeatures a_conv;
39296 a_conv.inner = untag_ptr(a);
39297 a_conv.is_owned = ptr_is_owned(a);
39298 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
39299 a_conv.is_owned = false;
39300 LDKNodeFeatures b_conv;
39301 b_conv.inner = untag_ptr(b);
39302 b_conv.is_owned = ptr_is_owned(b);
39303 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
39304 b_conv.is_owned = false;
39305 jboolean ret_conv = NodeFeatures_eq(&a_conv, &b_conv);
39309 jboolean __attribute__((export_name("TS_ChannelFeatures_eq"))) TS_ChannelFeatures_eq(uint64_t a, uint64_t b) {
39310 LDKChannelFeatures a_conv;
39311 a_conv.inner = untag_ptr(a);
39312 a_conv.is_owned = ptr_is_owned(a);
39313 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
39314 a_conv.is_owned = false;
39315 LDKChannelFeatures b_conv;
39316 b_conv.inner = untag_ptr(b);
39317 b_conv.is_owned = ptr_is_owned(b);
39318 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
39319 b_conv.is_owned = false;
39320 jboolean ret_conv = ChannelFeatures_eq(&a_conv, &b_conv);
39324 jboolean __attribute__((export_name("TS_InvoiceFeatures_eq"))) TS_InvoiceFeatures_eq(uint64_t a, uint64_t b) {
39325 LDKInvoiceFeatures a_conv;
39326 a_conv.inner = untag_ptr(a);
39327 a_conv.is_owned = ptr_is_owned(a);
39328 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
39329 a_conv.is_owned = false;
39330 LDKInvoiceFeatures b_conv;
39331 b_conv.inner = untag_ptr(b);
39332 b_conv.is_owned = ptr_is_owned(b);
39333 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
39334 b_conv.is_owned = false;
39335 jboolean ret_conv = InvoiceFeatures_eq(&a_conv, &b_conv);
39339 jboolean __attribute__((export_name("TS_OfferFeatures_eq"))) TS_OfferFeatures_eq(uint64_t a, uint64_t b) {
39340 LDKOfferFeatures a_conv;
39341 a_conv.inner = untag_ptr(a);
39342 a_conv.is_owned = ptr_is_owned(a);
39343 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
39344 a_conv.is_owned = false;
39345 LDKOfferFeatures b_conv;
39346 b_conv.inner = untag_ptr(b);
39347 b_conv.is_owned = ptr_is_owned(b);
39348 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
39349 b_conv.is_owned = false;
39350 jboolean ret_conv = OfferFeatures_eq(&a_conv, &b_conv);
39354 jboolean __attribute__((export_name("TS_InvoiceRequestFeatures_eq"))) TS_InvoiceRequestFeatures_eq(uint64_t a, uint64_t b) {
39355 LDKInvoiceRequestFeatures a_conv;
39356 a_conv.inner = untag_ptr(a);
39357 a_conv.is_owned = ptr_is_owned(a);
39358 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
39359 a_conv.is_owned = false;
39360 LDKInvoiceRequestFeatures b_conv;
39361 b_conv.inner = untag_ptr(b);
39362 b_conv.is_owned = ptr_is_owned(b);
39363 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
39364 b_conv.is_owned = false;
39365 jboolean ret_conv = InvoiceRequestFeatures_eq(&a_conv, &b_conv);
39369 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_eq"))) TS_ChannelTypeFeatures_eq(uint64_t a, uint64_t b) {
39370 LDKChannelTypeFeatures a_conv;
39371 a_conv.inner = untag_ptr(a);
39372 a_conv.is_owned = ptr_is_owned(a);
39373 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
39374 a_conv.is_owned = false;
39375 LDKChannelTypeFeatures b_conv;
39376 b_conv.inner = untag_ptr(b);
39377 b_conv.is_owned = ptr_is_owned(b);
39378 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
39379 b_conv.is_owned = false;
39380 jboolean ret_conv = ChannelTypeFeatures_eq(&a_conv, &b_conv);
39384 static inline uint64_t InitFeatures_clone_ptr(LDKInitFeatures *NONNULL_PTR arg) {
39385 LDKInitFeatures ret_var = InitFeatures_clone(arg);
39386 uint64_t ret_ref = 0;
39387 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39388 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39391 int64_t __attribute__((export_name("TS_InitFeatures_clone_ptr"))) TS_InitFeatures_clone_ptr(uint64_t arg) {
39392 LDKInitFeatures arg_conv;
39393 arg_conv.inner = untag_ptr(arg);
39394 arg_conv.is_owned = ptr_is_owned(arg);
39395 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
39396 arg_conv.is_owned = false;
39397 int64_t ret_conv = InitFeatures_clone_ptr(&arg_conv);
39401 uint64_t __attribute__((export_name("TS_InitFeatures_clone"))) TS_InitFeatures_clone(uint64_t orig) {
39402 LDKInitFeatures orig_conv;
39403 orig_conv.inner = untag_ptr(orig);
39404 orig_conv.is_owned = ptr_is_owned(orig);
39405 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
39406 orig_conv.is_owned = false;
39407 LDKInitFeatures ret_var = InitFeatures_clone(&orig_conv);
39408 uint64_t ret_ref = 0;
39409 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39410 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39414 static inline uint64_t NodeFeatures_clone_ptr(LDKNodeFeatures *NONNULL_PTR arg) {
39415 LDKNodeFeatures ret_var = NodeFeatures_clone(arg);
39416 uint64_t ret_ref = 0;
39417 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39418 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39421 int64_t __attribute__((export_name("TS_NodeFeatures_clone_ptr"))) TS_NodeFeatures_clone_ptr(uint64_t arg) {
39422 LDKNodeFeatures arg_conv;
39423 arg_conv.inner = untag_ptr(arg);
39424 arg_conv.is_owned = ptr_is_owned(arg);
39425 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
39426 arg_conv.is_owned = false;
39427 int64_t ret_conv = NodeFeatures_clone_ptr(&arg_conv);
39431 uint64_t __attribute__((export_name("TS_NodeFeatures_clone"))) TS_NodeFeatures_clone(uint64_t orig) {
39432 LDKNodeFeatures orig_conv;
39433 orig_conv.inner = untag_ptr(orig);
39434 orig_conv.is_owned = ptr_is_owned(orig);
39435 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
39436 orig_conv.is_owned = false;
39437 LDKNodeFeatures ret_var = NodeFeatures_clone(&orig_conv);
39438 uint64_t ret_ref = 0;
39439 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39440 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39444 static inline uint64_t ChannelFeatures_clone_ptr(LDKChannelFeatures *NONNULL_PTR arg) {
39445 LDKChannelFeatures ret_var = ChannelFeatures_clone(arg);
39446 uint64_t ret_ref = 0;
39447 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39448 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39451 int64_t __attribute__((export_name("TS_ChannelFeatures_clone_ptr"))) TS_ChannelFeatures_clone_ptr(uint64_t arg) {
39452 LDKChannelFeatures arg_conv;
39453 arg_conv.inner = untag_ptr(arg);
39454 arg_conv.is_owned = ptr_is_owned(arg);
39455 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
39456 arg_conv.is_owned = false;
39457 int64_t ret_conv = ChannelFeatures_clone_ptr(&arg_conv);
39461 uint64_t __attribute__((export_name("TS_ChannelFeatures_clone"))) TS_ChannelFeatures_clone(uint64_t orig) {
39462 LDKChannelFeatures orig_conv;
39463 orig_conv.inner = untag_ptr(orig);
39464 orig_conv.is_owned = ptr_is_owned(orig);
39465 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
39466 orig_conv.is_owned = false;
39467 LDKChannelFeatures ret_var = ChannelFeatures_clone(&orig_conv);
39468 uint64_t ret_ref = 0;
39469 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39470 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39474 static inline uint64_t InvoiceFeatures_clone_ptr(LDKInvoiceFeatures *NONNULL_PTR arg) {
39475 LDKInvoiceFeatures ret_var = InvoiceFeatures_clone(arg);
39476 uint64_t ret_ref = 0;
39477 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39478 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39481 int64_t __attribute__((export_name("TS_InvoiceFeatures_clone_ptr"))) TS_InvoiceFeatures_clone_ptr(uint64_t arg) {
39482 LDKInvoiceFeatures arg_conv;
39483 arg_conv.inner = untag_ptr(arg);
39484 arg_conv.is_owned = ptr_is_owned(arg);
39485 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
39486 arg_conv.is_owned = false;
39487 int64_t ret_conv = InvoiceFeatures_clone_ptr(&arg_conv);
39491 uint64_t __attribute__((export_name("TS_InvoiceFeatures_clone"))) TS_InvoiceFeatures_clone(uint64_t orig) {
39492 LDKInvoiceFeatures orig_conv;
39493 orig_conv.inner = untag_ptr(orig);
39494 orig_conv.is_owned = ptr_is_owned(orig);
39495 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
39496 orig_conv.is_owned = false;
39497 LDKInvoiceFeatures ret_var = InvoiceFeatures_clone(&orig_conv);
39498 uint64_t ret_ref = 0;
39499 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39500 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39504 static inline uint64_t OfferFeatures_clone_ptr(LDKOfferFeatures *NONNULL_PTR arg) {
39505 LDKOfferFeatures ret_var = OfferFeatures_clone(arg);
39506 uint64_t ret_ref = 0;
39507 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39508 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39511 int64_t __attribute__((export_name("TS_OfferFeatures_clone_ptr"))) TS_OfferFeatures_clone_ptr(uint64_t arg) {
39512 LDKOfferFeatures arg_conv;
39513 arg_conv.inner = untag_ptr(arg);
39514 arg_conv.is_owned = ptr_is_owned(arg);
39515 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
39516 arg_conv.is_owned = false;
39517 int64_t ret_conv = OfferFeatures_clone_ptr(&arg_conv);
39521 uint64_t __attribute__((export_name("TS_OfferFeatures_clone"))) TS_OfferFeatures_clone(uint64_t orig) {
39522 LDKOfferFeatures orig_conv;
39523 orig_conv.inner = untag_ptr(orig);
39524 orig_conv.is_owned = ptr_is_owned(orig);
39525 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
39526 orig_conv.is_owned = false;
39527 LDKOfferFeatures ret_var = OfferFeatures_clone(&orig_conv);
39528 uint64_t ret_ref = 0;
39529 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39530 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39534 static inline uint64_t InvoiceRequestFeatures_clone_ptr(LDKInvoiceRequestFeatures *NONNULL_PTR arg) {
39535 LDKInvoiceRequestFeatures ret_var = InvoiceRequestFeatures_clone(arg);
39536 uint64_t ret_ref = 0;
39537 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39538 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39541 int64_t __attribute__((export_name("TS_InvoiceRequestFeatures_clone_ptr"))) TS_InvoiceRequestFeatures_clone_ptr(uint64_t arg) {
39542 LDKInvoiceRequestFeatures arg_conv;
39543 arg_conv.inner = untag_ptr(arg);
39544 arg_conv.is_owned = ptr_is_owned(arg);
39545 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
39546 arg_conv.is_owned = false;
39547 int64_t ret_conv = InvoiceRequestFeatures_clone_ptr(&arg_conv);
39551 uint64_t __attribute__((export_name("TS_InvoiceRequestFeatures_clone"))) TS_InvoiceRequestFeatures_clone(uint64_t orig) {
39552 LDKInvoiceRequestFeatures orig_conv;
39553 orig_conv.inner = untag_ptr(orig);
39554 orig_conv.is_owned = ptr_is_owned(orig);
39555 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
39556 orig_conv.is_owned = false;
39557 LDKInvoiceRequestFeatures ret_var = InvoiceRequestFeatures_clone(&orig_conv);
39558 uint64_t ret_ref = 0;
39559 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39560 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39564 static inline uint64_t ChannelTypeFeatures_clone_ptr(LDKChannelTypeFeatures *NONNULL_PTR arg) {
39565 LDKChannelTypeFeatures ret_var = ChannelTypeFeatures_clone(arg);
39566 uint64_t ret_ref = 0;
39567 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39568 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39571 int64_t __attribute__((export_name("TS_ChannelTypeFeatures_clone_ptr"))) TS_ChannelTypeFeatures_clone_ptr(uint64_t arg) {
39572 LDKChannelTypeFeatures arg_conv;
39573 arg_conv.inner = untag_ptr(arg);
39574 arg_conv.is_owned = ptr_is_owned(arg);
39575 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
39576 arg_conv.is_owned = false;
39577 int64_t ret_conv = ChannelTypeFeatures_clone_ptr(&arg_conv);
39581 uint64_t __attribute__((export_name("TS_ChannelTypeFeatures_clone"))) TS_ChannelTypeFeatures_clone(uint64_t orig) {
39582 LDKChannelTypeFeatures orig_conv;
39583 orig_conv.inner = untag_ptr(orig);
39584 orig_conv.is_owned = ptr_is_owned(orig);
39585 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
39586 orig_conv.is_owned = false;
39587 LDKChannelTypeFeatures ret_var = ChannelTypeFeatures_clone(&orig_conv);
39588 uint64_t ret_ref = 0;
39589 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39590 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39594 void __attribute__((export_name("TS_InitFeatures_free"))) TS_InitFeatures_free(uint64_t this_obj) {
39595 LDKInitFeatures this_obj_conv;
39596 this_obj_conv.inner = untag_ptr(this_obj);
39597 this_obj_conv.is_owned = ptr_is_owned(this_obj);
39598 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39599 InitFeatures_free(this_obj_conv);
39602 void __attribute__((export_name("TS_NodeFeatures_free"))) TS_NodeFeatures_free(uint64_t this_obj) {
39603 LDKNodeFeatures this_obj_conv;
39604 this_obj_conv.inner = untag_ptr(this_obj);
39605 this_obj_conv.is_owned = ptr_is_owned(this_obj);
39606 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39607 NodeFeatures_free(this_obj_conv);
39610 void __attribute__((export_name("TS_ChannelFeatures_free"))) TS_ChannelFeatures_free(uint64_t this_obj) {
39611 LDKChannelFeatures this_obj_conv;
39612 this_obj_conv.inner = untag_ptr(this_obj);
39613 this_obj_conv.is_owned = ptr_is_owned(this_obj);
39614 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39615 ChannelFeatures_free(this_obj_conv);
39618 void __attribute__((export_name("TS_InvoiceFeatures_free"))) TS_InvoiceFeatures_free(uint64_t this_obj) {
39619 LDKInvoiceFeatures this_obj_conv;
39620 this_obj_conv.inner = untag_ptr(this_obj);
39621 this_obj_conv.is_owned = ptr_is_owned(this_obj);
39622 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39623 InvoiceFeatures_free(this_obj_conv);
39626 void __attribute__((export_name("TS_OfferFeatures_free"))) TS_OfferFeatures_free(uint64_t this_obj) {
39627 LDKOfferFeatures this_obj_conv;
39628 this_obj_conv.inner = untag_ptr(this_obj);
39629 this_obj_conv.is_owned = ptr_is_owned(this_obj);
39630 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39631 OfferFeatures_free(this_obj_conv);
39634 void __attribute__((export_name("TS_InvoiceRequestFeatures_free"))) TS_InvoiceRequestFeatures_free(uint64_t this_obj) {
39635 LDKInvoiceRequestFeatures this_obj_conv;
39636 this_obj_conv.inner = untag_ptr(this_obj);
39637 this_obj_conv.is_owned = ptr_is_owned(this_obj);
39638 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39639 InvoiceRequestFeatures_free(this_obj_conv);
39642 void __attribute__((export_name("TS_ChannelTypeFeatures_free"))) TS_ChannelTypeFeatures_free(uint64_t this_obj) {
39643 LDKChannelTypeFeatures this_obj_conv;
39644 this_obj_conv.inner = untag_ptr(this_obj);
39645 this_obj_conv.is_owned = ptr_is_owned(this_obj);
39646 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39647 ChannelTypeFeatures_free(this_obj_conv);
39650 uint64_t __attribute__((export_name("TS_InitFeatures_empty"))) TS_InitFeatures_empty() {
39651 LDKInitFeatures ret_var = InitFeatures_empty();
39652 uint64_t ret_ref = 0;
39653 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39654 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39658 jboolean __attribute__((export_name("TS_InitFeatures_requires_unknown_bits"))) TS_InitFeatures_requires_unknown_bits(uint64_t this_arg) {
39659 LDKInitFeatures this_arg_conv;
39660 this_arg_conv.inner = untag_ptr(this_arg);
39661 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39662 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39663 this_arg_conv.is_owned = false;
39664 jboolean ret_conv = InitFeatures_requires_unknown_bits(&this_arg_conv);
39668 uint64_t __attribute__((export_name("TS_NodeFeatures_empty"))) TS_NodeFeatures_empty() {
39669 LDKNodeFeatures ret_var = NodeFeatures_empty();
39670 uint64_t ret_ref = 0;
39671 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39672 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39676 jboolean __attribute__((export_name("TS_NodeFeatures_requires_unknown_bits"))) TS_NodeFeatures_requires_unknown_bits(uint64_t this_arg) {
39677 LDKNodeFeatures this_arg_conv;
39678 this_arg_conv.inner = untag_ptr(this_arg);
39679 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39680 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39681 this_arg_conv.is_owned = false;
39682 jboolean ret_conv = NodeFeatures_requires_unknown_bits(&this_arg_conv);
39686 uint64_t __attribute__((export_name("TS_ChannelFeatures_empty"))) TS_ChannelFeatures_empty() {
39687 LDKChannelFeatures ret_var = ChannelFeatures_empty();
39688 uint64_t ret_ref = 0;
39689 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39690 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39694 jboolean __attribute__((export_name("TS_ChannelFeatures_requires_unknown_bits"))) TS_ChannelFeatures_requires_unknown_bits(uint64_t this_arg) {
39695 LDKChannelFeatures this_arg_conv;
39696 this_arg_conv.inner = untag_ptr(this_arg);
39697 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39698 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39699 this_arg_conv.is_owned = false;
39700 jboolean ret_conv = ChannelFeatures_requires_unknown_bits(&this_arg_conv);
39704 uint64_t __attribute__((export_name("TS_InvoiceFeatures_empty"))) TS_InvoiceFeatures_empty() {
39705 LDKInvoiceFeatures ret_var = InvoiceFeatures_empty();
39706 uint64_t ret_ref = 0;
39707 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39708 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39712 jboolean __attribute__((export_name("TS_InvoiceFeatures_requires_unknown_bits"))) TS_InvoiceFeatures_requires_unknown_bits(uint64_t this_arg) {
39713 LDKInvoiceFeatures this_arg_conv;
39714 this_arg_conv.inner = untag_ptr(this_arg);
39715 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39716 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39717 this_arg_conv.is_owned = false;
39718 jboolean ret_conv = InvoiceFeatures_requires_unknown_bits(&this_arg_conv);
39722 uint64_t __attribute__((export_name("TS_OfferFeatures_empty"))) TS_OfferFeatures_empty() {
39723 LDKOfferFeatures ret_var = OfferFeatures_empty();
39724 uint64_t ret_ref = 0;
39725 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39726 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39730 jboolean __attribute__((export_name("TS_OfferFeatures_requires_unknown_bits"))) TS_OfferFeatures_requires_unknown_bits(uint64_t this_arg) {
39731 LDKOfferFeatures this_arg_conv;
39732 this_arg_conv.inner = untag_ptr(this_arg);
39733 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39734 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39735 this_arg_conv.is_owned = false;
39736 jboolean ret_conv = OfferFeatures_requires_unknown_bits(&this_arg_conv);
39740 uint64_t __attribute__((export_name("TS_InvoiceRequestFeatures_empty"))) TS_InvoiceRequestFeatures_empty() {
39741 LDKInvoiceRequestFeatures ret_var = InvoiceRequestFeatures_empty();
39742 uint64_t ret_ref = 0;
39743 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39744 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39748 jboolean __attribute__((export_name("TS_InvoiceRequestFeatures_requires_unknown_bits"))) TS_InvoiceRequestFeatures_requires_unknown_bits(uint64_t this_arg) {
39749 LDKInvoiceRequestFeatures this_arg_conv;
39750 this_arg_conv.inner = untag_ptr(this_arg);
39751 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39752 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39753 this_arg_conv.is_owned = false;
39754 jboolean ret_conv = InvoiceRequestFeatures_requires_unknown_bits(&this_arg_conv);
39758 uint64_t __attribute__((export_name("TS_ChannelTypeFeatures_empty"))) TS_ChannelTypeFeatures_empty() {
39759 LDKChannelTypeFeatures ret_var = ChannelTypeFeatures_empty();
39760 uint64_t ret_ref = 0;
39761 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39762 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39766 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_requires_unknown_bits"))) TS_ChannelTypeFeatures_requires_unknown_bits(uint64_t this_arg) {
39767 LDKChannelTypeFeatures this_arg_conv;
39768 this_arg_conv.inner = untag_ptr(this_arg);
39769 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39770 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39771 this_arg_conv.is_owned = false;
39772 jboolean ret_conv = ChannelTypeFeatures_requires_unknown_bits(&this_arg_conv);
39776 int8_tArray __attribute__((export_name("TS_InitFeatures_write"))) TS_InitFeatures_write(uint64_t obj) {
39777 LDKInitFeatures obj_conv;
39778 obj_conv.inner = untag_ptr(obj);
39779 obj_conv.is_owned = ptr_is_owned(obj);
39780 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
39781 obj_conv.is_owned = false;
39782 LDKCVec_u8Z ret_var = InitFeatures_write(&obj_conv);
39783 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39784 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39785 CVec_u8Z_free(ret_var);
39789 uint64_t __attribute__((export_name("TS_InitFeatures_read"))) TS_InitFeatures_read(int8_tArray ser) {
39790 LDKu8slice ser_ref;
39791 ser_ref.datalen = ser->arr_len;
39792 ser_ref.data = ser->elems;
39793 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
39794 *ret_conv = InitFeatures_read(ser_ref);
39796 return tag_ptr(ret_conv, true);
39799 int8_tArray __attribute__((export_name("TS_ChannelFeatures_write"))) TS_ChannelFeatures_write(uint64_t obj) {
39800 LDKChannelFeatures obj_conv;
39801 obj_conv.inner = untag_ptr(obj);
39802 obj_conv.is_owned = ptr_is_owned(obj);
39803 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
39804 obj_conv.is_owned = false;
39805 LDKCVec_u8Z ret_var = ChannelFeatures_write(&obj_conv);
39806 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39807 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39808 CVec_u8Z_free(ret_var);
39812 uint64_t __attribute__((export_name("TS_ChannelFeatures_read"))) TS_ChannelFeatures_read(int8_tArray ser) {
39813 LDKu8slice ser_ref;
39814 ser_ref.datalen = ser->arr_len;
39815 ser_ref.data = ser->elems;
39816 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
39817 *ret_conv = ChannelFeatures_read(ser_ref);
39819 return tag_ptr(ret_conv, true);
39822 int8_tArray __attribute__((export_name("TS_NodeFeatures_write"))) TS_NodeFeatures_write(uint64_t obj) {
39823 LDKNodeFeatures obj_conv;
39824 obj_conv.inner = untag_ptr(obj);
39825 obj_conv.is_owned = ptr_is_owned(obj);
39826 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
39827 obj_conv.is_owned = false;
39828 LDKCVec_u8Z ret_var = NodeFeatures_write(&obj_conv);
39829 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39830 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39831 CVec_u8Z_free(ret_var);
39835 uint64_t __attribute__((export_name("TS_NodeFeatures_read"))) TS_NodeFeatures_read(int8_tArray ser) {
39836 LDKu8slice ser_ref;
39837 ser_ref.datalen = ser->arr_len;
39838 ser_ref.data = ser->elems;
39839 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
39840 *ret_conv = NodeFeatures_read(ser_ref);
39842 return tag_ptr(ret_conv, true);
39845 int8_tArray __attribute__((export_name("TS_InvoiceFeatures_write"))) TS_InvoiceFeatures_write(uint64_t obj) {
39846 LDKInvoiceFeatures obj_conv;
39847 obj_conv.inner = untag_ptr(obj);
39848 obj_conv.is_owned = ptr_is_owned(obj);
39849 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
39850 obj_conv.is_owned = false;
39851 LDKCVec_u8Z ret_var = InvoiceFeatures_write(&obj_conv);
39852 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39853 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39854 CVec_u8Z_free(ret_var);
39858 uint64_t __attribute__((export_name("TS_InvoiceFeatures_read"))) TS_InvoiceFeatures_read(int8_tArray ser) {
39859 LDKu8slice ser_ref;
39860 ser_ref.datalen = ser->arr_len;
39861 ser_ref.data = ser->elems;
39862 LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
39863 *ret_conv = InvoiceFeatures_read(ser_ref);
39865 return tag_ptr(ret_conv, true);
39868 int8_tArray __attribute__((export_name("TS_ChannelTypeFeatures_write"))) TS_ChannelTypeFeatures_write(uint64_t obj) {
39869 LDKChannelTypeFeatures obj_conv;
39870 obj_conv.inner = untag_ptr(obj);
39871 obj_conv.is_owned = ptr_is_owned(obj);
39872 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
39873 obj_conv.is_owned = false;
39874 LDKCVec_u8Z ret_var = ChannelTypeFeatures_write(&obj_conv);
39875 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39876 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39877 CVec_u8Z_free(ret_var);
39881 uint64_t __attribute__((export_name("TS_ChannelTypeFeatures_read"))) TS_ChannelTypeFeatures_read(int8_tArray ser) {
39882 LDKu8slice ser_ref;
39883 ser_ref.datalen = ser->arr_len;
39884 ser_ref.data = ser->elems;
39885 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ), "LDKCResult_ChannelTypeFeaturesDecodeErrorZ");
39886 *ret_conv = ChannelTypeFeatures_read(ser_ref);
39888 return tag_ptr(ret_conv, true);
39891 int8_tArray __attribute__((export_name("TS_OfferFeatures_write"))) TS_OfferFeatures_write(uint64_t obj) {
39892 LDKOfferFeatures obj_conv;
39893 obj_conv.inner = untag_ptr(obj);
39894 obj_conv.is_owned = ptr_is_owned(obj);
39895 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
39896 obj_conv.is_owned = false;
39897 LDKCVec_u8Z ret_var = OfferFeatures_write(&obj_conv);
39898 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39899 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39900 CVec_u8Z_free(ret_var);
39904 uint64_t __attribute__((export_name("TS_OfferFeatures_read"))) TS_OfferFeatures_read(int8_tArray ser) {
39905 LDKu8slice ser_ref;
39906 ser_ref.datalen = ser->arr_len;
39907 ser_ref.data = ser->elems;
39908 LDKCResult_OfferFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OfferFeaturesDecodeErrorZ), "LDKCResult_OfferFeaturesDecodeErrorZ");
39909 *ret_conv = OfferFeatures_read(ser_ref);
39911 return tag_ptr(ret_conv, true);
39914 int8_tArray __attribute__((export_name("TS_InvoiceRequestFeatures_write"))) TS_InvoiceRequestFeatures_write(uint64_t obj) {
39915 LDKInvoiceRequestFeatures obj_conv;
39916 obj_conv.inner = untag_ptr(obj);
39917 obj_conv.is_owned = ptr_is_owned(obj);
39918 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
39919 obj_conv.is_owned = false;
39920 LDKCVec_u8Z ret_var = InvoiceRequestFeatures_write(&obj_conv);
39921 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39922 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39923 CVec_u8Z_free(ret_var);
39927 uint64_t __attribute__((export_name("TS_InvoiceRequestFeatures_read"))) TS_InvoiceRequestFeatures_read(int8_tArray ser) {
39928 LDKu8slice ser_ref;
39929 ser_ref.datalen = ser->arr_len;
39930 ser_ref.data = ser->elems;
39931 LDKCResult_InvoiceRequestFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceRequestFeaturesDecodeErrorZ), "LDKCResult_InvoiceRequestFeaturesDecodeErrorZ");
39932 *ret_conv = InvoiceRequestFeatures_read(ser_ref);
39934 return tag_ptr(ret_conv, true);
39937 void __attribute__((export_name("TS_InitFeatures_set_data_loss_protect_optional"))) TS_InitFeatures_set_data_loss_protect_optional(uint64_t this_arg) {
39938 LDKInitFeatures this_arg_conv;
39939 this_arg_conv.inner = untag_ptr(this_arg);
39940 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39941 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39942 this_arg_conv.is_owned = false;
39943 InitFeatures_set_data_loss_protect_optional(&this_arg_conv);
39946 void __attribute__((export_name("TS_InitFeatures_set_data_loss_protect_required"))) TS_InitFeatures_set_data_loss_protect_required(uint64_t this_arg) {
39947 LDKInitFeatures this_arg_conv;
39948 this_arg_conv.inner = untag_ptr(this_arg);
39949 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39950 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39951 this_arg_conv.is_owned = false;
39952 InitFeatures_set_data_loss_protect_required(&this_arg_conv);
39955 jboolean __attribute__((export_name("TS_InitFeatures_supports_data_loss_protect"))) TS_InitFeatures_supports_data_loss_protect(uint64_t this_arg) {
39956 LDKInitFeatures this_arg_conv;
39957 this_arg_conv.inner = untag_ptr(this_arg);
39958 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39959 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39960 this_arg_conv.is_owned = false;
39961 jboolean ret_conv = InitFeatures_supports_data_loss_protect(&this_arg_conv);
39965 void __attribute__((export_name("TS_NodeFeatures_set_data_loss_protect_optional"))) TS_NodeFeatures_set_data_loss_protect_optional(uint64_t this_arg) {
39966 LDKNodeFeatures this_arg_conv;
39967 this_arg_conv.inner = untag_ptr(this_arg);
39968 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39969 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39970 this_arg_conv.is_owned = false;
39971 NodeFeatures_set_data_loss_protect_optional(&this_arg_conv);
39974 void __attribute__((export_name("TS_NodeFeatures_set_data_loss_protect_required"))) TS_NodeFeatures_set_data_loss_protect_required(uint64_t this_arg) {
39975 LDKNodeFeatures this_arg_conv;
39976 this_arg_conv.inner = untag_ptr(this_arg);
39977 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39978 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39979 this_arg_conv.is_owned = false;
39980 NodeFeatures_set_data_loss_protect_required(&this_arg_conv);
39983 jboolean __attribute__((export_name("TS_NodeFeatures_supports_data_loss_protect"))) TS_NodeFeatures_supports_data_loss_protect(uint64_t this_arg) {
39984 LDKNodeFeatures this_arg_conv;
39985 this_arg_conv.inner = untag_ptr(this_arg);
39986 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39987 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39988 this_arg_conv.is_owned = false;
39989 jboolean ret_conv = NodeFeatures_supports_data_loss_protect(&this_arg_conv);
39993 jboolean __attribute__((export_name("TS_InitFeatures_requires_data_loss_protect"))) TS_InitFeatures_requires_data_loss_protect(uint64_t this_arg) {
39994 LDKInitFeatures this_arg_conv;
39995 this_arg_conv.inner = untag_ptr(this_arg);
39996 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39997 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39998 this_arg_conv.is_owned = false;
39999 jboolean ret_conv = InitFeatures_requires_data_loss_protect(&this_arg_conv);
40003 jboolean __attribute__((export_name("TS_NodeFeatures_requires_data_loss_protect"))) TS_NodeFeatures_requires_data_loss_protect(uint64_t this_arg) {
40004 LDKNodeFeatures this_arg_conv;
40005 this_arg_conv.inner = untag_ptr(this_arg);
40006 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40007 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40008 this_arg_conv.is_owned = false;
40009 jboolean ret_conv = NodeFeatures_requires_data_loss_protect(&this_arg_conv);
40013 void __attribute__((export_name("TS_InitFeatures_set_initial_routing_sync_optional"))) TS_InitFeatures_set_initial_routing_sync_optional(uint64_t this_arg) {
40014 LDKInitFeatures this_arg_conv;
40015 this_arg_conv.inner = untag_ptr(this_arg);
40016 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40017 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40018 this_arg_conv.is_owned = false;
40019 InitFeatures_set_initial_routing_sync_optional(&this_arg_conv);
40022 void __attribute__((export_name("TS_InitFeatures_set_initial_routing_sync_required"))) TS_InitFeatures_set_initial_routing_sync_required(uint64_t this_arg) {
40023 LDKInitFeatures this_arg_conv;
40024 this_arg_conv.inner = untag_ptr(this_arg);
40025 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40026 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40027 this_arg_conv.is_owned = false;
40028 InitFeatures_set_initial_routing_sync_required(&this_arg_conv);
40031 jboolean __attribute__((export_name("TS_InitFeatures_initial_routing_sync"))) TS_InitFeatures_initial_routing_sync(uint64_t this_arg) {
40032 LDKInitFeatures this_arg_conv;
40033 this_arg_conv.inner = untag_ptr(this_arg);
40034 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40035 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40036 this_arg_conv.is_owned = false;
40037 jboolean ret_conv = InitFeatures_initial_routing_sync(&this_arg_conv);
40041 void __attribute__((export_name("TS_InitFeatures_set_upfront_shutdown_script_optional"))) TS_InitFeatures_set_upfront_shutdown_script_optional(uint64_t this_arg) {
40042 LDKInitFeatures this_arg_conv;
40043 this_arg_conv.inner = untag_ptr(this_arg);
40044 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40045 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40046 this_arg_conv.is_owned = false;
40047 InitFeatures_set_upfront_shutdown_script_optional(&this_arg_conv);
40050 void __attribute__((export_name("TS_InitFeatures_set_upfront_shutdown_script_required"))) TS_InitFeatures_set_upfront_shutdown_script_required(uint64_t this_arg) {
40051 LDKInitFeatures this_arg_conv;
40052 this_arg_conv.inner = untag_ptr(this_arg);
40053 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40054 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40055 this_arg_conv.is_owned = false;
40056 InitFeatures_set_upfront_shutdown_script_required(&this_arg_conv);
40059 jboolean __attribute__((export_name("TS_InitFeatures_supports_upfront_shutdown_script"))) TS_InitFeatures_supports_upfront_shutdown_script(uint64_t this_arg) {
40060 LDKInitFeatures this_arg_conv;
40061 this_arg_conv.inner = untag_ptr(this_arg);
40062 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40063 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40064 this_arg_conv.is_owned = false;
40065 jboolean ret_conv = InitFeatures_supports_upfront_shutdown_script(&this_arg_conv);
40069 void __attribute__((export_name("TS_NodeFeatures_set_upfront_shutdown_script_optional"))) TS_NodeFeatures_set_upfront_shutdown_script_optional(uint64_t this_arg) {
40070 LDKNodeFeatures this_arg_conv;
40071 this_arg_conv.inner = untag_ptr(this_arg);
40072 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40073 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40074 this_arg_conv.is_owned = false;
40075 NodeFeatures_set_upfront_shutdown_script_optional(&this_arg_conv);
40078 void __attribute__((export_name("TS_NodeFeatures_set_upfront_shutdown_script_required"))) TS_NodeFeatures_set_upfront_shutdown_script_required(uint64_t this_arg) {
40079 LDKNodeFeatures this_arg_conv;
40080 this_arg_conv.inner = untag_ptr(this_arg);
40081 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40082 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40083 this_arg_conv.is_owned = false;
40084 NodeFeatures_set_upfront_shutdown_script_required(&this_arg_conv);
40087 jboolean __attribute__((export_name("TS_NodeFeatures_supports_upfront_shutdown_script"))) TS_NodeFeatures_supports_upfront_shutdown_script(uint64_t this_arg) {
40088 LDKNodeFeatures this_arg_conv;
40089 this_arg_conv.inner = untag_ptr(this_arg);
40090 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40091 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40092 this_arg_conv.is_owned = false;
40093 jboolean ret_conv = NodeFeatures_supports_upfront_shutdown_script(&this_arg_conv);
40097 jboolean __attribute__((export_name("TS_InitFeatures_requires_upfront_shutdown_script"))) TS_InitFeatures_requires_upfront_shutdown_script(uint64_t this_arg) {
40098 LDKInitFeatures this_arg_conv;
40099 this_arg_conv.inner = untag_ptr(this_arg);
40100 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40101 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40102 this_arg_conv.is_owned = false;
40103 jboolean ret_conv = InitFeatures_requires_upfront_shutdown_script(&this_arg_conv);
40107 jboolean __attribute__((export_name("TS_NodeFeatures_requires_upfront_shutdown_script"))) TS_NodeFeatures_requires_upfront_shutdown_script(uint64_t this_arg) {
40108 LDKNodeFeatures this_arg_conv;
40109 this_arg_conv.inner = untag_ptr(this_arg);
40110 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40111 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40112 this_arg_conv.is_owned = false;
40113 jboolean ret_conv = NodeFeatures_requires_upfront_shutdown_script(&this_arg_conv);
40117 void __attribute__((export_name("TS_InitFeatures_set_gossip_queries_optional"))) TS_InitFeatures_set_gossip_queries_optional(uint64_t this_arg) {
40118 LDKInitFeatures this_arg_conv;
40119 this_arg_conv.inner = untag_ptr(this_arg);
40120 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40121 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40122 this_arg_conv.is_owned = false;
40123 InitFeatures_set_gossip_queries_optional(&this_arg_conv);
40126 void __attribute__((export_name("TS_InitFeatures_set_gossip_queries_required"))) TS_InitFeatures_set_gossip_queries_required(uint64_t this_arg) {
40127 LDKInitFeatures this_arg_conv;
40128 this_arg_conv.inner = untag_ptr(this_arg);
40129 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40130 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40131 this_arg_conv.is_owned = false;
40132 InitFeatures_set_gossip_queries_required(&this_arg_conv);
40135 jboolean __attribute__((export_name("TS_InitFeatures_supports_gossip_queries"))) TS_InitFeatures_supports_gossip_queries(uint64_t this_arg) {
40136 LDKInitFeatures this_arg_conv;
40137 this_arg_conv.inner = untag_ptr(this_arg);
40138 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40139 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40140 this_arg_conv.is_owned = false;
40141 jboolean ret_conv = InitFeatures_supports_gossip_queries(&this_arg_conv);
40145 void __attribute__((export_name("TS_NodeFeatures_set_gossip_queries_optional"))) TS_NodeFeatures_set_gossip_queries_optional(uint64_t this_arg) {
40146 LDKNodeFeatures this_arg_conv;
40147 this_arg_conv.inner = untag_ptr(this_arg);
40148 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40149 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40150 this_arg_conv.is_owned = false;
40151 NodeFeatures_set_gossip_queries_optional(&this_arg_conv);
40154 void __attribute__((export_name("TS_NodeFeatures_set_gossip_queries_required"))) TS_NodeFeatures_set_gossip_queries_required(uint64_t this_arg) {
40155 LDKNodeFeatures this_arg_conv;
40156 this_arg_conv.inner = untag_ptr(this_arg);
40157 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40158 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40159 this_arg_conv.is_owned = false;
40160 NodeFeatures_set_gossip_queries_required(&this_arg_conv);
40163 jboolean __attribute__((export_name("TS_NodeFeatures_supports_gossip_queries"))) TS_NodeFeatures_supports_gossip_queries(uint64_t this_arg) {
40164 LDKNodeFeatures this_arg_conv;
40165 this_arg_conv.inner = untag_ptr(this_arg);
40166 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40167 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40168 this_arg_conv.is_owned = false;
40169 jboolean ret_conv = NodeFeatures_supports_gossip_queries(&this_arg_conv);
40173 jboolean __attribute__((export_name("TS_InitFeatures_requires_gossip_queries"))) TS_InitFeatures_requires_gossip_queries(uint64_t this_arg) {
40174 LDKInitFeatures this_arg_conv;
40175 this_arg_conv.inner = untag_ptr(this_arg);
40176 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40177 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40178 this_arg_conv.is_owned = false;
40179 jboolean ret_conv = InitFeatures_requires_gossip_queries(&this_arg_conv);
40183 jboolean __attribute__((export_name("TS_NodeFeatures_requires_gossip_queries"))) TS_NodeFeatures_requires_gossip_queries(uint64_t this_arg) {
40184 LDKNodeFeatures this_arg_conv;
40185 this_arg_conv.inner = untag_ptr(this_arg);
40186 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40187 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40188 this_arg_conv.is_owned = false;
40189 jboolean ret_conv = NodeFeatures_requires_gossip_queries(&this_arg_conv);
40193 void __attribute__((export_name("TS_InitFeatures_set_variable_length_onion_optional"))) TS_InitFeatures_set_variable_length_onion_optional(uint64_t this_arg) {
40194 LDKInitFeatures this_arg_conv;
40195 this_arg_conv.inner = untag_ptr(this_arg);
40196 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40197 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40198 this_arg_conv.is_owned = false;
40199 InitFeatures_set_variable_length_onion_optional(&this_arg_conv);
40202 void __attribute__((export_name("TS_InitFeatures_set_variable_length_onion_required"))) TS_InitFeatures_set_variable_length_onion_required(uint64_t this_arg) {
40203 LDKInitFeatures this_arg_conv;
40204 this_arg_conv.inner = untag_ptr(this_arg);
40205 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40206 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40207 this_arg_conv.is_owned = false;
40208 InitFeatures_set_variable_length_onion_required(&this_arg_conv);
40211 jboolean __attribute__((export_name("TS_InitFeatures_supports_variable_length_onion"))) TS_InitFeatures_supports_variable_length_onion(uint64_t this_arg) {
40212 LDKInitFeatures this_arg_conv;
40213 this_arg_conv.inner = untag_ptr(this_arg);
40214 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40215 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40216 this_arg_conv.is_owned = false;
40217 jboolean ret_conv = InitFeatures_supports_variable_length_onion(&this_arg_conv);
40221 void __attribute__((export_name("TS_NodeFeatures_set_variable_length_onion_optional"))) TS_NodeFeatures_set_variable_length_onion_optional(uint64_t this_arg) {
40222 LDKNodeFeatures this_arg_conv;
40223 this_arg_conv.inner = untag_ptr(this_arg);
40224 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40225 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40226 this_arg_conv.is_owned = false;
40227 NodeFeatures_set_variable_length_onion_optional(&this_arg_conv);
40230 void __attribute__((export_name("TS_NodeFeatures_set_variable_length_onion_required"))) TS_NodeFeatures_set_variable_length_onion_required(uint64_t this_arg) {
40231 LDKNodeFeatures this_arg_conv;
40232 this_arg_conv.inner = untag_ptr(this_arg);
40233 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40234 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40235 this_arg_conv.is_owned = false;
40236 NodeFeatures_set_variable_length_onion_required(&this_arg_conv);
40239 jboolean __attribute__((export_name("TS_NodeFeatures_supports_variable_length_onion"))) TS_NodeFeatures_supports_variable_length_onion(uint64_t this_arg) {
40240 LDKNodeFeatures this_arg_conv;
40241 this_arg_conv.inner = untag_ptr(this_arg);
40242 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40243 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40244 this_arg_conv.is_owned = false;
40245 jboolean ret_conv = NodeFeatures_supports_variable_length_onion(&this_arg_conv);
40249 void __attribute__((export_name("TS_InvoiceFeatures_set_variable_length_onion_optional"))) TS_InvoiceFeatures_set_variable_length_onion_optional(uint64_t this_arg) {
40250 LDKInvoiceFeatures this_arg_conv;
40251 this_arg_conv.inner = untag_ptr(this_arg);
40252 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40253 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40254 this_arg_conv.is_owned = false;
40255 InvoiceFeatures_set_variable_length_onion_optional(&this_arg_conv);
40258 void __attribute__((export_name("TS_InvoiceFeatures_set_variable_length_onion_required"))) TS_InvoiceFeatures_set_variable_length_onion_required(uint64_t this_arg) {
40259 LDKInvoiceFeatures this_arg_conv;
40260 this_arg_conv.inner = untag_ptr(this_arg);
40261 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40262 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40263 this_arg_conv.is_owned = false;
40264 InvoiceFeatures_set_variable_length_onion_required(&this_arg_conv);
40267 jboolean __attribute__((export_name("TS_InvoiceFeatures_supports_variable_length_onion"))) TS_InvoiceFeatures_supports_variable_length_onion(uint64_t this_arg) {
40268 LDKInvoiceFeatures this_arg_conv;
40269 this_arg_conv.inner = untag_ptr(this_arg);
40270 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40271 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40272 this_arg_conv.is_owned = false;
40273 jboolean ret_conv = InvoiceFeatures_supports_variable_length_onion(&this_arg_conv);
40277 jboolean __attribute__((export_name("TS_InitFeatures_requires_variable_length_onion"))) TS_InitFeatures_requires_variable_length_onion(uint64_t this_arg) {
40278 LDKInitFeatures this_arg_conv;
40279 this_arg_conv.inner = untag_ptr(this_arg);
40280 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40281 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40282 this_arg_conv.is_owned = false;
40283 jboolean ret_conv = InitFeatures_requires_variable_length_onion(&this_arg_conv);
40287 jboolean __attribute__((export_name("TS_NodeFeatures_requires_variable_length_onion"))) TS_NodeFeatures_requires_variable_length_onion(uint64_t this_arg) {
40288 LDKNodeFeatures this_arg_conv;
40289 this_arg_conv.inner = untag_ptr(this_arg);
40290 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40291 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40292 this_arg_conv.is_owned = false;
40293 jboolean ret_conv = NodeFeatures_requires_variable_length_onion(&this_arg_conv);
40297 jboolean __attribute__((export_name("TS_InvoiceFeatures_requires_variable_length_onion"))) TS_InvoiceFeatures_requires_variable_length_onion(uint64_t this_arg) {
40298 LDKInvoiceFeatures this_arg_conv;
40299 this_arg_conv.inner = untag_ptr(this_arg);
40300 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40301 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40302 this_arg_conv.is_owned = false;
40303 jboolean ret_conv = InvoiceFeatures_requires_variable_length_onion(&this_arg_conv);
40307 void __attribute__((export_name("TS_InitFeatures_set_static_remote_key_optional"))) TS_InitFeatures_set_static_remote_key_optional(uint64_t this_arg) {
40308 LDKInitFeatures this_arg_conv;
40309 this_arg_conv.inner = untag_ptr(this_arg);
40310 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40311 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40312 this_arg_conv.is_owned = false;
40313 InitFeatures_set_static_remote_key_optional(&this_arg_conv);
40316 void __attribute__((export_name("TS_InitFeatures_set_static_remote_key_required"))) TS_InitFeatures_set_static_remote_key_required(uint64_t this_arg) {
40317 LDKInitFeatures this_arg_conv;
40318 this_arg_conv.inner = untag_ptr(this_arg);
40319 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40320 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40321 this_arg_conv.is_owned = false;
40322 InitFeatures_set_static_remote_key_required(&this_arg_conv);
40325 jboolean __attribute__((export_name("TS_InitFeatures_supports_static_remote_key"))) TS_InitFeatures_supports_static_remote_key(uint64_t this_arg) {
40326 LDKInitFeatures this_arg_conv;
40327 this_arg_conv.inner = untag_ptr(this_arg);
40328 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40329 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40330 this_arg_conv.is_owned = false;
40331 jboolean ret_conv = InitFeatures_supports_static_remote_key(&this_arg_conv);
40335 void __attribute__((export_name("TS_NodeFeatures_set_static_remote_key_optional"))) TS_NodeFeatures_set_static_remote_key_optional(uint64_t this_arg) {
40336 LDKNodeFeatures this_arg_conv;
40337 this_arg_conv.inner = untag_ptr(this_arg);
40338 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40339 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40340 this_arg_conv.is_owned = false;
40341 NodeFeatures_set_static_remote_key_optional(&this_arg_conv);
40344 void __attribute__((export_name("TS_NodeFeatures_set_static_remote_key_required"))) TS_NodeFeatures_set_static_remote_key_required(uint64_t this_arg) {
40345 LDKNodeFeatures this_arg_conv;
40346 this_arg_conv.inner = untag_ptr(this_arg);
40347 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40348 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40349 this_arg_conv.is_owned = false;
40350 NodeFeatures_set_static_remote_key_required(&this_arg_conv);
40353 jboolean __attribute__((export_name("TS_NodeFeatures_supports_static_remote_key"))) TS_NodeFeatures_supports_static_remote_key(uint64_t this_arg) {
40354 LDKNodeFeatures this_arg_conv;
40355 this_arg_conv.inner = untag_ptr(this_arg);
40356 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40357 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40358 this_arg_conv.is_owned = false;
40359 jboolean ret_conv = NodeFeatures_supports_static_remote_key(&this_arg_conv);
40363 void __attribute__((export_name("TS_ChannelTypeFeatures_set_static_remote_key_optional"))) TS_ChannelTypeFeatures_set_static_remote_key_optional(uint64_t this_arg) {
40364 LDKChannelTypeFeatures this_arg_conv;
40365 this_arg_conv.inner = untag_ptr(this_arg);
40366 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40367 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40368 this_arg_conv.is_owned = false;
40369 ChannelTypeFeatures_set_static_remote_key_optional(&this_arg_conv);
40372 void __attribute__((export_name("TS_ChannelTypeFeatures_set_static_remote_key_required"))) TS_ChannelTypeFeatures_set_static_remote_key_required(uint64_t this_arg) {
40373 LDKChannelTypeFeatures this_arg_conv;
40374 this_arg_conv.inner = untag_ptr(this_arg);
40375 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40376 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40377 this_arg_conv.is_owned = false;
40378 ChannelTypeFeatures_set_static_remote_key_required(&this_arg_conv);
40381 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_supports_static_remote_key"))) TS_ChannelTypeFeatures_supports_static_remote_key(uint64_t this_arg) {
40382 LDKChannelTypeFeatures this_arg_conv;
40383 this_arg_conv.inner = untag_ptr(this_arg);
40384 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40385 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40386 this_arg_conv.is_owned = false;
40387 jboolean ret_conv = ChannelTypeFeatures_supports_static_remote_key(&this_arg_conv);
40391 jboolean __attribute__((export_name("TS_InitFeatures_requires_static_remote_key"))) TS_InitFeatures_requires_static_remote_key(uint64_t this_arg) {
40392 LDKInitFeatures this_arg_conv;
40393 this_arg_conv.inner = untag_ptr(this_arg);
40394 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40395 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40396 this_arg_conv.is_owned = false;
40397 jboolean ret_conv = InitFeatures_requires_static_remote_key(&this_arg_conv);
40401 jboolean __attribute__((export_name("TS_NodeFeatures_requires_static_remote_key"))) TS_NodeFeatures_requires_static_remote_key(uint64_t this_arg) {
40402 LDKNodeFeatures this_arg_conv;
40403 this_arg_conv.inner = untag_ptr(this_arg);
40404 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40405 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40406 this_arg_conv.is_owned = false;
40407 jboolean ret_conv = NodeFeatures_requires_static_remote_key(&this_arg_conv);
40411 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_requires_static_remote_key"))) TS_ChannelTypeFeatures_requires_static_remote_key(uint64_t this_arg) {
40412 LDKChannelTypeFeatures this_arg_conv;
40413 this_arg_conv.inner = untag_ptr(this_arg);
40414 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40415 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40416 this_arg_conv.is_owned = false;
40417 jboolean ret_conv = ChannelTypeFeatures_requires_static_remote_key(&this_arg_conv);
40421 void __attribute__((export_name("TS_InitFeatures_set_payment_secret_optional"))) TS_InitFeatures_set_payment_secret_optional(uint64_t this_arg) {
40422 LDKInitFeatures this_arg_conv;
40423 this_arg_conv.inner = untag_ptr(this_arg);
40424 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40425 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40426 this_arg_conv.is_owned = false;
40427 InitFeatures_set_payment_secret_optional(&this_arg_conv);
40430 void __attribute__((export_name("TS_InitFeatures_set_payment_secret_required"))) TS_InitFeatures_set_payment_secret_required(uint64_t this_arg) {
40431 LDKInitFeatures this_arg_conv;
40432 this_arg_conv.inner = untag_ptr(this_arg);
40433 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40434 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40435 this_arg_conv.is_owned = false;
40436 InitFeatures_set_payment_secret_required(&this_arg_conv);
40439 jboolean __attribute__((export_name("TS_InitFeatures_supports_payment_secret"))) TS_InitFeatures_supports_payment_secret(uint64_t this_arg) {
40440 LDKInitFeatures this_arg_conv;
40441 this_arg_conv.inner = untag_ptr(this_arg);
40442 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40443 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40444 this_arg_conv.is_owned = false;
40445 jboolean ret_conv = InitFeatures_supports_payment_secret(&this_arg_conv);
40449 void __attribute__((export_name("TS_NodeFeatures_set_payment_secret_optional"))) TS_NodeFeatures_set_payment_secret_optional(uint64_t this_arg) {
40450 LDKNodeFeatures this_arg_conv;
40451 this_arg_conv.inner = untag_ptr(this_arg);
40452 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40453 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40454 this_arg_conv.is_owned = false;
40455 NodeFeatures_set_payment_secret_optional(&this_arg_conv);
40458 void __attribute__((export_name("TS_NodeFeatures_set_payment_secret_required"))) TS_NodeFeatures_set_payment_secret_required(uint64_t this_arg) {
40459 LDKNodeFeatures this_arg_conv;
40460 this_arg_conv.inner = untag_ptr(this_arg);
40461 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40462 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40463 this_arg_conv.is_owned = false;
40464 NodeFeatures_set_payment_secret_required(&this_arg_conv);
40467 jboolean __attribute__((export_name("TS_NodeFeatures_supports_payment_secret"))) TS_NodeFeatures_supports_payment_secret(uint64_t this_arg) {
40468 LDKNodeFeatures this_arg_conv;
40469 this_arg_conv.inner = untag_ptr(this_arg);
40470 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40471 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40472 this_arg_conv.is_owned = false;
40473 jboolean ret_conv = NodeFeatures_supports_payment_secret(&this_arg_conv);
40477 void __attribute__((export_name("TS_InvoiceFeatures_set_payment_secret_optional"))) TS_InvoiceFeatures_set_payment_secret_optional(uint64_t this_arg) {
40478 LDKInvoiceFeatures this_arg_conv;
40479 this_arg_conv.inner = untag_ptr(this_arg);
40480 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40481 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40482 this_arg_conv.is_owned = false;
40483 InvoiceFeatures_set_payment_secret_optional(&this_arg_conv);
40486 void __attribute__((export_name("TS_InvoiceFeatures_set_payment_secret_required"))) TS_InvoiceFeatures_set_payment_secret_required(uint64_t this_arg) {
40487 LDKInvoiceFeatures this_arg_conv;
40488 this_arg_conv.inner = untag_ptr(this_arg);
40489 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40490 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40491 this_arg_conv.is_owned = false;
40492 InvoiceFeatures_set_payment_secret_required(&this_arg_conv);
40495 jboolean __attribute__((export_name("TS_InvoiceFeatures_supports_payment_secret"))) TS_InvoiceFeatures_supports_payment_secret(uint64_t this_arg) {
40496 LDKInvoiceFeatures this_arg_conv;
40497 this_arg_conv.inner = untag_ptr(this_arg);
40498 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40499 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40500 this_arg_conv.is_owned = false;
40501 jboolean ret_conv = InvoiceFeatures_supports_payment_secret(&this_arg_conv);
40505 jboolean __attribute__((export_name("TS_InitFeatures_requires_payment_secret"))) TS_InitFeatures_requires_payment_secret(uint64_t this_arg) {
40506 LDKInitFeatures this_arg_conv;
40507 this_arg_conv.inner = untag_ptr(this_arg);
40508 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40509 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40510 this_arg_conv.is_owned = false;
40511 jboolean ret_conv = InitFeatures_requires_payment_secret(&this_arg_conv);
40515 jboolean __attribute__((export_name("TS_NodeFeatures_requires_payment_secret"))) TS_NodeFeatures_requires_payment_secret(uint64_t this_arg) {
40516 LDKNodeFeatures this_arg_conv;
40517 this_arg_conv.inner = untag_ptr(this_arg);
40518 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40519 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40520 this_arg_conv.is_owned = false;
40521 jboolean ret_conv = NodeFeatures_requires_payment_secret(&this_arg_conv);
40525 jboolean __attribute__((export_name("TS_InvoiceFeatures_requires_payment_secret"))) TS_InvoiceFeatures_requires_payment_secret(uint64_t this_arg) {
40526 LDKInvoiceFeatures this_arg_conv;
40527 this_arg_conv.inner = untag_ptr(this_arg);
40528 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40529 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40530 this_arg_conv.is_owned = false;
40531 jboolean ret_conv = InvoiceFeatures_requires_payment_secret(&this_arg_conv);
40535 void __attribute__((export_name("TS_InitFeatures_set_basic_mpp_optional"))) TS_InitFeatures_set_basic_mpp_optional(uint64_t this_arg) {
40536 LDKInitFeatures this_arg_conv;
40537 this_arg_conv.inner = untag_ptr(this_arg);
40538 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40539 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40540 this_arg_conv.is_owned = false;
40541 InitFeatures_set_basic_mpp_optional(&this_arg_conv);
40544 void __attribute__((export_name("TS_InitFeatures_set_basic_mpp_required"))) TS_InitFeatures_set_basic_mpp_required(uint64_t this_arg) {
40545 LDKInitFeatures this_arg_conv;
40546 this_arg_conv.inner = untag_ptr(this_arg);
40547 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40548 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40549 this_arg_conv.is_owned = false;
40550 InitFeatures_set_basic_mpp_required(&this_arg_conv);
40553 jboolean __attribute__((export_name("TS_InitFeatures_supports_basic_mpp"))) TS_InitFeatures_supports_basic_mpp(uint64_t this_arg) {
40554 LDKInitFeatures this_arg_conv;
40555 this_arg_conv.inner = untag_ptr(this_arg);
40556 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40557 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40558 this_arg_conv.is_owned = false;
40559 jboolean ret_conv = InitFeatures_supports_basic_mpp(&this_arg_conv);
40563 void __attribute__((export_name("TS_NodeFeatures_set_basic_mpp_optional"))) TS_NodeFeatures_set_basic_mpp_optional(uint64_t this_arg) {
40564 LDKNodeFeatures this_arg_conv;
40565 this_arg_conv.inner = untag_ptr(this_arg);
40566 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40567 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40568 this_arg_conv.is_owned = false;
40569 NodeFeatures_set_basic_mpp_optional(&this_arg_conv);
40572 void __attribute__((export_name("TS_NodeFeatures_set_basic_mpp_required"))) TS_NodeFeatures_set_basic_mpp_required(uint64_t this_arg) {
40573 LDKNodeFeatures this_arg_conv;
40574 this_arg_conv.inner = untag_ptr(this_arg);
40575 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40576 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40577 this_arg_conv.is_owned = false;
40578 NodeFeatures_set_basic_mpp_required(&this_arg_conv);
40581 jboolean __attribute__((export_name("TS_NodeFeatures_supports_basic_mpp"))) TS_NodeFeatures_supports_basic_mpp(uint64_t this_arg) {
40582 LDKNodeFeatures this_arg_conv;
40583 this_arg_conv.inner = untag_ptr(this_arg);
40584 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40585 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40586 this_arg_conv.is_owned = false;
40587 jboolean ret_conv = NodeFeatures_supports_basic_mpp(&this_arg_conv);
40591 void __attribute__((export_name("TS_InvoiceFeatures_set_basic_mpp_optional"))) TS_InvoiceFeatures_set_basic_mpp_optional(uint64_t this_arg) {
40592 LDKInvoiceFeatures this_arg_conv;
40593 this_arg_conv.inner = untag_ptr(this_arg);
40594 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40595 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40596 this_arg_conv.is_owned = false;
40597 InvoiceFeatures_set_basic_mpp_optional(&this_arg_conv);
40600 void __attribute__((export_name("TS_InvoiceFeatures_set_basic_mpp_required"))) TS_InvoiceFeatures_set_basic_mpp_required(uint64_t this_arg) {
40601 LDKInvoiceFeatures this_arg_conv;
40602 this_arg_conv.inner = untag_ptr(this_arg);
40603 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40604 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40605 this_arg_conv.is_owned = false;
40606 InvoiceFeatures_set_basic_mpp_required(&this_arg_conv);
40609 jboolean __attribute__((export_name("TS_InvoiceFeatures_supports_basic_mpp"))) TS_InvoiceFeatures_supports_basic_mpp(uint64_t this_arg) {
40610 LDKInvoiceFeatures this_arg_conv;
40611 this_arg_conv.inner = untag_ptr(this_arg);
40612 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40613 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40614 this_arg_conv.is_owned = false;
40615 jboolean ret_conv = InvoiceFeatures_supports_basic_mpp(&this_arg_conv);
40619 jboolean __attribute__((export_name("TS_InitFeatures_requires_basic_mpp"))) TS_InitFeatures_requires_basic_mpp(uint64_t this_arg) {
40620 LDKInitFeatures this_arg_conv;
40621 this_arg_conv.inner = untag_ptr(this_arg);
40622 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40623 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40624 this_arg_conv.is_owned = false;
40625 jboolean ret_conv = InitFeatures_requires_basic_mpp(&this_arg_conv);
40629 jboolean __attribute__((export_name("TS_NodeFeatures_requires_basic_mpp"))) TS_NodeFeatures_requires_basic_mpp(uint64_t this_arg) {
40630 LDKNodeFeatures this_arg_conv;
40631 this_arg_conv.inner = untag_ptr(this_arg);
40632 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40633 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40634 this_arg_conv.is_owned = false;
40635 jboolean ret_conv = NodeFeatures_requires_basic_mpp(&this_arg_conv);
40639 jboolean __attribute__((export_name("TS_InvoiceFeatures_requires_basic_mpp"))) TS_InvoiceFeatures_requires_basic_mpp(uint64_t this_arg) {
40640 LDKInvoiceFeatures this_arg_conv;
40641 this_arg_conv.inner = untag_ptr(this_arg);
40642 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40643 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40644 this_arg_conv.is_owned = false;
40645 jboolean ret_conv = InvoiceFeatures_requires_basic_mpp(&this_arg_conv);
40649 void __attribute__((export_name("TS_InitFeatures_set_wumbo_optional"))) TS_InitFeatures_set_wumbo_optional(uint64_t this_arg) {
40650 LDKInitFeatures this_arg_conv;
40651 this_arg_conv.inner = untag_ptr(this_arg);
40652 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40653 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40654 this_arg_conv.is_owned = false;
40655 InitFeatures_set_wumbo_optional(&this_arg_conv);
40658 void __attribute__((export_name("TS_InitFeatures_set_wumbo_required"))) TS_InitFeatures_set_wumbo_required(uint64_t this_arg) {
40659 LDKInitFeatures this_arg_conv;
40660 this_arg_conv.inner = untag_ptr(this_arg);
40661 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40662 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40663 this_arg_conv.is_owned = false;
40664 InitFeatures_set_wumbo_required(&this_arg_conv);
40667 jboolean __attribute__((export_name("TS_InitFeatures_supports_wumbo"))) TS_InitFeatures_supports_wumbo(uint64_t this_arg) {
40668 LDKInitFeatures this_arg_conv;
40669 this_arg_conv.inner = untag_ptr(this_arg);
40670 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40671 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40672 this_arg_conv.is_owned = false;
40673 jboolean ret_conv = InitFeatures_supports_wumbo(&this_arg_conv);
40677 void __attribute__((export_name("TS_NodeFeatures_set_wumbo_optional"))) TS_NodeFeatures_set_wumbo_optional(uint64_t this_arg) {
40678 LDKNodeFeatures this_arg_conv;
40679 this_arg_conv.inner = untag_ptr(this_arg);
40680 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40681 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40682 this_arg_conv.is_owned = false;
40683 NodeFeatures_set_wumbo_optional(&this_arg_conv);
40686 void __attribute__((export_name("TS_NodeFeatures_set_wumbo_required"))) TS_NodeFeatures_set_wumbo_required(uint64_t this_arg) {
40687 LDKNodeFeatures this_arg_conv;
40688 this_arg_conv.inner = untag_ptr(this_arg);
40689 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40690 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40691 this_arg_conv.is_owned = false;
40692 NodeFeatures_set_wumbo_required(&this_arg_conv);
40695 jboolean __attribute__((export_name("TS_NodeFeatures_supports_wumbo"))) TS_NodeFeatures_supports_wumbo(uint64_t this_arg) {
40696 LDKNodeFeatures this_arg_conv;
40697 this_arg_conv.inner = untag_ptr(this_arg);
40698 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40699 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40700 this_arg_conv.is_owned = false;
40701 jboolean ret_conv = NodeFeatures_supports_wumbo(&this_arg_conv);
40705 jboolean __attribute__((export_name("TS_InitFeatures_requires_wumbo"))) TS_InitFeatures_requires_wumbo(uint64_t this_arg) {
40706 LDKInitFeatures this_arg_conv;
40707 this_arg_conv.inner = untag_ptr(this_arg);
40708 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40709 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40710 this_arg_conv.is_owned = false;
40711 jboolean ret_conv = InitFeatures_requires_wumbo(&this_arg_conv);
40715 jboolean __attribute__((export_name("TS_NodeFeatures_requires_wumbo"))) TS_NodeFeatures_requires_wumbo(uint64_t this_arg) {
40716 LDKNodeFeatures this_arg_conv;
40717 this_arg_conv.inner = untag_ptr(this_arg);
40718 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40719 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40720 this_arg_conv.is_owned = false;
40721 jboolean ret_conv = NodeFeatures_requires_wumbo(&this_arg_conv);
40725 void __attribute__((export_name("TS_InitFeatures_set_shutdown_any_segwit_optional"))) TS_InitFeatures_set_shutdown_any_segwit_optional(uint64_t this_arg) {
40726 LDKInitFeatures this_arg_conv;
40727 this_arg_conv.inner = untag_ptr(this_arg);
40728 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40729 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40730 this_arg_conv.is_owned = false;
40731 InitFeatures_set_shutdown_any_segwit_optional(&this_arg_conv);
40734 void __attribute__((export_name("TS_InitFeatures_set_shutdown_any_segwit_required"))) TS_InitFeatures_set_shutdown_any_segwit_required(uint64_t this_arg) {
40735 LDKInitFeatures this_arg_conv;
40736 this_arg_conv.inner = untag_ptr(this_arg);
40737 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40738 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40739 this_arg_conv.is_owned = false;
40740 InitFeatures_set_shutdown_any_segwit_required(&this_arg_conv);
40743 jboolean __attribute__((export_name("TS_InitFeatures_supports_shutdown_anysegwit"))) TS_InitFeatures_supports_shutdown_anysegwit(uint64_t this_arg) {
40744 LDKInitFeatures this_arg_conv;
40745 this_arg_conv.inner = untag_ptr(this_arg);
40746 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40747 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40748 this_arg_conv.is_owned = false;
40749 jboolean ret_conv = InitFeatures_supports_shutdown_anysegwit(&this_arg_conv);
40753 void __attribute__((export_name("TS_NodeFeatures_set_shutdown_any_segwit_optional"))) TS_NodeFeatures_set_shutdown_any_segwit_optional(uint64_t this_arg) {
40754 LDKNodeFeatures this_arg_conv;
40755 this_arg_conv.inner = untag_ptr(this_arg);
40756 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40757 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40758 this_arg_conv.is_owned = false;
40759 NodeFeatures_set_shutdown_any_segwit_optional(&this_arg_conv);
40762 void __attribute__((export_name("TS_NodeFeatures_set_shutdown_any_segwit_required"))) TS_NodeFeatures_set_shutdown_any_segwit_required(uint64_t this_arg) {
40763 LDKNodeFeatures this_arg_conv;
40764 this_arg_conv.inner = untag_ptr(this_arg);
40765 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40766 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40767 this_arg_conv.is_owned = false;
40768 NodeFeatures_set_shutdown_any_segwit_required(&this_arg_conv);
40771 jboolean __attribute__((export_name("TS_NodeFeatures_supports_shutdown_anysegwit"))) TS_NodeFeatures_supports_shutdown_anysegwit(uint64_t this_arg) {
40772 LDKNodeFeatures this_arg_conv;
40773 this_arg_conv.inner = untag_ptr(this_arg);
40774 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40775 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40776 this_arg_conv.is_owned = false;
40777 jboolean ret_conv = NodeFeatures_supports_shutdown_anysegwit(&this_arg_conv);
40781 jboolean __attribute__((export_name("TS_InitFeatures_requires_shutdown_anysegwit"))) TS_InitFeatures_requires_shutdown_anysegwit(uint64_t this_arg) {
40782 LDKInitFeatures this_arg_conv;
40783 this_arg_conv.inner = untag_ptr(this_arg);
40784 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40785 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40786 this_arg_conv.is_owned = false;
40787 jboolean ret_conv = InitFeatures_requires_shutdown_anysegwit(&this_arg_conv);
40791 jboolean __attribute__((export_name("TS_NodeFeatures_requires_shutdown_anysegwit"))) TS_NodeFeatures_requires_shutdown_anysegwit(uint64_t this_arg) {
40792 LDKNodeFeatures this_arg_conv;
40793 this_arg_conv.inner = untag_ptr(this_arg);
40794 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40795 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40796 this_arg_conv.is_owned = false;
40797 jboolean ret_conv = NodeFeatures_requires_shutdown_anysegwit(&this_arg_conv);
40801 void __attribute__((export_name("TS_InitFeatures_set_onion_messages_optional"))) TS_InitFeatures_set_onion_messages_optional(uint64_t this_arg) {
40802 LDKInitFeatures this_arg_conv;
40803 this_arg_conv.inner = untag_ptr(this_arg);
40804 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40805 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40806 this_arg_conv.is_owned = false;
40807 InitFeatures_set_onion_messages_optional(&this_arg_conv);
40810 void __attribute__((export_name("TS_InitFeatures_set_onion_messages_required"))) TS_InitFeatures_set_onion_messages_required(uint64_t this_arg) {
40811 LDKInitFeatures this_arg_conv;
40812 this_arg_conv.inner = untag_ptr(this_arg);
40813 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40814 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40815 this_arg_conv.is_owned = false;
40816 InitFeatures_set_onion_messages_required(&this_arg_conv);
40819 jboolean __attribute__((export_name("TS_InitFeatures_supports_onion_messages"))) TS_InitFeatures_supports_onion_messages(uint64_t this_arg) {
40820 LDKInitFeatures this_arg_conv;
40821 this_arg_conv.inner = untag_ptr(this_arg);
40822 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40823 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40824 this_arg_conv.is_owned = false;
40825 jboolean ret_conv = InitFeatures_supports_onion_messages(&this_arg_conv);
40829 void __attribute__((export_name("TS_NodeFeatures_set_onion_messages_optional"))) TS_NodeFeatures_set_onion_messages_optional(uint64_t this_arg) {
40830 LDKNodeFeatures this_arg_conv;
40831 this_arg_conv.inner = untag_ptr(this_arg);
40832 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40833 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40834 this_arg_conv.is_owned = false;
40835 NodeFeatures_set_onion_messages_optional(&this_arg_conv);
40838 void __attribute__((export_name("TS_NodeFeatures_set_onion_messages_required"))) TS_NodeFeatures_set_onion_messages_required(uint64_t this_arg) {
40839 LDKNodeFeatures this_arg_conv;
40840 this_arg_conv.inner = untag_ptr(this_arg);
40841 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40842 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40843 this_arg_conv.is_owned = false;
40844 NodeFeatures_set_onion_messages_required(&this_arg_conv);
40847 jboolean __attribute__((export_name("TS_NodeFeatures_supports_onion_messages"))) TS_NodeFeatures_supports_onion_messages(uint64_t this_arg) {
40848 LDKNodeFeatures this_arg_conv;
40849 this_arg_conv.inner = untag_ptr(this_arg);
40850 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40851 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40852 this_arg_conv.is_owned = false;
40853 jboolean ret_conv = NodeFeatures_supports_onion_messages(&this_arg_conv);
40857 jboolean __attribute__((export_name("TS_InitFeatures_requires_onion_messages"))) TS_InitFeatures_requires_onion_messages(uint64_t this_arg) {
40858 LDKInitFeatures this_arg_conv;
40859 this_arg_conv.inner = untag_ptr(this_arg);
40860 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40861 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40862 this_arg_conv.is_owned = false;
40863 jboolean ret_conv = InitFeatures_requires_onion_messages(&this_arg_conv);
40867 jboolean __attribute__((export_name("TS_NodeFeatures_requires_onion_messages"))) TS_NodeFeatures_requires_onion_messages(uint64_t this_arg) {
40868 LDKNodeFeatures this_arg_conv;
40869 this_arg_conv.inner = untag_ptr(this_arg);
40870 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40871 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40872 this_arg_conv.is_owned = false;
40873 jboolean ret_conv = NodeFeatures_requires_onion_messages(&this_arg_conv);
40877 void __attribute__((export_name("TS_InitFeatures_set_channel_type_optional"))) TS_InitFeatures_set_channel_type_optional(uint64_t this_arg) {
40878 LDKInitFeatures this_arg_conv;
40879 this_arg_conv.inner = untag_ptr(this_arg);
40880 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40881 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40882 this_arg_conv.is_owned = false;
40883 InitFeatures_set_channel_type_optional(&this_arg_conv);
40886 void __attribute__((export_name("TS_InitFeatures_set_channel_type_required"))) TS_InitFeatures_set_channel_type_required(uint64_t this_arg) {
40887 LDKInitFeatures this_arg_conv;
40888 this_arg_conv.inner = untag_ptr(this_arg);
40889 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40890 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40891 this_arg_conv.is_owned = false;
40892 InitFeatures_set_channel_type_required(&this_arg_conv);
40895 jboolean __attribute__((export_name("TS_InitFeatures_supports_channel_type"))) TS_InitFeatures_supports_channel_type(uint64_t this_arg) {
40896 LDKInitFeatures this_arg_conv;
40897 this_arg_conv.inner = untag_ptr(this_arg);
40898 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40899 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40900 this_arg_conv.is_owned = false;
40901 jboolean ret_conv = InitFeatures_supports_channel_type(&this_arg_conv);
40905 void __attribute__((export_name("TS_NodeFeatures_set_channel_type_optional"))) TS_NodeFeatures_set_channel_type_optional(uint64_t this_arg) {
40906 LDKNodeFeatures this_arg_conv;
40907 this_arg_conv.inner = untag_ptr(this_arg);
40908 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40909 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40910 this_arg_conv.is_owned = false;
40911 NodeFeatures_set_channel_type_optional(&this_arg_conv);
40914 void __attribute__((export_name("TS_NodeFeatures_set_channel_type_required"))) TS_NodeFeatures_set_channel_type_required(uint64_t this_arg) {
40915 LDKNodeFeatures this_arg_conv;
40916 this_arg_conv.inner = untag_ptr(this_arg);
40917 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40918 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40919 this_arg_conv.is_owned = false;
40920 NodeFeatures_set_channel_type_required(&this_arg_conv);
40923 jboolean __attribute__((export_name("TS_NodeFeatures_supports_channel_type"))) TS_NodeFeatures_supports_channel_type(uint64_t this_arg) {
40924 LDKNodeFeatures this_arg_conv;
40925 this_arg_conv.inner = untag_ptr(this_arg);
40926 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40927 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40928 this_arg_conv.is_owned = false;
40929 jboolean ret_conv = NodeFeatures_supports_channel_type(&this_arg_conv);
40933 jboolean __attribute__((export_name("TS_InitFeatures_requires_channel_type"))) TS_InitFeatures_requires_channel_type(uint64_t this_arg) {
40934 LDKInitFeatures this_arg_conv;
40935 this_arg_conv.inner = untag_ptr(this_arg);
40936 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40937 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40938 this_arg_conv.is_owned = false;
40939 jboolean ret_conv = InitFeatures_requires_channel_type(&this_arg_conv);
40943 jboolean __attribute__((export_name("TS_NodeFeatures_requires_channel_type"))) TS_NodeFeatures_requires_channel_type(uint64_t this_arg) {
40944 LDKNodeFeatures this_arg_conv;
40945 this_arg_conv.inner = untag_ptr(this_arg);
40946 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40947 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40948 this_arg_conv.is_owned = false;
40949 jboolean ret_conv = NodeFeatures_requires_channel_type(&this_arg_conv);
40953 void __attribute__((export_name("TS_InitFeatures_set_scid_privacy_optional"))) TS_InitFeatures_set_scid_privacy_optional(uint64_t this_arg) {
40954 LDKInitFeatures this_arg_conv;
40955 this_arg_conv.inner = untag_ptr(this_arg);
40956 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40957 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40958 this_arg_conv.is_owned = false;
40959 InitFeatures_set_scid_privacy_optional(&this_arg_conv);
40962 void __attribute__((export_name("TS_InitFeatures_set_scid_privacy_required"))) TS_InitFeatures_set_scid_privacy_required(uint64_t this_arg) {
40963 LDKInitFeatures this_arg_conv;
40964 this_arg_conv.inner = untag_ptr(this_arg);
40965 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40966 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40967 this_arg_conv.is_owned = false;
40968 InitFeatures_set_scid_privacy_required(&this_arg_conv);
40971 jboolean __attribute__((export_name("TS_InitFeatures_supports_scid_privacy"))) TS_InitFeatures_supports_scid_privacy(uint64_t this_arg) {
40972 LDKInitFeatures this_arg_conv;
40973 this_arg_conv.inner = untag_ptr(this_arg);
40974 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40975 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40976 this_arg_conv.is_owned = false;
40977 jboolean ret_conv = InitFeatures_supports_scid_privacy(&this_arg_conv);
40981 void __attribute__((export_name("TS_NodeFeatures_set_scid_privacy_optional"))) TS_NodeFeatures_set_scid_privacy_optional(uint64_t this_arg) {
40982 LDKNodeFeatures this_arg_conv;
40983 this_arg_conv.inner = untag_ptr(this_arg);
40984 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40985 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40986 this_arg_conv.is_owned = false;
40987 NodeFeatures_set_scid_privacy_optional(&this_arg_conv);
40990 void __attribute__((export_name("TS_NodeFeatures_set_scid_privacy_required"))) TS_NodeFeatures_set_scid_privacy_required(uint64_t this_arg) {
40991 LDKNodeFeatures this_arg_conv;
40992 this_arg_conv.inner = untag_ptr(this_arg);
40993 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40994 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40995 this_arg_conv.is_owned = false;
40996 NodeFeatures_set_scid_privacy_required(&this_arg_conv);
40999 jboolean __attribute__((export_name("TS_NodeFeatures_supports_scid_privacy"))) TS_NodeFeatures_supports_scid_privacy(uint64_t this_arg) {
41000 LDKNodeFeatures this_arg_conv;
41001 this_arg_conv.inner = untag_ptr(this_arg);
41002 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41003 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41004 this_arg_conv.is_owned = false;
41005 jboolean ret_conv = NodeFeatures_supports_scid_privacy(&this_arg_conv);
41009 void __attribute__((export_name("TS_ChannelTypeFeatures_set_scid_privacy_optional"))) TS_ChannelTypeFeatures_set_scid_privacy_optional(uint64_t this_arg) {
41010 LDKChannelTypeFeatures this_arg_conv;
41011 this_arg_conv.inner = untag_ptr(this_arg);
41012 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41013 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41014 this_arg_conv.is_owned = false;
41015 ChannelTypeFeatures_set_scid_privacy_optional(&this_arg_conv);
41018 void __attribute__((export_name("TS_ChannelTypeFeatures_set_scid_privacy_required"))) TS_ChannelTypeFeatures_set_scid_privacy_required(uint64_t this_arg) {
41019 LDKChannelTypeFeatures this_arg_conv;
41020 this_arg_conv.inner = untag_ptr(this_arg);
41021 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41022 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41023 this_arg_conv.is_owned = false;
41024 ChannelTypeFeatures_set_scid_privacy_required(&this_arg_conv);
41027 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_supports_scid_privacy"))) TS_ChannelTypeFeatures_supports_scid_privacy(uint64_t this_arg) {
41028 LDKChannelTypeFeatures this_arg_conv;
41029 this_arg_conv.inner = untag_ptr(this_arg);
41030 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41031 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41032 this_arg_conv.is_owned = false;
41033 jboolean ret_conv = ChannelTypeFeatures_supports_scid_privacy(&this_arg_conv);
41037 jboolean __attribute__((export_name("TS_InitFeatures_requires_scid_privacy"))) TS_InitFeatures_requires_scid_privacy(uint64_t this_arg) {
41038 LDKInitFeatures this_arg_conv;
41039 this_arg_conv.inner = untag_ptr(this_arg);
41040 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41041 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41042 this_arg_conv.is_owned = false;
41043 jboolean ret_conv = InitFeatures_requires_scid_privacy(&this_arg_conv);
41047 jboolean __attribute__((export_name("TS_NodeFeatures_requires_scid_privacy"))) TS_NodeFeatures_requires_scid_privacy(uint64_t this_arg) {
41048 LDKNodeFeatures this_arg_conv;
41049 this_arg_conv.inner = untag_ptr(this_arg);
41050 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41051 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41052 this_arg_conv.is_owned = false;
41053 jboolean ret_conv = NodeFeatures_requires_scid_privacy(&this_arg_conv);
41057 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_requires_scid_privacy"))) TS_ChannelTypeFeatures_requires_scid_privacy(uint64_t this_arg) {
41058 LDKChannelTypeFeatures this_arg_conv;
41059 this_arg_conv.inner = untag_ptr(this_arg);
41060 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41061 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41062 this_arg_conv.is_owned = false;
41063 jboolean ret_conv = ChannelTypeFeatures_requires_scid_privacy(&this_arg_conv);
41067 void __attribute__((export_name("TS_InitFeatures_set_zero_conf_optional"))) TS_InitFeatures_set_zero_conf_optional(uint64_t this_arg) {
41068 LDKInitFeatures this_arg_conv;
41069 this_arg_conv.inner = untag_ptr(this_arg);
41070 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41071 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41072 this_arg_conv.is_owned = false;
41073 InitFeatures_set_zero_conf_optional(&this_arg_conv);
41076 void __attribute__((export_name("TS_InitFeatures_set_zero_conf_required"))) TS_InitFeatures_set_zero_conf_required(uint64_t this_arg) {
41077 LDKInitFeatures this_arg_conv;
41078 this_arg_conv.inner = untag_ptr(this_arg);
41079 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41080 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41081 this_arg_conv.is_owned = false;
41082 InitFeatures_set_zero_conf_required(&this_arg_conv);
41085 jboolean __attribute__((export_name("TS_InitFeatures_supports_zero_conf"))) TS_InitFeatures_supports_zero_conf(uint64_t this_arg) {
41086 LDKInitFeatures this_arg_conv;
41087 this_arg_conv.inner = untag_ptr(this_arg);
41088 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41089 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41090 this_arg_conv.is_owned = false;
41091 jboolean ret_conv = InitFeatures_supports_zero_conf(&this_arg_conv);
41095 void __attribute__((export_name("TS_NodeFeatures_set_zero_conf_optional"))) TS_NodeFeatures_set_zero_conf_optional(uint64_t this_arg) {
41096 LDKNodeFeatures this_arg_conv;
41097 this_arg_conv.inner = untag_ptr(this_arg);
41098 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41099 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41100 this_arg_conv.is_owned = false;
41101 NodeFeatures_set_zero_conf_optional(&this_arg_conv);
41104 void __attribute__((export_name("TS_NodeFeatures_set_zero_conf_required"))) TS_NodeFeatures_set_zero_conf_required(uint64_t this_arg) {
41105 LDKNodeFeatures this_arg_conv;
41106 this_arg_conv.inner = untag_ptr(this_arg);
41107 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41108 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41109 this_arg_conv.is_owned = false;
41110 NodeFeatures_set_zero_conf_required(&this_arg_conv);
41113 jboolean __attribute__((export_name("TS_NodeFeatures_supports_zero_conf"))) TS_NodeFeatures_supports_zero_conf(uint64_t this_arg) {
41114 LDKNodeFeatures this_arg_conv;
41115 this_arg_conv.inner = untag_ptr(this_arg);
41116 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41117 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41118 this_arg_conv.is_owned = false;
41119 jboolean ret_conv = NodeFeatures_supports_zero_conf(&this_arg_conv);
41123 void __attribute__((export_name("TS_ChannelTypeFeatures_set_zero_conf_optional"))) TS_ChannelTypeFeatures_set_zero_conf_optional(uint64_t this_arg) {
41124 LDKChannelTypeFeatures this_arg_conv;
41125 this_arg_conv.inner = untag_ptr(this_arg);
41126 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41127 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41128 this_arg_conv.is_owned = false;
41129 ChannelTypeFeatures_set_zero_conf_optional(&this_arg_conv);
41132 void __attribute__((export_name("TS_ChannelTypeFeatures_set_zero_conf_required"))) TS_ChannelTypeFeatures_set_zero_conf_required(uint64_t this_arg) {
41133 LDKChannelTypeFeatures this_arg_conv;
41134 this_arg_conv.inner = untag_ptr(this_arg);
41135 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41136 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41137 this_arg_conv.is_owned = false;
41138 ChannelTypeFeatures_set_zero_conf_required(&this_arg_conv);
41141 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_supports_zero_conf"))) TS_ChannelTypeFeatures_supports_zero_conf(uint64_t this_arg) {
41142 LDKChannelTypeFeatures this_arg_conv;
41143 this_arg_conv.inner = untag_ptr(this_arg);
41144 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41145 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41146 this_arg_conv.is_owned = false;
41147 jboolean ret_conv = ChannelTypeFeatures_supports_zero_conf(&this_arg_conv);
41151 jboolean __attribute__((export_name("TS_InitFeatures_requires_zero_conf"))) TS_InitFeatures_requires_zero_conf(uint64_t this_arg) {
41152 LDKInitFeatures this_arg_conv;
41153 this_arg_conv.inner = untag_ptr(this_arg);
41154 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41155 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41156 this_arg_conv.is_owned = false;
41157 jboolean ret_conv = InitFeatures_requires_zero_conf(&this_arg_conv);
41161 jboolean __attribute__((export_name("TS_NodeFeatures_requires_zero_conf"))) TS_NodeFeatures_requires_zero_conf(uint64_t this_arg) {
41162 LDKNodeFeatures this_arg_conv;
41163 this_arg_conv.inner = untag_ptr(this_arg);
41164 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41165 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41166 this_arg_conv.is_owned = false;
41167 jboolean ret_conv = NodeFeatures_requires_zero_conf(&this_arg_conv);
41171 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_requires_zero_conf"))) TS_ChannelTypeFeatures_requires_zero_conf(uint64_t this_arg) {
41172 LDKChannelTypeFeatures this_arg_conv;
41173 this_arg_conv.inner = untag_ptr(this_arg);
41174 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41175 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41176 this_arg_conv.is_owned = false;
41177 jboolean ret_conv = ChannelTypeFeatures_requires_zero_conf(&this_arg_conv);
41181 void __attribute__((export_name("TS_NodeFeatures_set_keysend_optional"))) TS_NodeFeatures_set_keysend_optional(uint64_t this_arg) {
41182 LDKNodeFeatures this_arg_conv;
41183 this_arg_conv.inner = untag_ptr(this_arg);
41184 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41185 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41186 this_arg_conv.is_owned = false;
41187 NodeFeatures_set_keysend_optional(&this_arg_conv);
41190 void __attribute__((export_name("TS_NodeFeatures_set_keysend_required"))) TS_NodeFeatures_set_keysend_required(uint64_t this_arg) {
41191 LDKNodeFeatures this_arg_conv;
41192 this_arg_conv.inner = untag_ptr(this_arg);
41193 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41194 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41195 this_arg_conv.is_owned = false;
41196 NodeFeatures_set_keysend_required(&this_arg_conv);
41199 jboolean __attribute__((export_name("TS_NodeFeatures_supports_keysend"))) TS_NodeFeatures_supports_keysend(uint64_t this_arg) {
41200 LDKNodeFeatures this_arg_conv;
41201 this_arg_conv.inner = untag_ptr(this_arg);
41202 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41203 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41204 this_arg_conv.is_owned = false;
41205 jboolean ret_conv = NodeFeatures_supports_keysend(&this_arg_conv);
41209 jboolean __attribute__((export_name("TS_NodeFeatures_requires_keysend"))) TS_NodeFeatures_requires_keysend(uint64_t this_arg) {
41210 LDKNodeFeatures this_arg_conv;
41211 this_arg_conv.inner = untag_ptr(this_arg);
41212 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41213 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41214 this_arg_conv.is_owned = false;
41215 jboolean ret_conv = NodeFeatures_requires_keysend(&this_arg_conv);
41219 void __attribute__((export_name("TS_ShutdownScript_free"))) TS_ShutdownScript_free(uint64_t this_obj) {
41220 LDKShutdownScript this_obj_conv;
41221 this_obj_conv.inner = untag_ptr(this_obj);
41222 this_obj_conv.is_owned = ptr_is_owned(this_obj);
41223 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
41224 ShutdownScript_free(this_obj_conv);
41227 static inline uint64_t ShutdownScript_clone_ptr(LDKShutdownScript *NONNULL_PTR arg) {
41228 LDKShutdownScript ret_var = ShutdownScript_clone(arg);
41229 uint64_t ret_ref = 0;
41230 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41231 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41234 int64_t __attribute__((export_name("TS_ShutdownScript_clone_ptr"))) TS_ShutdownScript_clone_ptr(uint64_t arg) {
41235 LDKShutdownScript arg_conv;
41236 arg_conv.inner = untag_ptr(arg);
41237 arg_conv.is_owned = ptr_is_owned(arg);
41238 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
41239 arg_conv.is_owned = false;
41240 int64_t ret_conv = ShutdownScript_clone_ptr(&arg_conv);
41244 uint64_t __attribute__((export_name("TS_ShutdownScript_clone"))) TS_ShutdownScript_clone(uint64_t orig) {
41245 LDKShutdownScript orig_conv;
41246 orig_conv.inner = untag_ptr(orig);
41247 orig_conv.is_owned = ptr_is_owned(orig);
41248 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
41249 orig_conv.is_owned = false;
41250 LDKShutdownScript ret_var = ShutdownScript_clone(&orig_conv);
41251 uint64_t ret_ref = 0;
41252 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41253 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41257 jboolean __attribute__((export_name("TS_ShutdownScript_eq"))) TS_ShutdownScript_eq(uint64_t a, uint64_t b) {
41258 LDKShutdownScript a_conv;
41259 a_conv.inner = untag_ptr(a);
41260 a_conv.is_owned = ptr_is_owned(a);
41261 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
41262 a_conv.is_owned = false;
41263 LDKShutdownScript b_conv;
41264 b_conv.inner = untag_ptr(b);
41265 b_conv.is_owned = ptr_is_owned(b);
41266 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
41267 b_conv.is_owned = false;
41268 jboolean ret_conv = ShutdownScript_eq(&a_conv, &b_conv);
41272 void __attribute__((export_name("TS_InvalidShutdownScript_free"))) TS_InvalidShutdownScript_free(uint64_t this_obj) {
41273 LDKInvalidShutdownScript this_obj_conv;
41274 this_obj_conv.inner = untag_ptr(this_obj);
41275 this_obj_conv.is_owned = ptr_is_owned(this_obj);
41276 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
41277 InvalidShutdownScript_free(this_obj_conv);
41280 int8_tArray __attribute__((export_name("TS_InvalidShutdownScript_get_script"))) TS_InvalidShutdownScript_get_script(uint64_t this_ptr) {
41281 LDKInvalidShutdownScript this_ptr_conv;
41282 this_ptr_conv.inner = untag_ptr(this_ptr);
41283 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41284 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41285 this_ptr_conv.is_owned = false;
41286 LDKu8slice ret_var = InvalidShutdownScript_get_script(&this_ptr_conv);
41287 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
41288 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
41292 void __attribute__((export_name("TS_InvalidShutdownScript_set_script"))) TS_InvalidShutdownScript_set_script(uint64_t this_ptr, int8_tArray val) {
41293 LDKInvalidShutdownScript this_ptr_conv;
41294 this_ptr_conv.inner = untag_ptr(this_ptr);
41295 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41296 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41297 this_ptr_conv.is_owned = false;
41298 LDKCVec_u8Z val_ref;
41299 val_ref.datalen = val->arr_len;
41300 val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
41301 memcpy(val_ref.data, val->elems, val_ref.datalen); FREE(val);
41302 InvalidShutdownScript_set_script(&this_ptr_conv, val_ref);
41305 uint64_t __attribute__((export_name("TS_InvalidShutdownScript_new"))) TS_InvalidShutdownScript_new(int8_tArray script_arg) {
41306 LDKCVec_u8Z script_arg_ref;
41307 script_arg_ref.datalen = script_arg->arr_len;
41308 script_arg_ref.data = MALLOC(script_arg_ref.datalen, "LDKCVec_u8Z Bytes");
41309 memcpy(script_arg_ref.data, script_arg->elems, script_arg_ref.datalen); FREE(script_arg);
41310 LDKInvalidShutdownScript ret_var = InvalidShutdownScript_new(script_arg_ref);
41311 uint64_t ret_ref = 0;
41312 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41313 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41317 static inline uint64_t InvalidShutdownScript_clone_ptr(LDKInvalidShutdownScript *NONNULL_PTR arg) {
41318 LDKInvalidShutdownScript ret_var = InvalidShutdownScript_clone(arg);
41319 uint64_t ret_ref = 0;
41320 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41321 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41324 int64_t __attribute__((export_name("TS_InvalidShutdownScript_clone_ptr"))) TS_InvalidShutdownScript_clone_ptr(uint64_t arg) {
41325 LDKInvalidShutdownScript arg_conv;
41326 arg_conv.inner = untag_ptr(arg);
41327 arg_conv.is_owned = ptr_is_owned(arg);
41328 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
41329 arg_conv.is_owned = false;
41330 int64_t ret_conv = InvalidShutdownScript_clone_ptr(&arg_conv);
41334 uint64_t __attribute__((export_name("TS_InvalidShutdownScript_clone"))) TS_InvalidShutdownScript_clone(uint64_t orig) {
41335 LDKInvalidShutdownScript orig_conv;
41336 orig_conv.inner = untag_ptr(orig);
41337 orig_conv.is_owned = ptr_is_owned(orig);
41338 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
41339 orig_conv.is_owned = false;
41340 LDKInvalidShutdownScript ret_var = InvalidShutdownScript_clone(&orig_conv);
41341 uint64_t ret_ref = 0;
41342 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41343 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41347 int8_tArray __attribute__((export_name("TS_ShutdownScript_write"))) TS_ShutdownScript_write(uint64_t obj) {
41348 LDKShutdownScript obj_conv;
41349 obj_conv.inner = untag_ptr(obj);
41350 obj_conv.is_owned = ptr_is_owned(obj);
41351 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
41352 obj_conv.is_owned = false;
41353 LDKCVec_u8Z ret_var = ShutdownScript_write(&obj_conv);
41354 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
41355 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
41356 CVec_u8Z_free(ret_var);
41360 uint64_t __attribute__((export_name("TS_ShutdownScript_read"))) TS_ShutdownScript_read(int8_tArray ser) {
41361 LDKu8slice ser_ref;
41362 ser_ref.datalen = ser->arr_len;
41363 ser_ref.data = ser->elems;
41364 LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
41365 *ret_conv = ShutdownScript_read(ser_ref);
41367 return tag_ptr(ret_conv, true);
41370 uint64_t __attribute__((export_name("TS_ShutdownScript_new_p2wpkh"))) TS_ShutdownScript_new_p2wpkh(int8_tArray pubkey_hash) {
41371 unsigned char pubkey_hash_arr[20];
41372 CHECK(pubkey_hash->arr_len == 20);
41373 memcpy(pubkey_hash_arr, pubkey_hash->elems, 20); FREE(pubkey_hash);
41374 unsigned char (*pubkey_hash_ref)[20] = &pubkey_hash_arr;
41375 LDKShutdownScript ret_var = ShutdownScript_new_p2wpkh(pubkey_hash_ref);
41376 uint64_t ret_ref = 0;
41377 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41378 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41382 uint64_t __attribute__((export_name("TS_ShutdownScript_new_p2wsh"))) TS_ShutdownScript_new_p2wsh(int8_tArray script_hash) {
41383 unsigned char script_hash_arr[32];
41384 CHECK(script_hash->arr_len == 32);
41385 memcpy(script_hash_arr, script_hash->elems, 32); FREE(script_hash);
41386 unsigned char (*script_hash_ref)[32] = &script_hash_arr;
41387 LDKShutdownScript ret_var = ShutdownScript_new_p2wsh(script_hash_ref);
41388 uint64_t ret_ref = 0;
41389 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41390 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41394 uint64_t __attribute__((export_name("TS_ShutdownScript_new_witness_program"))) TS_ShutdownScript_new_witness_program(int8_t version, int8_tArray program) {
41396 LDKu8slice program_ref;
41397 program_ref.datalen = program->arr_len;
41398 program_ref.data = program->elems;
41399 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
41400 *ret_conv = ShutdownScript_new_witness_program((LDKWitnessVersion){ ._0 = version }, program_ref);
41402 return tag_ptr(ret_conv, true);
41405 int8_tArray __attribute__((export_name("TS_ShutdownScript_into_inner"))) TS_ShutdownScript_into_inner(uint64_t this_arg) {
41406 LDKShutdownScript this_arg_conv;
41407 this_arg_conv.inner = untag_ptr(this_arg);
41408 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41409 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41410 this_arg_conv = ShutdownScript_clone(&this_arg_conv);
41411 LDKCVec_u8Z ret_var = ShutdownScript_into_inner(this_arg_conv);
41412 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
41413 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
41414 CVec_u8Z_free(ret_var);
41418 int8_tArray __attribute__((export_name("TS_ShutdownScript_as_legacy_pubkey"))) TS_ShutdownScript_as_legacy_pubkey(uint64_t this_arg) {
41419 LDKShutdownScript this_arg_conv;
41420 this_arg_conv.inner = untag_ptr(this_arg);
41421 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41422 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41423 this_arg_conv.is_owned = false;
41424 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
41425 memcpy(ret_arr->elems, ShutdownScript_as_legacy_pubkey(&this_arg_conv).compressed_form, 33);
41429 jboolean __attribute__((export_name("TS_ShutdownScript_is_compatible"))) TS_ShutdownScript_is_compatible(uint64_t this_arg, uint64_t features) {
41430 LDKShutdownScript this_arg_conv;
41431 this_arg_conv.inner = untag_ptr(this_arg);
41432 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41433 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41434 this_arg_conv.is_owned = false;
41435 LDKInitFeatures features_conv;
41436 features_conv.inner = untag_ptr(features);
41437 features_conv.is_owned = ptr_is_owned(features);
41438 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_conv);
41439 features_conv.is_owned = false;
41440 jboolean ret_conv = ShutdownScript_is_compatible(&this_arg_conv, &features_conv);
41444 void __attribute__((export_name("TS_CustomMessageReader_free"))) TS_CustomMessageReader_free(uint64_t this_ptr) {
41445 if (!ptr_is_owned(this_ptr)) return;
41446 void* this_ptr_ptr = untag_ptr(this_ptr);
41447 CHECK_ACCESS(this_ptr_ptr);
41448 LDKCustomMessageReader this_ptr_conv = *(LDKCustomMessageReader*)(this_ptr_ptr);
41449 FREE(untag_ptr(this_ptr));
41450 CustomMessageReader_free(this_ptr_conv);
41453 static inline uint64_t Type_clone_ptr(LDKType *NONNULL_PTR arg) {
41454 LDKType* ret_ret = MALLOC(sizeof(LDKType), "LDKType");
41455 *ret_ret = Type_clone(arg);
41456 return tag_ptr(ret_ret, true);
41458 int64_t __attribute__((export_name("TS_Type_clone_ptr"))) TS_Type_clone_ptr(uint64_t arg) {
41459 void* arg_ptr = untag_ptr(arg);
41460 if (ptr_is_owned(arg)) { CHECK_ACCESS(arg_ptr); }
41461 LDKType* arg_conv = (LDKType*)arg_ptr;
41462 int64_t ret_conv = Type_clone_ptr(arg_conv);
41466 uint64_t __attribute__((export_name("TS_Type_clone"))) TS_Type_clone(uint64_t orig) {
41467 void* orig_ptr = untag_ptr(orig);
41468 if (ptr_is_owned(orig)) { CHECK_ACCESS(orig_ptr); }
41469 LDKType* orig_conv = (LDKType*)orig_ptr;
41470 LDKType* ret_ret = MALLOC(sizeof(LDKType), "LDKType");
41471 *ret_ret = Type_clone(orig_conv);
41472 return tag_ptr(ret_ret, true);
41475 void __attribute__((export_name("TS_Type_free"))) TS_Type_free(uint64_t this_ptr) {
41476 if (!ptr_is_owned(this_ptr)) return;
41477 void* this_ptr_ptr = untag_ptr(this_ptr);
41478 CHECK_ACCESS(this_ptr_ptr);
41479 LDKType this_ptr_conv = *(LDKType*)(this_ptr_ptr);
41480 FREE(untag_ptr(this_ptr));
41481 Type_free(this_ptr_conv);
41484 void __attribute__((export_name("TS_NodeId_free"))) TS_NodeId_free(uint64_t this_obj) {
41485 LDKNodeId this_obj_conv;
41486 this_obj_conv.inner = untag_ptr(this_obj);
41487 this_obj_conv.is_owned = ptr_is_owned(this_obj);
41488 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
41489 NodeId_free(this_obj_conv);
41492 static inline uint64_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg) {
41493 LDKNodeId ret_var = NodeId_clone(arg);
41494 uint64_t ret_ref = 0;
41495 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41496 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41499 int64_t __attribute__((export_name("TS_NodeId_clone_ptr"))) TS_NodeId_clone_ptr(uint64_t arg) {
41500 LDKNodeId arg_conv;
41501 arg_conv.inner = untag_ptr(arg);
41502 arg_conv.is_owned = ptr_is_owned(arg);
41503 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
41504 arg_conv.is_owned = false;
41505 int64_t ret_conv = NodeId_clone_ptr(&arg_conv);
41509 uint64_t __attribute__((export_name("TS_NodeId_clone"))) TS_NodeId_clone(uint64_t orig) {
41510 LDKNodeId orig_conv;
41511 orig_conv.inner = untag_ptr(orig);
41512 orig_conv.is_owned = ptr_is_owned(orig);
41513 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
41514 orig_conv.is_owned = false;
41515 LDKNodeId ret_var = NodeId_clone(&orig_conv);
41516 uint64_t ret_ref = 0;
41517 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41518 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41522 uint64_t __attribute__((export_name("TS_NodeId_from_pubkey"))) TS_NodeId_from_pubkey(int8_tArray pubkey) {
41523 LDKPublicKey pubkey_ref;
41524 CHECK(pubkey->arr_len == 33);
41525 memcpy(pubkey_ref.compressed_form, pubkey->elems, 33); FREE(pubkey);
41526 LDKNodeId ret_var = NodeId_from_pubkey(pubkey_ref);
41527 uint64_t ret_ref = 0;
41528 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41529 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41533 int8_tArray __attribute__((export_name("TS_NodeId_as_slice"))) TS_NodeId_as_slice(uint64_t this_arg) {
41534 LDKNodeId this_arg_conv;
41535 this_arg_conv.inner = untag_ptr(this_arg);
41536 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41537 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41538 this_arg_conv.is_owned = false;
41539 LDKu8slice ret_var = NodeId_as_slice(&this_arg_conv);
41540 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
41541 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
41545 int64_t __attribute__((export_name("TS_NodeId_hash"))) TS_NodeId_hash(uint64_t o) {
41547 o_conv.inner = untag_ptr(o);
41548 o_conv.is_owned = ptr_is_owned(o);
41549 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
41550 o_conv.is_owned = false;
41551 int64_t ret_conv = NodeId_hash(&o_conv);
41555 int8_tArray __attribute__((export_name("TS_NodeId_write"))) TS_NodeId_write(uint64_t obj) {
41556 LDKNodeId obj_conv;
41557 obj_conv.inner = untag_ptr(obj);
41558 obj_conv.is_owned = ptr_is_owned(obj);
41559 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
41560 obj_conv.is_owned = false;
41561 LDKCVec_u8Z ret_var = NodeId_write(&obj_conv);
41562 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
41563 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
41564 CVec_u8Z_free(ret_var);
41568 uint64_t __attribute__((export_name("TS_NodeId_read"))) TS_NodeId_read(int8_tArray ser) {
41569 LDKu8slice ser_ref;
41570 ser_ref.datalen = ser->arr_len;
41571 ser_ref.data = ser->elems;
41572 LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
41573 *ret_conv = NodeId_read(ser_ref);
41575 return tag_ptr(ret_conv, true);
41578 void __attribute__((export_name("TS_NetworkGraph_free"))) TS_NetworkGraph_free(uint64_t this_obj) {
41579 LDKNetworkGraph this_obj_conv;
41580 this_obj_conv.inner = untag_ptr(this_obj);
41581 this_obj_conv.is_owned = ptr_is_owned(this_obj);
41582 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
41583 NetworkGraph_free(this_obj_conv);
41586 void __attribute__((export_name("TS_ReadOnlyNetworkGraph_free"))) TS_ReadOnlyNetworkGraph_free(uint64_t this_obj) {
41587 LDKReadOnlyNetworkGraph this_obj_conv;
41588 this_obj_conv.inner = untag_ptr(this_obj);
41589 this_obj_conv.is_owned = ptr_is_owned(this_obj);
41590 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
41591 ReadOnlyNetworkGraph_free(this_obj_conv);
41594 void __attribute__((export_name("TS_NetworkUpdate_free"))) TS_NetworkUpdate_free(uint64_t this_ptr) {
41595 if (!ptr_is_owned(this_ptr)) return;
41596 void* this_ptr_ptr = untag_ptr(this_ptr);
41597 CHECK_ACCESS(this_ptr_ptr);
41598 LDKNetworkUpdate this_ptr_conv = *(LDKNetworkUpdate*)(this_ptr_ptr);
41599 FREE(untag_ptr(this_ptr));
41600 NetworkUpdate_free(this_ptr_conv);
41603 static inline uint64_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg) {
41604 LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
41605 *ret_copy = NetworkUpdate_clone(arg);
41606 uint64_t ret_ref = tag_ptr(ret_copy, true);
41609 int64_t __attribute__((export_name("TS_NetworkUpdate_clone_ptr"))) TS_NetworkUpdate_clone_ptr(uint64_t arg) {
41610 LDKNetworkUpdate* arg_conv = (LDKNetworkUpdate*)untag_ptr(arg);
41611 int64_t ret_conv = NetworkUpdate_clone_ptr(arg_conv);
41615 uint64_t __attribute__((export_name("TS_NetworkUpdate_clone"))) TS_NetworkUpdate_clone(uint64_t orig) {
41616 LDKNetworkUpdate* orig_conv = (LDKNetworkUpdate*)untag_ptr(orig);
41617 LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
41618 *ret_copy = NetworkUpdate_clone(orig_conv);
41619 uint64_t ret_ref = tag_ptr(ret_copy, true);
41623 uint64_t __attribute__((export_name("TS_NetworkUpdate_channel_update_message"))) TS_NetworkUpdate_channel_update_message(uint64_t msg) {
41624 LDKChannelUpdate msg_conv;
41625 msg_conv.inner = untag_ptr(msg);
41626 msg_conv.is_owned = ptr_is_owned(msg);
41627 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
41628 msg_conv = ChannelUpdate_clone(&msg_conv);
41629 LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
41630 *ret_copy = NetworkUpdate_channel_update_message(msg_conv);
41631 uint64_t ret_ref = tag_ptr(ret_copy, true);
41635 uint64_t __attribute__((export_name("TS_NetworkUpdate_channel_failure"))) TS_NetworkUpdate_channel_failure(int64_t short_channel_id, jboolean is_permanent) {
41636 LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
41637 *ret_copy = NetworkUpdate_channel_failure(short_channel_id, is_permanent);
41638 uint64_t ret_ref = tag_ptr(ret_copy, true);
41642 uint64_t __attribute__((export_name("TS_NetworkUpdate_node_failure"))) TS_NetworkUpdate_node_failure(int8_tArray node_id, jboolean is_permanent) {
41643 LDKPublicKey node_id_ref;
41644 CHECK(node_id->arr_len == 33);
41645 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
41646 LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
41647 *ret_copy = NetworkUpdate_node_failure(node_id_ref, is_permanent);
41648 uint64_t ret_ref = tag_ptr(ret_copy, true);
41652 jboolean __attribute__((export_name("TS_NetworkUpdate_eq"))) TS_NetworkUpdate_eq(uint64_t a, uint64_t b) {
41653 LDKNetworkUpdate* a_conv = (LDKNetworkUpdate*)untag_ptr(a);
41654 LDKNetworkUpdate* b_conv = (LDKNetworkUpdate*)untag_ptr(b);
41655 jboolean ret_conv = NetworkUpdate_eq(a_conv, b_conv);
41659 int8_tArray __attribute__((export_name("TS_NetworkUpdate_write"))) TS_NetworkUpdate_write(uint64_t obj) {
41660 LDKNetworkUpdate* obj_conv = (LDKNetworkUpdate*)untag_ptr(obj);
41661 LDKCVec_u8Z ret_var = NetworkUpdate_write(obj_conv);
41662 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
41663 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
41664 CVec_u8Z_free(ret_var);
41668 uint64_t __attribute__((export_name("TS_NetworkUpdate_read"))) TS_NetworkUpdate_read(int8_tArray ser) {
41669 LDKu8slice ser_ref;
41670 ser_ref.datalen = ser->arr_len;
41671 ser_ref.data = ser->elems;
41672 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
41673 *ret_conv = NetworkUpdate_read(ser_ref);
41675 return tag_ptr(ret_conv, true);
41678 void __attribute__((export_name("TS_P2PGossipSync_free"))) TS_P2PGossipSync_free(uint64_t this_obj) {
41679 LDKP2PGossipSync this_obj_conv;
41680 this_obj_conv.inner = untag_ptr(this_obj);
41681 this_obj_conv.is_owned = ptr_is_owned(this_obj);
41682 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
41683 P2PGossipSync_free(this_obj_conv);
41686 uint64_t __attribute__((export_name("TS_P2PGossipSync_new"))) TS_P2PGossipSync_new(uint64_t network_graph, uint64_t chain_access, uint64_t logger) {
41687 LDKNetworkGraph network_graph_conv;
41688 network_graph_conv.inner = untag_ptr(network_graph);
41689 network_graph_conv.is_owned = ptr_is_owned(network_graph);
41690 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
41691 network_graph_conv.is_owned = false;
41692 void* chain_access_ptr = untag_ptr(chain_access);
41693 CHECK_ACCESS(chain_access_ptr);
41694 LDKCOption_AccessZ chain_access_conv = *(LDKCOption_AccessZ*)(chain_access_ptr);
41695 // WARNING: we may need a move here but no clone is available for LDKCOption_AccessZ
41696 if (chain_access_conv.tag == LDKCOption_AccessZ_Some) {
41697 // Manually implement clone for Java trait instances
41698 if (chain_access_conv.some.free == LDKAccess_JCalls_free) {
41699 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
41700 LDKAccess_JCalls_cloned(&chain_access_conv.some);
41703 void* logger_ptr = untag_ptr(logger);
41704 CHECK_ACCESS(logger_ptr);
41705 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
41706 if (logger_conv.free == LDKLogger_JCalls_free) {
41707 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
41708 LDKLogger_JCalls_cloned(&logger_conv);
41710 LDKP2PGossipSync ret_var = P2PGossipSync_new(&network_graph_conv, chain_access_conv, logger_conv);
41711 uint64_t ret_ref = 0;
41712 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41713 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41717 void __attribute__((export_name("TS_P2PGossipSync_add_chain_access"))) TS_P2PGossipSync_add_chain_access(uint64_t this_arg, uint64_t chain_access) {
41718 LDKP2PGossipSync this_arg_conv;
41719 this_arg_conv.inner = untag_ptr(this_arg);
41720 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41721 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41722 this_arg_conv.is_owned = false;
41723 void* chain_access_ptr = untag_ptr(chain_access);
41724 CHECK_ACCESS(chain_access_ptr);
41725 LDKCOption_AccessZ chain_access_conv = *(LDKCOption_AccessZ*)(chain_access_ptr);
41726 // WARNING: we may need a move here but no clone is available for LDKCOption_AccessZ
41727 if (chain_access_conv.tag == LDKCOption_AccessZ_Some) {
41728 // Manually implement clone for Java trait instances
41729 if (chain_access_conv.some.free == LDKAccess_JCalls_free) {
41730 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
41731 LDKAccess_JCalls_cloned(&chain_access_conv.some);
41734 P2PGossipSync_add_chain_access(&this_arg_conv, chain_access_conv);
41737 void __attribute__((export_name("TS_NetworkGraph_handle_network_update"))) TS_NetworkGraph_handle_network_update(uint64_t this_arg, uint64_t network_update) {
41738 LDKNetworkGraph this_arg_conv;
41739 this_arg_conv.inner = untag_ptr(this_arg);
41740 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41741 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41742 this_arg_conv.is_owned = false;
41743 LDKNetworkUpdate* network_update_conv = (LDKNetworkUpdate*)untag_ptr(network_update);
41744 NetworkGraph_handle_network_update(&this_arg_conv, network_update_conv);
41747 uint64_t __attribute__((export_name("TS_P2PGossipSync_as_RoutingMessageHandler"))) TS_P2PGossipSync_as_RoutingMessageHandler(uint64_t this_arg) {
41748 LDKP2PGossipSync this_arg_conv;
41749 this_arg_conv.inner = untag_ptr(this_arg);
41750 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41751 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41752 this_arg_conv.is_owned = false;
41753 LDKRoutingMessageHandler* ret_ret = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
41754 *ret_ret = P2PGossipSync_as_RoutingMessageHandler(&this_arg_conv);
41755 return tag_ptr(ret_ret, true);
41758 uint64_t __attribute__((export_name("TS_P2PGossipSync_as_MessageSendEventsProvider"))) TS_P2PGossipSync_as_MessageSendEventsProvider(uint64_t this_arg) {
41759 LDKP2PGossipSync this_arg_conv;
41760 this_arg_conv.inner = untag_ptr(this_arg);
41761 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41762 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41763 this_arg_conv.is_owned = false;
41764 LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
41765 *ret_ret = P2PGossipSync_as_MessageSendEventsProvider(&this_arg_conv);
41766 return tag_ptr(ret_ret, true);
41769 void __attribute__((export_name("TS_ChannelUpdateInfo_free"))) TS_ChannelUpdateInfo_free(uint64_t this_obj) {
41770 LDKChannelUpdateInfo this_obj_conv;
41771 this_obj_conv.inner = untag_ptr(this_obj);
41772 this_obj_conv.is_owned = ptr_is_owned(this_obj);
41773 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
41774 ChannelUpdateInfo_free(this_obj_conv);
41777 int32_t __attribute__((export_name("TS_ChannelUpdateInfo_get_last_update"))) TS_ChannelUpdateInfo_get_last_update(uint64_t this_ptr) {
41778 LDKChannelUpdateInfo this_ptr_conv;
41779 this_ptr_conv.inner = untag_ptr(this_ptr);
41780 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41781 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41782 this_ptr_conv.is_owned = false;
41783 int32_t ret_conv = ChannelUpdateInfo_get_last_update(&this_ptr_conv);
41787 void __attribute__((export_name("TS_ChannelUpdateInfo_set_last_update"))) TS_ChannelUpdateInfo_set_last_update(uint64_t this_ptr, int32_t val) {
41788 LDKChannelUpdateInfo this_ptr_conv;
41789 this_ptr_conv.inner = untag_ptr(this_ptr);
41790 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41791 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41792 this_ptr_conv.is_owned = false;
41793 ChannelUpdateInfo_set_last_update(&this_ptr_conv, val);
41796 jboolean __attribute__((export_name("TS_ChannelUpdateInfo_get_enabled"))) TS_ChannelUpdateInfo_get_enabled(uint64_t this_ptr) {
41797 LDKChannelUpdateInfo this_ptr_conv;
41798 this_ptr_conv.inner = untag_ptr(this_ptr);
41799 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41800 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41801 this_ptr_conv.is_owned = false;
41802 jboolean ret_conv = ChannelUpdateInfo_get_enabled(&this_ptr_conv);
41806 void __attribute__((export_name("TS_ChannelUpdateInfo_set_enabled"))) TS_ChannelUpdateInfo_set_enabled(uint64_t this_ptr, jboolean val) {
41807 LDKChannelUpdateInfo this_ptr_conv;
41808 this_ptr_conv.inner = untag_ptr(this_ptr);
41809 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41810 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41811 this_ptr_conv.is_owned = false;
41812 ChannelUpdateInfo_set_enabled(&this_ptr_conv, val);
41815 int16_t __attribute__((export_name("TS_ChannelUpdateInfo_get_cltv_expiry_delta"))) TS_ChannelUpdateInfo_get_cltv_expiry_delta(uint64_t this_ptr) {
41816 LDKChannelUpdateInfo this_ptr_conv;
41817 this_ptr_conv.inner = untag_ptr(this_ptr);
41818 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41819 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41820 this_ptr_conv.is_owned = false;
41821 int16_t ret_conv = ChannelUpdateInfo_get_cltv_expiry_delta(&this_ptr_conv);
41825 void __attribute__((export_name("TS_ChannelUpdateInfo_set_cltv_expiry_delta"))) TS_ChannelUpdateInfo_set_cltv_expiry_delta(uint64_t this_ptr, int16_t val) {
41826 LDKChannelUpdateInfo this_ptr_conv;
41827 this_ptr_conv.inner = untag_ptr(this_ptr);
41828 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41829 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41830 this_ptr_conv.is_owned = false;
41831 ChannelUpdateInfo_set_cltv_expiry_delta(&this_ptr_conv, val);
41834 int64_t __attribute__((export_name("TS_ChannelUpdateInfo_get_htlc_minimum_msat"))) TS_ChannelUpdateInfo_get_htlc_minimum_msat(uint64_t this_ptr) {
41835 LDKChannelUpdateInfo this_ptr_conv;
41836 this_ptr_conv.inner = untag_ptr(this_ptr);
41837 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41838 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41839 this_ptr_conv.is_owned = false;
41840 int64_t ret_conv = ChannelUpdateInfo_get_htlc_minimum_msat(&this_ptr_conv);
41844 void __attribute__((export_name("TS_ChannelUpdateInfo_set_htlc_minimum_msat"))) TS_ChannelUpdateInfo_set_htlc_minimum_msat(uint64_t this_ptr, int64_t val) {
41845 LDKChannelUpdateInfo this_ptr_conv;
41846 this_ptr_conv.inner = untag_ptr(this_ptr);
41847 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41848 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41849 this_ptr_conv.is_owned = false;
41850 ChannelUpdateInfo_set_htlc_minimum_msat(&this_ptr_conv, val);
41853 int64_t __attribute__((export_name("TS_ChannelUpdateInfo_get_htlc_maximum_msat"))) TS_ChannelUpdateInfo_get_htlc_maximum_msat(uint64_t this_ptr) {
41854 LDKChannelUpdateInfo this_ptr_conv;
41855 this_ptr_conv.inner = untag_ptr(this_ptr);
41856 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41857 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41858 this_ptr_conv.is_owned = false;
41859 int64_t ret_conv = ChannelUpdateInfo_get_htlc_maximum_msat(&this_ptr_conv);
41863 void __attribute__((export_name("TS_ChannelUpdateInfo_set_htlc_maximum_msat"))) TS_ChannelUpdateInfo_set_htlc_maximum_msat(uint64_t this_ptr, int64_t val) {
41864 LDKChannelUpdateInfo this_ptr_conv;
41865 this_ptr_conv.inner = untag_ptr(this_ptr);
41866 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41867 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41868 this_ptr_conv.is_owned = false;
41869 ChannelUpdateInfo_set_htlc_maximum_msat(&this_ptr_conv, val);
41872 uint64_t __attribute__((export_name("TS_ChannelUpdateInfo_get_fees"))) TS_ChannelUpdateInfo_get_fees(uint64_t this_ptr) {
41873 LDKChannelUpdateInfo this_ptr_conv;
41874 this_ptr_conv.inner = untag_ptr(this_ptr);
41875 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41876 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41877 this_ptr_conv.is_owned = false;
41878 LDKRoutingFees ret_var = ChannelUpdateInfo_get_fees(&this_ptr_conv);
41879 uint64_t ret_ref = 0;
41880 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41881 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41885 void __attribute__((export_name("TS_ChannelUpdateInfo_set_fees"))) TS_ChannelUpdateInfo_set_fees(uint64_t this_ptr, uint64_t val) {
41886 LDKChannelUpdateInfo this_ptr_conv;
41887 this_ptr_conv.inner = untag_ptr(this_ptr);
41888 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41889 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41890 this_ptr_conv.is_owned = false;
41891 LDKRoutingFees val_conv;
41892 val_conv.inner = untag_ptr(val);
41893 val_conv.is_owned = ptr_is_owned(val);
41894 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
41895 val_conv = RoutingFees_clone(&val_conv);
41896 ChannelUpdateInfo_set_fees(&this_ptr_conv, val_conv);
41899 uint64_t __attribute__((export_name("TS_ChannelUpdateInfo_get_last_update_message"))) TS_ChannelUpdateInfo_get_last_update_message(uint64_t this_ptr) {
41900 LDKChannelUpdateInfo this_ptr_conv;
41901 this_ptr_conv.inner = untag_ptr(this_ptr);
41902 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41903 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41904 this_ptr_conv.is_owned = false;
41905 LDKChannelUpdate ret_var = ChannelUpdateInfo_get_last_update_message(&this_ptr_conv);
41906 uint64_t ret_ref = 0;
41907 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41908 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41912 void __attribute__((export_name("TS_ChannelUpdateInfo_set_last_update_message"))) TS_ChannelUpdateInfo_set_last_update_message(uint64_t this_ptr, uint64_t val) {
41913 LDKChannelUpdateInfo this_ptr_conv;
41914 this_ptr_conv.inner = untag_ptr(this_ptr);
41915 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41916 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41917 this_ptr_conv.is_owned = false;
41918 LDKChannelUpdate val_conv;
41919 val_conv.inner = untag_ptr(val);
41920 val_conv.is_owned = ptr_is_owned(val);
41921 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
41922 val_conv = ChannelUpdate_clone(&val_conv);
41923 ChannelUpdateInfo_set_last_update_message(&this_ptr_conv, val_conv);
41926 uint64_t __attribute__((export_name("TS_ChannelUpdateInfo_new"))) TS_ChannelUpdateInfo_new(int32_t last_update_arg, jboolean enabled_arg, int16_t cltv_expiry_delta_arg, int64_t htlc_minimum_msat_arg, int64_t htlc_maximum_msat_arg, uint64_t fees_arg, uint64_t last_update_message_arg) {
41927 LDKRoutingFees fees_arg_conv;
41928 fees_arg_conv.inner = untag_ptr(fees_arg);
41929 fees_arg_conv.is_owned = ptr_is_owned(fees_arg);
41930 CHECK_INNER_FIELD_ACCESS_OR_NULL(fees_arg_conv);
41931 fees_arg_conv = RoutingFees_clone(&fees_arg_conv);
41932 LDKChannelUpdate last_update_message_arg_conv;
41933 last_update_message_arg_conv.inner = untag_ptr(last_update_message_arg);
41934 last_update_message_arg_conv.is_owned = ptr_is_owned(last_update_message_arg);
41935 CHECK_INNER_FIELD_ACCESS_OR_NULL(last_update_message_arg_conv);
41936 last_update_message_arg_conv = ChannelUpdate_clone(&last_update_message_arg_conv);
41937 LDKChannelUpdateInfo ret_var = ChannelUpdateInfo_new(last_update_arg, enabled_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg, htlc_maximum_msat_arg, fees_arg_conv, last_update_message_arg_conv);
41938 uint64_t ret_ref = 0;
41939 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41940 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41944 static inline uint64_t ChannelUpdateInfo_clone_ptr(LDKChannelUpdateInfo *NONNULL_PTR arg) {
41945 LDKChannelUpdateInfo ret_var = ChannelUpdateInfo_clone(arg);
41946 uint64_t ret_ref = 0;
41947 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41948 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41951 int64_t __attribute__((export_name("TS_ChannelUpdateInfo_clone_ptr"))) TS_ChannelUpdateInfo_clone_ptr(uint64_t arg) {
41952 LDKChannelUpdateInfo arg_conv;
41953 arg_conv.inner = untag_ptr(arg);
41954 arg_conv.is_owned = ptr_is_owned(arg);
41955 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
41956 arg_conv.is_owned = false;
41957 int64_t ret_conv = ChannelUpdateInfo_clone_ptr(&arg_conv);
41961 uint64_t __attribute__((export_name("TS_ChannelUpdateInfo_clone"))) TS_ChannelUpdateInfo_clone(uint64_t orig) {
41962 LDKChannelUpdateInfo orig_conv;
41963 orig_conv.inner = untag_ptr(orig);
41964 orig_conv.is_owned = ptr_is_owned(orig);
41965 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
41966 orig_conv.is_owned = false;
41967 LDKChannelUpdateInfo ret_var = ChannelUpdateInfo_clone(&orig_conv);
41968 uint64_t ret_ref = 0;
41969 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41970 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41974 jboolean __attribute__((export_name("TS_ChannelUpdateInfo_eq"))) TS_ChannelUpdateInfo_eq(uint64_t a, uint64_t b) {
41975 LDKChannelUpdateInfo a_conv;
41976 a_conv.inner = untag_ptr(a);
41977 a_conv.is_owned = ptr_is_owned(a);
41978 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
41979 a_conv.is_owned = false;
41980 LDKChannelUpdateInfo b_conv;
41981 b_conv.inner = untag_ptr(b);
41982 b_conv.is_owned = ptr_is_owned(b);
41983 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
41984 b_conv.is_owned = false;
41985 jboolean ret_conv = ChannelUpdateInfo_eq(&a_conv, &b_conv);
41989 int8_tArray __attribute__((export_name("TS_ChannelUpdateInfo_write"))) TS_ChannelUpdateInfo_write(uint64_t obj) {
41990 LDKChannelUpdateInfo obj_conv;
41991 obj_conv.inner = untag_ptr(obj);
41992 obj_conv.is_owned = ptr_is_owned(obj);
41993 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
41994 obj_conv.is_owned = false;
41995 LDKCVec_u8Z ret_var = ChannelUpdateInfo_write(&obj_conv);
41996 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
41997 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
41998 CVec_u8Z_free(ret_var);
42002 uint64_t __attribute__((export_name("TS_ChannelUpdateInfo_read"))) TS_ChannelUpdateInfo_read(int8_tArray ser) {
42003 LDKu8slice ser_ref;
42004 ser_ref.datalen = ser->arr_len;
42005 ser_ref.data = ser->elems;
42006 LDKCResult_ChannelUpdateInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ), "LDKCResult_ChannelUpdateInfoDecodeErrorZ");
42007 *ret_conv = ChannelUpdateInfo_read(ser_ref);
42009 return tag_ptr(ret_conv, true);
42012 void __attribute__((export_name("TS_ChannelInfo_free"))) TS_ChannelInfo_free(uint64_t this_obj) {
42013 LDKChannelInfo this_obj_conv;
42014 this_obj_conv.inner = untag_ptr(this_obj);
42015 this_obj_conv.is_owned = ptr_is_owned(this_obj);
42016 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
42017 ChannelInfo_free(this_obj_conv);
42020 uint64_t __attribute__((export_name("TS_ChannelInfo_get_features"))) TS_ChannelInfo_get_features(uint64_t this_ptr) {
42021 LDKChannelInfo this_ptr_conv;
42022 this_ptr_conv.inner = untag_ptr(this_ptr);
42023 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42024 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42025 this_ptr_conv.is_owned = false;
42026 LDKChannelFeatures ret_var = ChannelInfo_get_features(&this_ptr_conv);
42027 uint64_t ret_ref = 0;
42028 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42029 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42033 void __attribute__((export_name("TS_ChannelInfo_set_features"))) TS_ChannelInfo_set_features(uint64_t this_ptr, uint64_t val) {
42034 LDKChannelInfo this_ptr_conv;
42035 this_ptr_conv.inner = untag_ptr(this_ptr);
42036 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42037 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42038 this_ptr_conv.is_owned = false;
42039 LDKChannelFeatures val_conv;
42040 val_conv.inner = untag_ptr(val);
42041 val_conv.is_owned = ptr_is_owned(val);
42042 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
42043 val_conv = ChannelFeatures_clone(&val_conv);
42044 ChannelInfo_set_features(&this_ptr_conv, val_conv);
42047 uint64_t __attribute__((export_name("TS_ChannelInfo_get_node_one"))) TS_ChannelInfo_get_node_one(uint64_t this_ptr) {
42048 LDKChannelInfo this_ptr_conv;
42049 this_ptr_conv.inner = untag_ptr(this_ptr);
42050 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42051 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42052 this_ptr_conv.is_owned = false;
42053 LDKNodeId ret_var = ChannelInfo_get_node_one(&this_ptr_conv);
42054 uint64_t ret_ref = 0;
42055 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42056 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42060 void __attribute__((export_name("TS_ChannelInfo_set_node_one"))) TS_ChannelInfo_set_node_one(uint64_t this_ptr, uint64_t val) {
42061 LDKChannelInfo this_ptr_conv;
42062 this_ptr_conv.inner = untag_ptr(this_ptr);
42063 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42064 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42065 this_ptr_conv.is_owned = false;
42066 LDKNodeId val_conv;
42067 val_conv.inner = untag_ptr(val);
42068 val_conv.is_owned = ptr_is_owned(val);
42069 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
42070 val_conv = NodeId_clone(&val_conv);
42071 ChannelInfo_set_node_one(&this_ptr_conv, val_conv);
42074 uint64_t __attribute__((export_name("TS_ChannelInfo_get_one_to_two"))) TS_ChannelInfo_get_one_to_two(uint64_t this_ptr) {
42075 LDKChannelInfo this_ptr_conv;
42076 this_ptr_conv.inner = untag_ptr(this_ptr);
42077 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42078 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42079 this_ptr_conv.is_owned = false;
42080 LDKChannelUpdateInfo ret_var = ChannelInfo_get_one_to_two(&this_ptr_conv);
42081 uint64_t ret_ref = 0;
42082 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42083 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42087 void __attribute__((export_name("TS_ChannelInfo_set_one_to_two"))) TS_ChannelInfo_set_one_to_two(uint64_t this_ptr, uint64_t val) {
42088 LDKChannelInfo this_ptr_conv;
42089 this_ptr_conv.inner = untag_ptr(this_ptr);
42090 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42091 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42092 this_ptr_conv.is_owned = false;
42093 LDKChannelUpdateInfo val_conv;
42094 val_conv.inner = untag_ptr(val);
42095 val_conv.is_owned = ptr_is_owned(val);
42096 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
42097 val_conv = ChannelUpdateInfo_clone(&val_conv);
42098 ChannelInfo_set_one_to_two(&this_ptr_conv, val_conv);
42101 uint64_t __attribute__((export_name("TS_ChannelInfo_get_node_two"))) TS_ChannelInfo_get_node_two(uint64_t this_ptr) {
42102 LDKChannelInfo this_ptr_conv;
42103 this_ptr_conv.inner = untag_ptr(this_ptr);
42104 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42105 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42106 this_ptr_conv.is_owned = false;
42107 LDKNodeId ret_var = ChannelInfo_get_node_two(&this_ptr_conv);
42108 uint64_t ret_ref = 0;
42109 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42110 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42114 void __attribute__((export_name("TS_ChannelInfo_set_node_two"))) TS_ChannelInfo_set_node_two(uint64_t this_ptr, uint64_t val) {
42115 LDKChannelInfo this_ptr_conv;
42116 this_ptr_conv.inner = untag_ptr(this_ptr);
42117 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42118 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42119 this_ptr_conv.is_owned = false;
42120 LDKNodeId val_conv;
42121 val_conv.inner = untag_ptr(val);
42122 val_conv.is_owned = ptr_is_owned(val);
42123 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
42124 val_conv = NodeId_clone(&val_conv);
42125 ChannelInfo_set_node_two(&this_ptr_conv, val_conv);
42128 uint64_t __attribute__((export_name("TS_ChannelInfo_get_two_to_one"))) TS_ChannelInfo_get_two_to_one(uint64_t this_ptr) {
42129 LDKChannelInfo this_ptr_conv;
42130 this_ptr_conv.inner = untag_ptr(this_ptr);
42131 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42132 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42133 this_ptr_conv.is_owned = false;
42134 LDKChannelUpdateInfo ret_var = ChannelInfo_get_two_to_one(&this_ptr_conv);
42135 uint64_t ret_ref = 0;
42136 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42137 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42141 void __attribute__((export_name("TS_ChannelInfo_set_two_to_one"))) TS_ChannelInfo_set_two_to_one(uint64_t this_ptr, uint64_t val) {
42142 LDKChannelInfo this_ptr_conv;
42143 this_ptr_conv.inner = untag_ptr(this_ptr);
42144 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42145 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42146 this_ptr_conv.is_owned = false;
42147 LDKChannelUpdateInfo val_conv;
42148 val_conv.inner = untag_ptr(val);
42149 val_conv.is_owned = ptr_is_owned(val);
42150 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
42151 val_conv = ChannelUpdateInfo_clone(&val_conv);
42152 ChannelInfo_set_two_to_one(&this_ptr_conv, val_conv);
42155 uint64_t __attribute__((export_name("TS_ChannelInfo_get_capacity_sats"))) TS_ChannelInfo_get_capacity_sats(uint64_t this_ptr) {
42156 LDKChannelInfo this_ptr_conv;
42157 this_ptr_conv.inner = untag_ptr(this_ptr);
42158 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42159 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42160 this_ptr_conv.is_owned = false;
42161 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
42162 *ret_copy = ChannelInfo_get_capacity_sats(&this_ptr_conv);
42163 uint64_t ret_ref = tag_ptr(ret_copy, true);
42167 void __attribute__((export_name("TS_ChannelInfo_set_capacity_sats"))) TS_ChannelInfo_set_capacity_sats(uint64_t this_ptr, uint64_t val) {
42168 LDKChannelInfo this_ptr_conv;
42169 this_ptr_conv.inner = untag_ptr(this_ptr);
42170 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42171 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42172 this_ptr_conv.is_owned = false;
42173 void* val_ptr = untag_ptr(val);
42174 CHECK_ACCESS(val_ptr);
42175 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
42176 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
42177 ChannelInfo_set_capacity_sats(&this_ptr_conv, val_conv);
42180 uint64_t __attribute__((export_name("TS_ChannelInfo_get_announcement_message"))) TS_ChannelInfo_get_announcement_message(uint64_t this_ptr) {
42181 LDKChannelInfo this_ptr_conv;
42182 this_ptr_conv.inner = untag_ptr(this_ptr);
42183 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42184 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42185 this_ptr_conv.is_owned = false;
42186 LDKChannelAnnouncement ret_var = ChannelInfo_get_announcement_message(&this_ptr_conv);
42187 uint64_t ret_ref = 0;
42188 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42189 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42193 void __attribute__((export_name("TS_ChannelInfo_set_announcement_message"))) TS_ChannelInfo_set_announcement_message(uint64_t this_ptr, uint64_t val) {
42194 LDKChannelInfo this_ptr_conv;
42195 this_ptr_conv.inner = untag_ptr(this_ptr);
42196 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42197 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42198 this_ptr_conv.is_owned = false;
42199 LDKChannelAnnouncement val_conv;
42200 val_conv.inner = untag_ptr(val);
42201 val_conv.is_owned = ptr_is_owned(val);
42202 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
42203 val_conv = ChannelAnnouncement_clone(&val_conv);
42204 ChannelInfo_set_announcement_message(&this_ptr_conv, val_conv);
42207 static inline uint64_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg) {
42208 LDKChannelInfo ret_var = ChannelInfo_clone(arg);
42209 uint64_t ret_ref = 0;
42210 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42211 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42214 int64_t __attribute__((export_name("TS_ChannelInfo_clone_ptr"))) TS_ChannelInfo_clone_ptr(uint64_t arg) {
42215 LDKChannelInfo arg_conv;
42216 arg_conv.inner = untag_ptr(arg);
42217 arg_conv.is_owned = ptr_is_owned(arg);
42218 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
42219 arg_conv.is_owned = false;
42220 int64_t ret_conv = ChannelInfo_clone_ptr(&arg_conv);
42224 uint64_t __attribute__((export_name("TS_ChannelInfo_clone"))) TS_ChannelInfo_clone(uint64_t orig) {
42225 LDKChannelInfo orig_conv;
42226 orig_conv.inner = untag_ptr(orig);
42227 orig_conv.is_owned = ptr_is_owned(orig);
42228 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
42229 orig_conv.is_owned = false;
42230 LDKChannelInfo ret_var = ChannelInfo_clone(&orig_conv);
42231 uint64_t ret_ref = 0;
42232 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42233 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42237 jboolean __attribute__((export_name("TS_ChannelInfo_eq"))) TS_ChannelInfo_eq(uint64_t a, uint64_t b) {
42238 LDKChannelInfo a_conv;
42239 a_conv.inner = untag_ptr(a);
42240 a_conv.is_owned = ptr_is_owned(a);
42241 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
42242 a_conv.is_owned = false;
42243 LDKChannelInfo b_conv;
42244 b_conv.inner = untag_ptr(b);
42245 b_conv.is_owned = ptr_is_owned(b);
42246 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
42247 b_conv.is_owned = false;
42248 jboolean ret_conv = ChannelInfo_eq(&a_conv, &b_conv);
42252 uint64_t __attribute__((export_name("TS_ChannelInfo_get_directional_info"))) TS_ChannelInfo_get_directional_info(uint64_t this_arg, int8_t channel_flags) {
42253 LDKChannelInfo this_arg_conv;
42254 this_arg_conv.inner = untag_ptr(this_arg);
42255 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42256 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42257 this_arg_conv.is_owned = false;
42258 LDKChannelUpdateInfo ret_var = ChannelInfo_get_directional_info(&this_arg_conv, channel_flags);
42259 uint64_t ret_ref = 0;
42260 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42261 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42265 int8_tArray __attribute__((export_name("TS_ChannelInfo_write"))) TS_ChannelInfo_write(uint64_t obj) {
42266 LDKChannelInfo obj_conv;
42267 obj_conv.inner = untag_ptr(obj);
42268 obj_conv.is_owned = ptr_is_owned(obj);
42269 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
42270 obj_conv.is_owned = false;
42271 LDKCVec_u8Z ret_var = ChannelInfo_write(&obj_conv);
42272 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
42273 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
42274 CVec_u8Z_free(ret_var);
42278 uint64_t __attribute__((export_name("TS_ChannelInfo_read"))) TS_ChannelInfo_read(int8_tArray ser) {
42279 LDKu8slice ser_ref;
42280 ser_ref.datalen = ser->arr_len;
42281 ser_ref.data = ser->elems;
42282 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
42283 *ret_conv = ChannelInfo_read(ser_ref);
42285 return tag_ptr(ret_conv, true);
42288 void __attribute__((export_name("TS_DirectedChannelInfo_free"))) TS_DirectedChannelInfo_free(uint64_t this_obj) {
42289 LDKDirectedChannelInfo this_obj_conv;
42290 this_obj_conv.inner = untag_ptr(this_obj);
42291 this_obj_conv.is_owned = ptr_is_owned(this_obj);
42292 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
42293 DirectedChannelInfo_free(this_obj_conv);
42296 static inline uint64_t DirectedChannelInfo_clone_ptr(LDKDirectedChannelInfo *NONNULL_PTR arg) {
42297 LDKDirectedChannelInfo ret_var = DirectedChannelInfo_clone(arg);
42298 uint64_t ret_ref = 0;
42299 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42300 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42303 int64_t __attribute__((export_name("TS_DirectedChannelInfo_clone_ptr"))) TS_DirectedChannelInfo_clone_ptr(uint64_t arg) {
42304 LDKDirectedChannelInfo arg_conv;
42305 arg_conv.inner = untag_ptr(arg);
42306 arg_conv.is_owned = ptr_is_owned(arg);
42307 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
42308 arg_conv.is_owned = false;
42309 int64_t ret_conv = DirectedChannelInfo_clone_ptr(&arg_conv);
42313 uint64_t __attribute__((export_name("TS_DirectedChannelInfo_clone"))) TS_DirectedChannelInfo_clone(uint64_t orig) {
42314 LDKDirectedChannelInfo orig_conv;
42315 orig_conv.inner = untag_ptr(orig);
42316 orig_conv.is_owned = ptr_is_owned(orig);
42317 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
42318 orig_conv.is_owned = false;
42319 LDKDirectedChannelInfo ret_var = DirectedChannelInfo_clone(&orig_conv);
42320 uint64_t ret_ref = 0;
42321 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42322 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42326 uint64_t __attribute__((export_name("TS_DirectedChannelInfo_channel"))) TS_DirectedChannelInfo_channel(uint64_t this_arg) {
42327 LDKDirectedChannelInfo this_arg_conv;
42328 this_arg_conv.inner = untag_ptr(this_arg);
42329 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42330 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42331 this_arg_conv.is_owned = false;
42332 LDKChannelInfo ret_var = DirectedChannelInfo_channel(&this_arg_conv);
42333 uint64_t ret_ref = 0;
42334 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42335 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42339 int64_t __attribute__((export_name("TS_DirectedChannelInfo_htlc_maximum_msat"))) TS_DirectedChannelInfo_htlc_maximum_msat(uint64_t this_arg) {
42340 LDKDirectedChannelInfo this_arg_conv;
42341 this_arg_conv.inner = untag_ptr(this_arg);
42342 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42343 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42344 this_arg_conv.is_owned = false;
42345 int64_t ret_conv = DirectedChannelInfo_htlc_maximum_msat(&this_arg_conv);
42349 uint64_t __attribute__((export_name("TS_DirectedChannelInfo_effective_capacity"))) TS_DirectedChannelInfo_effective_capacity(uint64_t this_arg) {
42350 LDKDirectedChannelInfo this_arg_conv;
42351 this_arg_conv.inner = untag_ptr(this_arg);
42352 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42353 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42354 this_arg_conv.is_owned = false;
42355 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
42356 *ret_copy = DirectedChannelInfo_effective_capacity(&this_arg_conv);
42357 uint64_t ret_ref = tag_ptr(ret_copy, true);
42361 void __attribute__((export_name("TS_EffectiveCapacity_free"))) TS_EffectiveCapacity_free(uint64_t this_ptr) {
42362 if (!ptr_is_owned(this_ptr)) return;
42363 void* this_ptr_ptr = untag_ptr(this_ptr);
42364 CHECK_ACCESS(this_ptr_ptr);
42365 LDKEffectiveCapacity this_ptr_conv = *(LDKEffectiveCapacity*)(this_ptr_ptr);
42366 FREE(untag_ptr(this_ptr));
42367 EffectiveCapacity_free(this_ptr_conv);
42370 static inline uint64_t EffectiveCapacity_clone_ptr(LDKEffectiveCapacity *NONNULL_PTR arg) {
42371 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
42372 *ret_copy = EffectiveCapacity_clone(arg);
42373 uint64_t ret_ref = tag_ptr(ret_copy, true);
42376 int64_t __attribute__((export_name("TS_EffectiveCapacity_clone_ptr"))) TS_EffectiveCapacity_clone_ptr(uint64_t arg) {
42377 LDKEffectiveCapacity* arg_conv = (LDKEffectiveCapacity*)untag_ptr(arg);
42378 int64_t ret_conv = EffectiveCapacity_clone_ptr(arg_conv);
42382 uint64_t __attribute__((export_name("TS_EffectiveCapacity_clone"))) TS_EffectiveCapacity_clone(uint64_t orig) {
42383 LDKEffectiveCapacity* orig_conv = (LDKEffectiveCapacity*)untag_ptr(orig);
42384 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
42385 *ret_copy = EffectiveCapacity_clone(orig_conv);
42386 uint64_t ret_ref = tag_ptr(ret_copy, true);
42390 uint64_t __attribute__((export_name("TS_EffectiveCapacity_exact_liquidity"))) TS_EffectiveCapacity_exact_liquidity(int64_t liquidity_msat) {
42391 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
42392 *ret_copy = EffectiveCapacity_exact_liquidity(liquidity_msat);
42393 uint64_t ret_ref = tag_ptr(ret_copy, true);
42397 uint64_t __attribute__((export_name("TS_EffectiveCapacity_maximum_htlc"))) TS_EffectiveCapacity_maximum_htlc(int64_t amount_msat) {
42398 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
42399 *ret_copy = EffectiveCapacity_maximum_htlc(amount_msat);
42400 uint64_t ret_ref = tag_ptr(ret_copy, true);
42404 uint64_t __attribute__((export_name("TS_EffectiveCapacity_total"))) TS_EffectiveCapacity_total(int64_t capacity_msat, int64_t htlc_maximum_msat) {
42405 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
42406 *ret_copy = EffectiveCapacity_total(capacity_msat, htlc_maximum_msat);
42407 uint64_t ret_ref = tag_ptr(ret_copy, true);
42411 uint64_t __attribute__((export_name("TS_EffectiveCapacity_infinite"))) TS_EffectiveCapacity_infinite() {
42412 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
42413 *ret_copy = EffectiveCapacity_infinite();
42414 uint64_t ret_ref = tag_ptr(ret_copy, true);
42418 uint64_t __attribute__((export_name("TS_EffectiveCapacity_unknown"))) TS_EffectiveCapacity_unknown() {
42419 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
42420 *ret_copy = EffectiveCapacity_unknown();
42421 uint64_t ret_ref = tag_ptr(ret_copy, true);
42425 int64_t __attribute__((export_name("TS_EffectiveCapacity_as_msat"))) TS_EffectiveCapacity_as_msat(uint64_t this_arg) {
42426 LDKEffectiveCapacity* this_arg_conv = (LDKEffectiveCapacity*)untag_ptr(this_arg);
42427 int64_t ret_conv = EffectiveCapacity_as_msat(this_arg_conv);
42431 void __attribute__((export_name("TS_RoutingFees_free"))) TS_RoutingFees_free(uint64_t this_obj) {
42432 LDKRoutingFees this_obj_conv;
42433 this_obj_conv.inner = untag_ptr(this_obj);
42434 this_obj_conv.is_owned = ptr_is_owned(this_obj);
42435 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
42436 RoutingFees_free(this_obj_conv);
42439 int32_t __attribute__((export_name("TS_RoutingFees_get_base_msat"))) TS_RoutingFees_get_base_msat(uint64_t this_ptr) {
42440 LDKRoutingFees this_ptr_conv;
42441 this_ptr_conv.inner = untag_ptr(this_ptr);
42442 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42443 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42444 this_ptr_conv.is_owned = false;
42445 int32_t ret_conv = RoutingFees_get_base_msat(&this_ptr_conv);
42449 void __attribute__((export_name("TS_RoutingFees_set_base_msat"))) TS_RoutingFees_set_base_msat(uint64_t this_ptr, int32_t val) {
42450 LDKRoutingFees this_ptr_conv;
42451 this_ptr_conv.inner = untag_ptr(this_ptr);
42452 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42453 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42454 this_ptr_conv.is_owned = false;
42455 RoutingFees_set_base_msat(&this_ptr_conv, val);
42458 int32_t __attribute__((export_name("TS_RoutingFees_get_proportional_millionths"))) TS_RoutingFees_get_proportional_millionths(uint64_t this_ptr) {
42459 LDKRoutingFees this_ptr_conv;
42460 this_ptr_conv.inner = untag_ptr(this_ptr);
42461 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42462 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42463 this_ptr_conv.is_owned = false;
42464 int32_t ret_conv = RoutingFees_get_proportional_millionths(&this_ptr_conv);
42468 void __attribute__((export_name("TS_RoutingFees_set_proportional_millionths"))) TS_RoutingFees_set_proportional_millionths(uint64_t this_ptr, int32_t val) {
42469 LDKRoutingFees this_ptr_conv;
42470 this_ptr_conv.inner = untag_ptr(this_ptr);
42471 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42472 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42473 this_ptr_conv.is_owned = false;
42474 RoutingFees_set_proportional_millionths(&this_ptr_conv, val);
42477 uint64_t __attribute__((export_name("TS_RoutingFees_new"))) TS_RoutingFees_new(int32_t base_msat_arg, int32_t proportional_millionths_arg) {
42478 LDKRoutingFees ret_var = RoutingFees_new(base_msat_arg, proportional_millionths_arg);
42479 uint64_t ret_ref = 0;
42480 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42481 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42485 jboolean __attribute__((export_name("TS_RoutingFees_eq"))) TS_RoutingFees_eq(uint64_t a, uint64_t b) {
42486 LDKRoutingFees a_conv;
42487 a_conv.inner = untag_ptr(a);
42488 a_conv.is_owned = ptr_is_owned(a);
42489 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
42490 a_conv.is_owned = false;
42491 LDKRoutingFees b_conv;
42492 b_conv.inner = untag_ptr(b);
42493 b_conv.is_owned = ptr_is_owned(b);
42494 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
42495 b_conv.is_owned = false;
42496 jboolean ret_conv = RoutingFees_eq(&a_conv, &b_conv);
42500 static inline uint64_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg) {
42501 LDKRoutingFees ret_var = RoutingFees_clone(arg);
42502 uint64_t ret_ref = 0;
42503 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42504 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42507 int64_t __attribute__((export_name("TS_RoutingFees_clone_ptr"))) TS_RoutingFees_clone_ptr(uint64_t arg) {
42508 LDKRoutingFees arg_conv;
42509 arg_conv.inner = untag_ptr(arg);
42510 arg_conv.is_owned = ptr_is_owned(arg);
42511 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
42512 arg_conv.is_owned = false;
42513 int64_t ret_conv = RoutingFees_clone_ptr(&arg_conv);
42517 uint64_t __attribute__((export_name("TS_RoutingFees_clone"))) TS_RoutingFees_clone(uint64_t orig) {
42518 LDKRoutingFees orig_conv;
42519 orig_conv.inner = untag_ptr(orig);
42520 orig_conv.is_owned = ptr_is_owned(orig);
42521 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
42522 orig_conv.is_owned = false;
42523 LDKRoutingFees ret_var = RoutingFees_clone(&orig_conv);
42524 uint64_t ret_ref = 0;
42525 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42526 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42530 int64_t __attribute__((export_name("TS_RoutingFees_hash"))) TS_RoutingFees_hash(uint64_t o) {
42531 LDKRoutingFees o_conv;
42532 o_conv.inner = untag_ptr(o);
42533 o_conv.is_owned = ptr_is_owned(o);
42534 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
42535 o_conv.is_owned = false;
42536 int64_t ret_conv = RoutingFees_hash(&o_conv);
42540 int8_tArray __attribute__((export_name("TS_RoutingFees_write"))) TS_RoutingFees_write(uint64_t obj) {
42541 LDKRoutingFees obj_conv;
42542 obj_conv.inner = untag_ptr(obj);
42543 obj_conv.is_owned = ptr_is_owned(obj);
42544 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
42545 obj_conv.is_owned = false;
42546 LDKCVec_u8Z ret_var = RoutingFees_write(&obj_conv);
42547 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
42548 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
42549 CVec_u8Z_free(ret_var);
42553 uint64_t __attribute__((export_name("TS_RoutingFees_read"))) TS_RoutingFees_read(int8_tArray ser) {
42554 LDKu8slice ser_ref;
42555 ser_ref.datalen = ser->arr_len;
42556 ser_ref.data = ser->elems;
42557 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
42558 *ret_conv = RoutingFees_read(ser_ref);
42560 return tag_ptr(ret_conv, true);
42563 void __attribute__((export_name("TS_NodeAnnouncementInfo_free"))) TS_NodeAnnouncementInfo_free(uint64_t this_obj) {
42564 LDKNodeAnnouncementInfo this_obj_conv;
42565 this_obj_conv.inner = untag_ptr(this_obj);
42566 this_obj_conv.is_owned = ptr_is_owned(this_obj);
42567 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
42568 NodeAnnouncementInfo_free(this_obj_conv);
42571 uint64_t __attribute__((export_name("TS_NodeAnnouncementInfo_get_features"))) TS_NodeAnnouncementInfo_get_features(uint64_t this_ptr) {
42572 LDKNodeAnnouncementInfo this_ptr_conv;
42573 this_ptr_conv.inner = untag_ptr(this_ptr);
42574 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42575 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42576 this_ptr_conv.is_owned = false;
42577 LDKNodeFeatures ret_var = NodeAnnouncementInfo_get_features(&this_ptr_conv);
42578 uint64_t ret_ref = 0;
42579 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42580 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42584 void __attribute__((export_name("TS_NodeAnnouncementInfo_set_features"))) TS_NodeAnnouncementInfo_set_features(uint64_t this_ptr, uint64_t val) {
42585 LDKNodeAnnouncementInfo this_ptr_conv;
42586 this_ptr_conv.inner = untag_ptr(this_ptr);
42587 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42588 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42589 this_ptr_conv.is_owned = false;
42590 LDKNodeFeatures val_conv;
42591 val_conv.inner = untag_ptr(val);
42592 val_conv.is_owned = ptr_is_owned(val);
42593 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
42594 val_conv = NodeFeatures_clone(&val_conv);
42595 NodeAnnouncementInfo_set_features(&this_ptr_conv, val_conv);
42598 int32_t __attribute__((export_name("TS_NodeAnnouncementInfo_get_last_update"))) TS_NodeAnnouncementInfo_get_last_update(uint64_t this_ptr) {
42599 LDKNodeAnnouncementInfo this_ptr_conv;
42600 this_ptr_conv.inner = untag_ptr(this_ptr);
42601 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42602 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42603 this_ptr_conv.is_owned = false;
42604 int32_t ret_conv = NodeAnnouncementInfo_get_last_update(&this_ptr_conv);
42608 void __attribute__((export_name("TS_NodeAnnouncementInfo_set_last_update"))) TS_NodeAnnouncementInfo_set_last_update(uint64_t this_ptr, int32_t val) {
42609 LDKNodeAnnouncementInfo this_ptr_conv;
42610 this_ptr_conv.inner = untag_ptr(this_ptr);
42611 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42612 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42613 this_ptr_conv.is_owned = false;
42614 NodeAnnouncementInfo_set_last_update(&this_ptr_conv, val);
42617 int8_tArray __attribute__((export_name("TS_NodeAnnouncementInfo_get_rgb"))) TS_NodeAnnouncementInfo_get_rgb(uint64_t this_ptr) {
42618 LDKNodeAnnouncementInfo this_ptr_conv;
42619 this_ptr_conv.inner = untag_ptr(this_ptr);
42620 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42621 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42622 this_ptr_conv.is_owned = false;
42623 int8_tArray ret_arr = init_int8_tArray(3, __LINE__);
42624 memcpy(ret_arr->elems, *NodeAnnouncementInfo_get_rgb(&this_ptr_conv), 3);
42628 void __attribute__((export_name("TS_NodeAnnouncementInfo_set_rgb"))) TS_NodeAnnouncementInfo_set_rgb(uint64_t this_ptr, int8_tArray val) {
42629 LDKNodeAnnouncementInfo this_ptr_conv;
42630 this_ptr_conv.inner = untag_ptr(this_ptr);
42631 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42632 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42633 this_ptr_conv.is_owned = false;
42634 LDKThreeBytes val_ref;
42635 CHECK(val->arr_len == 3);
42636 memcpy(val_ref.data, val->elems, 3); FREE(val);
42637 NodeAnnouncementInfo_set_rgb(&this_ptr_conv, val_ref);
42640 uint64_t __attribute__((export_name("TS_NodeAnnouncementInfo_get_alias"))) TS_NodeAnnouncementInfo_get_alias(uint64_t this_ptr) {
42641 LDKNodeAnnouncementInfo this_ptr_conv;
42642 this_ptr_conv.inner = untag_ptr(this_ptr);
42643 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42644 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42645 this_ptr_conv.is_owned = false;
42646 LDKNodeAlias ret_var = NodeAnnouncementInfo_get_alias(&this_ptr_conv);
42647 uint64_t ret_ref = 0;
42648 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42649 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42653 void __attribute__((export_name("TS_NodeAnnouncementInfo_set_alias"))) TS_NodeAnnouncementInfo_set_alias(uint64_t this_ptr, uint64_t val) {
42654 LDKNodeAnnouncementInfo this_ptr_conv;
42655 this_ptr_conv.inner = untag_ptr(this_ptr);
42656 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42657 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42658 this_ptr_conv.is_owned = false;
42659 LDKNodeAlias val_conv;
42660 val_conv.inner = untag_ptr(val);
42661 val_conv.is_owned = ptr_is_owned(val);
42662 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
42663 val_conv = NodeAlias_clone(&val_conv);
42664 NodeAnnouncementInfo_set_alias(&this_ptr_conv, val_conv);
42667 uint64_tArray __attribute__((export_name("TS_NodeAnnouncementInfo_get_addresses"))) TS_NodeAnnouncementInfo_get_addresses(uint64_t this_ptr) {
42668 LDKNodeAnnouncementInfo this_ptr_conv;
42669 this_ptr_conv.inner = untag_ptr(this_ptr);
42670 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42671 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42672 this_ptr_conv.is_owned = false;
42673 LDKCVec_NetAddressZ ret_var = NodeAnnouncementInfo_get_addresses(&this_ptr_conv);
42674 uint64_tArray ret_arr = NULL;
42675 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
42676 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
42677 for (size_t m = 0; m < ret_var.datalen; m++) {
42678 LDKNetAddress *ret_conv_12_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
42679 *ret_conv_12_copy = ret_var.data[m];
42680 uint64_t ret_conv_12_ref = tag_ptr(ret_conv_12_copy, true);
42681 ret_arr_ptr[m] = ret_conv_12_ref;
42684 FREE(ret_var.data);
42688 void __attribute__((export_name("TS_NodeAnnouncementInfo_set_addresses"))) TS_NodeAnnouncementInfo_set_addresses(uint64_t this_ptr, uint64_tArray val) {
42689 LDKNodeAnnouncementInfo this_ptr_conv;
42690 this_ptr_conv.inner = untag_ptr(this_ptr);
42691 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42692 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42693 this_ptr_conv.is_owned = false;
42694 LDKCVec_NetAddressZ val_constr;
42695 val_constr.datalen = val->arr_len;
42696 if (val_constr.datalen > 0)
42697 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
42699 val_constr.data = NULL;
42700 uint64_t* val_vals = val->elems;
42701 for (size_t m = 0; m < val_constr.datalen; m++) {
42702 uint64_t val_conv_12 = val_vals[m];
42703 void* val_conv_12_ptr = untag_ptr(val_conv_12);
42704 CHECK_ACCESS(val_conv_12_ptr);
42705 LDKNetAddress val_conv_12_conv = *(LDKNetAddress*)(val_conv_12_ptr);
42706 val_conv_12_conv = NetAddress_clone((LDKNetAddress*)untag_ptr(val_conv_12));
42707 val_constr.data[m] = val_conv_12_conv;
42710 NodeAnnouncementInfo_set_addresses(&this_ptr_conv, val_constr);
42713 uint64_t __attribute__((export_name("TS_NodeAnnouncementInfo_get_announcement_message"))) TS_NodeAnnouncementInfo_get_announcement_message(uint64_t this_ptr) {
42714 LDKNodeAnnouncementInfo this_ptr_conv;
42715 this_ptr_conv.inner = untag_ptr(this_ptr);
42716 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42717 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42718 this_ptr_conv.is_owned = false;
42719 LDKNodeAnnouncement ret_var = NodeAnnouncementInfo_get_announcement_message(&this_ptr_conv);
42720 uint64_t ret_ref = 0;
42721 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42722 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42726 void __attribute__((export_name("TS_NodeAnnouncementInfo_set_announcement_message"))) TS_NodeAnnouncementInfo_set_announcement_message(uint64_t this_ptr, uint64_t val) {
42727 LDKNodeAnnouncementInfo this_ptr_conv;
42728 this_ptr_conv.inner = untag_ptr(this_ptr);
42729 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42730 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42731 this_ptr_conv.is_owned = false;
42732 LDKNodeAnnouncement val_conv;
42733 val_conv.inner = untag_ptr(val);
42734 val_conv.is_owned = ptr_is_owned(val);
42735 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
42736 val_conv = NodeAnnouncement_clone(&val_conv);
42737 NodeAnnouncementInfo_set_announcement_message(&this_ptr_conv, val_conv);
42740 uint64_t __attribute__((export_name("TS_NodeAnnouncementInfo_new"))) TS_NodeAnnouncementInfo_new(uint64_t features_arg, int32_t last_update_arg, int8_tArray rgb_arg, uint64_t alias_arg, uint64_tArray addresses_arg, uint64_t announcement_message_arg) {
42741 LDKNodeFeatures features_arg_conv;
42742 features_arg_conv.inner = untag_ptr(features_arg);
42743 features_arg_conv.is_owned = ptr_is_owned(features_arg);
42744 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
42745 features_arg_conv = NodeFeatures_clone(&features_arg_conv);
42746 LDKThreeBytes rgb_arg_ref;
42747 CHECK(rgb_arg->arr_len == 3);
42748 memcpy(rgb_arg_ref.data, rgb_arg->elems, 3); FREE(rgb_arg);
42749 LDKNodeAlias alias_arg_conv;
42750 alias_arg_conv.inner = untag_ptr(alias_arg);
42751 alias_arg_conv.is_owned = ptr_is_owned(alias_arg);
42752 CHECK_INNER_FIELD_ACCESS_OR_NULL(alias_arg_conv);
42753 alias_arg_conv = NodeAlias_clone(&alias_arg_conv);
42754 LDKCVec_NetAddressZ addresses_arg_constr;
42755 addresses_arg_constr.datalen = addresses_arg->arr_len;
42756 if (addresses_arg_constr.datalen > 0)
42757 addresses_arg_constr.data = MALLOC(addresses_arg_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
42759 addresses_arg_constr.data = NULL;
42760 uint64_t* addresses_arg_vals = addresses_arg->elems;
42761 for (size_t m = 0; m < addresses_arg_constr.datalen; m++) {
42762 uint64_t addresses_arg_conv_12 = addresses_arg_vals[m];
42763 void* addresses_arg_conv_12_ptr = untag_ptr(addresses_arg_conv_12);
42764 CHECK_ACCESS(addresses_arg_conv_12_ptr);
42765 LDKNetAddress addresses_arg_conv_12_conv = *(LDKNetAddress*)(addresses_arg_conv_12_ptr);
42766 addresses_arg_constr.data[m] = addresses_arg_conv_12_conv;
42768 FREE(addresses_arg);
42769 LDKNodeAnnouncement announcement_message_arg_conv;
42770 announcement_message_arg_conv.inner = untag_ptr(announcement_message_arg);
42771 announcement_message_arg_conv.is_owned = ptr_is_owned(announcement_message_arg);
42772 CHECK_INNER_FIELD_ACCESS_OR_NULL(announcement_message_arg_conv);
42773 announcement_message_arg_conv = NodeAnnouncement_clone(&announcement_message_arg_conv);
42774 LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_new(features_arg_conv, last_update_arg, rgb_arg_ref, alias_arg_conv, addresses_arg_constr, announcement_message_arg_conv);
42775 uint64_t ret_ref = 0;
42776 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42777 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42781 static inline uint64_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg) {
42782 LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_clone(arg);
42783 uint64_t ret_ref = 0;
42784 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42785 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42788 int64_t __attribute__((export_name("TS_NodeAnnouncementInfo_clone_ptr"))) TS_NodeAnnouncementInfo_clone_ptr(uint64_t arg) {
42789 LDKNodeAnnouncementInfo arg_conv;
42790 arg_conv.inner = untag_ptr(arg);
42791 arg_conv.is_owned = ptr_is_owned(arg);
42792 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
42793 arg_conv.is_owned = false;
42794 int64_t ret_conv = NodeAnnouncementInfo_clone_ptr(&arg_conv);
42798 uint64_t __attribute__((export_name("TS_NodeAnnouncementInfo_clone"))) TS_NodeAnnouncementInfo_clone(uint64_t orig) {
42799 LDKNodeAnnouncementInfo orig_conv;
42800 orig_conv.inner = untag_ptr(orig);
42801 orig_conv.is_owned = ptr_is_owned(orig);
42802 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
42803 orig_conv.is_owned = false;
42804 LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_clone(&orig_conv);
42805 uint64_t ret_ref = 0;
42806 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42807 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42811 jboolean __attribute__((export_name("TS_NodeAnnouncementInfo_eq"))) TS_NodeAnnouncementInfo_eq(uint64_t a, uint64_t b) {
42812 LDKNodeAnnouncementInfo a_conv;
42813 a_conv.inner = untag_ptr(a);
42814 a_conv.is_owned = ptr_is_owned(a);
42815 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
42816 a_conv.is_owned = false;
42817 LDKNodeAnnouncementInfo b_conv;
42818 b_conv.inner = untag_ptr(b);
42819 b_conv.is_owned = ptr_is_owned(b);
42820 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
42821 b_conv.is_owned = false;
42822 jboolean ret_conv = NodeAnnouncementInfo_eq(&a_conv, &b_conv);
42826 int8_tArray __attribute__((export_name("TS_NodeAnnouncementInfo_write"))) TS_NodeAnnouncementInfo_write(uint64_t obj) {
42827 LDKNodeAnnouncementInfo obj_conv;
42828 obj_conv.inner = untag_ptr(obj);
42829 obj_conv.is_owned = ptr_is_owned(obj);
42830 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
42831 obj_conv.is_owned = false;
42832 LDKCVec_u8Z ret_var = NodeAnnouncementInfo_write(&obj_conv);
42833 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
42834 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
42835 CVec_u8Z_free(ret_var);
42839 uint64_t __attribute__((export_name("TS_NodeAnnouncementInfo_read"))) TS_NodeAnnouncementInfo_read(int8_tArray ser) {
42840 LDKu8slice ser_ref;
42841 ser_ref.datalen = ser->arr_len;
42842 ser_ref.data = ser->elems;
42843 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
42844 *ret_conv = NodeAnnouncementInfo_read(ser_ref);
42846 return tag_ptr(ret_conv, true);
42849 void __attribute__((export_name("TS_NodeAlias_free"))) TS_NodeAlias_free(uint64_t this_obj) {
42850 LDKNodeAlias this_obj_conv;
42851 this_obj_conv.inner = untag_ptr(this_obj);
42852 this_obj_conv.is_owned = ptr_is_owned(this_obj);
42853 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
42854 NodeAlias_free(this_obj_conv);
42857 int8_tArray __attribute__((export_name("TS_NodeAlias_get_a"))) TS_NodeAlias_get_a(uint64_t this_ptr) {
42858 LDKNodeAlias this_ptr_conv;
42859 this_ptr_conv.inner = untag_ptr(this_ptr);
42860 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42861 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42862 this_ptr_conv.is_owned = false;
42863 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
42864 memcpy(ret_arr->elems, *NodeAlias_get_a(&this_ptr_conv), 32);
42868 void __attribute__((export_name("TS_NodeAlias_set_a"))) TS_NodeAlias_set_a(uint64_t this_ptr, int8_tArray val) {
42869 LDKNodeAlias this_ptr_conv;
42870 this_ptr_conv.inner = untag_ptr(this_ptr);
42871 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42872 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42873 this_ptr_conv.is_owned = false;
42874 LDKThirtyTwoBytes val_ref;
42875 CHECK(val->arr_len == 32);
42876 memcpy(val_ref.data, val->elems, 32); FREE(val);
42877 NodeAlias_set_a(&this_ptr_conv, val_ref);
42880 uint64_t __attribute__((export_name("TS_NodeAlias_new"))) TS_NodeAlias_new(int8_tArray a_arg) {
42881 LDKThirtyTwoBytes a_arg_ref;
42882 CHECK(a_arg->arr_len == 32);
42883 memcpy(a_arg_ref.data, a_arg->elems, 32); FREE(a_arg);
42884 LDKNodeAlias ret_var = NodeAlias_new(a_arg_ref);
42885 uint64_t ret_ref = 0;
42886 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42887 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42891 static inline uint64_t NodeAlias_clone_ptr(LDKNodeAlias *NONNULL_PTR arg) {
42892 LDKNodeAlias ret_var = NodeAlias_clone(arg);
42893 uint64_t ret_ref = 0;
42894 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42895 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42898 int64_t __attribute__((export_name("TS_NodeAlias_clone_ptr"))) TS_NodeAlias_clone_ptr(uint64_t arg) {
42899 LDKNodeAlias arg_conv;
42900 arg_conv.inner = untag_ptr(arg);
42901 arg_conv.is_owned = ptr_is_owned(arg);
42902 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
42903 arg_conv.is_owned = false;
42904 int64_t ret_conv = NodeAlias_clone_ptr(&arg_conv);
42908 uint64_t __attribute__((export_name("TS_NodeAlias_clone"))) TS_NodeAlias_clone(uint64_t orig) {
42909 LDKNodeAlias orig_conv;
42910 orig_conv.inner = untag_ptr(orig);
42911 orig_conv.is_owned = ptr_is_owned(orig);
42912 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
42913 orig_conv.is_owned = false;
42914 LDKNodeAlias ret_var = NodeAlias_clone(&orig_conv);
42915 uint64_t ret_ref = 0;
42916 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42917 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42921 jboolean __attribute__((export_name("TS_NodeAlias_eq"))) TS_NodeAlias_eq(uint64_t a, uint64_t b) {
42922 LDKNodeAlias a_conv;
42923 a_conv.inner = untag_ptr(a);
42924 a_conv.is_owned = ptr_is_owned(a);
42925 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
42926 a_conv.is_owned = false;
42927 LDKNodeAlias b_conv;
42928 b_conv.inner = untag_ptr(b);
42929 b_conv.is_owned = ptr_is_owned(b);
42930 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
42931 b_conv.is_owned = false;
42932 jboolean ret_conv = NodeAlias_eq(&a_conv, &b_conv);
42936 int8_tArray __attribute__((export_name("TS_NodeAlias_write"))) TS_NodeAlias_write(uint64_t obj) {
42937 LDKNodeAlias obj_conv;
42938 obj_conv.inner = untag_ptr(obj);
42939 obj_conv.is_owned = ptr_is_owned(obj);
42940 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
42941 obj_conv.is_owned = false;
42942 LDKCVec_u8Z ret_var = NodeAlias_write(&obj_conv);
42943 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
42944 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
42945 CVec_u8Z_free(ret_var);
42949 uint64_t __attribute__((export_name("TS_NodeAlias_read"))) TS_NodeAlias_read(int8_tArray ser) {
42950 LDKu8slice ser_ref;
42951 ser_ref.datalen = ser->arr_len;
42952 ser_ref.data = ser->elems;
42953 LDKCResult_NodeAliasDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAliasDecodeErrorZ), "LDKCResult_NodeAliasDecodeErrorZ");
42954 *ret_conv = NodeAlias_read(ser_ref);
42956 return tag_ptr(ret_conv, true);
42959 void __attribute__((export_name("TS_NodeInfo_free"))) TS_NodeInfo_free(uint64_t this_obj) {
42960 LDKNodeInfo this_obj_conv;
42961 this_obj_conv.inner = untag_ptr(this_obj);
42962 this_obj_conv.is_owned = ptr_is_owned(this_obj);
42963 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
42964 NodeInfo_free(this_obj_conv);
42967 int64_tArray __attribute__((export_name("TS_NodeInfo_get_channels"))) TS_NodeInfo_get_channels(uint64_t this_ptr) {
42968 LDKNodeInfo this_ptr_conv;
42969 this_ptr_conv.inner = untag_ptr(this_ptr);
42970 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42971 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42972 this_ptr_conv.is_owned = false;
42973 LDKCVec_u64Z ret_var = NodeInfo_get_channels(&this_ptr_conv);
42974 int64_tArray ret_arr = NULL;
42975 ret_arr = init_int64_tArray(ret_var.datalen, __LINE__);
42976 int64_t *ret_arr_ptr = (int64_t*)(((uint8_t*)ret_arr) + 8);
42977 for (size_t i = 0; i < ret_var.datalen; i++) {
42978 int64_t ret_conv_8_conv = ret_var.data[i];
42979 ret_arr_ptr[i] = ret_conv_8_conv;
42982 FREE(ret_var.data);
42986 void __attribute__((export_name("TS_NodeInfo_set_channels"))) TS_NodeInfo_set_channels(uint64_t this_ptr, int64_tArray val) {
42987 LDKNodeInfo this_ptr_conv;
42988 this_ptr_conv.inner = untag_ptr(this_ptr);
42989 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42990 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42991 this_ptr_conv.is_owned = false;
42992 LDKCVec_u64Z val_constr;
42993 val_constr.datalen = val->arr_len;
42994 if (val_constr.datalen > 0)
42995 val_constr.data = MALLOC(val_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
42997 val_constr.data = NULL;
42998 int64_t* val_vals = val->elems;
42999 for (size_t i = 0; i < val_constr.datalen; i++) {
43000 int64_t val_conv_8 = val_vals[i];
43001 val_constr.data[i] = val_conv_8;
43004 NodeInfo_set_channels(&this_ptr_conv, val_constr);
43007 uint64_t __attribute__((export_name("TS_NodeInfo_get_lowest_inbound_channel_fees"))) TS_NodeInfo_get_lowest_inbound_channel_fees(uint64_t this_ptr) {
43008 LDKNodeInfo this_ptr_conv;
43009 this_ptr_conv.inner = untag_ptr(this_ptr);
43010 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43011 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43012 this_ptr_conv.is_owned = false;
43013 LDKRoutingFees ret_var = NodeInfo_get_lowest_inbound_channel_fees(&this_ptr_conv);
43014 uint64_t ret_ref = 0;
43015 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43016 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43020 void __attribute__((export_name("TS_NodeInfo_set_lowest_inbound_channel_fees"))) TS_NodeInfo_set_lowest_inbound_channel_fees(uint64_t this_ptr, uint64_t val) {
43021 LDKNodeInfo this_ptr_conv;
43022 this_ptr_conv.inner = untag_ptr(this_ptr);
43023 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43024 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43025 this_ptr_conv.is_owned = false;
43026 LDKRoutingFees val_conv;
43027 val_conv.inner = untag_ptr(val);
43028 val_conv.is_owned = ptr_is_owned(val);
43029 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
43030 val_conv = RoutingFees_clone(&val_conv);
43031 NodeInfo_set_lowest_inbound_channel_fees(&this_ptr_conv, val_conv);
43034 uint64_t __attribute__((export_name("TS_NodeInfo_get_announcement_info"))) TS_NodeInfo_get_announcement_info(uint64_t this_ptr) {
43035 LDKNodeInfo this_ptr_conv;
43036 this_ptr_conv.inner = untag_ptr(this_ptr);
43037 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43038 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43039 this_ptr_conv.is_owned = false;
43040 LDKNodeAnnouncementInfo ret_var = NodeInfo_get_announcement_info(&this_ptr_conv);
43041 uint64_t ret_ref = 0;
43042 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43043 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43047 void __attribute__((export_name("TS_NodeInfo_set_announcement_info"))) TS_NodeInfo_set_announcement_info(uint64_t this_ptr, uint64_t val) {
43048 LDKNodeInfo this_ptr_conv;
43049 this_ptr_conv.inner = untag_ptr(this_ptr);
43050 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43051 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43052 this_ptr_conv.is_owned = false;
43053 LDKNodeAnnouncementInfo val_conv;
43054 val_conv.inner = untag_ptr(val);
43055 val_conv.is_owned = ptr_is_owned(val);
43056 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
43057 val_conv = NodeAnnouncementInfo_clone(&val_conv);
43058 NodeInfo_set_announcement_info(&this_ptr_conv, val_conv);
43061 uint64_t __attribute__((export_name("TS_NodeInfo_new"))) TS_NodeInfo_new(int64_tArray channels_arg, uint64_t lowest_inbound_channel_fees_arg, uint64_t announcement_info_arg) {
43062 LDKCVec_u64Z channels_arg_constr;
43063 channels_arg_constr.datalen = channels_arg->arr_len;
43064 if (channels_arg_constr.datalen > 0)
43065 channels_arg_constr.data = MALLOC(channels_arg_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
43067 channels_arg_constr.data = NULL;
43068 int64_t* channels_arg_vals = channels_arg->elems;
43069 for (size_t i = 0; i < channels_arg_constr.datalen; i++) {
43070 int64_t channels_arg_conv_8 = channels_arg_vals[i];
43071 channels_arg_constr.data[i] = channels_arg_conv_8;
43073 FREE(channels_arg);
43074 LDKRoutingFees lowest_inbound_channel_fees_arg_conv;
43075 lowest_inbound_channel_fees_arg_conv.inner = untag_ptr(lowest_inbound_channel_fees_arg);
43076 lowest_inbound_channel_fees_arg_conv.is_owned = ptr_is_owned(lowest_inbound_channel_fees_arg);
43077 CHECK_INNER_FIELD_ACCESS_OR_NULL(lowest_inbound_channel_fees_arg_conv);
43078 lowest_inbound_channel_fees_arg_conv = RoutingFees_clone(&lowest_inbound_channel_fees_arg_conv);
43079 LDKNodeAnnouncementInfo announcement_info_arg_conv;
43080 announcement_info_arg_conv.inner = untag_ptr(announcement_info_arg);
43081 announcement_info_arg_conv.is_owned = ptr_is_owned(announcement_info_arg);
43082 CHECK_INNER_FIELD_ACCESS_OR_NULL(announcement_info_arg_conv);
43083 announcement_info_arg_conv = NodeAnnouncementInfo_clone(&announcement_info_arg_conv);
43084 LDKNodeInfo ret_var = NodeInfo_new(channels_arg_constr, lowest_inbound_channel_fees_arg_conv, announcement_info_arg_conv);
43085 uint64_t ret_ref = 0;
43086 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43087 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43091 static inline uint64_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg) {
43092 LDKNodeInfo ret_var = NodeInfo_clone(arg);
43093 uint64_t ret_ref = 0;
43094 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43095 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43098 int64_t __attribute__((export_name("TS_NodeInfo_clone_ptr"))) TS_NodeInfo_clone_ptr(uint64_t arg) {
43099 LDKNodeInfo arg_conv;
43100 arg_conv.inner = untag_ptr(arg);
43101 arg_conv.is_owned = ptr_is_owned(arg);
43102 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
43103 arg_conv.is_owned = false;
43104 int64_t ret_conv = NodeInfo_clone_ptr(&arg_conv);
43108 uint64_t __attribute__((export_name("TS_NodeInfo_clone"))) TS_NodeInfo_clone(uint64_t orig) {
43109 LDKNodeInfo orig_conv;
43110 orig_conv.inner = untag_ptr(orig);
43111 orig_conv.is_owned = ptr_is_owned(orig);
43112 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
43113 orig_conv.is_owned = false;
43114 LDKNodeInfo ret_var = NodeInfo_clone(&orig_conv);
43115 uint64_t ret_ref = 0;
43116 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43117 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43121 jboolean __attribute__((export_name("TS_NodeInfo_eq"))) TS_NodeInfo_eq(uint64_t a, uint64_t b) {
43122 LDKNodeInfo a_conv;
43123 a_conv.inner = untag_ptr(a);
43124 a_conv.is_owned = ptr_is_owned(a);
43125 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
43126 a_conv.is_owned = false;
43127 LDKNodeInfo b_conv;
43128 b_conv.inner = untag_ptr(b);
43129 b_conv.is_owned = ptr_is_owned(b);
43130 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
43131 b_conv.is_owned = false;
43132 jboolean ret_conv = NodeInfo_eq(&a_conv, &b_conv);
43136 int8_tArray __attribute__((export_name("TS_NodeInfo_write"))) TS_NodeInfo_write(uint64_t obj) {
43137 LDKNodeInfo obj_conv;
43138 obj_conv.inner = untag_ptr(obj);
43139 obj_conv.is_owned = ptr_is_owned(obj);
43140 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
43141 obj_conv.is_owned = false;
43142 LDKCVec_u8Z ret_var = NodeInfo_write(&obj_conv);
43143 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
43144 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
43145 CVec_u8Z_free(ret_var);
43149 uint64_t __attribute__((export_name("TS_NodeInfo_read"))) TS_NodeInfo_read(int8_tArray ser) {
43150 LDKu8slice ser_ref;
43151 ser_ref.datalen = ser->arr_len;
43152 ser_ref.data = ser->elems;
43153 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
43154 *ret_conv = NodeInfo_read(ser_ref);
43156 return tag_ptr(ret_conv, true);
43159 int8_tArray __attribute__((export_name("TS_NetworkGraph_write"))) TS_NetworkGraph_write(uint64_t obj) {
43160 LDKNetworkGraph obj_conv;
43161 obj_conv.inner = untag_ptr(obj);
43162 obj_conv.is_owned = ptr_is_owned(obj);
43163 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
43164 obj_conv.is_owned = false;
43165 LDKCVec_u8Z ret_var = NetworkGraph_write(&obj_conv);
43166 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
43167 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
43168 CVec_u8Z_free(ret_var);
43172 uint64_t __attribute__((export_name("TS_NetworkGraph_read"))) TS_NetworkGraph_read(int8_tArray ser, uint64_t arg) {
43173 LDKu8slice ser_ref;
43174 ser_ref.datalen = ser->arr_len;
43175 ser_ref.data = ser->elems;
43176 void* arg_ptr = untag_ptr(arg);
43177 CHECK_ACCESS(arg_ptr);
43178 LDKLogger arg_conv = *(LDKLogger*)(arg_ptr);
43179 if (arg_conv.free == LDKLogger_JCalls_free) {
43180 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
43181 LDKLogger_JCalls_cloned(&arg_conv);
43183 LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
43184 *ret_conv = NetworkGraph_read(ser_ref, arg_conv);
43186 return tag_ptr(ret_conv, true);
43189 uint64_t __attribute__((export_name("TS_NetworkGraph_new"))) TS_NetworkGraph_new(int8_tArray genesis_hash, uint64_t logger) {
43190 LDKThirtyTwoBytes genesis_hash_ref;
43191 CHECK(genesis_hash->arr_len == 32);
43192 memcpy(genesis_hash_ref.data, genesis_hash->elems, 32); FREE(genesis_hash);
43193 void* logger_ptr = untag_ptr(logger);
43194 CHECK_ACCESS(logger_ptr);
43195 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
43196 if (logger_conv.free == LDKLogger_JCalls_free) {
43197 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
43198 LDKLogger_JCalls_cloned(&logger_conv);
43200 LDKNetworkGraph ret_var = NetworkGraph_new(genesis_hash_ref, logger_conv);
43201 uint64_t ret_ref = 0;
43202 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43203 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43207 uint64_t __attribute__((export_name("TS_NetworkGraph_read_only"))) TS_NetworkGraph_read_only(uint64_t this_arg) {
43208 LDKNetworkGraph this_arg_conv;
43209 this_arg_conv.inner = untag_ptr(this_arg);
43210 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43211 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43212 this_arg_conv.is_owned = false;
43213 LDKReadOnlyNetworkGraph ret_var = NetworkGraph_read_only(&this_arg_conv);
43214 uint64_t ret_ref = 0;
43215 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43216 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43220 uint64_t __attribute__((export_name("TS_NetworkGraph_get_last_rapid_gossip_sync_timestamp"))) TS_NetworkGraph_get_last_rapid_gossip_sync_timestamp(uint64_t this_arg) {
43221 LDKNetworkGraph this_arg_conv;
43222 this_arg_conv.inner = untag_ptr(this_arg);
43223 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43224 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43225 this_arg_conv.is_owned = false;
43226 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
43227 *ret_copy = NetworkGraph_get_last_rapid_gossip_sync_timestamp(&this_arg_conv);
43228 uint64_t ret_ref = tag_ptr(ret_copy, true);
43232 void __attribute__((export_name("TS_NetworkGraph_set_last_rapid_gossip_sync_timestamp"))) TS_NetworkGraph_set_last_rapid_gossip_sync_timestamp(uint64_t this_arg, int32_t last_rapid_gossip_sync_timestamp) {
43233 LDKNetworkGraph this_arg_conv;
43234 this_arg_conv.inner = untag_ptr(this_arg);
43235 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43236 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43237 this_arg_conv.is_owned = false;
43238 NetworkGraph_set_last_rapid_gossip_sync_timestamp(&this_arg_conv, last_rapid_gossip_sync_timestamp);
43241 uint64_t __attribute__((export_name("TS_NetworkGraph_update_node_from_announcement"))) TS_NetworkGraph_update_node_from_announcement(uint64_t this_arg, uint64_t msg) {
43242 LDKNetworkGraph this_arg_conv;
43243 this_arg_conv.inner = untag_ptr(this_arg);
43244 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43245 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43246 this_arg_conv.is_owned = false;
43247 LDKNodeAnnouncement msg_conv;
43248 msg_conv.inner = untag_ptr(msg);
43249 msg_conv.is_owned = ptr_is_owned(msg);
43250 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
43251 msg_conv.is_owned = false;
43252 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
43253 *ret_conv = NetworkGraph_update_node_from_announcement(&this_arg_conv, &msg_conv);
43254 return tag_ptr(ret_conv, true);
43257 uint64_t __attribute__((export_name("TS_NetworkGraph_update_node_from_unsigned_announcement"))) TS_NetworkGraph_update_node_from_unsigned_announcement(uint64_t this_arg, uint64_t msg) {
43258 LDKNetworkGraph this_arg_conv;
43259 this_arg_conv.inner = untag_ptr(this_arg);
43260 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43261 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43262 this_arg_conv.is_owned = false;
43263 LDKUnsignedNodeAnnouncement msg_conv;
43264 msg_conv.inner = untag_ptr(msg);
43265 msg_conv.is_owned = ptr_is_owned(msg);
43266 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
43267 msg_conv.is_owned = false;
43268 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
43269 *ret_conv = NetworkGraph_update_node_from_unsigned_announcement(&this_arg_conv, &msg_conv);
43270 return tag_ptr(ret_conv, true);
43273 uint64_t __attribute__((export_name("TS_NetworkGraph_update_channel_from_announcement"))) TS_NetworkGraph_update_channel_from_announcement(uint64_t this_arg, uint64_t msg, uint64_t chain_access) {
43274 LDKNetworkGraph this_arg_conv;
43275 this_arg_conv.inner = untag_ptr(this_arg);
43276 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43277 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43278 this_arg_conv.is_owned = false;
43279 LDKChannelAnnouncement msg_conv;
43280 msg_conv.inner = untag_ptr(msg);
43281 msg_conv.is_owned = ptr_is_owned(msg);
43282 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
43283 msg_conv.is_owned = false;
43284 void* chain_access_ptr = untag_ptr(chain_access);
43285 CHECK_ACCESS(chain_access_ptr);
43286 LDKCOption_AccessZ chain_access_conv = *(LDKCOption_AccessZ*)(chain_access_ptr);
43287 // WARNING: we may need a move here but no clone is available for LDKCOption_AccessZ
43288 if (chain_access_conv.tag == LDKCOption_AccessZ_Some) {
43289 // Manually implement clone for Java trait instances
43290 if (chain_access_conv.some.free == LDKAccess_JCalls_free) {
43291 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
43292 LDKAccess_JCalls_cloned(&chain_access_conv.some);
43295 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
43296 *ret_conv = NetworkGraph_update_channel_from_announcement(&this_arg_conv, &msg_conv, chain_access_conv);
43297 return tag_ptr(ret_conv, true);
43300 uint64_t __attribute__((export_name("TS_NetworkGraph_update_channel_from_unsigned_announcement"))) TS_NetworkGraph_update_channel_from_unsigned_announcement(uint64_t this_arg, uint64_t msg, uint64_t chain_access) {
43301 LDKNetworkGraph this_arg_conv;
43302 this_arg_conv.inner = untag_ptr(this_arg);
43303 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43304 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43305 this_arg_conv.is_owned = false;
43306 LDKUnsignedChannelAnnouncement msg_conv;
43307 msg_conv.inner = untag_ptr(msg);
43308 msg_conv.is_owned = ptr_is_owned(msg);
43309 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
43310 msg_conv.is_owned = false;
43311 void* chain_access_ptr = untag_ptr(chain_access);
43312 CHECK_ACCESS(chain_access_ptr);
43313 LDKCOption_AccessZ chain_access_conv = *(LDKCOption_AccessZ*)(chain_access_ptr);
43314 // WARNING: we may need a move here but no clone is available for LDKCOption_AccessZ
43315 if (chain_access_conv.tag == LDKCOption_AccessZ_Some) {
43316 // Manually implement clone for Java trait instances
43317 if (chain_access_conv.some.free == LDKAccess_JCalls_free) {
43318 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
43319 LDKAccess_JCalls_cloned(&chain_access_conv.some);
43322 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
43323 *ret_conv = NetworkGraph_update_channel_from_unsigned_announcement(&this_arg_conv, &msg_conv, chain_access_conv);
43324 return tag_ptr(ret_conv, true);
43327 uint64_t __attribute__((export_name("TS_NetworkGraph_add_channel_from_partial_announcement"))) TS_NetworkGraph_add_channel_from_partial_announcement(uint64_t this_arg, int64_t short_channel_id, int64_t timestamp, uint64_t features, int8_tArray node_id_1, int8_tArray node_id_2) {
43328 LDKNetworkGraph this_arg_conv;
43329 this_arg_conv.inner = untag_ptr(this_arg);
43330 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43331 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43332 this_arg_conv.is_owned = false;
43333 LDKChannelFeatures features_conv;
43334 features_conv.inner = untag_ptr(features);
43335 features_conv.is_owned = ptr_is_owned(features);
43336 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_conv);
43337 features_conv = ChannelFeatures_clone(&features_conv);
43338 LDKPublicKey node_id_1_ref;
43339 CHECK(node_id_1->arr_len == 33);
43340 memcpy(node_id_1_ref.compressed_form, node_id_1->elems, 33); FREE(node_id_1);
43341 LDKPublicKey node_id_2_ref;
43342 CHECK(node_id_2->arr_len == 33);
43343 memcpy(node_id_2_ref.compressed_form, node_id_2->elems, 33); FREE(node_id_2);
43344 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
43345 *ret_conv = NetworkGraph_add_channel_from_partial_announcement(&this_arg_conv, short_channel_id, timestamp, features_conv, node_id_1_ref, node_id_2_ref);
43346 return tag_ptr(ret_conv, true);
43349 void __attribute__((export_name("TS_NetworkGraph_channel_failed"))) TS_NetworkGraph_channel_failed(uint64_t this_arg, int64_t short_channel_id, jboolean is_permanent) {
43350 LDKNetworkGraph this_arg_conv;
43351 this_arg_conv.inner = untag_ptr(this_arg);
43352 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43353 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43354 this_arg_conv.is_owned = false;
43355 NetworkGraph_channel_failed(&this_arg_conv, short_channel_id, is_permanent);
43358 void __attribute__((export_name("TS_NetworkGraph_node_failed_permanent"))) TS_NetworkGraph_node_failed_permanent(uint64_t this_arg, int8_tArray node_id) {
43359 LDKNetworkGraph this_arg_conv;
43360 this_arg_conv.inner = untag_ptr(this_arg);
43361 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43362 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43363 this_arg_conv.is_owned = false;
43364 LDKPublicKey node_id_ref;
43365 CHECK(node_id->arr_len == 33);
43366 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
43367 NetworkGraph_node_failed_permanent(&this_arg_conv, node_id_ref);
43370 void __attribute__((export_name("TS_NetworkGraph_remove_stale_channels_and_tracking_with_time"))) TS_NetworkGraph_remove_stale_channels_and_tracking_with_time(uint64_t this_arg, int64_t current_time_unix) {
43371 LDKNetworkGraph this_arg_conv;
43372 this_arg_conv.inner = untag_ptr(this_arg);
43373 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43374 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43375 this_arg_conv.is_owned = false;
43376 NetworkGraph_remove_stale_channels_and_tracking_with_time(&this_arg_conv, current_time_unix);
43379 uint64_t __attribute__((export_name("TS_NetworkGraph_update_channel"))) TS_NetworkGraph_update_channel(uint64_t this_arg, uint64_t msg) {
43380 LDKNetworkGraph this_arg_conv;
43381 this_arg_conv.inner = untag_ptr(this_arg);
43382 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43383 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43384 this_arg_conv.is_owned = false;
43385 LDKChannelUpdate msg_conv;
43386 msg_conv.inner = untag_ptr(msg);
43387 msg_conv.is_owned = ptr_is_owned(msg);
43388 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
43389 msg_conv.is_owned = false;
43390 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
43391 *ret_conv = NetworkGraph_update_channel(&this_arg_conv, &msg_conv);
43392 return tag_ptr(ret_conv, true);
43395 uint64_t __attribute__((export_name("TS_NetworkGraph_update_channel_unsigned"))) TS_NetworkGraph_update_channel_unsigned(uint64_t this_arg, uint64_t msg) {
43396 LDKNetworkGraph this_arg_conv;
43397 this_arg_conv.inner = untag_ptr(this_arg);
43398 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43399 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43400 this_arg_conv.is_owned = false;
43401 LDKUnsignedChannelUpdate msg_conv;
43402 msg_conv.inner = untag_ptr(msg);
43403 msg_conv.is_owned = ptr_is_owned(msg);
43404 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
43405 msg_conv.is_owned = false;
43406 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
43407 *ret_conv = NetworkGraph_update_channel_unsigned(&this_arg_conv, &msg_conv);
43408 return tag_ptr(ret_conv, true);
43411 uint64_t __attribute__((export_name("TS_ReadOnlyNetworkGraph_channel"))) TS_ReadOnlyNetworkGraph_channel(uint64_t this_arg, int64_t short_channel_id) {
43412 LDKReadOnlyNetworkGraph this_arg_conv;
43413 this_arg_conv.inner = untag_ptr(this_arg);
43414 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43415 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43416 this_arg_conv.is_owned = false;
43417 LDKChannelInfo ret_var = ReadOnlyNetworkGraph_channel(&this_arg_conv, short_channel_id);
43418 uint64_t ret_ref = 0;
43419 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43420 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43424 int64_tArray __attribute__((export_name("TS_ReadOnlyNetworkGraph_list_channels"))) TS_ReadOnlyNetworkGraph_list_channels(uint64_t this_arg) {
43425 LDKReadOnlyNetworkGraph this_arg_conv;
43426 this_arg_conv.inner = untag_ptr(this_arg);
43427 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43428 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43429 this_arg_conv.is_owned = false;
43430 LDKCVec_u64Z ret_var = ReadOnlyNetworkGraph_list_channels(&this_arg_conv);
43431 int64_tArray ret_arr = NULL;
43432 ret_arr = init_int64_tArray(ret_var.datalen, __LINE__);
43433 int64_t *ret_arr_ptr = (int64_t*)(((uint8_t*)ret_arr) + 8);
43434 for (size_t i = 0; i < ret_var.datalen; i++) {
43435 int64_t ret_conv_8_conv = ret_var.data[i];
43436 ret_arr_ptr[i] = ret_conv_8_conv;
43439 FREE(ret_var.data);
43443 uint64_t __attribute__((export_name("TS_ReadOnlyNetworkGraph_node"))) TS_ReadOnlyNetworkGraph_node(uint64_t this_arg, uint64_t node_id) {
43444 LDKReadOnlyNetworkGraph this_arg_conv;
43445 this_arg_conv.inner = untag_ptr(this_arg);
43446 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43447 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43448 this_arg_conv.is_owned = false;
43449 LDKNodeId node_id_conv;
43450 node_id_conv.inner = untag_ptr(node_id);
43451 node_id_conv.is_owned = ptr_is_owned(node_id);
43452 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_id_conv);
43453 node_id_conv.is_owned = false;
43454 LDKNodeInfo ret_var = ReadOnlyNetworkGraph_node(&this_arg_conv, &node_id_conv);
43455 uint64_t ret_ref = 0;
43456 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43457 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43461 uint64_tArray __attribute__((export_name("TS_ReadOnlyNetworkGraph_list_nodes"))) TS_ReadOnlyNetworkGraph_list_nodes(uint64_t this_arg) {
43462 LDKReadOnlyNetworkGraph this_arg_conv;
43463 this_arg_conv.inner = untag_ptr(this_arg);
43464 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43465 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43466 this_arg_conv.is_owned = false;
43467 LDKCVec_NodeIdZ ret_var = ReadOnlyNetworkGraph_list_nodes(&this_arg_conv);
43468 uint64_tArray ret_arr = NULL;
43469 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
43470 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
43471 for (size_t i = 0; i < ret_var.datalen; i++) {
43472 LDKNodeId ret_conv_8_var = ret_var.data[i];
43473 uint64_t ret_conv_8_ref = 0;
43474 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_8_var);
43475 ret_conv_8_ref = tag_ptr(ret_conv_8_var.inner, ret_conv_8_var.is_owned);
43476 ret_arr_ptr[i] = ret_conv_8_ref;
43479 FREE(ret_var.data);
43483 uint64_t __attribute__((export_name("TS_ReadOnlyNetworkGraph_get_addresses"))) TS_ReadOnlyNetworkGraph_get_addresses(uint64_t this_arg, int8_tArray pubkey) {
43484 LDKReadOnlyNetworkGraph this_arg_conv;
43485 this_arg_conv.inner = untag_ptr(this_arg);
43486 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43487 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43488 this_arg_conv.is_owned = false;
43489 LDKPublicKey pubkey_ref;
43490 CHECK(pubkey->arr_len == 33);
43491 memcpy(pubkey_ref.compressed_form, pubkey->elems, 33); FREE(pubkey);
43492 LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ");
43493 *ret_copy = ReadOnlyNetworkGraph_get_addresses(&this_arg_conv, pubkey_ref);
43494 uint64_t ret_ref = tag_ptr(ret_copy, true);
43498 void __attribute__((export_name("TS_DefaultRouter_free"))) TS_DefaultRouter_free(uint64_t this_obj) {
43499 LDKDefaultRouter this_obj_conv;
43500 this_obj_conv.inner = untag_ptr(this_obj);
43501 this_obj_conv.is_owned = ptr_is_owned(this_obj);
43502 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
43503 DefaultRouter_free(this_obj_conv);
43506 uint64_t __attribute__((export_name("TS_DefaultRouter_new"))) TS_DefaultRouter_new(uint64_t network_graph, uint64_t logger, int8_tArray random_seed_bytes, uint64_t scorer) {
43507 LDKNetworkGraph network_graph_conv;
43508 network_graph_conv.inner = untag_ptr(network_graph);
43509 network_graph_conv.is_owned = ptr_is_owned(network_graph);
43510 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
43511 network_graph_conv.is_owned = false;
43512 void* logger_ptr = untag_ptr(logger);
43513 CHECK_ACCESS(logger_ptr);
43514 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
43515 if (logger_conv.free == LDKLogger_JCalls_free) {
43516 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
43517 LDKLogger_JCalls_cloned(&logger_conv);
43519 LDKThirtyTwoBytes random_seed_bytes_ref;
43520 CHECK(random_seed_bytes->arr_len == 32);
43521 memcpy(random_seed_bytes_ref.data, random_seed_bytes->elems, 32); FREE(random_seed_bytes);
43522 void* scorer_ptr = untag_ptr(scorer);
43523 CHECK_ACCESS(scorer_ptr);
43524 LDKLockableScore scorer_conv = *(LDKLockableScore*)(scorer_ptr);
43525 if (scorer_conv.free == LDKLockableScore_JCalls_free) {
43526 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
43527 LDKLockableScore_JCalls_cloned(&scorer_conv);
43529 LDKDefaultRouter ret_var = DefaultRouter_new(&network_graph_conv, logger_conv, random_seed_bytes_ref, scorer_conv);
43530 uint64_t ret_ref = 0;
43531 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43532 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43536 uint64_t __attribute__((export_name("TS_DefaultRouter_as_Router"))) TS_DefaultRouter_as_Router(uint64_t this_arg) {
43537 LDKDefaultRouter this_arg_conv;
43538 this_arg_conv.inner = untag_ptr(this_arg);
43539 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43540 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43541 this_arg_conv.is_owned = false;
43542 LDKRouter* ret_ret = MALLOC(sizeof(LDKRouter), "LDKRouter");
43543 *ret_ret = DefaultRouter_as_Router(&this_arg_conv);
43544 return tag_ptr(ret_ret, true);
43547 void __attribute__((export_name("TS_Router_free"))) TS_Router_free(uint64_t this_ptr) {
43548 if (!ptr_is_owned(this_ptr)) return;
43549 void* this_ptr_ptr = untag_ptr(this_ptr);
43550 CHECK_ACCESS(this_ptr_ptr);
43551 LDKRouter this_ptr_conv = *(LDKRouter*)(this_ptr_ptr);
43552 FREE(untag_ptr(this_ptr));
43553 Router_free(this_ptr_conv);
43556 void __attribute__((export_name("TS_ScorerAccountingForInFlightHtlcs_free"))) TS_ScorerAccountingForInFlightHtlcs_free(uint64_t this_obj) {
43557 LDKScorerAccountingForInFlightHtlcs this_obj_conv;
43558 this_obj_conv.inner = untag_ptr(this_obj);
43559 this_obj_conv.is_owned = ptr_is_owned(this_obj);
43560 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
43561 ScorerAccountingForInFlightHtlcs_free(this_obj_conv);
43564 uint64_t __attribute__((export_name("TS_ScorerAccountingForInFlightHtlcs_new"))) TS_ScorerAccountingForInFlightHtlcs_new(uint64_t scorer, uint64_t inflight_htlcs) {
43565 void* scorer_ptr = untag_ptr(scorer);
43566 CHECK_ACCESS(scorer_ptr);
43567 LDKScore scorer_conv = *(LDKScore*)(scorer_ptr);
43568 if (scorer_conv.free == LDKScore_JCalls_free) {
43569 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
43570 LDKScore_JCalls_cloned(&scorer_conv);
43572 LDKInFlightHtlcs inflight_htlcs_conv;
43573 inflight_htlcs_conv.inner = untag_ptr(inflight_htlcs);
43574 inflight_htlcs_conv.is_owned = ptr_is_owned(inflight_htlcs);
43575 CHECK_INNER_FIELD_ACCESS_OR_NULL(inflight_htlcs_conv);
43576 inflight_htlcs_conv = InFlightHtlcs_clone(&inflight_htlcs_conv);
43577 LDKScorerAccountingForInFlightHtlcs ret_var = ScorerAccountingForInFlightHtlcs_new(scorer_conv, inflight_htlcs_conv);
43578 uint64_t ret_ref = 0;
43579 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43580 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43584 int8_tArray __attribute__((export_name("TS_ScorerAccountingForInFlightHtlcs_write"))) TS_ScorerAccountingForInFlightHtlcs_write(uint64_t obj) {
43585 LDKScorerAccountingForInFlightHtlcs obj_conv;
43586 obj_conv.inner = untag_ptr(obj);
43587 obj_conv.is_owned = ptr_is_owned(obj);
43588 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
43589 obj_conv.is_owned = false;
43590 LDKCVec_u8Z ret_var = ScorerAccountingForInFlightHtlcs_write(&obj_conv);
43591 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
43592 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
43593 CVec_u8Z_free(ret_var);
43597 uint64_t __attribute__((export_name("TS_ScorerAccountingForInFlightHtlcs_as_Score"))) TS_ScorerAccountingForInFlightHtlcs_as_Score(uint64_t this_arg) {
43598 LDKScorerAccountingForInFlightHtlcs this_arg_conv;
43599 this_arg_conv.inner = untag_ptr(this_arg);
43600 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43601 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43602 this_arg_conv.is_owned = false;
43603 LDKScore* ret_ret = MALLOC(sizeof(LDKScore), "LDKScore");
43604 *ret_ret = ScorerAccountingForInFlightHtlcs_as_Score(&this_arg_conv);
43605 return tag_ptr(ret_ret, true);
43608 void __attribute__((export_name("TS_InFlightHtlcs_free"))) TS_InFlightHtlcs_free(uint64_t this_obj) {
43609 LDKInFlightHtlcs this_obj_conv;
43610 this_obj_conv.inner = untag_ptr(this_obj);
43611 this_obj_conv.is_owned = ptr_is_owned(this_obj);
43612 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
43613 InFlightHtlcs_free(this_obj_conv);
43616 static inline uint64_t InFlightHtlcs_clone_ptr(LDKInFlightHtlcs *NONNULL_PTR arg) {
43617 LDKInFlightHtlcs ret_var = InFlightHtlcs_clone(arg);
43618 uint64_t ret_ref = 0;
43619 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43620 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43623 int64_t __attribute__((export_name("TS_InFlightHtlcs_clone_ptr"))) TS_InFlightHtlcs_clone_ptr(uint64_t arg) {
43624 LDKInFlightHtlcs arg_conv;
43625 arg_conv.inner = untag_ptr(arg);
43626 arg_conv.is_owned = ptr_is_owned(arg);
43627 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
43628 arg_conv.is_owned = false;
43629 int64_t ret_conv = InFlightHtlcs_clone_ptr(&arg_conv);
43633 uint64_t __attribute__((export_name("TS_InFlightHtlcs_clone"))) TS_InFlightHtlcs_clone(uint64_t orig) {
43634 LDKInFlightHtlcs orig_conv;
43635 orig_conv.inner = untag_ptr(orig);
43636 orig_conv.is_owned = ptr_is_owned(orig);
43637 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
43638 orig_conv.is_owned = false;
43639 LDKInFlightHtlcs ret_var = InFlightHtlcs_clone(&orig_conv);
43640 uint64_t ret_ref = 0;
43641 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43642 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43646 uint64_t __attribute__((export_name("TS_InFlightHtlcs_new"))) TS_InFlightHtlcs_new() {
43647 LDKInFlightHtlcs ret_var = InFlightHtlcs_new();
43648 uint64_t ret_ref = 0;
43649 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43650 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43654 uint64_t __attribute__((export_name("TS_InFlightHtlcs_used_liquidity_msat"))) TS_InFlightHtlcs_used_liquidity_msat(uint64_t this_arg, uint64_t source, uint64_t target, int64_t channel_scid) {
43655 LDKInFlightHtlcs this_arg_conv;
43656 this_arg_conv.inner = untag_ptr(this_arg);
43657 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43658 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43659 this_arg_conv.is_owned = false;
43660 LDKNodeId source_conv;
43661 source_conv.inner = untag_ptr(source);
43662 source_conv.is_owned = ptr_is_owned(source);
43663 CHECK_INNER_FIELD_ACCESS_OR_NULL(source_conv);
43664 source_conv.is_owned = false;
43665 LDKNodeId target_conv;
43666 target_conv.inner = untag_ptr(target);
43667 target_conv.is_owned = ptr_is_owned(target);
43668 CHECK_INNER_FIELD_ACCESS_OR_NULL(target_conv);
43669 target_conv.is_owned = false;
43670 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
43671 *ret_copy = InFlightHtlcs_used_liquidity_msat(&this_arg_conv, &source_conv, &target_conv, channel_scid);
43672 uint64_t ret_ref = tag_ptr(ret_copy, true);
43676 int8_tArray __attribute__((export_name("TS_InFlightHtlcs_write"))) TS_InFlightHtlcs_write(uint64_t obj) {
43677 LDKInFlightHtlcs obj_conv;
43678 obj_conv.inner = untag_ptr(obj);
43679 obj_conv.is_owned = ptr_is_owned(obj);
43680 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
43681 obj_conv.is_owned = false;
43682 LDKCVec_u8Z ret_var = InFlightHtlcs_write(&obj_conv);
43683 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
43684 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
43685 CVec_u8Z_free(ret_var);
43689 uint64_t __attribute__((export_name("TS_InFlightHtlcs_read"))) TS_InFlightHtlcs_read(int8_tArray ser) {
43690 LDKu8slice ser_ref;
43691 ser_ref.datalen = ser->arr_len;
43692 ser_ref.data = ser->elems;
43693 LDKCResult_InFlightHtlcsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ), "LDKCResult_InFlightHtlcsDecodeErrorZ");
43694 *ret_conv = InFlightHtlcs_read(ser_ref);
43696 return tag_ptr(ret_conv, true);
43699 void __attribute__((export_name("TS_RouteHop_free"))) TS_RouteHop_free(uint64_t this_obj) {
43700 LDKRouteHop this_obj_conv;
43701 this_obj_conv.inner = untag_ptr(this_obj);
43702 this_obj_conv.is_owned = ptr_is_owned(this_obj);
43703 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
43704 RouteHop_free(this_obj_conv);
43707 int8_tArray __attribute__((export_name("TS_RouteHop_get_pubkey"))) TS_RouteHop_get_pubkey(uint64_t this_ptr) {
43708 LDKRouteHop this_ptr_conv;
43709 this_ptr_conv.inner = untag_ptr(this_ptr);
43710 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43711 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43712 this_ptr_conv.is_owned = false;
43713 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
43714 memcpy(ret_arr->elems, RouteHop_get_pubkey(&this_ptr_conv).compressed_form, 33);
43718 void __attribute__((export_name("TS_RouteHop_set_pubkey"))) TS_RouteHop_set_pubkey(uint64_t this_ptr, int8_tArray val) {
43719 LDKRouteHop this_ptr_conv;
43720 this_ptr_conv.inner = untag_ptr(this_ptr);
43721 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43722 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43723 this_ptr_conv.is_owned = false;
43724 LDKPublicKey val_ref;
43725 CHECK(val->arr_len == 33);
43726 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
43727 RouteHop_set_pubkey(&this_ptr_conv, val_ref);
43730 uint64_t __attribute__((export_name("TS_RouteHop_get_node_features"))) TS_RouteHop_get_node_features(uint64_t this_ptr) {
43731 LDKRouteHop this_ptr_conv;
43732 this_ptr_conv.inner = untag_ptr(this_ptr);
43733 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43734 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43735 this_ptr_conv.is_owned = false;
43736 LDKNodeFeatures ret_var = RouteHop_get_node_features(&this_ptr_conv);
43737 uint64_t ret_ref = 0;
43738 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43739 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43743 void __attribute__((export_name("TS_RouteHop_set_node_features"))) TS_RouteHop_set_node_features(uint64_t this_ptr, uint64_t val) {
43744 LDKRouteHop this_ptr_conv;
43745 this_ptr_conv.inner = untag_ptr(this_ptr);
43746 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43747 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43748 this_ptr_conv.is_owned = false;
43749 LDKNodeFeatures val_conv;
43750 val_conv.inner = untag_ptr(val);
43751 val_conv.is_owned = ptr_is_owned(val);
43752 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
43753 val_conv = NodeFeatures_clone(&val_conv);
43754 RouteHop_set_node_features(&this_ptr_conv, val_conv);
43757 int64_t __attribute__((export_name("TS_RouteHop_get_short_channel_id"))) TS_RouteHop_get_short_channel_id(uint64_t this_ptr) {
43758 LDKRouteHop this_ptr_conv;
43759 this_ptr_conv.inner = untag_ptr(this_ptr);
43760 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43761 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43762 this_ptr_conv.is_owned = false;
43763 int64_t ret_conv = RouteHop_get_short_channel_id(&this_ptr_conv);
43767 void __attribute__((export_name("TS_RouteHop_set_short_channel_id"))) TS_RouteHop_set_short_channel_id(uint64_t this_ptr, int64_t val) {
43768 LDKRouteHop this_ptr_conv;
43769 this_ptr_conv.inner = untag_ptr(this_ptr);
43770 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43771 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43772 this_ptr_conv.is_owned = false;
43773 RouteHop_set_short_channel_id(&this_ptr_conv, val);
43776 uint64_t __attribute__((export_name("TS_RouteHop_get_channel_features"))) TS_RouteHop_get_channel_features(uint64_t this_ptr) {
43777 LDKRouteHop this_ptr_conv;
43778 this_ptr_conv.inner = untag_ptr(this_ptr);
43779 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43780 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43781 this_ptr_conv.is_owned = false;
43782 LDKChannelFeatures ret_var = RouteHop_get_channel_features(&this_ptr_conv);
43783 uint64_t ret_ref = 0;
43784 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43785 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43789 void __attribute__((export_name("TS_RouteHop_set_channel_features"))) TS_RouteHop_set_channel_features(uint64_t this_ptr, uint64_t val) {
43790 LDKRouteHop this_ptr_conv;
43791 this_ptr_conv.inner = untag_ptr(this_ptr);
43792 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43793 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43794 this_ptr_conv.is_owned = false;
43795 LDKChannelFeatures val_conv;
43796 val_conv.inner = untag_ptr(val);
43797 val_conv.is_owned = ptr_is_owned(val);
43798 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
43799 val_conv = ChannelFeatures_clone(&val_conv);
43800 RouteHop_set_channel_features(&this_ptr_conv, val_conv);
43803 int64_t __attribute__((export_name("TS_RouteHop_get_fee_msat"))) TS_RouteHop_get_fee_msat(uint64_t this_ptr) {
43804 LDKRouteHop this_ptr_conv;
43805 this_ptr_conv.inner = untag_ptr(this_ptr);
43806 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43807 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43808 this_ptr_conv.is_owned = false;
43809 int64_t ret_conv = RouteHop_get_fee_msat(&this_ptr_conv);
43813 void __attribute__((export_name("TS_RouteHop_set_fee_msat"))) TS_RouteHop_set_fee_msat(uint64_t this_ptr, int64_t val) {
43814 LDKRouteHop this_ptr_conv;
43815 this_ptr_conv.inner = untag_ptr(this_ptr);
43816 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43817 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43818 this_ptr_conv.is_owned = false;
43819 RouteHop_set_fee_msat(&this_ptr_conv, val);
43822 int32_t __attribute__((export_name("TS_RouteHop_get_cltv_expiry_delta"))) TS_RouteHop_get_cltv_expiry_delta(uint64_t this_ptr) {
43823 LDKRouteHop this_ptr_conv;
43824 this_ptr_conv.inner = untag_ptr(this_ptr);
43825 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43826 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43827 this_ptr_conv.is_owned = false;
43828 int32_t ret_conv = RouteHop_get_cltv_expiry_delta(&this_ptr_conv);
43832 void __attribute__((export_name("TS_RouteHop_set_cltv_expiry_delta"))) TS_RouteHop_set_cltv_expiry_delta(uint64_t this_ptr, int32_t val) {
43833 LDKRouteHop this_ptr_conv;
43834 this_ptr_conv.inner = untag_ptr(this_ptr);
43835 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43836 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43837 this_ptr_conv.is_owned = false;
43838 RouteHop_set_cltv_expiry_delta(&this_ptr_conv, val);
43841 uint64_t __attribute__((export_name("TS_RouteHop_new"))) TS_RouteHop_new(int8_tArray pubkey_arg, uint64_t node_features_arg, int64_t short_channel_id_arg, uint64_t channel_features_arg, int64_t fee_msat_arg, int32_t cltv_expiry_delta_arg) {
43842 LDKPublicKey pubkey_arg_ref;
43843 CHECK(pubkey_arg->arr_len == 33);
43844 memcpy(pubkey_arg_ref.compressed_form, pubkey_arg->elems, 33); FREE(pubkey_arg);
43845 LDKNodeFeatures node_features_arg_conv;
43846 node_features_arg_conv.inner = untag_ptr(node_features_arg);
43847 node_features_arg_conv.is_owned = ptr_is_owned(node_features_arg);
43848 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_features_arg_conv);
43849 node_features_arg_conv = NodeFeatures_clone(&node_features_arg_conv);
43850 LDKChannelFeatures channel_features_arg_conv;
43851 channel_features_arg_conv.inner = untag_ptr(channel_features_arg);
43852 channel_features_arg_conv.is_owned = ptr_is_owned(channel_features_arg);
43853 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_features_arg_conv);
43854 channel_features_arg_conv = ChannelFeatures_clone(&channel_features_arg_conv);
43855 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);
43856 uint64_t ret_ref = 0;
43857 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43858 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43862 static inline uint64_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg) {
43863 LDKRouteHop ret_var = RouteHop_clone(arg);
43864 uint64_t ret_ref = 0;
43865 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43866 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43869 int64_t __attribute__((export_name("TS_RouteHop_clone_ptr"))) TS_RouteHop_clone_ptr(uint64_t arg) {
43870 LDKRouteHop arg_conv;
43871 arg_conv.inner = untag_ptr(arg);
43872 arg_conv.is_owned = ptr_is_owned(arg);
43873 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
43874 arg_conv.is_owned = false;
43875 int64_t ret_conv = RouteHop_clone_ptr(&arg_conv);
43879 uint64_t __attribute__((export_name("TS_RouteHop_clone"))) TS_RouteHop_clone(uint64_t orig) {
43880 LDKRouteHop orig_conv;
43881 orig_conv.inner = untag_ptr(orig);
43882 orig_conv.is_owned = ptr_is_owned(orig);
43883 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
43884 orig_conv.is_owned = false;
43885 LDKRouteHop ret_var = RouteHop_clone(&orig_conv);
43886 uint64_t ret_ref = 0;
43887 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43888 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43892 int64_t __attribute__((export_name("TS_RouteHop_hash"))) TS_RouteHop_hash(uint64_t o) {
43893 LDKRouteHop o_conv;
43894 o_conv.inner = untag_ptr(o);
43895 o_conv.is_owned = ptr_is_owned(o);
43896 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
43897 o_conv.is_owned = false;
43898 int64_t ret_conv = RouteHop_hash(&o_conv);
43902 jboolean __attribute__((export_name("TS_RouteHop_eq"))) TS_RouteHop_eq(uint64_t a, uint64_t b) {
43903 LDKRouteHop a_conv;
43904 a_conv.inner = untag_ptr(a);
43905 a_conv.is_owned = ptr_is_owned(a);
43906 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
43907 a_conv.is_owned = false;
43908 LDKRouteHop b_conv;
43909 b_conv.inner = untag_ptr(b);
43910 b_conv.is_owned = ptr_is_owned(b);
43911 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
43912 b_conv.is_owned = false;
43913 jboolean ret_conv = RouteHop_eq(&a_conv, &b_conv);
43917 int8_tArray __attribute__((export_name("TS_RouteHop_write"))) TS_RouteHop_write(uint64_t obj) {
43918 LDKRouteHop obj_conv;
43919 obj_conv.inner = untag_ptr(obj);
43920 obj_conv.is_owned = ptr_is_owned(obj);
43921 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
43922 obj_conv.is_owned = false;
43923 LDKCVec_u8Z ret_var = RouteHop_write(&obj_conv);
43924 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
43925 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
43926 CVec_u8Z_free(ret_var);
43930 uint64_t __attribute__((export_name("TS_RouteHop_read"))) TS_RouteHop_read(int8_tArray ser) {
43931 LDKu8slice ser_ref;
43932 ser_ref.datalen = ser->arr_len;
43933 ser_ref.data = ser->elems;
43934 LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
43935 *ret_conv = RouteHop_read(ser_ref);
43937 return tag_ptr(ret_conv, true);
43940 void __attribute__((export_name("TS_Route_free"))) TS_Route_free(uint64_t this_obj) {
43941 LDKRoute this_obj_conv;
43942 this_obj_conv.inner = untag_ptr(this_obj);
43943 this_obj_conv.is_owned = ptr_is_owned(this_obj);
43944 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
43945 Route_free(this_obj_conv);
43948 ptrArray __attribute__((export_name("TS_Route_get_paths"))) TS_Route_get_paths(uint64_t this_ptr) {
43949 LDKRoute this_ptr_conv;
43950 this_ptr_conv.inner = untag_ptr(this_ptr);
43951 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43952 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43953 this_ptr_conv.is_owned = false;
43954 LDKCVec_CVec_RouteHopZZ ret_var = Route_get_paths(&this_ptr_conv);
43955 ptrArray ret_arr = NULL;
43956 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
43957 uint64_tArray *ret_arr_ptr = (uint64_tArray*)(((uint8_t*)ret_arr) + 8);
43958 for (size_t m = 0; m < ret_var.datalen; m++) {
43959 LDKCVec_RouteHopZ ret_conv_12_var = ret_var.data[m];
43960 uint64_tArray ret_conv_12_arr = NULL;
43961 ret_conv_12_arr = init_uint64_tArray(ret_conv_12_var.datalen, __LINE__);
43962 uint64_t *ret_conv_12_arr_ptr = (uint64_t*)(((uint8_t*)ret_conv_12_arr) + 8);
43963 for (size_t k = 0; k < ret_conv_12_var.datalen; k++) {
43964 LDKRouteHop ret_conv_12_conv_10_var = ret_conv_12_var.data[k];
43965 uint64_t ret_conv_12_conv_10_ref = 0;
43966 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_12_conv_10_var);
43967 ret_conv_12_conv_10_ref = tag_ptr(ret_conv_12_conv_10_var.inner, ret_conv_12_conv_10_var.is_owned);
43968 ret_conv_12_arr_ptr[k] = ret_conv_12_conv_10_ref;
43971 FREE(ret_conv_12_var.data);
43972 ret_arr_ptr[m] = ret_conv_12_arr;
43975 FREE(ret_var.data);
43979 void __attribute__((export_name("TS_Route_set_paths"))) TS_Route_set_paths(uint64_t this_ptr, ptrArray val) {
43980 LDKRoute this_ptr_conv;
43981 this_ptr_conv.inner = untag_ptr(this_ptr);
43982 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43983 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43984 this_ptr_conv.is_owned = false;
43985 LDKCVec_CVec_RouteHopZZ val_constr;
43986 val_constr.datalen = val->arr_len;
43987 if (val_constr.datalen > 0)
43988 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKCVec_RouteHopZ), "LDKCVec_CVec_RouteHopZZ Elements");
43990 val_constr.data = NULL;
43991 uint64_tArray* val_vals = (void*) val->elems;
43992 for (size_t m = 0; m < val_constr.datalen; m++) {
43993 uint64_tArray val_conv_12 = val_vals[m];
43994 LDKCVec_RouteHopZ val_conv_12_constr;
43995 val_conv_12_constr.datalen = val_conv_12->arr_len;
43996 if (val_conv_12_constr.datalen > 0)
43997 val_conv_12_constr.data = MALLOC(val_conv_12_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
43999 val_conv_12_constr.data = NULL;
44000 uint64_t* val_conv_12_vals = val_conv_12->elems;
44001 for (size_t k = 0; k < val_conv_12_constr.datalen; k++) {
44002 uint64_t val_conv_12_conv_10 = val_conv_12_vals[k];
44003 LDKRouteHop val_conv_12_conv_10_conv;
44004 val_conv_12_conv_10_conv.inner = untag_ptr(val_conv_12_conv_10);
44005 val_conv_12_conv_10_conv.is_owned = ptr_is_owned(val_conv_12_conv_10);
44006 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_12_conv_10_conv);
44007 val_conv_12_conv_10_conv = RouteHop_clone(&val_conv_12_conv_10_conv);
44008 val_conv_12_constr.data[k] = val_conv_12_conv_10_conv;
44011 val_constr.data[m] = val_conv_12_constr;
44014 Route_set_paths(&this_ptr_conv, val_constr);
44017 uint64_t __attribute__((export_name("TS_Route_get_payment_params"))) TS_Route_get_payment_params(uint64_t this_ptr) {
44018 LDKRoute this_ptr_conv;
44019 this_ptr_conv.inner = untag_ptr(this_ptr);
44020 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44021 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44022 this_ptr_conv.is_owned = false;
44023 LDKPaymentParameters ret_var = Route_get_payment_params(&this_ptr_conv);
44024 uint64_t ret_ref = 0;
44025 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44026 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44030 void __attribute__((export_name("TS_Route_set_payment_params"))) TS_Route_set_payment_params(uint64_t this_ptr, uint64_t val) {
44031 LDKRoute this_ptr_conv;
44032 this_ptr_conv.inner = untag_ptr(this_ptr);
44033 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44034 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44035 this_ptr_conv.is_owned = false;
44036 LDKPaymentParameters val_conv;
44037 val_conv.inner = untag_ptr(val);
44038 val_conv.is_owned = ptr_is_owned(val);
44039 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
44040 val_conv = PaymentParameters_clone(&val_conv);
44041 Route_set_payment_params(&this_ptr_conv, val_conv);
44044 uint64_t __attribute__((export_name("TS_Route_new"))) TS_Route_new(ptrArray paths_arg, uint64_t payment_params_arg) {
44045 LDKCVec_CVec_RouteHopZZ paths_arg_constr;
44046 paths_arg_constr.datalen = paths_arg->arr_len;
44047 if (paths_arg_constr.datalen > 0)
44048 paths_arg_constr.data = MALLOC(paths_arg_constr.datalen * sizeof(LDKCVec_RouteHopZ), "LDKCVec_CVec_RouteHopZZ Elements");
44050 paths_arg_constr.data = NULL;
44051 uint64_tArray* paths_arg_vals = (void*) paths_arg->elems;
44052 for (size_t m = 0; m < paths_arg_constr.datalen; m++) {
44053 uint64_tArray paths_arg_conv_12 = paths_arg_vals[m];
44054 LDKCVec_RouteHopZ paths_arg_conv_12_constr;
44055 paths_arg_conv_12_constr.datalen = paths_arg_conv_12->arr_len;
44056 if (paths_arg_conv_12_constr.datalen > 0)
44057 paths_arg_conv_12_constr.data = MALLOC(paths_arg_conv_12_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
44059 paths_arg_conv_12_constr.data = NULL;
44060 uint64_t* paths_arg_conv_12_vals = paths_arg_conv_12->elems;
44061 for (size_t k = 0; k < paths_arg_conv_12_constr.datalen; k++) {
44062 uint64_t paths_arg_conv_12_conv_10 = paths_arg_conv_12_vals[k];
44063 LDKRouteHop paths_arg_conv_12_conv_10_conv;
44064 paths_arg_conv_12_conv_10_conv.inner = untag_ptr(paths_arg_conv_12_conv_10);
44065 paths_arg_conv_12_conv_10_conv.is_owned = ptr_is_owned(paths_arg_conv_12_conv_10);
44066 CHECK_INNER_FIELD_ACCESS_OR_NULL(paths_arg_conv_12_conv_10_conv);
44067 paths_arg_conv_12_conv_10_conv = RouteHop_clone(&paths_arg_conv_12_conv_10_conv);
44068 paths_arg_conv_12_constr.data[k] = paths_arg_conv_12_conv_10_conv;
44070 FREE(paths_arg_conv_12);
44071 paths_arg_constr.data[m] = paths_arg_conv_12_constr;
44074 LDKPaymentParameters payment_params_arg_conv;
44075 payment_params_arg_conv.inner = untag_ptr(payment_params_arg);
44076 payment_params_arg_conv.is_owned = ptr_is_owned(payment_params_arg);
44077 CHECK_INNER_FIELD_ACCESS_OR_NULL(payment_params_arg_conv);
44078 payment_params_arg_conv = PaymentParameters_clone(&payment_params_arg_conv);
44079 LDKRoute ret_var = Route_new(paths_arg_constr, payment_params_arg_conv);
44080 uint64_t ret_ref = 0;
44081 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44082 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44086 static inline uint64_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg) {
44087 LDKRoute ret_var = Route_clone(arg);
44088 uint64_t ret_ref = 0;
44089 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44090 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44093 int64_t __attribute__((export_name("TS_Route_clone_ptr"))) TS_Route_clone_ptr(uint64_t arg) {
44095 arg_conv.inner = untag_ptr(arg);
44096 arg_conv.is_owned = ptr_is_owned(arg);
44097 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
44098 arg_conv.is_owned = false;
44099 int64_t ret_conv = Route_clone_ptr(&arg_conv);
44103 uint64_t __attribute__((export_name("TS_Route_clone"))) TS_Route_clone(uint64_t orig) {
44104 LDKRoute orig_conv;
44105 orig_conv.inner = untag_ptr(orig);
44106 orig_conv.is_owned = ptr_is_owned(orig);
44107 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
44108 orig_conv.is_owned = false;
44109 LDKRoute ret_var = Route_clone(&orig_conv);
44110 uint64_t ret_ref = 0;
44111 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44112 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44116 int64_t __attribute__((export_name("TS_Route_hash"))) TS_Route_hash(uint64_t o) {
44118 o_conv.inner = untag_ptr(o);
44119 o_conv.is_owned = ptr_is_owned(o);
44120 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
44121 o_conv.is_owned = false;
44122 int64_t ret_conv = Route_hash(&o_conv);
44126 jboolean __attribute__((export_name("TS_Route_eq"))) TS_Route_eq(uint64_t a, uint64_t b) {
44128 a_conv.inner = untag_ptr(a);
44129 a_conv.is_owned = ptr_is_owned(a);
44130 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
44131 a_conv.is_owned = false;
44133 b_conv.inner = untag_ptr(b);
44134 b_conv.is_owned = ptr_is_owned(b);
44135 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
44136 b_conv.is_owned = false;
44137 jboolean ret_conv = Route_eq(&a_conv, &b_conv);
44141 int64_t __attribute__((export_name("TS_Route_get_total_fees"))) TS_Route_get_total_fees(uint64_t this_arg) {
44142 LDKRoute this_arg_conv;
44143 this_arg_conv.inner = untag_ptr(this_arg);
44144 this_arg_conv.is_owned = ptr_is_owned(this_arg);
44145 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44146 this_arg_conv.is_owned = false;
44147 int64_t ret_conv = Route_get_total_fees(&this_arg_conv);
44151 int64_t __attribute__((export_name("TS_Route_get_total_amount"))) TS_Route_get_total_amount(uint64_t this_arg) {
44152 LDKRoute this_arg_conv;
44153 this_arg_conv.inner = untag_ptr(this_arg);
44154 this_arg_conv.is_owned = ptr_is_owned(this_arg);
44155 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44156 this_arg_conv.is_owned = false;
44157 int64_t ret_conv = Route_get_total_amount(&this_arg_conv);
44161 int8_tArray __attribute__((export_name("TS_Route_write"))) TS_Route_write(uint64_t obj) {
44163 obj_conv.inner = untag_ptr(obj);
44164 obj_conv.is_owned = ptr_is_owned(obj);
44165 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
44166 obj_conv.is_owned = false;
44167 LDKCVec_u8Z ret_var = Route_write(&obj_conv);
44168 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
44169 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
44170 CVec_u8Z_free(ret_var);
44174 uint64_t __attribute__((export_name("TS_Route_read"))) TS_Route_read(int8_tArray ser) {
44175 LDKu8slice ser_ref;
44176 ser_ref.datalen = ser->arr_len;
44177 ser_ref.data = ser->elems;
44178 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
44179 *ret_conv = Route_read(ser_ref);
44181 return tag_ptr(ret_conv, true);
44184 void __attribute__((export_name("TS_RouteParameters_free"))) TS_RouteParameters_free(uint64_t this_obj) {
44185 LDKRouteParameters this_obj_conv;
44186 this_obj_conv.inner = untag_ptr(this_obj);
44187 this_obj_conv.is_owned = ptr_is_owned(this_obj);
44188 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
44189 RouteParameters_free(this_obj_conv);
44192 uint64_t __attribute__((export_name("TS_RouteParameters_get_payment_params"))) TS_RouteParameters_get_payment_params(uint64_t this_ptr) {
44193 LDKRouteParameters this_ptr_conv;
44194 this_ptr_conv.inner = untag_ptr(this_ptr);
44195 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44196 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44197 this_ptr_conv.is_owned = false;
44198 LDKPaymentParameters ret_var = RouteParameters_get_payment_params(&this_ptr_conv);
44199 uint64_t ret_ref = 0;
44200 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44201 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44205 void __attribute__((export_name("TS_RouteParameters_set_payment_params"))) TS_RouteParameters_set_payment_params(uint64_t this_ptr, uint64_t val) {
44206 LDKRouteParameters this_ptr_conv;
44207 this_ptr_conv.inner = untag_ptr(this_ptr);
44208 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44209 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44210 this_ptr_conv.is_owned = false;
44211 LDKPaymentParameters val_conv;
44212 val_conv.inner = untag_ptr(val);
44213 val_conv.is_owned = ptr_is_owned(val);
44214 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
44215 val_conv = PaymentParameters_clone(&val_conv);
44216 RouteParameters_set_payment_params(&this_ptr_conv, val_conv);
44219 int64_t __attribute__((export_name("TS_RouteParameters_get_final_value_msat"))) TS_RouteParameters_get_final_value_msat(uint64_t this_ptr) {
44220 LDKRouteParameters this_ptr_conv;
44221 this_ptr_conv.inner = untag_ptr(this_ptr);
44222 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44223 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44224 this_ptr_conv.is_owned = false;
44225 int64_t ret_conv = RouteParameters_get_final_value_msat(&this_ptr_conv);
44229 void __attribute__((export_name("TS_RouteParameters_set_final_value_msat"))) TS_RouteParameters_set_final_value_msat(uint64_t this_ptr, int64_t val) {
44230 LDKRouteParameters this_ptr_conv;
44231 this_ptr_conv.inner = untag_ptr(this_ptr);
44232 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44233 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44234 this_ptr_conv.is_owned = false;
44235 RouteParameters_set_final_value_msat(&this_ptr_conv, val);
44238 int32_t __attribute__((export_name("TS_RouteParameters_get_final_cltv_expiry_delta"))) TS_RouteParameters_get_final_cltv_expiry_delta(uint64_t this_ptr) {
44239 LDKRouteParameters this_ptr_conv;
44240 this_ptr_conv.inner = untag_ptr(this_ptr);
44241 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44242 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44243 this_ptr_conv.is_owned = false;
44244 int32_t ret_conv = RouteParameters_get_final_cltv_expiry_delta(&this_ptr_conv);
44248 void __attribute__((export_name("TS_RouteParameters_set_final_cltv_expiry_delta"))) TS_RouteParameters_set_final_cltv_expiry_delta(uint64_t this_ptr, int32_t val) {
44249 LDKRouteParameters this_ptr_conv;
44250 this_ptr_conv.inner = untag_ptr(this_ptr);
44251 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44252 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44253 this_ptr_conv.is_owned = false;
44254 RouteParameters_set_final_cltv_expiry_delta(&this_ptr_conv, val);
44257 uint64_t __attribute__((export_name("TS_RouteParameters_new"))) TS_RouteParameters_new(uint64_t payment_params_arg, int64_t final_value_msat_arg, int32_t final_cltv_expiry_delta_arg) {
44258 LDKPaymentParameters payment_params_arg_conv;
44259 payment_params_arg_conv.inner = untag_ptr(payment_params_arg);
44260 payment_params_arg_conv.is_owned = ptr_is_owned(payment_params_arg);
44261 CHECK_INNER_FIELD_ACCESS_OR_NULL(payment_params_arg_conv);
44262 payment_params_arg_conv = PaymentParameters_clone(&payment_params_arg_conv);
44263 LDKRouteParameters ret_var = RouteParameters_new(payment_params_arg_conv, final_value_msat_arg, final_cltv_expiry_delta_arg);
44264 uint64_t ret_ref = 0;
44265 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44266 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44270 static inline uint64_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg) {
44271 LDKRouteParameters ret_var = RouteParameters_clone(arg);
44272 uint64_t ret_ref = 0;
44273 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44274 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44277 int64_t __attribute__((export_name("TS_RouteParameters_clone_ptr"))) TS_RouteParameters_clone_ptr(uint64_t arg) {
44278 LDKRouteParameters arg_conv;
44279 arg_conv.inner = untag_ptr(arg);
44280 arg_conv.is_owned = ptr_is_owned(arg);
44281 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
44282 arg_conv.is_owned = false;
44283 int64_t ret_conv = RouteParameters_clone_ptr(&arg_conv);
44287 uint64_t __attribute__((export_name("TS_RouteParameters_clone"))) TS_RouteParameters_clone(uint64_t orig) {
44288 LDKRouteParameters orig_conv;
44289 orig_conv.inner = untag_ptr(orig);
44290 orig_conv.is_owned = ptr_is_owned(orig);
44291 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
44292 orig_conv.is_owned = false;
44293 LDKRouteParameters ret_var = RouteParameters_clone(&orig_conv);
44294 uint64_t ret_ref = 0;
44295 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44296 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44300 int8_tArray __attribute__((export_name("TS_RouteParameters_write"))) TS_RouteParameters_write(uint64_t obj) {
44301 LDKRouteParameters obj_conv;
44302 obj_conv.inner = untag_ptr(obj);
44303 obj_conv.is_owned = ptr_is_owned(obj);
44304 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
44305 obj_conv.is_owned = false;
44306 LDKCVec_u8Z ret_var = RouteParameters_write(&obj_conv);
44307 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
44308 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
44309 CVec_u8Z_free(ret_var);
44313 uint64_t __attribute__((export_name("TS_RouteParameters_read"))) TS_RouteParameters_read(int8_tArray ser) {
44314 LDKu8slice ser_ref;
44315 ser_ref.datalen = ser->arr_len;
44316 ser_ref.data = ser->elems;
44317 LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
44318 *ret_conv = RouteParameters_read(ser_ref);
44320 return tag_ptr(ret_conv, true);
44323 void __attribute__((export_name("TS_PaymentParameters_free"))) TS_PaymentParameters_free(uint64_t this_obj) {
44324 LDKPaymentParameters this_obj_conv;
44325 this_obj_conv.inner = untag_ptr(this_obj);
44326 this_obj_conv.is_owned = ptr_is_owned(this_obj);
44327 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
44328 PaymentParameters_free(this_obj_conv);
44331 int8_tArray __attribute__((export_name("TS_PaymentParameters_get_payee_pubkey"))) TS_PaymentParameters_get_payee_pubkey(uint64_t this_ptr) {
44332 LDKPaymentParameters this_ptr_conv;
44333 this_ptr_conv.inner = untag_ptr(this_ptr);
44334 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44335 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44336 this_ptr_conv.is_owned = false;
44337 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
44338 memcpy(ret_arr->elems, PaymentParameters_get_payee_pubkey(&this_ptr_conv).compressed_form, 33);
44342 void __attribute__((export_name("TS_PaymentParameters_set_payee_pubkey"))) TS_PaymentParameters_set_payee_pubkey(uint64_t this_ptr, int8_tArray val) {
44343 LDKPaymentParameters this_ptr_conv;
44344 this_ptr_conv.inner = untag_ptr(this_ptr);
44345 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44346 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44347 this_ptr_conv.is_owned = false;
44348 LDKPublicKey val_ref;
44349 CHECK(val->arr_len == 33);
44350 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
44351 PaymentParameters_set_payee_pubkey(&this_ptr_conv, val_ref);
44354 uint64_t __attribute__((export_name("TS_PaymentParameters_get_features"))) TS_PaymentParameters_get_features(uint64_t this_ptr) {
44355 LDKPaymentParameters this_ptr_conv;
44356 this_ptr_conv.inner = untag_ptr(this_ptr);
44357 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44358 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44359 this_ptr_conv.is_owned = false;
44360 LDKInvoiceFeatures ret_var = PaymentParameters_get_features(&this_ptr_conv);
44361 uint64_t ret_ref = 0;
44362 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44363 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44367 void __attribute__((export_name("TS_PaymentParameters_set_features"))) TS_PaymentParameters_set_features(uint64_t this_ptr, uint64_t val) {
44368 LDKPaymentParameters this_ptr_conv;
44369 this_ptr_conv.inner = untag_ptr(this_ptr);
44370 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44371 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44372 this_ptr_conv.is_owned = false;
44373 LDKInvoiceFeatures val_conv;
44374 val_conv.inner = untag_ptr(val);
44375 val_conv.is_owned = ptr_is_owned(val);
44376 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
44377 val_conv = InvoiceFeatures_clone(&val_conv);
44378 PaymentParameters_set_features(&this_ptr_conv, val_conv);
44381 uint64_tArray __attribute__((export_name("TS_PaymentParameters_get_route_hints"))) TS_PaymentParameters_get_route_hints(uint64_t this_ptr) {
44382 LDKPaymentParameters this_ptr_conv;
44383 this_ptr_conv.inner = untag_ptr(this_ptr);
44384 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44385 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44386 this_ptr_conv.is_owned = false;
44387 LDKCVec_RouteHintZ ret_var = PaymentParameters_get_route_hints(&this_ptr_conv);
44388 uint64_tArray ret_arr = NULL;
44389 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
44390 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
44391 for (size_t l = 0; l < ret_var.datalen; l++) {
44392 LDKRouteHint ret_conv_11_var = ret_var.data[l];
44393 uint64_t ret_conv_11_ref = 0;
44394 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_11_var);
44395 ret_conv_11_ref = tag_ptr(ret_conv_11_var.inner, ret_conv_11_var.is_owned);
44396 ret_arr_ptr[l] = ret_conv_11_ref;
44399 FREE(ret_var.data);
44403 void __attribute__((export_name("TS_PaymentParameters_set_route_hints"))) TS_PaymentParameters_set_route_hints(uint64_t this_ptr, uint64_tArray val) {
44404 LDKPaymentParameters this_ptr_conv;
44405 this_ptr_conv.inner = untag_ptr(this_ptr);
44406 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44407 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44408 this_ptr_conv.is_owned = false;
44409 LDKCVec_RouteHintZ val_constr;
44410 val_constr.datalen = val->arr_len;
44411 if (val_constr.datalen > 0)
44412 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKRouteHint), "LDKCVec_RouteHintZ Elements");
44414 val_constr.data = NULL;
44415 uint64_t* val_vals = val->elems;
44416 for (size_t l = 0; l < val_constr.datalen; l++) {
44417 uint64_t val_conv_11 = val_vals[l];
44418 LDKRouteHint val_conv_11_conv;
44419 val_conv_11_conv.inner = untag_ptr(val_conv_11);
44420 val_conv_11_conv.is_owned = ptr_is_owned(val_conv_11);
44421 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_11_conv);
44422 val_conv_11_conv = RouteHint_clone(&val_conv_11_conv);
44423 val_constr.data[l] = val_conv_11_conv;
44426 PaymentParameters_set_route_hints(&this_ptr_conv, val_constr);
44429 uint64_t __attribute__((export_name("TS_PaymentParameters_get_expiry_time"))) TS_PaymentParameters_get_expiry_time(uint64_t this_ptr) {
44430 LDKPaymentParameters this_ptr_conv;
44431 this_ptr_conv.inner = untag_ptr(this_ptr);
44432 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44433 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44434 this_ptr_conv.is_owned = false;
44435 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
44436 *ret_copy = PaymentParameters_get_expiry_time(&this_ptr_conv);
44437 uint64_t ret_ref = tag_ptr(ret_copy, true);
44441 void __attribute__((export_name("TS_PaymentParameters_set_expiry_time"))) TS_PaymentParameters_set_expiry_time(uint64_t this_ptr, uint64_t val) {
44442 LDKPaymentParameters this_ptr_conv;
44443 this_ptr_conv.inner = untag_ptr(this_ptr);
44444 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44445 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44446 this_ptr_conv.is_owned = false;
44447 void* val_ptr = untag_ptr(val);
44448 CHECK_ACCESS(val_ptr);
44449 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
44450 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
44451 PaymentParameters_set_expiry_time(&this_ptr_conv, val_conv);
44454 int32_t __attribute__((export_name("TS_PaymentParameters_get_max_total_cltv_expiry_delta"))) TS_PaymentParameters_get_max_total_cltv_expiry_delta(uint64_t this_ptr) {
44455 LDKPaymentParameters this_ptr_conv;
44456 this_ptr_conv.inner = untag_ptr(this_ptr);
44457 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44458 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44459 this_ptr_conv.is_owned = false;
44460 int32_t ret_conv = PaymentParameters_get_max_total_cltv_expiry_delta(&this_ptr_conv);
44464 void __attribute__((export_name("TS_PaymentParameters_set_max_total_cltv_expiry_delta"))) TS_PaymentParameters_set_max_total_cltv_expiry_delta(uint64_t this_ptr, int32_t val) {
44465 LDKPaymentParameters this_ptr_conv;
44466 this_ptr_conv.inner = untag_ptr(this_ptr);
44467 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44468 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44469 this_ptr_conv.is_owned = false;
44470 PaymentParameters_set_max_total_cltv_expiry_delta(&this_ptr_conv, val);
44473 int8_t __attribute__((export_name("TS_PaymentParameters_get_max_path_count"))) TS_PaymentParameters_get_max_path_count(uint64_t this_ptr) {
44474 LDKPaymentParameters this_ptr_conv;
44475 this_ptr_conv.inner = untag_ptr(this_ptr);
44476 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44477 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44478 this_ptr_conv.is_owned = false;
44479 int8_t ret_conv = PaymentParameters_get_max_path_count(&this_ptr_conv);
44483 void __attribute__((export_name("TS_PaymentParameters_set_max_path_count"))) TS_PaymentParameters_set_max_path_count(uint64_t this_ptr, int8_t val) {
44484 LDKPaymentParameters this_ptr_conv;
44485 this_ptr_conv.inner = untag_ptr(this_ptr);
44486 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44487 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44488 this_ptr_conv.is_owned = false;
44489 PaymentParameters_set_max_path_count(&this_ptr_conv, val);
44492 int8_t __attribute__((export_name("TS_PaymentParameters_get_max_channel_saturation_power_of_half"))) TS_PaymentParameters_get_max_channel_saturation_power_of_half(uint64_t this_ptr) {
44493 LDKPaymentParameters this_ptr_conv;
44494 this_ptr_conv.inner = untag_ptr(this_ptr);
44495 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44496 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44497 this_ptr_conv.is_owned = false;
44498 int8_t ret_conv = PaymentParameters_get_max_channel_saturation_power_of_half(&this_ptr_conv);
44502 void __attribute__((export_name("TS_PaymentParameters_set_max_channel_saturation_power_of_half"))) TS_PaymentParameters_set_max_channel_saturation_power_of_half(uint64_t this_ptr, int8_t val) {
44503 LDKPaymentParameters this_ptr_conv;
44504 this_ptr_conv.inner = untag_ptr(this_ptr);
44505 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44506 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44507 this_ptr_conv.is_owned = false;
44508 PaymentParameters_set_max_channel_saturation_power_of_half(&this_ptr_conv, val);
44511 int64_tArray __attribute__((export_name("TS_PaymentParameters_get_previously_failed_channels"))) TS_PaymentParameters_get_previously_failed_channels(uint64_t this_ptr) {
44512 LDKPaymentParameters this_ptr_conv;
44513 this_ptr_conv.inner = untag_ptr(this_ptr);
44514 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44515 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44516 this_ptr_conv.is_owned = false;
44517 LDKCVec_u64Z ret_var = PaymentParameters_get_previously_failed_channels(&this_ptr_conv);
44518 int64_tArray ret_arr = NULL;
44519 ret_arr = init_int64_tArray(ret_var.datalen, __LINE__);
44520 int64_t *ret_arr_ptr = (int64_t*)(((uint8_t*)ret_arr) + 8);
44521 for (size_t i = 0; i < ret_var.datalen; i++) {
44522 int64_t ret_conv_8_conv = ret_var.data[i];
44523 ret_arr_ptr[i] = ret_conv_8_conv;
44526 FREE(ret_var.data);
44530 void __attribute__((export_name("TS_PaymentParameters_set_previously_failed_channels"))) TS_PaymentParameters_set_previously_failed_channels(uint64_t this_ptr, int64_tArray val) {
44531 LDKPaymentParameters this_ptr_conv;
44532 this_ptr_conv.inner = untag_ptr(this_ptr);
44533 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44534 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44535 this_ptr_conv.is_owned = false;
44536 LDKCVec_u64Z val_constr;
44537 val_constr.datalen = val->arr_len;
44538 if (val_constr.datalen > 0)
44539 val_constr.data = MALLOC(val_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
44541 val_constr.data = NULL;
44542 int64_t* val_vals = val->elems;
44543 for (size_t i = 0; i < val_constr.datalen; i++) {
44544 int64_t val_conv_8 = val_vals[i];
44545 val_constr.data[i] = val_conv_8;
44548 PaymentParameters_set_previously_failed_channels(&this_ptr_conv, val_constr);
44551 uint64_t __attribute__((export_name("TS_PaymentParameters_new"))) TS_PaymentParameters_new(int8_tArray payee_pubkey_arg, uint64_t features_arg, uint64_tArray route_hints_arg, uint64_t expiry_time_arg, int32_t max_total_cltv_expiry_delta_arg, int8_t max_path_count_arg, int8_t max_channel_saturation_power_of_half_arg, int64_tArray previously_failed_channels_arg) {
44552 LDKPublicKey payee_pubkey_arg_ref;
44553 CHECK(payee_pubkey_arg->arr_len == 33);
44554 memcpy(payee_pubkey_arg_ref.compressed_form, payee_pubkey_arg->elems, 33); FREE(payee_pubkey_arg);
44555 LDKInvoiceFeatures features_arg_conv;
44556 features_arg_conv.inner = untag_ptr(features_arg);
44557 features_arg_conv.is_owned = ptr_is_owned(features_arg);
44558 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
44559 features_arg_conv = InvoiceFeatures_clone(&features_arg_conv);
44560 LDKCVec_RouteHintZ route_hints_arg_constr;
44561 route_hints_arg_constr.datalen = route_hints_arg->arr_len;
44562 if (route_hints_arg_constr.datalen > 0)
44563 route_hints_arg_constr.data = MALLOC(route_hints_arg_constr.datalen * sizeof(LDKRouteHint), "LDKCVec_RouteHintZ Elements");
44565 route_hints_arg_constr.data = NULL;
44566 uint64_t* route_hints_arg_vals = route_hints_arg->elems;
44567 for (size_t l = 0; l < route_hints_arg_constr.datalen; l++) {
44568 uint64_t route_hints_arg_conv_11 = route_hints_arg_vals[l];
44569 LDKRouteHint route_hints_arg_conv_11_conv;
44570 route_hints_arg_conv_11_conv.inner = untag_ptr(route_hints_arg_conv_11);
44571 route_hints_arg_conv_11_conv.is_owned = ptr_is_owned(route_hints_arg_conv_11);
44572 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_hints_arg_conv_11_conv);
44573 route_hints_arg_conv_11_conv = RouteHint_clone(&route_hints_arg_conv_11_conv);
44574 route_hints_arg_constr.data[l] = route_hints_arg_conv_11_conv;
44576 FREE(route_hints_arg);
44577 void* expiry_time_arg_ptr = untag_ptr(expiry_time_arg);
44578 CHECK_ACCESS(expiry_time_arg_ptr);
44579 LDKCOption_u64Z expiry_time_arg_conv = *(LDKCOption_u64Z*)(expiry_time_arg_ptr);
44580 expiry_time_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(expiry_time_arg));
44581 LDKCVec_u64Z previously_failed_channels_arg_constr;
44582 previously_failed_channels_arg_constr.datalen = previously_failed_channels_arg->arr_len;
44583 if (previously_failed_channels_arg_constr.datalen > 0)
44584 previously_failed_channels_arg_constr.data = MALLOC(previously_failed_channels_arg_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
44586 previously_failed_channels_arg_constr.data = NULL;
44587 int64_t* previously_failed_channels_arg_vals = previously_failed_channels_arg->elems;
44588 for (size_t i = 0; i < previously_failed_channels_arg_constr.datalen; i++) {
44589 int64_t previously_failed_channels_arg_conv_8 = previously_failed_channels_arg_vals[i];
44590 previously_failed_channels_arg_constr.data[i] = previously_failed_channels_arg_conv_8;
44592 FREE(previously_failed_channels_arg);
44593 LDKPaymentParameters ret_var = PaymentParameters_new(payee_pubkey_arg_ref, features_arg_conv, route_hints_arg_constr, expiry_time_arg_conv, max_total_cltv_expiry_delta_arg, max_path_count_arg, max_channel_saturation_power_of_half_arg, previously_failed_channels_arg_constr);
44594 uint64_t ret_ref = 0;
44595 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44596 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44600 static inline uint64_t PaymentParameters_clone_ptr(LDKPaymentParameters *NONNULL_PTR arg) {
44601 LDKPaymentParameters ret_var = PaymentParameters_clone(arg);
44602 uint64_t ret_ref = 0;
44603 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44604 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44607 int64_t __attribute__((export_name("TS_PaymentParameters_clone_ptr"))) TS_PaymentParameters_clone_ptr(uint64_t arg) {
44608 LDKPaymentParameters arg_conv;
44609 arg_conv.inner = untag_ptr(arg);
44610 arg_conv.is_owned = ptr_is_owned(arg);
44611 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
44612 arg_conv.is_owned = false;
44613 int64_t ret_conv = PaymentParameters_clone_ptr(&arg_conv);
44617 uint64_t __attribute__((export_name("TS_PaymentParameters_clone"))) TS_PaymentParameters_clone(uint64_t orig) {
44618 LDKPaymentParameters orig_conv;
44619 orig_conv.inner = untag_ptr(orig);
44620 orig_conv.is_owned = ptr_is_owned(orig);
44621 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
44622 orig_conv.is_owned = false;
44623 LDKPaymentParameters ret_var = PaymentParameters_clone(&orig_conv);
44624 uint64_t ret_ref = 0;
44625 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44626 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44630 int64_t __attribute__((export_name("TS_PaymentParameters_hash"))) TS_PaymentParameters_hash(uint64_t o) {
44631 LDKPaymentParameters o_conv;
44632 o_conv.inner = untag_ptr(o);
44633 o_conv.is_owned = ptr_is_owned(o);
44634 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
44635 o_conv.is_owned = false;
44636 int64_t ret_conv = PaymentParameters_hash(&o_conv);
44640 jboolean __attribute__((export_name("TS_PaymentParameters_eq"))) TS_PaymentParameters_eq(uint64_t a, uint64_t b) {
44641 LDKPaymentParameters a_conv;
44642 a_conv.inner = untag_ptr(a);
44643 a_conv.is_owned = ptr_is_owned(a);
44644 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
44645 a_conv.is_owned = false;
44646 LDKPaymentParameters b_conv;
44647 b_conv.inner = untag_ptr(b);
44648 b_conv.is_owned = ptr_is_owned(b);
44649 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
44650 b_conv.is_owned = false;
44651 jboolean ret_conv = PaymentParameters_eq(&a_conv, &b_conv);
44655 int8_tArray __attribute__((export_name("TS_PaymentParameters_write"))) TS_PaymentParameters_write(uint64_t obj) {
44656 LDKPaymentParameters obj_conv;
44657 obj_conv.inner = untag_ptr(obj);
44658 obj_conv.is_owned = ptr_is_owned(obj);
44659 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
44660 obj_conv.is_owned = false;
44661 LDKCVec_u8Z ret_var = PaymentParameters_write(&obj_conv);
44662 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
44663 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
44664 CVec_u8Z_free(ret_var);
44668 uint64_t __attribute__((export_name("TS_PaymentParameters_read"))) TS_PaymentParameters_read(int8_tArray ser) {
44669 LDKu8slice ser_ref;
44670 ser_ref.datalen = ser->arr_len;
44671 ser_ref.data = ser->elems;
44672 LDKCResult_PaymentParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentParametersDecodeErrorZ), "LDKCResult_PaymentParametersDecodeErrorZ");
44673 *ret_conv = PaymentParameters_read(ser_ref);
44675 return tag_ptr(ret_conv, true);
44678 uint64_t __attribute__((export_name("TS_PaymentParameters_from_node_id"))) TS_PaymentParameters_from_node_id(int8_tArray payee_pubkey) {
44679 LDKPublicKey payee_pubkey_ref;
44680 CHECK(payee_pubkey->arr_len == 33);
44681 memcpy(payee_pubkey_ref.compressed_form, payee_pubkey->elems, 33); FREE(payee_pubkey);
44682 LDKPaymentParameters ret_var = PaymentParameters_from_node_id(payee_pubkey_ref);
44683 uint64_t ret_ref = 0;
44684 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44685 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44689 uint64_t __attribute__((export_name("TS_PaymentParameters_for_keysend"))) TS_PaymentParameters_for_keysend(int8_tArray payee_pubkey) {
44690 LDKPublicKey payee_pubkey_ref;
44691 CHECK(payee_pubkey->arr_len == 33);
44692 memcpy(payee_pubkey_ref.compressed_form, payee_pubkey->elems, 33); FREE(payee_pubkey);
44693 LDKPaymentParameters ret_var = PaymentParameters_for_keysend(payee_pubkey_ref);
44694 uint64_t ret_ref = 0;
44695 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44696 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44700 void __attribute__((export_name("TS_RouteHint_free"))) TS_RouteHint_free(uint64_t this_obj) {
44701 LDKRouteHint this_obj_conv;
44702 this_obj_conv.inner = untag_ptr(this_obj);
44703 this_obj_conv.is_owned = ptr_is_owned(this_obj);
44704 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
44705 RouteHint_free(this_obj_conv);
44708 uint64_tArray __attribute__((export_name("TS_RouteHint_get_a"))) TS_RouteHint_get_a(uint64_t this_ptr) {
44709 LDKRouteHint this_ptr_conv;
44710 this_ptr_conv.inner = untag_ptr(this_ptr);
44711 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44712 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44713 this_ptr_conv.is_owned = false;
44714 LDKCVec_RouteHintHopZ ret_var = RouteHint_get_a(&this_ptr_conv);
44715 uint64_tArray ret_arr = NULL;
44716 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
44717 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
44718 for (size_t o = 0; o < ret_var.datalen; o++) {
44719 LDKRouteHintHop ret_conv_14_var = ret_var.data[o];
44720 uint64_t ret_conv_14_ref = 0;
44721 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_14_var);
44722 ret_conv_14_ref = tag_ptr(ret_conv_14_var.inner, ret_conv_14_var.is_owned);
44723 ret_arr_ptr[o] = ret_conv_14_ref;
44726 FREE(ret_var.data);
44730 void __attribute__((export_name("TS_RouteHint_set_a"))) TS_RouteHint_set_a(uint64_t this_ptr, uint64_tArray val) {
44731 LDKRouteHint this_ptr_conv;
44732 this_ptr_conv.inner = untag_ptr(this_ptr);
44733 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44734 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44735 this_ptr_conv.is_owned = false;
44736 LDKCVec_RouteHintHopZ val_constr;
44737 val_constr.datalen = val->arr_len;
44738 if (val_constr.datalen > 0)
44739 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKRouteHintHop), "LDKCVec_RouteHintHopZ Elements");
44741 val_constr.data = NULL;
44742 uint64_t* val_vals = val->elems;
44743 for (size_t o = 0; o < val_constr.datalen; o++) {
44744 uint64_t val_conv_14 = val_vals[o];
44745 LDKRouteHintHop val_conv_14_conv;
44746 val_conv_14_conv.inner = untag_ptr(val_conv_14);
44747 val_conv_14_conv.is_owned = ptr_is_owned(val_conv_14);
44748 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_14_conv);
44749 val_conv_14_conv = RouteHintHop_clone(&val_conv_14_conv);
44750 val_constr.data[o] = val_conv_14_conv;
44753 RouteHint_set_a(&this_ptr_conv, val_constr);
44756 uint64_t __attribute__((export_name("TS_RouteHint_new"))) TS_RouteHint_new(uint64_tArray a_arg) {
44757 LDKCVec_RouteHintHopZ a_arg_constr;
44758 a_arg_constr.datalen = a_arg->arr_len;
44759 if (a_arg_constr.datalen > 0)
44760 a_arg_constr.data = MALLOC(a_arg_constr.datalen * sizeof(LDKRouteHintHop), "LDKCVec_RouteHintHopZ Elements");
44762 a_arg_constr.data = NULL;
44763 uint64_t* a_arg_vals = a_arg->elems;
44764 for (size_t o = 0; o < a_arg_constr.datalen; o++) {
44765 uint64_t a_arg_conv_14 = a_arg_vals[o];
44766 LDKRouteHintHop a_arg_conv_14_conv;
44767 a_arg_conv_14_conv.inner = untag_ptr(a_arg_conv_14);
44768 a_arg_conv_14_conv.is_owned = ptr_is_owned(a_arg_conv_14);
44769 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_arg_conv_14_conv);
44770 a_arg_conv_14_conv = RouteHintHop_clone(&a_arg_conv_14_conv);
44771 a_arg_constr.data[o] = a_arg_conv_14_conv;
44774 LDKRouteHint ret_var = RouteHint_new(a_arg_constr);
44775 uint64_t ret_ref = 0;
44776 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44777 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44781 static inline uint64_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg) {
44782 LDKRouteHint ret_var = RouteHint_clone(arg);
44783 uint64_t ret_ref = 0;
44784 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44785 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44788 int64_t __attribute__((export_name("TS_RouteHint_clone_ptr"))) TS_RouteHint_clone_ptr(uint64_t arg) {
44789 LDKRouteHint arg_conv;
44790 arg_conv.inner = untag_ptr(arg);
44791 arg_conv.is_owned = ptr_is_owned(arg);
44792 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
44793 arg_conv.is_owned = false;
44794 int64_t ret_conv = RouteHint_clone_ptr(&arg_conv);
44798 uint64_t __attribute__((export_name("TS_RouteHint_clone"))) TS_RouteHint_clone(uint64_t orig) {
44799 LDKRouteHint orig_conv;
44800 orig_conv.inner = untag_ptr(orig);
44801 orig_conv.is_owned = ptr_is_owned(orig);
44802 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
44803 orig_conv.is_owned = false;
44804 LDKRouteHint ret_var = RouteHint_clone(&orig_conv);
44805 uint64_t ret_ref = 0;
44806 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44807 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44811 int64_t __attribute__((export_name("TS_RouteHint_hash"))) TS_RouteHint_hash(uint64_t o) {
44812 LDKRouteHint o_conv;
44813 o_conv.inner = untag_ptr(o);
44814 o_conv.is_owned = ptr_is_owned(o);
44815 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
44816 o_conv.is_owned = false;
44817 int64_t ret_conv = RouteHint_hash(&o_conv);
44821 jboolean __attribute__((export_name("TS_RouteHint_eq"))) TS_RouteHint_eq(uint64_t a, uint64_t b) {
44822 LDKRouteHint a_conv;
44823 a_conv.inner = untag_ptr(a);
44824 a_conv.is_owned = ptr_is_owned(a);
44825 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
44826 a_conv.is_owned = false;
44827 LDKRouteHint b_conv;
44828 b_conv.inner = untag_ptr(b);
44829 b_conv.is_owned = ptr_is_owned(b);
44830 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
44831 b_conv.is_owned = false;
44832 jboolean ret_conv = RouteHint_eq(&a_conv, &b_conv);
44836 int8_tArray __attribute__((export_name("TS_RouteHint_write"))) TS_RouteHint_write(uint64_t obj) {
44837 LDKRouteHint obj_conv;
44838 obj_conv.inner = untag_ptr(obj);
44839 obj_conv.is_owned = ptr_is_owned(obj);
44840 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
44841 obj_conv.is_owned = false;
44842 LDKCVec_u8Z ret_var = RouteHint_write(&obj_conv);
44843 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
44844 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
44845 CVec_u8Z_free(ret_var);
44849 uint64_t __attribute__((export_name("TS_RouteHint_read"))) TS_RouteHint_read(int8_tArray ser) {
44850 LDKu8slice ser_ref;
44851 ser_ref.datalen = ser->arr_len;
44852 ser_ref.data = ser->elems;
44853 LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
44854 *ret_conv = RouteHint_read(ser_ref);
44856 return tag_ptr(ret_conv, true);
44859 void __attribute__((export_name("TS_RouteHintHop_free"))) TS_RouteHintHop_free(uint64_t this_obj) {
44860 LDKRouteHintHop this_obj_conv;
44861 this_obj_conv.inner = untag_ptr(this_obj);
44862 this_obj_conv.is_owned = ptr_is_owned(this_obj);
44863 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
44864 RouteHintHop_free(this_obj_conv);
44867 int8_tArray __attribute__((export_name("TS_RouteHintHop_get_src_node_id"))) TS_RouteHintHop_get_src_node_id(uint64_t this_ptr) {
44868 LDKRouteHintHop this_ptr_conv;
44869 this_ptr_conv.inner = untag_ptr(this_ptr);
44870 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44871 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44872 this_ptr_conv.is_owned = false;
44873 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
44874 memcpy(ret_arr->elems, RouteHintHop_get_src_node_id(&this_ptr_conv).compressed_form, 33);
44878 void __attribute__((export_name("TS_RouteHintHop_set_src_node_id"))) TS_RouteHintHop_set_src_node_id(uint64_t this_ptr, int8_tArray val) {
44879 LDKRouteHintHop this_ptr_conv;
44880 this_ptr_conv.inner = untag_ptr(this_ptr);
44881 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44882 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44883 this_ptr_conv.is_owned = false;
44884 LDKPublicKey val_ref;
44885 CHECK(val->arr_len == 33);
44886 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
44887 RouteHintHop_set_src_node_id(&this_ptr_conv, val_ref);
44890 int64_t __attribute__((export_name("TS_RouteHintHop_get_short_channel_id"))) TS_RouteHintHop_get_short_channel_id(uint64_t this_ptr) {
44891 LDKRouteHintHop this_ptr_conv;
44892 this_ptr_conv.inner = untag_ptr(this_ptr);
44893 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44894 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44895 this_ptr_conv.is_owned = false;
44896 int64_t ret_conv = RouteHintHop_get_short_channel_id(&this_ptr_conv);
44900 void __attribute__((export_name("TS_RouteHintHop_set_short_channel_id"))) TS_RouteHintHop_set_short_channel_id(uint64_t this_ptr, int64_t val) {
44901 LDKRouteHintHop this_ptr_conv;
44902 this_ptr_conv.inner = untag_ptr(this_ptr);
44903 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44904 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44905 this_ptr_conv.is_owned = false;
44906 RouteHintHop_set_short_channel_id(&this_ptr_conv, val);
44909 uint64_t __attribute__((export_name("TS_RouteHintHop_get_fees"))) TS_RouteHintHop_get_fees(uint64_t this_ptr) {
44910 LDKRouteHintHop this_ptr_conv;
44911 this_ptr_conv.inner = untag_ptr(this_ptr);
44912 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44913 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44914 this_ptr_conv.is_owned = false;
44915 LDKRoutingFees ret_var = RouteHintHop_get_fees(&this_ptr_conv);
44916 uint64_t ret_ref = 0;
44917 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44918 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44922 void __attribute__((export_name("TS_RouteHintHop_set_fees"))) TS_RouteHintHop_set_fees(uint64_t this_ptr, uint64_t val) {
44923 LDKRouteHintHop this_ptr_conv;
44924 this_ptr_conv.inner = untag_ptr(this_ptr);
44925 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44926 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44927 this_ptr_conv.is_owned = false;
44928 LDKRoutingFees val_conv;
44929 val_conv.inner = untag_ptr(val);
44930 val_conv.is_owned = ptr_is_owned(val);
44931 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
44932 val_conv = RoutingFees_clone(&val_conv);
44933 RouteHintHop_set_fees(&this_ptr_conv, val_conv);
44936 int16_t __attribute__((export_name("TS_RouteHintHop_get_cltv_expiry_delta"))) TS_RouteHintHop_get_cltv_expiry_delta(uint64_t this_ptr) {
44937 LDKRouteHintHop this_ptr_conv;
44938 this_ptr_conv.inner = untag_ptr(this_ptr);
44939 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44940 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44941 this_ptr_conv.is_owned = false;
44942 int16_t ret_conv = RouteHintHop_get_cltv_expiry_delta(&this_ptr_conv);
44946 void __attribute__((export_name("TS_RouteHintHop_set_cltv_expiry_delta"))) TS_RouteHintHop_set_cltv_expiry_delta(uint64_t this_ptr, int16_t val) {
44947 LDKRouteHintHop this_ptr_conv;
44948 this_ptr_conv.inner = untag_ptr(this_ptr);
44949 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44950 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44951 this_ptr_conv.is_owned = false;
44952 RouteHintHop_set_cltv_expiry_delta(&this_ptr_conv, val);
44955 uint64_t __attribute__((export_name("TS_RouteHintHop_get_htlc_minimum_msat"))) TS_RouteHintHop_get_htlc_minimum_msat(uint64_t this_ptr) {
44956 LDKRouteHintHop this_ptr_conv;
44957 this_ptr_conv.inner = untag_ptr(this_ptr);
44958 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44959 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44960 this_ptr_conv.is_owned = false;
44961 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
44962 *ret_copy = RouteHintHop_get_htlc_minimum_msat(&this_ptr_conv);
44963 uint64_t ret_ref = tag_ptr(ret_copy, true);
44967 void __attribute__((export_name("TS_RouteHintHop_set_htlc_minimum_msat"))) TS_RouteHintHop_set_htlc_minimum_msat(uint64_t this_ptr, uint64_t val) {
44968 LDKRouteHintHop this_ptr_conv;
44969 this_ptr_conv.inner = untag_ptr(this_ptr);
44970 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44971 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44972 this_ptr_conv.is_owned = false;
44973 void* val_ptr = untag_ptr(val);
44974 CHECK_ACCESS(val_ptr);
44975 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
44976 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
44977 RouteHintHop_set_htlc_minimum_msat(&this_ptr_conv, val_conv);
44980 uint64_t __attribute__((export_name("TS_RouteHintHop_get_htlc_maximum_msat"))) TS_RouteHintHop_get_htlc_maximum_msat(uint64_t this_ptr) {
44981 LDKRouteHintHop this_ptr_conv;
44982 this_ptr_conv.inner = untag_ptr(this_ptr);
44983 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44984 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44985 this_ptr_conv.is_owned = false;
44986 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
44987 *ret_copy = RouteHintHop_get_htlc_maximum_msat(&this_ptr_conv);
44988 uint64_t ret_ref = tag_ptr(ret_copy, true);
44992 void __attribute__((export_name("TS_RouteHintHop_set_htlc_maximum_msat"))) TS_RouteHintHop_set_htlc_maximum_msat(uint64_t this_ptr, uint64_t val) {
44993 LDKRouteHintHop this_ptr_conv;
44994 this_ptr_conv.inner = untag_ptr(this_ptr);
44995 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44996 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44997 this_ptr_conv.is_owned = false;
44998 void* val_ptr = untag_ptr(val);
44999 CHECK_ACCESS(val_ptr);
45000 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
45001 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
45002 RouteHintHop_set_htlc_maximum_msat(&this_ptr_conv, val_conv);
45005 uint64_t __attribute__((export_name("TS_RouteHintHop_new"))) TS_RouteHintHop_new(int8_tArray src_node_id_arg, int64_t short_channel_id_arg, uint64_t fees_arg, int16_t cltv_expiry_delta_arg, uint64_t htlc_minimum_msat_arg, uint64_t htlc_maximum_msat_arg) {
45006 LDKPublicKey src_node_id_arg_ref;
45007 CHECK(src_node_id_arg->arr_len == 33);
45008 memcpy(src_node_id_arg_ref.compressed_form, src_node_id_arg->elems, 33); FREE(src_node_id_arg);
45009 LDKRoutingFees fees_arg_conv;
45010 fees_arg_conv.inner = untag_ptr(fees_arg);
45011 fees_arg_conv.is_owned = ptr_is_owned(fees_arg);
45012 CHECK_INNER_FIELD_ACCESS_OR_NULL(fees_arg_conv);
45013 fees_arg_conv = RoutingFees_clone(&fees_arg_conv);
45014 void* htlc_minimum_msat_arg_ptr = untag_ptr(htlc_minimum_msat_arg);
45015 CHECK_ACCESS(htlc_minimum_msat_arg_ptr);
45016 LDKCOption_u64Z htlc_minimum_msat_arg_conv = *(LDKCOption_u64Z*)(htlc_minimum_msat_arg_ptr);
45017 htlc_minimum_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(htlc_minimum_msat_arg));
45018 void* htlc_maximum_msat_arg_ptr = untag_ptr(htlc_maximum_msat_arg);
45019 CHECK_ACCESS(htlc_maximum_msat_arg_ptr);
45020 LDKCOption_u64Z htlc_maximum_msat_arg_conv = *(LDKCOption_u64Z*)(htlc_maximum_msat_arg_ptr);
45021 htlc_maximum_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(htlc_maximum_msat_arg));
45022 LDKRouteHintHop ret_var = RouteHintHop_new(src_node_id_arg_ref, short_channel_id_arg, fees_arg_conv, cltv_expiry_delta_arg, htlc_minimum_msat_arg_conv, htlc_maximum_msat_arg_conv);
45023 uint64_t ret_ref = 0;
45024 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45025 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45029 static inline uint64_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg) {
45030 LDKRouteHintHop ret_var = RouteHintHop_clone(arg);
45031 uint64_t ret_ref = 0;
45032 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45033 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45036 int64_t __attribute__((export_name("TS_RouteHintHop_clone_ptr"))) TS_RouteHintHop_clone_ptr(uint64_t arg) {
45037 LDKRouteHintHop arg_conv;
45038 arg_conv.inner = untag_ptr(arg);
45039 arg_conv.is_owned = ptr_is_owned(arg);
45040 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
45041 arg_conv.is_owned = false;
45042 int64_t ret_conv = RouteHintHop_clone_ptr(&arg_conv);
45046 uint64_t __attribute__((export_name("TS_RouteHintHop_clone"))) TS_RouteHintHop_clone(uint64_t orig) {
45047 LDKRouteHintHop orig_conv;
45048 orig_conv.inner = untag_ptr(orig);
45049 orig_conv.is_owned = ptr_is_owned(orig);
45050 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
45051 orig_conv.is_owned = false;
45052 LDKRouteHintHop ret_var = RouteHintHop_clone(&orig_conv);
45053 uint64_t ret_ref = 0;
45054 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45055 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45059 int64_t __attribute__((export_name("TS_RouteHintHop_hash"))) TS_RouteHintHop_hash(uint64_t o) {
45060 LDKRouteHintHop o_conv;
45061 o_conv.inner = untag_ptr(o);
45062 o_conv.is_owned = ptr_is_owned(o);
45063 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
45064 o_conv.is_owned = false;
45065 int64_t ret_conv = RouteHintHop_hash(&o_conv);
45069 jboolean __attribute__((export_name("TS_RouteHintHop_eq"))) TS_RouteHintHop_eq(uint64_t a, uint64_t b) {
45070 LDKRouteHintHop a_conv;
45071 a_conv.inner = untag_ptr(a);
45072 a_conv.is_owned = ptr_is_owned(a);
45073 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
45074 a_conv.is_owned = false;
45075 LDKRouteHintHop b_conv;
45076 b_conv.inner = untag_ptr(b);
45077 b_conv.is_owned = ptr_is_owned(b);
45078 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
45079 b_conv.is_owned = false;
45080 jboolean ret_conv = RouteHintHop_eq(&a_conv, &b_conv);
45084 int8_tArray __attribute__((export_name("TS_RouteHintHop_write"))) TS_RouteHintHop_write(uint64_t obj) {
45085 LDKRouteHintHop obj_conv;
45086 obj_conv.inner = untag_ptr(obj);
45087 obj_conv.is_owned = ptr_is_owned(obj);
45088 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45089 obj_conv.is_owned = false;
45090 LDKCVec_u8Z ret_var = RouteHintHop_write(&obj_conv);
45091 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45092 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45093 CVec_u8Z_free(ret_var);
45097 uint64_t __attribute__((export_name("TS_RouteHintHop_read"))) TS_RouteHintHop_read(int8_tArray ser) {
45098 LDKu8slice ser_ref;
45099 ser_ref.datalen = ser->arr_len;
45100 ser_ref.data = ser->elems;
45101 LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
45102 *ret_conv = RouteHintHop_read(ser_ref);
45104 return tag_ptr(ret_conv, true);
45107 uint64_t __attribute__((export_name("TS_find_route"))) TS_find_route(int8_tArray our_node_pubkey, uint64_t route_params, uint64_t network_graph, uint64_tArray first_hops, uint64_t logger, uint64_t scorer, int8_tArray random_seed_bytes) {
45108 LDKPublicKey our_node_pubkey_ref;
45109 CHECK(our_node_pubkey->arr_len == 33);
45110 memcpy(our_node_pubkey_ref.compressed_form, our_node_pubkey->elems, 33); FREE(our_node_pubkey);
45111 LDKRouteParameters route_params_conv;
45112 route_params_conv.inner = untag_ptr(route_params);
45113 route_params_conv.is_owned = ptr_is_owned(route_params);
45114 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_conv);
45115 route_params_conv.is_owned = false;
45116 LDKNetworkGraph network_graph_conv;
45117 network_graph_conv.inner = untag_ptr(network_graph);
45118 network_graph_conv.is_owned = ptr_is_owned(network_graph);
45119 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
45120 network_graph_conv.is_owned = false;
45121 LDKCVec_ChannelDetailsZ first_hops_constr;
45122 LDKCVec_ChannelDetailsZ *first_hops_ptr = NULL;
45123 if (first_hops != 0) {
45124 first_hops_constr.datalen = first_hops->arr_len;
45125 if (first_hops_constr.datalen > 0)
45126 first_hops_constr.data = MALLOC(first_hops_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
45128 first_hops_constr.data = NULL;
45129 uint64_t* first_hops_vals = first_hops->elems;
45130 for (size_t q = 0; q < first_hops_constr.datalen; q++) {
45131 uint64_t first_hops_conv_16 = first_hops_vals[q];
45132 LDKChannelDetails first_hops_conv_16_conv;
45133 first_hops_conv_16_conv.inner = untag_ptr(first_hops_conv_16);
45134 first_hops_conv_16_conv.is_owned = ptr_is_owned(first_hops_conv_16);
45135 CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_conv);
45136 first_hops_conv_16_conv.is_owned = false;
45137 first_hops_constr.data[q] = first_hops_conv_16_conv;
45140 first_hops_ptr = &first_hops_constr;
45142 void* logger_ptr = untag_ptr(logger);
45143 CHECK_ACCESS(logger_ptr);
45144 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
45145 if (logger_conv.free == LDKLogger_JCalls_free) {
45146 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
45147 LDKLogger_JCalls_cloned(&logger_conv);
45149 void* scorer_ptr = untag_ptr(scorer);
45150 if (ptr_is_owned(scorer)) { CHECK_ACCESS(scorer_ptr); }
45151 LDKScore* scorer_conv = (LDKScore*)scorer_ptr;
45152 unsigned char random_seed_bytes_arr[32];
45153 CHECK(random_seed_bytes->arr_len == 32);
45154 memcpy(random_seed_bytes_arr, random_seed_bytes->elems, 32); FREE(random_seed_bytes);
45155 unsigned char (*random_seed_bytes_ref)[32] = &random_seed_bytes_arr;
45156 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
45157 *ret_conv = find_route(our_node_pubkey_ref, &route_params_conv, &network_graph_conv, first_hops_ptr, logger_conv, scorer_conv, random_seed_bytes_ref);
45158 if (first_hops_ptr != NULL) { FREE(first_hops_constr.data); }
45159 return tag_ptr(ret_conv, true);
45162 uint64_t __attribute__((export_name("TS_build_route_from_hops"))) TS_build_route_from_hops(int8_tArray our_node_pubkey, ptrArray hops, uint64_t route_params, uint64_t network_graph, uint64_t logger, int8_tArray random_seed_bytes) {
45163 LDKPublicKey our_node_pubkey_ref;
45164 CHECK(our_node_pubkey->arr_len == 33);
45165 memcpy(our_node_pubkey_ref.compressed_form, our_node_pubkey->elems, 33); FREE(our_node_pubkey);
45166 LDKCVec_PublicKeyZ hops_constr;
45167 hops_constr.datalen = hops->arr_len;
45168 if (hops_constr.datalen > 0)
45169 hops_constr.data = MALLOC(hops_constr.datalen * sizeof(LDKPublicKey), "LDKCVec_PublicKeyZ Elements");
45171 hops_constr.data = NULL;
45172 int8_tArray* hops_vals = (void*) hops->elems;
45173 for (size_t m = 0; m < hops_constr.datalen; m++) {
45174 int8_tArray hops_conv_12 = hops_vals[m];
45175 LDKPublicKey hops_conv_12_ref;
45176 CHECK(hops_conv_12->arr_len == 33);
45177 memcpy(hops_conv_12_ref.compressed_form, hops_conv_12->elems, 33); FREE(hops_conv_12);
45178 hops_constr.data[m] = hops_conv_12_ref;
45181 LDKRouteParameters route_params_conv;
45182 route_params_conv.inner = untag_ptr(route_params);
45183 route_params_conv.is_owned = ptr_is_owned(route_params);
45184 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_conv);
45185 route_params_conv.is_owned = false;
45186 LDKNetworkGraph network_graph_conv;
45187 network_graph_conv.inner = untag_ptr(network_graph);
45188 network_graph_conv.is_owned = ptr_is_owned(network_graph);
45189 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
45190 network_graph_conv.is_owned = false;
45191 void* logger_ptr = untag_ptr(logger);
45192 CHECK_ACCESS(logger_ptr);
45193 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
45194 if (logger_conv.free == LDKLogger_JCalls_free) {
45195 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
45196 LDKLogger_JCalls_cloned(&logger_conv);
45198 unsigned char random_seed_bytes_arr[32];
45199 CHECK(random_seed_bytes->arr_len == 32);
45200 memcpy(random_seed_bytes_arr, random_seed_bytes->elems, 32); FREE(random_seed_bytes);
45201 unsigned char (*random_seed_bytes_ref)[32] = &random_seed_bytes_arr;
45202 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
45203 *ret_conv = build_route_from_hops(our_node_pubkey_ref, hops_constr, &route_params_conv, &network_graph_conv, logger_conv, random_seed_bytes_ref);
45204 return tag_ptr(ret_conv, true);
45207 void __attribute__((export_name("TS_Score_free"))) TS_Score_free(uint64_t this_ptr) {
45208 if (!ptr_is_owned(this_ptr)) return;
45209 void* this_ptr_ptr = untag_ptr(this_ptr);
45210 CHECK_ACCESS(this_ptr_ptr);
45211 LDKScore this_ptr_conv = *(LDKScore*)(this_ptr_ptr);
45212 FREE(untag_ptr(this_ptr));
45213 Score_free(this_ptr_conv);
45216 void __attribute__((export_name("TS_LockableScore_free"))) TS_LockableScore_free(uint64_t this_ptr) {
45217 if (!ptr_is_owned(this_ptr)) return;
45218 void* this_ptr_ptr = untag_ptr(this_ptr);
45219 CHECK_ACCESS(this_ptr_ptr);
45220 LDKLockableScore this_ptr_conv = *(LDKLockableScore*)(this_ptr_ptr);
45221 FREE(untag_ptr(this_ptr));
45222 LockableScore_free(this_ptr_conv);
45225 void __attribute__((export_name("TS_WriteableScore_free"))) TS_WriteableScore_free(uint64_t this_ptr) {
45226 if (!ptr_is_owned(this_ptr)) return;
45227 void* this_ptr_ptr = untag_ptr(this_ptr);
45228 CHECK_ACCESS(this_ptr_ptr);
45229 LDKWriteableScore this_ptr_conv = *(LDKWriteableScore*)(this_ptr_ptr);
45230 FREE(untag_ptr(this_ptr));
45231 WriteableScore_free(this_ptr_conv);
45234 void __attribute__((export_name("TS_MultiThreadedLockableScore_free"))) TS_MultiThreadedLockableScore_free(uint64_t this_obj) {
45235 LDKMultiThreadedLockableScore this_obj_conv;
45236 this_obj_conv.inner = untag_ptr(this_obj);
45237 this_obj_conv.is_owned = ptr_is_owned(this_obj);
45238 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
45239 MultiThreadedLockableScore_free(this_obj_conv);
45242 void __attribute__((export_name("TS_MultiThreadedScoreLock_free"))) TS_MultiThreadedScoreLock_free(uint64_t this_obj) {
45243 LDKMultiThreadedScoreLock this_obj_conv;
45244 this_obj_conv.inner = untag_ptr(this_obj);
45245 this_obj_conv.is_owned = ptr_is_owned(this_obj);
45246 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
45247 MultiThreadedScoreLock_free(this_obj_conv);
45250 uint64_t __attribute__((export_name("TS_MultiThreadedScoreLock_as_Score"))) TS_MultiThreadedScoreLock_as_Score(uint64_t this_arg) {
45251 LDKMultiThreadedScoreLock this_arg_conv;
45252 this_arg_conv.inner = untag_ptr(this_arg);
45253 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45254 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45255 this_arg_conv.is_owned = false;
45256 LDKScore* ret_ret = MALLOC(sizeof(LDKScore), "LDKScore");
45257 *ret_ret = MultiThreadedScoreLock_as_Score(&this_arg_conv);
45258 return tag_ptr(ret_ret, true);
45261 int8_tArray __attribute__((export_name("TS_MultiThreadedScoreLock_write"))) TS_MultiThreadedScoreLock_write(uint64_t obj) {
45262 LDKMultiThreadedScoreLock obj_conv;
45263 obj_conv.inner = untag_ptr(obj);
45264 obj_conv.is_owned = ptr_is_owned(obj);
45265 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45266 obj_conv.is_owned = false;
45267 LDKCVec_u8Z ret_var = MultiThreadedScoreLock_write(&obj_conv);
45268 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45269 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45270 CVec_u8Z_free(ret_var);
45274 uint64_t __attribute__((export_name("TS_MultiThreadedLockableScore_as_LockableScore"))) TS_MultiThreadedLockableScore_as_LockableScore(uint64_t this_arg) {
45275 LDKMultiThreadedLockableScore this_arg_conv;
45276 this_arg_conv.inner = untag_ptr(this_arg);
45277 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45278 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45279 this_arg_conv.is_owned = false;
45280 LDKLockableScore* ret_ret = MALLOC(sizeof(LDKLockableScore), "LDKLockableScore");
45281 *ret_ret = MultiThreadedLockableScore_as_LockableScore(&this_arg_conv);
45282 return tag_ptr(ret_ret, true);
45285 int8_tArray __attribute__((export_name("TS_MultiThreadedLockableScore_write"))) TS_MultiThreadedLockableScore_write(uint64_t obj) {
45286 LDKMultiThreadedLockableScore obj_conv;
45287 obj_conv.inner = untag_ptr(obj);
45288 obj_conv.is_owned = ptr_is_owned(obj);
45289 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45290 obj_conv.is_owned = false;
45291 LDKCVec_u8Z ret_var = MultiThreadedLockableScore_write(&obj_conv);
45292 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45293 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45294 CVec_u8Z_free(ret_var);
45298 uint64_t __attribute__((export_name("TS_MultiThreadedLockableScore_as_WriteableScore"))) TS_MultiThreadedLockableScore_as_WriteableScore(uint64_t this_arg) {
45299 LDKMultiThreadedLockableScore this_arg_conv;
45300 this_arg_conv.inner = untag_ptr(this_arg);
45301 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45302 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45303 this_arg_conv.is_owned = false;
45304 LDKWriteableScore* ret_ret = MALLOC(sizeof(LDKWriteableScore), "LDKWriteableScore");
45305 *ret_ret = MultiThreadedLockableScore_as_WriteableScore(&this_arg_conv);
45306 return tag_ptr(ret_ret, true);
45309 uint64_t __attribute__((export_name("TS_MultiThreadedLockableScore_new"))) TS_MultiThreadedLockableScore_new(uint64_t score) {
45310 void* score_ptr = untag_ptr(score);
45311 CHECK_ACCESS(score_ptr);
45312 LDKScore score_conv = *(LDKScore*)(score_ptr);
45313 if (score_conv.free == LDKScore_JCalls_free) {
45314 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
45315 LDKScore_JCalls_cloned(&score_conv);
45317 LDKMultiThreadedLockableScore ret_var = MultiThreadedLockableScore_new(score_conv);
45318 uint64_t ret_ref = 0;
45319 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45320 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45324 void __attribute__((export_name("TS_ChannelUsage_free"))) TS_ChannelUsage_free(uint64_t this_obj) {
45325 LDKChannelUsage this_obj_conv;
45326 this_obj_conv.inner = untag_ptr(this_obj);
45327 this_obj_conv.is_owned = ptr_is_owned(this_obj);
45328 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
45329 ChannelUsage_free(this_obj_conv);
45332 int64_t __attribute__((export_name("TS_ChannelUsage_get_amount_msat"))) TS_ChannelUsage_get_amount_msat(uint64_t this_ptr) {
45333 LDKChannelUsage this_ptr_conv;
45334 this_ptr_conv.inner = untag_ptr(this_ptr);
45335 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45336 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45337 this_ptr_conv.is_owned = false;
45338 int64_t ret_conv = ChannelUsage_get_amount_msat(&this_ptr_conv);
45342 void __attribute__((export_name("TS_ChannelUsage_set_amount_msat"))) TS_ChannelUsage_set_amount_msat(uint64_t this_ptr, int64_t val) {
45343 LDKChannelUsage this_ptr_conv;
45344 this_ptr_conv.inner = untag_ptr(this_ptr);
45345 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45346 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45347 this_ptr_conv.is_owned = false;
45348 ChannelUsage_set_amount_msat(&this_ptr_conv, val);
45351 int64_t __attribute__((export_name("TS_ChannelUsage_get_inflight_htlc_msat"))) TS_ChannelUsage_get_inflight_htlc_msat(uint64_t this_ptr) {
45352 LDKChannelUsage this_ptr_conv;
45353 this_ptr_conv.inner = untag_ptr(this_ptr);
45354 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45355 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45356 this_ptr_conv.is_owned = false;
45357 int64_t ret_conv = ChannelUsage_get_inflight_htlc_msat(&this_ptr_conv);
45361 void __attribute__((export_name("TS_ChannelUsage_set_inflight_htlc_msat"))) TS_ChannelUsage_set_inflight_htlc_msat(uint64_t this_ptr, int64_t val) {
45362 LDKChannelUsage this_ptr_conv;
45363 this_ptr_conv.inner = untag_ptr(this_ptr);
45364 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45365 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45366 this_ptr_conv.is_owned = false;
45367 ChannelUsage_set_inflight_htlc_msat(&this_ptr_conv, val);
45370 uint64_t __attribute__((export_name("TS_ChannelUsage_get_effective_capacity"))) TS_ChannelUsage_get_effective_capacity(uint64_t this_ptr) {
45371 LDKChannelUsage this_ptr_conv;
45372 this_ptr_conv.inner = untag_ptr(this_ptr);
45373 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45374 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45375 this_ptr_conv.is_owned = false;
45376 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
45377 *ret_copy = ChannelUsage_get_effective_capacity(&this_ptr_conv);
45378 uint64_t ret_ref = tag_ptr(ret_copy, true);
45382 void __attribute__((export_name("TS_ChannelUsage_set_effective_capacity"))) TS_ChannelUsage_set_effective_capacity(uint64_t this_ptr, uint64_t val) {
45383 LDKChannelUsage this_ptr_conv;
45384 this_ptr_conv.inner = untag_ptr(this_ptr);
45385 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45386 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45387 this_ptr_conv.is_owned = false;
45388 void* val_ptr = untag_ptr(val);
45389 CHECK_ACCESS(val_ptr);
45390 LDKEffectiveCapacity val_conv = *(LDKEffectiveCapacity*)(val_ptr);
45391 val_conv = EffectiveCapacity_clone((LDKEffectiveCapacity*)untag_ptr(val));
45392 ChannelUsage_set_effective_capacity(&this_ptr_conv, val_conv);
45395 uint64_t __attribute__((export_name("TS_ChannelUsage_new"))) TS_ChannelUsage_new(int64_t amount_msat_arg, int64_t inflight_htlc_msat_arg, uint64_t effective_capacity_arg) {
45396 void* effective_capacity_arg_ptr = untag_ptr(effective_capacity_arg);
45397 CHECK_ACCESS(effective_capacity_arg_ptr);
45398 LDKEffectiveCapacity effective_capacity_arg_conv = *(LDKEffectiveCapacity*)(effective_capacity_arg_ptr);
45399 effective_capacity_arg_conv = EffectiveCapacity_clone((LDKEffectiveCapacity*)untag_ptr(effective_capacity_arg));
45400 LDKChannelUsage ret_var = ChannelUsage_new(amount_msat_arg, inflight_htlc_msat_arg, effective_capacity_arg_conv);
45401 uint64_t ret_ref = 0;
45402 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45403 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45407 static inline uint64_t ChannelUsage_clone_ptr(LDKChannelUsage *NONNULL_PTR arg) {
45408 LDKChannelUsage ret_var = ChannelUsage_clone(arg);
45409 uint64_t ret_ref = 0;
45410 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45411 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45414 int64_t __attribute__((export_name("TS_ChannelUsage_clone_ptr"))) TS_ChannelUsage_clone_ptr(uint64_t arg) {
45415 LDKChannelUsage arg_conv;
45416 arg_conv.inner = untag_ptr(arg);
45417 arg_conv.is_owned = ptr_is_owned(arg);
45418 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
45419 arg_conv.is_owned = false;
45420 int64_t ret_conv = ChannelUsage_clone_ptr(&arg_conv);
45424 uint64_t __attribute__((export_name("TS_ChannelUsage_clone"))) TS_ChannelUsage_clone(uint64_t orig) {
45425 LDKChannelUsage orig_conv;
45426 orig_conv.inner = untag_ptr(orig);
45427 orig_conv.is_owned = ptr_is_owned(orig);
45428 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
45429 orig_conv.is_owned = false;
45430 LDKChannelUsage ret_var = ChannelUsage_clone(&orig_conv);
45431 uint64_t ret_ref = 0;
45432 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45433 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45437 void __attribute__((export_name("TS_FixedPenaltyScorer_free"))) TS_FixedPenaltyScorer_free(uint64_t this_obj) {
45438 LDKFixedPenaltyScorer this_obj_conv;
45439 this_obj_conv.inner = untag_ptr(this_obj);
45440 this_obj_conv.is_owned = ptr_is_owned(this_obj);
45441 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
45442 FixedPenaltyScorer_free(this_obj_conv);
45445 static inline uint64_t FixedPenaltyScorer_clone_ptr(LDKFixedPenaltyScorer *NONNULL_PTR arg) {
45446 LDKFixedPenaltyScorer ret_var = FixedPenaltyScorer_clone(arg);
45447 uint64_t ret_ref = 0;
45448 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45449 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45452 int64_t __attribute__((export_name("TS_FixedPenaltyScorer_clone_ptr"))) TS_FixedPenaltyScorer_clone_ptr(uint64_t arg) {
45453 LDKFixedPenaltyScorer arg_conv;
45454 arg_conv.inner = untag_ptr(arg);
45455 arg_conv.is_owned = ptr_is_owned(arg);
45456 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
45457 arg_conv.is_owned = false;
45458 int64_t ret_conv = FixedPenaltyScorer_clone_ptr(&arg_conv);
45462 uint64_t __attribute__((export_name("TS_FixedPenaltyScorer_clone"))) TS_FixedPenaltyScorer_clone(uint64_t orig) {
45463 LDKFixedPenaltyScorer orig_conv;
45464 orig_conv.inner = untag_ptr(orig);
45465 orig_conv.is_owned = ptr_is_owned(orig);
45466 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
45467 orig_conv.is_owned = false;
45468 LDKFixedPenaltyScorer ret_var = FixedPenaltyScorer_clone(&orig_conv);
45469 uint64_t ret_ref = 0;
45470 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45471 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45475 uint64_t __attribute__((export_name("TS_FixedPenaltyScorer_with_penalty"))) TS_FixedPenaltyScorer_with_penalty(int64_t penalty_msat) {
45476 LDKFixedPenaltyScorer ret_var = FixedPenaltyScorer_with_penalty(penalty_msat);
45477 uint64_t ret_ref = 0;
45478 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45479 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45483 uint64_t __attribute__((export_name("TS_FixedPenaltyScorer_as_Score"))) TS_FixedPenaltyScorer_as_Score(uint64_t this_arg) {
45484 LDKFixedPenaltyScorer this_arg_conv;
45485 this_arg_conv.inner = untag_ptr(this_arg);
45486 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45487 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45488 this_arg_conv.is_owned = false;
45489 LDKScore* ret_ret = MALLOC(sizeof(LDKScore), "LDKScore");
45490 *ret_ret = FixedPenaltyScorer_as_Score(&this_arg_conv);
45491 return tag_ptr(ret_ret, true);
45494 int8_tArray __attribute__((export_name("TS_FixedPenaltyScorer_write"))) TS_FixedPenaltyScorer_write(uint64_t obj) {
45495 LDKFixedPenaltyScorer obj_conv;
45496 obj_conv.inner = untag_ptr(obj);
45497 obj_conv.is_owned = ptr_is_owned(obj);
45498 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45499 obj_conv.is_owned = false;
45500 LDKCVec_u8Z ret_var = FixedPenaltyScorer_write(&obj_conv);
45501 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45502 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45503 CVec_u8Z_free(ret_var);
45507 uint64_t __attribute__((export_name("TS_FixedPenaltyScorer_read"))) TS_FixedPenaltyScorer_read(int8_tArray ser, int64_t arg) {
45508 LDKu8slice ser_ref;
45509 ser_ref.datalen = ser->arr_len;
45510 ser_ref.data = ser->elems;
45511 LDKCResult_FixedPenaltyScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ), "LDKCResult_FixedPenaltyScorerDecodeErrorZ");
45512 *ret_conv = FixedPenaltyScorer_read(ser_ref, arg);
45514 return tag_ptr(ret_conv, true);
45517 void __attribute__((export_name("TS_ProbabilisticScorer_free"))) TS_ProbabilisticScorer_free(uint64_t this_obj) {
45518 LDKProbabilisticScorer this_obj_conv;
45519 this_obj_conv.inner = untag_ptr(this_obj);
45520 this_obj_conv.is_owned = ptr_is_owned(this_obj);
45521 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
45522 ProbabilisticScorer_free(this_obj_conv);
45525 void __attribute__((export_name("TS_ProbabilisticScoringParameters_free"))) TS_ProbabilisticScoringParameters_free(uint64_t this_obj) {
45526 LDKProbabilisticScoringParameters this_obj_conv;
45527 this_obj_conv.inner = untag_ptr(this_obj);
45528 this_obj_conv.is_owned = ptr_is_owned(this_obj);
45529 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
45530 ProbabilisticScoringParameters_free(this_obj_conv);
45533 int64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_get_base_penalty_msat"))) TS_ProbabilisticScoringParameters_get_base_penalty_msat(uint64_t this_ptr) {
45534 LDKProbabilisticScoringParameters this_ptr_conv;
45535 this_ptr_conv.inner = untag_ptr(this_ptr);
45536 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45537 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45538 this_ptr_conv.is_owned = false;
45539 int64_t ret_conv = ProbabilisticScoringParameters_get_base_penalty_msat(&this_ptr_conv);
45543 void __attribute__((export_name("TS_ProbabilisticScoringParameters_set_base_penalty_msat"))) TS_ProbabilisticScoringParameters_set_base_penalty_msat(uint64_t this_ptr, int64_t val) {
45544 LDKProbabilisticScoringParameters this_ptr_conv;
45545 this_ptr_conv.inner = untag_ptr(this_ptr);
45546 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45547 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45548 this_ptr_conv.is_owned = false;
45549 ProbabilisticScoringParameters_set_base_penalty_msat(&this_ptr_conv, val);
45552 int64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat"))) TS_ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat(uint64_t this_ptr) {
45553 LDKProbabilisticScoringParameters this_ptr_conv;
45554 this_ptr_conv.inner = untag_ptr(this_ptr);
45555 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45556 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45557 this_ptr_conv.is_owned = false;
45558 int64_t ret_conv = ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat(&this_ptr_conv);
45562 void __attribute__((export_name("TS_ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat"))) TS_ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat(uint64_t this_ptr, int64_t val) {
45563 LDKProbabilisticScoringParameters this_ptr_conv;
45564 this_ptr_conv.inner = untag_ptr(this_ptr);
45565 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45566 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45567 this_ptr_conv.is_owned = false;
45568 ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat(&this_ptr_conv, val);
45571 int64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat"))) TS_ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(uint64_t this_ptr) {
45572 LDKProbabilisticScoringParameters this_ptr_conv;
45573 this_ptr_conv.inner = untag_ptr(this_ptr);
45574 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45575 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45576 this_ptr_conv.is_owned = false;
45577 int64_t ret_conv = ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(&this_ptr_conv);
45581 void __attribute__((export_name("TS_ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat"))) TS_ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(uint64_t this_ptr, int64_t val) {
45582 LDKProbabilisticScoringParameters this_ptr_conv;
45583 this_ptr_conv.inner = untag_ptr(this_ptr);
45584 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45585 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45586 this_ptr_conv.is_owned = false;
45587 ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(&this_ptr_conv, val);
45590 int64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_get_liquidity_offset_half_life"))) TS_ProbabilisticScoringParameters_get_liquidity_offset_half_life(uint64_t this_ptr) {
45591 LDKProbabilisticScoringParameters this_ptr_conv;
45592 this_ptr_conv.inner = untag_ptr(this_ptr);
45593 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45594 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45595 this_ptr_conv.is_owned = false;
45596 int64_t ret_conv = ProbabilisticScoringParameters_get_liquidity_offset_half_life(&this_ptr_conv);
45600 void __attribute__((export_name("TS_ProbabilisticScoringParameters_set_liquidity_offset_half_life"))) TS_ProbabilisticScoringParameters_set_liquidity_offset_half_life(uint64_t this_ptr, int64_t val) {
45601 LDKProbabilisticScoringParameters this_ptr_conv;
45602 this_ptr_conv.inner = untag_ptr(this_ptr);
45603 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45604 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45605 this_ptr_conv.is_owned = false;
45606 ProbabilisticScoringParameters_set_liquidity_offset_half_life(&this_ptr_conv, val);
45609 int64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat"))) TS_ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat(uint64_t this_ptr) {
45610 LDKProbabilisticScoringParameters this_ptr_conv;
45611 this_ptr_conv.inner = untag_ptr(this_ptr);
45612 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45613 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45614 this_ptr_conv.is_owned = false;
45615 int64_t ret_conv = ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat(&this_ptr_conv);
45619 void __attribute__((export_name("TS_ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat"))) TS_ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat(uint64_t this_ptr, int64_t val) {
45620 LDKProbabilisticScoringParameters this_ptr_conv;
45621 this_ptr_conv.inner = untag_ptr(this_ptr);
45622 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45623 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45624 this_ptr_conv.is_owned = false;
45625 ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat(&this_ptr_conv, val);
45628 int64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_get_historical_liquidity_penalty_multiplier_msat"))) TS_ProbabilisticScoringParameters_get_historical_liquidity_penalty_multiplier_msat(uint64_t this_ptr) {
45629 LDKProbabilisticScoringParameters this_ptr_conv;
45630 this_ptr_conv.inner = untag_ptr(this_ptr);
45631 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45632 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45633 this_ptr_conv.is_owned = false;
45634 int64_t ret_conv = ProbabilisticScoringParameters_get_historical_liquidity_penalty_multiplier_msat(&this_ptr_conv);
45638 void __attribute__((export_name("TS_ProbabilisticScoringParameters_set_historical_liquidity_penalty_multiplier_msat"))) TS_ProbabilisticScoringParameters_set_historical_liquidity_penalty_multiplier_msat(uint64_t this_ptr, int64_t val) {
45639 LDKProbabilisticScoringParameters this_ptr_conv;
45640 this_ptr_conv.inner = untag_ptr(this_ptr);
45641 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45642 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45643 this_ptr_conv.is_owned = false;
45644 ProbabilisticScoringParameters_set_historical_liquidity_penalty_multiplier_msat(&this_ptr_conv, val);
45647 int64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_get_historical_liquidity_penalty_amount_multiplier_msat"))) TS_ProbabilisticScoringParameters_get_historical_liquidity_penalty_amount_multiplier_msat(uint64_t this_ptr) {
45648 LDKProbabilisticScoringParameters this_ptr_conv;
45649 this_ptr_conv.inner = untag_ptr(this_ptr);
45650 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45651 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45652 this_ptr_conv.is_owned = false;
45653 int64_t ret_conv = ProbabilisticScoringParameters_get_historical_liquidity_penalty_amount_multiplier_msat(&this_ptr_conv);
45657 void __attribute__((export_name("TS_ProbabilisticScoringParameters_set_historical_liquidity_penalty_amount_multiplier_msat"))) TS_ProbabilisticScoringParameters_set_historical_liquidity_penalty_amount_multiplier_msat(uint64_t this_ptr, int64_t val) {
45658 LDKProbabilisticScoringParameters this_ptr_conv;
45659 this_ptr_conv.inner = untag_ptr(this_ptr);
45660 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45661 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45662 this_ptr_conv.is_owned = false;
45663 ProbabilisticScoringParameters_set_historical_liquidity_penalty_amount_multiplier_msat(&this_ptr_conv, val);
45666 int64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_get_historical_no_updates_half_life"))) TS_ProbabilisticScoringParameters_get_historical_no_updates_half_life(uint64_t this_ptr) {
45667 LDKProbabilisticScoringParameters this_ptr_conv;
45668 this_ptr_conv.inner = untag_ptr(this_ptr);
45669 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45670 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45671 this_ptr_conv.is_owned = false;
45672 int64_t ret_conv = ProbabilisticScoringParameters_get_historical_no_updates_half_life(&this_ptr_conv);
45676 void __attribute__((export_name("TS_ProbabilisticScoringParameters_set_historical_no_updates_half_life"))) TS_ProbabilisticScoringParameters_set_historical_no_updates_half_life(uint64_t this_ptr, int64_t val) {
45677 LDKProbabilisticScoringParameters this_ptr_conv;
45678 this_ptr_conv.inner = untag_ptr(this_ptr);
45679 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45680 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45681 this_ptr_conv.is_owned = false;
45682 ProbabilisticScoringParameters_set_historical_no_updates_half_life(&this_ptr_conv, val);
45685 int64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_get_anti_probing_penalty_msat"))) TS_ProbabilisticScoringParameters_get_anti_probing_penalty_msat(uint64_t this_ptr) {
45686 LDKProbabilisticScoringParameters this_ptr_conv;
45687 this_ptr_conv.inner = untag_ptr(this_ptr);
45688 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45689 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45690 this_ptr_conv.is_owned = false;
45691 int64_t ret_conv = ProbabilisticScoringParameters_get_anti_probing_penalty_msat(&this_ptr_conv);
45695 void __attribute__((export_name("TS_ProbabilisticScoringParameters_set_anti_probing_penalty_msat"))) TS_ProbabilisticScoringParameters_set_anti_probing_penalty_msat(uint64_t this_ptr, int64_t val) {
45696 LDKProbabilisticScoringParameters this_ptr_conv;
45697 this_ptr_conv.inner = untag_ptr(this_ptr);
45698 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45699 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45700 this_ptr_conv.is_owned = false;
45701 ProbabilisticScoringParameters_set_anti_probing_penalty_msat(&this_ptr_conv, val);
45704 int64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_get_considered_impossible_penalty_msat"))) TS_ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(uint64_t this_ptr) {
45705 LDKProbabilisticScoringParameters this_ptr_conv;
45706 this_ptr_conv.inner = untag_ptr(this_ptr);
45707 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45708 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45709 this_ptr_conv.is_owned = false;
45710 int64_t ret_conv = ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(&this_ptr_conv);
45714 void __attribute__((export_name("TS_ProbabilisticScoringParameters_set_considered_impossible_penalty_msat"))) TS_ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(uint64_t this_ptr, int64_t val) {
45715 LDKProbabilisticScoringParameters this_ptr_conv;
45716 this_ptr_conv.inner = untag_ptr(this_ptr);
45717 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45718 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45719 this_ptr_conv.is_owned = false;
45720 ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(&this_ptr_conv, val);
45723 static inline uint64_t ProbabilisticScoringParameters_clone_ptr(LDKProbabilisticScoringParameters *NONNULL_PTR arg) {
45724 LDKProbabilisticScoringParameters ret_var = ProbabilisticScoringParameters_clone(arg);
45725 uint64_t ret_ref = 0;
45726 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45727 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45730 int64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_clone_ptr"))) TS_ProbabilisticScoringParameters_clone_ptr(uint64_t arg) {
45731 LDKProbabilisticScoringParameters arg_conv;
45732 arg_conv.inner = untag_ptr(arg);
45733 arg_conv.is_owned = ptr_is_owned(arg);
45734 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
45735 arg_conv.is_owned = false;
45736 int64_t ret_conv = ProbabilisticScoringParameters_clone_ptr(&arg_conv);
45740 uint64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_clone"))) TS_ProbabilisticScoringParameters_clone(uint64_t orig) {
45741 LDKProbabilisticScoringParameters orig_conv;
45742 orig_conv.inner = untag_ptr(orig);
45743 orig_conv.is_owned = ptr_is_owned(orig);
45744 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
45745 orig_conv.is_owned = false;
45746 LDKProbabilisticScoringParameters ret_var = ProbabilisticScoringParameters_clone(&orig_conv);
45747 uint64_t ret_ref = 0;
45748 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45749 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45753 uint64_t __attribute__((export_name("TS_ProbabilisticScorer_new"))) TS_ProbabilisticScorer_new(uint64_t params, uint64_t network_graph, uint64_t logger) {
45754 LDKProbabilisticScoringParameters params_conv;
45755 params_conv.inner = untag_ptr(params);
45756 params_conv.is_owned = ptr_is_owned(params);
45757 CHECK_INNER_FIELD_ACCESS_OR_NULL(params_conv);
45758 params_conv = ProbabilisticScoringParameters_clone(¶ms_conv);
45759 LDKNetworkGraph network_graph_conv;
45760 network_graph_conv.inner = untag_ptr(network_graph);
45761 network_graph_conv.is_owned = ptr_is_owned(network_graph);
45762 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
45763 network_graph_conv.is_owned = false;
45764 void* logger_ptr = untag_ptr(logger);
45765 CHECK_ACCESS(logger_ptr);
45766 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
45767 if (logger_conv.free == LDKLogger_JCalls_free) {
45768 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
45769 LDKLogger_JCalls_cloned(&logger_conv);
45771 LDKProbabilisticScorer ret_var = ProbabilisticScorer_new(params_conv, &network_graph_conv, logger_conv);
45772 uint64_t ret_ref = 0;
45773 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45774 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45778 void __attribute__((export_name("TS_ProbabilisticScorer_debug_log_liquidity_stats"))) TS_ProbabilisticScorer_debug_log_liquidity_stats(uint64_t this_arg) {
45779 LDKProbabilisticScorer this_arg_conv;
45780 this_arg_conv.inner = untag_ptr(this_arg);
45781 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45782 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45783 this_arg_conv.is_owned = false;
45784 ProbabilisticScorer_debug_log_liquidity_stats(&this_arg_conv);
45787 uint64_t __attribute__((export_name("TS_ProbabilisticScorer_estimated_channel_liquidity_range"))) TS_ProbabilisticScorer_estimated_channel_liquidity_range(uint64_t this_arg, int64_t scid, uint64_t target) {
45788 LDKProbabilisticScorer this_arg_conv;
45789 this_arg_conv.inner = untag_ptr(this_arg);
45790 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45791 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45792 this_arg_conv.is_owned = false;
45793 LDKNodeId target_conv;
45794 target_conv.inner = untag_ptr(target);
45795 target_conv.is_owned = ptr_is_owned(target);
45796 CHECK_INNER_FIELD_ACCESS_OR_NULL(target_conv);
45797 target_conv.is_owned = false;
45798 LDKCOption_C2Tuple_u64u64ZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_u64u64ZZ), "LDKCOption_C2Tuple_u64u64ZZ");
45799 *ret_copy = ProbabilisticScorer_estimated_channel_liquidity_range(&this_arg_conv, scid, &target_conv);
45800 uint64_t ret_ref = tag_ptr(ret_copy, true);
45804 void __attribute__((export_name("TS_ProbabilisticScorer_add_banned"))) TS_ProbabilisticScorer_add_banned(uint64_t this_arg, uint64_t node_id) {
45805 LDKProbabilisticScorer this_arg_conv;
45806 this_arg_conv.inner = untag_ptr(this_arg);
45807 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45808 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45809 this_arg_conv.is_owned = false;
45810 LDKNodeId node_id_conv;
45811 node_id_conv.inner = untag_ptr(node_id);
45812 node_id_conv.is_owned = ptr_is_owned(node_id);
45813 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_id_conv);
45814 node_id_conv.is_owned = false;
45815 ProbabilisticScorer_add_banned(&this_arg_conv, &node_id_conv);
45818 void __attribute__((export_name("TS_ProbabilisticScorer_remove_banned"))) TS_ProbabilisticScorer_remove_banned(uint64_t this_arg, uint64_t node_id) {
45819 LDKProbabilisticScorer this_arg_conv;
45820 this_arg_conv.inner = untag_ptr(this_arg);
45821 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45822 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45823 this_arg_conv.is_owned = false;
45824 LDKNodeId node_id_conv;
45825 node_id_conv.inner = untag_ptr(node_id);
45826 node_id_conv.is_owned = ptr_is_owned(node_id);
45827 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_id_conv);
45828 node_id_conv.is_owned = false;
45829 ProbabilisticScorer_remove_banned(&this_arg_conv, &node_id_conv);
45832 void __attribute__((export_name("TS_ProbabilisticScorer_set_manual_penalty"))) TS_ProbabilisticScorer_set_manual_penalty(uint64_t this_arg, uint64_t node_id, int64_t penalty) {
45833 LDKProbabilisticScorer this_arg_conv;
45834 this_arg_conv.inner = untag_ptr(this_arg);
45835 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45836 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45837 this_arg_conv.is_owned = false;
45838 LDKNodeId node_id_conv;
45839 node_id_conv.inner = untag_ptr(node_id);
45840 node_id_conv.is_owned = ptr_is_owned(node_id);
45841 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_id_conv);
45842 node_id_conv.is_owned = false;
45843 ProbabilisticScorer_set_manual_penalty(&this_arg_conv, &node_id_conv, penalty);
45846 void __attribute__((export_name("TS_ProbabilisticScorer_remove_manual_penalty"))) TS_ProbabilisticScorer_remove_manual_penalty(uint64_t this_arg, uint64_t node_id) {
45847 LDKProbabilisticScorer this_arg_conv;
45848 this_arg_conv.inner = untag_ptr(this_arg);
45849 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45850 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45851 this_arg_conv.is_owned = false;
45852 LDKNodeId node_id_conv;
45853 node_id_conv.inner = untag_ptr(node_id);
45854 node_id_conv.is_owned = ptr_is_owned(node_id);
45855 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_id_conv);
45856 node_id_conv.is_owned = false;
45857 ProbabilisticScorer_remove_manual_penalty(&this_arg_conv, &node_id_conv);
45860 void __attribute__((export_name("TS_ProbabilisticScorer_clear_manual_penalties"))) TS_ProbabilisticScorer_clear_manual_penalties(uint64_t this_arg) {
45861 LDKProbabilisticScorer this_arg_conv;
45862 this_arg_conv.inner = untag_ptr(this_arg);
45863 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45864 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45865 this_arg_conv.is_owned = false;
45866 ProbabilisticScorer_clear_manual_penalties(&this_arg_conv);
45869 void __attribute__((export_name("TS_ProbabilisticScoringParameters_add_banned_from_list"))) TS_ProbabilisticScoringParameters_add_banned_from_list(uint64_t this_arg, uint64_tArray node_ids) {
45870 LDKProbabilisticScoringParameters this_arg_conv;
45871 this_arg_conv.inner = untag_ptr(this_arg);
45872 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45873 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45874 this_arg_conv.is_owned = false;
45875 LDKCVec_NodeIdZ node_ids_constr;
45876 node_ids_constr.datalen = node_ids->arr_len;
45877 if (node_ids_constr.datalen > 0)
45878 node_ids_constr.data = MALLOC(node_ids_constr.datalen * sizeof(LDKNodeId), "LDKCVec_NodeIdZ Elements");
45880 node_ids_constr.data = NULL;
45881 uint64_t* node_ids_vals = node_ids->elems;
45882 for (size_t i = 0; i < node_ids_constr.datalen; i++) {
45883 uint64_t node_ids_conv_8 = node_ids_vals[i];
45884 LDKNodeId node_ids_conv_8_conv;
45885 node_ids_conv_8_conv.inner = untag_ptr(node_ids_conv_8);
45886 node_ids_conv_8_conv.is_owned = ptr_is_owned(node_ids_conv_8);
45887 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_ids_conv_8_conv);
45888 node_ids_conv_8_conv = NodeId_clone(&node_ids_conv_8_conv);
45889 node_ids_constr.data[i] = node_ids_conv_8_conv;
45892 ProbabilisticScoringParameters_add_banned_from_list(&this_arg_conv, node_ids_constr);
45895 uint64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_default"))) TS_ProbabilisticScoringParameters_default() {
45896 LDKProbabilisticScoringParameters ret_var = ProbabilisticScoringParameters_default();
45897 uint64_t ret_ref = 0;
45898 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45899 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45903 uint64_t __attribute__((export_name("TS_ProbabilisticScorer_as_Score"))) TS_ProbabilisticScorer_as_Score(uint64_t this_arg) {
45904 LDKProbabilisticScorer this_arg_conv;
45905 this_arg_conv.inner = untag_ptr(this_arg);
45906 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45907 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45908 this_arg_conv.is_owned = false;
45909 LDKScore* ret_ret = MALLOC(sizeof(LDKScore), "LDKScore");
45910 *ret_ret = ProbabilisticScorer_as_Score(&this_arg_conv);
45911 return tag_ptr(ret_ret, true);
45914 int8_tArray __attribute__((export_name("TS_ProbabilisticScorer_write"))) TS_ProbabilisticScorer_write(uint64_t obj) {
45915 LDKProbabilisticScorer obj_conv;
45916 obj_conv.inner = untag_ptr(obj);
45917 obj_conv.is_owned = ptr_is_owned(obj);
45918 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45919 obj_conv.is_owned = false;
45920 LDKCVec_u8Z ret_var = ProbabilisticScorer_write(&obj_conv);
45921 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45922 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45923 CVec_u8Z_free(ret_var);
45927 uint64_t __attribute__((export_name("TS_ProbabilisticScorer_read"))) TS_ProbabilisticScorer_read(int8_tArray ser, uint64_t arg_a, uint64_t arg_b, uint64_t arg_c) {
45928 LDKu8slice ser_ref;
45929 ser_ref.datalen = ser->arr_len;
45930 ser_ref.data = ser->elems;
45931 LDKProbabilisticScoringParameters arg_a_conv;
45932 arg_a_conv.inner = untag_ptr(arg_a);
45933 arg_a_conv.is_owned = ptr_is_owned(arg_a);
45934 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_a_conv);
45935 arg_a_conv = ProbabilisticScoringParameters_clone(&arg_a_conv);
45936 LDKNetworkGraph arg_b_conv;
45937 arg_b_conv.inner = untag_ptr(arg_b);
45938 arg_b_conv.is_owned = ptr_is_owned(arg_b);
45939 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_b_conv);
45940 arg_b_conv.is_owned = false;
45941 void* arg_c_ptr = untag_ptr(arg_c);
45942 CHECK_ACCESS(arg_c_ptr);
45943 LDKLogger arg_c_conv = *(LDKLogger*)(arg_c_ptr);
45944 if (arg_c_conv.free == LDKLogger_JCalls_free) {
45945 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
45946 LDKLogger_JCalls_cloned(&arg_c_conv);
45948 LDKCResult_ProbabilisticScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ProbabilisticScorerDecodeErrorZ), "LDKCResult_ProbabilisticScorerDecodeErrorZ");
45949 *ret_conv = ProbabilisticScorer_read(ser_ref, arg_a_conv, &arg_b_conv, arg_c_conv);
45951 return tag_ptr(ret_conv, true);
45954 void __attribute__((export_name("TS_BlindedPath_free"))) TS_BlindedPath_free(uint64_t this_obj) {
45955 LDKBlindedPath this_obj_conv;
45956 this_obj_conv.inner = untag_ptr(this_obj);
45957 this_obj_conv.is_owned = ptr_is_owned(this_obj);
45958 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
45959 BlindedPath_free(this_obj_conv);
45962 static inline uint64_t BlindedPath_clone_ptr(LDKBlindedPath *NONNULL_PTR arg) {
45963 LDKBlindedPath ret_var = BlindedPath_clone(arg);
45964 uint64_t ret_ref = 0;
45965 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45966 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45969 int64_t __attribute__((export_name("TS_BlindedPath_clone_ptr"))) TS_BlindedPath_clone_ptr(uint64_t arg) {
45970 LDKBlindedPath arg_conv;
45971 arg_conv.inner = untag_ptr(arg);
45972 arg_conv.is_owned = ptr_is_owned(arg);
45973 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
45974 arg_conv.is_owned = false;
45975 int64_t ret_conv = BlindedPath_clone_ptr(&arg_conv);
45979 uint64_t __attribute__((export_name("TS_BlindedPath_clone"))) TS_BlindedPath_clone(uint64_t orig) {
45980 LDKBlindedPath orig_conv;
45981 orig_conv.inner = untag_ptr(orig);
45982 orig_conv.is_owned = ptr_is_owned(orig);
45983 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
45984 orig_conv.is_owned = false;
45985 LDKBlindedPath ret_var = BlindedPath_clone(&orig_conv);
45986 uint64_t ret_ref = 0;
45987 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45988 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45992 void __attribute__((export_name("TS_BlindedHop_free"))) TS_BlindedHop_free(uint64_t this_obj) {
45993 LDKBlindedHop this_obj_conv;
45994 this_obj_conv.inner = untag_ptr(this_obj);
45995 this_obj_conv.is_owned = ptr_is_owned(this_obj);
45996 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
45997 BlindedHop_free(this_obj_conv);
46000 static inline uint64_t BlindedHop_clone_ptr(LDKBlindedHop *NONNULL_PTR arg) {
46001 LDKBlindedHop ret_var = BlindedHop_clone(arg);
46002 uint64_t ret_ref = 0;
46003 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46004 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46007 int64_t __attribute__((export_name("TS_BlindedHop_clone_ptr"))) TS_BlindedHop_clone_ptr(uint64_t arg) {
46008 LDKBlindedHop arg_conv;
46009 arg_conv.inner = untag_ptr(arg);
46010 arg_conv.is_owned = ptr_is_owned(arg);
46011 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
46012 arg_conv.is_owned = false;
46013 int64_t ret_conv = BlindedHop_clone_ptr(&arg_conv);
46017 uint64_t __attribute__((export_name("TS_BlindedHop_clone"))) TS_BlindedHop_clone(uint64_t orig) {
46018 LDKBlindedHop orig_conv;
46019 orig_conv.inner = untag_ptr(orig);
46020 orig_conv.is_owned = ptr_is_owned(orig);
46021 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
46022 orig_conv.is_owned = false;
46023 LDKBlindedHop ret_var = BlindedHop_clone(&orig_conv);
46024 uint64_t ret_ref = 0;
46025 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46026 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46030 uint64_t __attribute__((export_name("TS_BlindedPath_new"))) TS_BlindedPath_new(ptrArray node_pks, uint64_t keys_manager) {
46031 LDKCVec_PublicKeyZ node_pks_constr;
46032 node_pks_constr.datalen = node_pks->arr_len;
46033 if (node_pks_constr.datalen > 0)
46034 node_pks_constr.data = MALLOC(node_pks_constr.datalen * sizeof(LDKPublicKey), "LDKCVec_PublicKeyZ Elements");
46036 node_pks_constr.data = NULL;
46037 int8_tArray* node_pks_vals = (void*) node_pks->elems;
46038 for (size_t m = 0; m < node_pks_constr.datalen; m++) {
46039 int8_tArray node_pks_conv_12 = node_pks_vals[m];
46040 LDKPublicKey node_pks_conv_12_ref;
46041 CHECK(node_pks_conv_12->arr_len == 33);
46042 memcpy(node_pks_conv_12_ref.compressed_form, node_pks_conv_12->elems, 33); FREE(node_pks_conv_12);
46043 node_pks_constr.data[m] = node_pks_conv_12_ref;
46046 void* keys_manager_ptr = untag_ptr(keys_manager);
46047 if (ptr_is_owned(keys_manager)) { CHECK_ACCESS(keys_manager_ptr); }
46048 LDKKeysInterface* keys_manager_conv = (LDKKeysInterface*)keys_manager_ptr;
46049 LDKCResult_BlindedPathNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathNoneZ), "LDKCResult_BlindedPathNoneZ");
46050 *ret_conv = BlindedPath_new(node_pks_constr, keys_manager_conv);
46051 return tag_ptr(ret_conv, true);
46054 int8_tArray __attribute__((export_name("TS_BlindedPath_write"))) TS_BlindedPath_write(uint64_t obj) {
46055 LDKBlindedPath obj_conv;
46056 obj_conv.inner = untag_ptr(obj);
46057 obj_conv.is_owned = ptr_is_owned(obj);
46058 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
46059 obj_conv.is_owned = false;
46060 LDKCVec_u8Z ret_var = BlindedPath_write(&obj_conv);
46061 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
46062 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
46063 CVec_u8Z_free(ret_var);
46067 uint64_t __attribute__((export_name("TS_BlindedPath_read"))) TS_BlindedPath_read(int8_tArray ser) {
46068 LDKu8slice ser_ref;
46069 ser_ref.datalen = ser->arr_len;
46070 ser_ref.data = ser->elems;
46071 LDKCResult_BlindedPathDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathDecodeErrorZ), "LDKCResult_BlindedPathDecodeErrorZ");
46072 *ret_conv = BlindedPath_read(ser_ref);
46074 return tag_ptr(ret_conv, true);
46077 int8_tArray __attribute__((export_name("TS_BlindedHop_write"))) TS_BlindedHop_write(uint64_t obj) {
46078 LDKBlindedHop obj_conv;
46079 obj_conv.inner = untag_ptr(obj);
46080 obj_conv.is_owned = ptr_is_owned(obj);
46081 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
46082 obj_conv.is_owned = false;
46083 LDKCVec_u8Z ret_var = BlindedHop_write(&obj_conv);
46084 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
46085 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
46086 CVec_u8Z_free(ret_var);
46090 uint64_t __attribute__((export_name("TS_BlindedHop_read"))) TS_BlindedHop_read(int8_tArray ser) {
46091 LDKu8slice ser_ref;
46092 ser_ref.datalen = ser->arr_len;
46093 ser_ref.data = ser->elems;
46094 LDKCResult_BlindedHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopDecodeErrorZ), "LDKCResult_BlindedHopDecodeErrorZ");
46095 *ret_conv = BlindedHop_read(ser_ref);
46097 return tag_ptr(ret_conv, true);
46100 void __attribute__((export_name("TS_OnionMessenger_free"))) TS_OnionMessenger_free(uint64_t this_obj) {
46101 LDKOnionMessenger this_obj_conv;
46102 this_obj_conv.inner = untag_ptr(this_obj);
46103 this_obj_conv.is_owned = ptr_is_owned(this_obj);
46104 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
46105 OnionMessenger_free(this_obj_conv);
46108 void __attribute__((export_name("TS_Destination_free"))) TS_Destination_free(uint64_t this_ptr) {
46109 if (!ptr_is_owned(this_ptr)) return;
46110 void* this_ptr_ptr = untag_ptr(this_ptr);
46111 CHECK_ACCESS(this_ptr_ptr);
46112 LDKDestination this_ptr_conv = *(LDKDestination*)(this_ptr_ptr);
46113 FREE(untag_ptr(this_ptr));
46114 Destination_free(this_ptr_conv);
46117 static inline uint64_t Destination_clone_ptr(LDKDestination *NONNULL_PTR arg) {
46118 LDKDestination *ret_copy = MALLOC(sizeof(LDKDestination), "LDKDestination");
46119 *ret_copy = Destination_clone(arg);
46120 uint64_t ret_ref = tag_ptr(ret_copy, true);
46123 int64_t __attribute__((export_name("TS_Destination_clone_ptr"))) TS_Destination_clone_ptr(uint64_t arg) {
46124 LDKDestination* arg_conv = (LDKDestination*)untag_ptr(arg);
46125 int64_t ret_conv = Destination_clone_ptr(arg_conv);
46129 uint64_t __attribute__((export_name("TS_Destination_clone"))) TS_Destination_clone(uint64_t orig) {
46130 LDKDestination* orig_conv = (LDKDestination*)untag_ptr(orig);
46131 LDKDestination *ret_copy = MALLOC(sizeof(LDKDestination), "LDKDestination");
46132 *ret_copy = Destination_clone(orig_conv);
46133 uint64_t ret_ref = tag_ptr(ret_copy, true);
46137 uint64_t __attribute__((export_name("TS_Destination_node"))) TS_Destination_node(int8_tArray a) {
46138 LDKPublicKey a_ref;
46139 CHECK(a->arr_len == 33);
46140 memcpy(a_ref.compressed_form, a->elems, 33); FREE(a);
46141 LDKDestination *ret_copy = MALLOC(sizeof(LDKDestination), "LDKDestination");
46142 *ret_copy = Destination_node(a_ref);
46143 uint64_t ret_ref = tag_ptr(ret_copy, true);
46147 uint64_t __attribute__((export_name("TS_Destination_blinded_path"))) TS_Destination_blinded_path(uint64_t a) {
46148 LDKBlindedPath a_conv;
46149 a_conv.inner = untag_ptr(a);
46150 a_conv.is_owned = ptr_is_owned(a);
46151 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
46152 a_conv = BlindedPath_clone(&a_conv);
46153 LDKDestination *ret_copy = MALLOC(sizeof(LDKDestination), "LDKDestination");
46154 *ret_copy = Destination_blinded_path(a_conv);
46155 uint64_t ret_ref = tag_ptr(ret_copy, true);
46159 void __attribute__((export_name("TS_SendError_free"))) TS_SendError_free(uint64_t this_ptr) {
46160 if (!ptr_is_owned(this_ptr)) return;
46161 void* this_ptr_ptr = untag_ptr(this_ptr);
46162 CHECK_ACCESS(this_ptr_ptr);
46163 LDKSendError this_ptr_conv = *(LDKSendError*)(this_ptr_ptr);
46164 FREE(untag_ptr(this_ptr));
46165 SendError_free(this_ptr_conv);
46168 static inline uint64_t SendError_clone_ptr(LDKSendError *NONNULL_PTR arg) {
46169 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
46170 *ret_copy = SendError_clone(arg);
46171 uint64_t ret_ref = tag_ptr(ret_copy, true);
46174 int64_t __attribute__((export_name("TS_SendError_clone_ptr"))) TS_SendError_clone_ptr(uint64_t arg) {
46175 LDKSendError* arg_conv = (LDKSendError*)untag_ptr(arg);
46176 int64_t ret_conv = SendError_clone_ptr(arg_conv);
46180 uint64_t __attribute__((export_name("TS_SendError_clone"))) TS_SendError_clone(uint64_t orig) {
46181 LDKSendError* orig_conv = (LDKSendError*)untag_ptr(orig);
46182 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
46183 *ret_copy = SendError_clone(orig_conv);
46184 uint64_t ret_ref = tag_ptr(ret_copy, true);
46188 uint64_t __attribute__((export_name("TS_SendError_secp256k1"))) TS_SendError_secp256k1(uint32_t a) {
46189 LDKSecp256k1Error a_conv = LDKSecp256k1Error_from_js(a);
46190 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
46191 *ret_copy = SendError_secp256k1(a_conv);
46192 uint64_t ret_ref = tag_ptr(ret_copy, true);
46196 uint64_t __attribute__((export_name("TS_SendError_too_big_packet"))) TS_SendError_too_big_packet() {
46197 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
46198 *ret_copy = SendError_too_big_packet();
46199 uint64_t ret_ref = tag_ptr(ret_copy, true);
46203 uint64_t __attribute__((export_name("TS_SendError_too_few_blinded_hops"))) TS_SendError_too_few_blinded_hops() {
46204 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
46205 *ret_copy = SendError_too_few_blinded_hops();
46206 uint64_t ret_ref = tag_ptr(ret_copy, true);
46210 uint64_t __attribute__((export_name("TS_SendError_invalid_first_hop"))) TS_SendError_invalid_first_hop() {
46211 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
46212 *ret_copy = SendError_invalid_first_hop();
46213 uint64_t ret_ref = tag_ptr(ret_copy, true);
46217 uint64_t __attribute__((export_name("TS_SendError_invalid_message"))) TS_SendError_invalid_message() {
46218 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
46219 *ret_copy = SendError_invalid_message();
46220 uint64_t ret_ref = tag_ptr(ret_copy, true);
46224 uint64_t __attribute__((export_name("TS_SendError_buffer_full"))) TS_SendError_buffer_full() {
46225 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
46226 *ret_copy = SendError_buffer_full();
46227 uint64_t ret_ref = tag_ptr(ret_copy, true);
46231 uint64_t __attribute__((export_name("TS_SendError_get_node_id_failed"))) TS_SendError_get_node_id_failed() {
46232 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
46233 *ret_copy = SendError_get_node_id_failed();
46234 uint64_t ret_ref = tag_ptr(ret_copy, true);
46238 uint64_t __attribute__((export_name("TS_SendError_blinded_path_advance_failed"))) TS_SendError_blinded_path_advance_failed() {
46239 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
46240 *ret_copy = SendError_blinded_path_advance_failed();
46241 uint64_t ret_ref = tag_ptr(ret_copy, true);
46245 jboolean __attribute__((export_name("TS_SendError_eq"))) TS_SendError_eq(uint64_t a, uint64_t b) {
46246 LDKSendError* a_conv = (LDKSendError*)untag_ptr(a);
46247 LDKSendError* b_conv = (LDKSendError*)untag_ptr(b);
46248 jboolean ret_conv = SendError_eq(a_conv, b_conv);
46252 void __attribute__((export_name("TS_CustomOnionMessageHandler_free"))) TS_CustomOnionMessageHandler_free(uint64_t this_ptr) {
46253 if (!ptr_is_owned(this_ptr)) return;
46254 void* this_ptr_ptr = untag_ptr(this_ptr);
46255 CHECK_ACCESS(this_ptr_ptr);
46256 LDKCustomOnionMessageHandler this_ptr_conv = *(LDKCustomOnionMessageHandler*)(this_ptr_ptr);
46257 FREE(untag_ptr(this_ptr));
46258 CustomOnionMessageHandler_free(this_ptr_conv);
46261 uint64_t __attribute__((export_name("TS_OnionMessenger_new"))) TS_OnionMessenger_new(uint64_t keys_manager, uint64_t logger, uint64_t custom_handler) {
46262 void* keys_manager_ptr = untag_ptr(keys_manager);
46263 CHECK_ACCESS(keys_manager_ptr);
46264 LDKKeysInterface keys_manager_conv = *(LDKKeysInterface*)(keys_manager_ptr);
46265 if (keys_manager_conv.free == LDKKeysInterface_JCalls_free) {
46266 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
46267 LDKKeysInterface_JCalls_cloned(&keys_manager_conv);
46269 void* logger_ptr = untag_ptr(logger);
46270 CHECK_ACCESS(logger_ptr);
46271 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
46272 if (logger_conv.free == LDKLogger_JCalls_free) {
46273 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
46274 LDKLogger_JCalls_cloned(&logger_conv);
46276 void* custom_handler_ptr = untag_ptr(custom_handler);
46277 CHECK_ACCESS(custom_handler_ptr);
46278 LDKCustomOnionMessageHandler custom_handler_conv = *(LDKCustomOnionMessageHandler*)(custom_handler_ptr);
46279 if (custom_handler_conv.free == LDKCustomOnionMessageHandler_JCalls_free) {
46280 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
46281 LDKCustomOnionMessageHandler_JCalls_cloned(&custom_handler_conv);
46283 LDKOnionMessenger ret_var = OnionMessenger_new(keys_manager_conv, logger_conv, custom_handler_conv);
46284 uint64_t ret_ref = 0;
46285 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46286 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46290 uint64_t __attribute__((export_name("TS_OnionMessenger_send_onion_message"))) TS_OnionMessenger_send_onion_message(uint64_t this_arg, ptrArray intermediate_nodes, uint64_t destination, uint64_t message, uint64_t reply_path) {
46291 LDKOnionMessenger this_arg_conv;
46292 this_arg_conv.inner = untag_ptr(this_arg);
46293 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46294 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46295 this_arg_conv.is_owned = false;
46296 LDKCVec_PublicKeyZ intermediate_nodes_constr;
46297 intermediate_nodes_constr.datalen = intermediate_nodes->arr_len;
46298 if (intermediate_nodes_constr.datalen > 0)
46299 intermediate_nodes_constr.data = MALLOC(intermediate_nodes_constr.datalen * sizeof(LDKPublicKey), "LDKCVec_PublicKeyZ Elements");
46301 intermediate_nodes_constr.data = NULL;
46302 int8_tArray* intermediate_nodes_vals = (void*) intermediate_nodes->elems;
46303 for (size_t m = 0; m < intermediate_nodes_constr.datalen; m++) {
46304 int8_tArray intermediate_nodes_conv_12 = intermediate_nodes_vals[m];
46305 LDKPublicKey intermediate_nodes_conv_12_ref;
46306 CHECK(intermediate_nodes_conv_12->arr_len == 33);
46307 memcpy(intermediate_nodes_conv_12_ref.compressed_form, intermediate_nodes_conv_12->elems, 33); FREE(intermediate_nodes_conv_12);
46308 intermediate_nodes_constr.data[m] = intermediate_nodes_conv_12_ref;
46310 FREE(intermediate_nodes);
46311 void* destination_ptr = untag_ptr(destination);
46312 CHECK_ACCESS(destination_ptr);
46313 LDKDestination destination_conv = *(LDKDestination*)(destination_ptr);
46314 destination_conv = Destination_clone((LDKDestination*)untag_ptr(destination));
46315 void* message_ptr = untag_ptr(message);
46316 CHECK_ACCESS(message_ptr);
46317 LDKOnionMessageContents message_conv = *(LDKOnionMessageContents*)(message_ptr);
46318 message_conv = OnionMessageContents_clone((LDKOnionMessageContents*)untag_ptr(message));
46319 LDKBlindedPath reply_path_conv;
46320 reply_path_conv.inner = untag_ptr(reply_path);
46321 reply_path_conv.is_owned = ptr_is_owned(reply_path);
46322 CHECK_INNER_FIELD_ACCESS_OR_NULL(reply_path_conv);
46323 reply_path_conv = BlindedPath_clone(&reply_path_conv);
46324 LDKCResult_NoneSendErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSendErrorZ), "LDKCResult_NoneSendErrorZ");
46325 *ret_conv = OnionMessenger_send_onion_message(&this_arg_conv, intermediate_nodes_constr, destination_conv, message_conv, reply_path_conv);
46326 return tag_ptr(ret_conv, true);
46329 uint64_t __attribute__((export_name("TS_OnionMessenger_as_OnionMessageHandler"))) TS_OnionMessenger_as_OnionMessageHandler(uint64_t this_arg) {
46330 LDKOnionMessenger this_arg_conv;
46331 this_arg_conv.inner = untag_ptr(this_arg);
46332 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46333 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46334 this_arg_conv.is_owned = false;
46335 LDKOnionMessageHandler* ret_ret = MALLOC(sizeof(LDKOnionMessageHandler), "LDKOnionMessageHandler");
46336 *ret_ret = OnionMessenger_as_OnionMessageHandler(&this_arg_conv);
46337 return tag_ptr(ret_ret, true);
46340 uint64_t __attribute__((export_name("TS_OnionMessenger_as_OnionMessageProvider"))) TS_OnionMessenger_as_OnionMessageProvider(uint64_t this_arg) {
46341 LDKOnionMessenger this_arg_conv;
46342 this_arg_conv.inner = untag_ptr(this_arg);
46343 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46344 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46345 this_arg_conv.is_owned = false;
46346 LDKOnionMessageProvider* ret_ret = MALLOC(sizeof(LDKOnionMessageProvider), "LDKOnionMessageProvider");
46347 *ret_ret = OnionMessenger_as_OnionMessageProvider(&this_arg_conv);
46348 return tag_ptr(ret_ret, true);
46351 void __attribute__((export_name("TS_OnionMessageContents_free"))) TS_OnionMessageContents_free(uint64_t this_ptr) {
46352 if (!ptr_is_owned(this_ptr)) return;
46353 void* this_ptr_ptr = untag_ptr(this_ptr);
46354 CHECK_ACCESS(this_ptr_ptr);
46355 LDKOnionMessageContents this_ptr_conv = *(LDKOnionMessageContents*)(this_ptr_ptr);
46356 FREE(untag_ptr(this_ptr));
46357 OnionMessageContents_free(this_ptr_conv);
46360 static inline uint64_t OnionMessageContents_clone_ptr(LDKOnionMessageContents *NONNULL_PTR arg) {
46361 LDKOnionMessageContents *ret_copy = MALLOC(sizeof(LDKOnionMessageContents), "LDKOnionMessageContents");
46362 *ret_copy = OnionMessageContents_clone(arg);
46363 uint64_t ret_ref = tag_ptr(ret_copy, true);
46366 int64_t __attribute__((export_name("TS_OnionMessageContents_clone_ptr"))) TS_OnionMessageContents_clone_ptr(uint64_t arg) {
46367 LDKOnionMessageContents* arg_conv = (LDKOnionMessageContents*)untag_ptr(arg);
46368 int64_t ret_conv = OnionMessageContents_clone_ptr(arg_conv);
46372 uint64_t __attribute__((export_name("TS_OnionMessageContents_clone"))) TS_OnionMessageContents_clone(uint64_t orig) {
46373 LDKOnionMessageContents* orig_conv = (LDKOnionMessageContents*)untag_ptr(orig);
46374 LDKOnionMessageContents *ret_copy = MALLOC(sizeof(LDKOnionMessageContents), "LDKOnionMessageContents");
46375 *ret_copy = OnionMessageContents_clone(orig_conv);
46376 uint64_t ret_ref = tag_ptr(ret_copy, true);
46380 uint64_t __attribute__((export_name("TS_OnionMessageContents_custom"))) TS_OnionMessageContents_custom(uint64_t a) {
46381 void* a_ptr = untag_ptr(a);
46382 CHECK_ACCESS(a_ptr);
46383 LDKCustomOnionMessageContents a_conv = *(LDKCustomOnionMessageContents*)(a_ptr);
46384 if (a_conv.free == LDKCustomOnionMessageContents_JCalls_free) {
46385 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
46386 LDKCustomOnionMessageContents_JCalls_cloned(&a_conv);
46388 LDKOnionMessageContents *ret_copy = MALLOC(sizeof(LDKOnionMessageContents), "LDKOnionMessageContents");
46389 *ret_copy = OnionMessageContents_custom(a_conv);
46390 uint64_t ret_ref = tag_ptr(ret_copy, true);
46394 static inline uint64_t CustomOnionMessageContents_clone_ptr(LDKCustomOnionMessageContents *NONNULL_PTR arg) {
46395 LDKCustomOnionMessageContents* ret_ret = MALLOC(sizeof(LDKCustomOnionMessageContents), "LDKCustomOnionMessageContents");
46396 *ret_ret = CustomOnionMessageContents_clone(arg);
46397 return tag_ptr(ret_ret, true);
46399 int64_t __attribute__((export_name("TS_CustomOnionMessageContents_clone_ptr"))) TS_CustomOnionMessageContents_clone_ptr(uint64_t arg) {
46400 void* arg_ptr = untag_ptr(arg);
46401 if (ptr_is_owned(arg)) { CHECK_ACCESS(arg_ptr); }
46402 LDKCustomOnionMessageContents* arg_conv = (LDKCustomOnionMessageContents*)arg_ptr;
46403 int64_t ret_conv = CustomOnionMessageContents_clone_ptr(arg_conv);
46407 uint64_t __attribute__((export_name("TS_CustomOnionMessageContents_clone"))) TS_CustomOnionMessageContents_clone(uint64_t orig) {
46408 void* orig_ptr = untag_ptr(orig);
46409 if (ptr_is_owned(orig)) { CHECK_ACCESS(orig_ptr); }
46410 LDKCustomOnionMessageContents* orig_conv = (LDKCustomOnionMessageContents*)orig_ptr;
46411 LDKCustomOnionMessageContents* ret_ret = MALLOC(sizeof(LDKCustomOnionMessageContents), "LDKCustomOnionMessageContents");
46412 *ret_ret = CustomOnionMessageContents_clone(orig_conv);
46413 return tag_ptr(ret_ret, true);
46416 void __attribute__((export_name("TS_CustomOnionMessageContents_free"))) TS_CustomOnionMessageContents_free(uint64_t this_ptr) {
46417 if (!ptr_is_owned(this_ptr)) return;
46418 void* this_ptr_ptr = untag_ptr(this_ptr);
46419 CHECK_ACCESS(this_ptr_ptr);
46420 LDKCustomOnionMessageContents this_ptr_conv = *(LDKCustomOnionMessageContents*)(this_ptr_ptr);
46421 FREE(untag_ptr(this_ptr));
46422 CustomOnionMessageContents_free(this_ptr_conv);
46425 void __attribute__((export_name("TS_RapidGossipSync_free"))) TS_RapidGossipSync_free(uint64_t this_obj) {
46426 LDKRapidGossipSync this_obj_conv;
46427 this_obj_conv.inner = untag_ptr(this_obj);
46428 this_obj_conv.is_owned = ptr_is_owned(this_obj);
46429 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
46430 RapidGossipSync_free(this_obj_conv);
46433 uint64_t __attribute__((export_name("TS_RapidGossipSync_new"))) TS_RapidGossipSync_new(uint64_t network_graph) {
46434 LDKNetworkGraph network_graph_conv;
46435 network_graph_conv.inner = untag_ptr(network_graph);
46436 network_graph_conv.is_owned = ptr_is_owned(network_graph);
46437 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
46438 network_graph_conv.is_owned = false;
46439 LDKRapidGossipSync ret_var = RapidGossipSync_new(&network_graph_conv);
46440 uint64_t ret_ref = 0;
46441 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46442 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46446 uint64_t __attribute__((export_name("TS_RapidGossipSync_update_network_graph"))) TS_RapidGossipSync_update_network_graph(uint64_t this_arg, int8_tArray update_data) {
46447 LDKRapidGossipSync this_arg_conv;
46448 this_arg_conv.inner = untag_ptr(this_arg);
46449 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46450 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46451 this_arg_conv.is_owned = false;
46452 LDKu8slice update_data_ref;
46453 update_data_ref.datalen = update_data->arr_len;
46454 update_data_ref.data = update_data->elems;
46455 LDKCResult_u32GraphSyncErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_u32GraphSyncErrorZ), "LDKCResult_u32GraphSyncErrorZ");
46456 *ret_conv = RapidGossipSync_update_network_graph(&this_arg_conv, update_data_ref);
46458 return tag_ptr(ret_conv, true);
46461 jboolean __attribute__((export_name("TS_RapidGossipSync_is_initial_sync_complete"))) TS_RapidGossipSync_is_initial_sync_complete(uint64_t this_arg) {
46462 LDKRapidGossipSync this_arg_conv;
46463 this_arg_conv.inner = untag_ptr(this_arg);
46464 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46465 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46466 this_arg_conv.is_owned = false;
46467 jboolean ret_conv = RapidGossipSync_is_initial_sync_complete(&this_arg_conv);
46471 void __attribute__((export_name("TS_GraphSyncError_free"))) TS_GraphSyncError_free(uint64_t this_ptr) {
46472 if (!ptr_is_owned(this_ptr)) return;
46473 void* this_ptr_ptr = untag_ptr(this_ptr);
46474 CHECK_ACCESS(this_ptr_ptr);
46475 LDKGraphSyncError this_ptr_conv = *(LDKGraphSyncError*)(this_ptr_ptr);
46476 FREE(untag_ptr(this_ptr));
46477 GraphSyncError_free(this_ptr_conv);
46480 static inline uint64_t GraphSyncError_clone_ptr(LDKGraphSyncError *NONNULL_PTR arg) {
46481 LDKGraphSyncError *ret_copy = MALLOC(sizeof(LDKGraphSyncError), "LDKGraphSyncError");
46482 *ret_copy = GraphSyncError_clone(arg);
46483 uint64_t ret_ref = tag_ptr(ret_copy, true);
46486 int64_t __attribute__((export_name("TS_GraphSyncError_clone_ptr"))) TS_GraphSyncError_clone_ptr(uint64_t arg) {
46487 LDKGraphSyncError* arg_conv = (LDKGraphSyncError*)untag_ptr(arg);
46488 int64_t ret_conv = GraphSyncError_clone_ptr(arg_conv);
46492 uint64_t __attribute__((export_name("TS_GraphSyncError_clone"))) TS_GraphSyncError_clone(uint64_t orig) {
46493 LDKGraphSyncError* orig_conv = (LDKGraphSyncError*)untag_ptr(orig);
46494 LDKGraphSyncError *ret_copy = MALLOC(sizeof(LDKGraphSyncError), "LDKGraphSyncError");
46495 *ret_copy = GraphSyncError_clone(orig_conv);
46496 uint64_t ret_ref = tag_ptr(ret_copy, true);
46500 uint64_t __attribute__((export_name("TS_GraphSyncError_decode_error"))) TS_GraphSyncError_decode_error(uint64_t a) {
46501 void* a_ptr = untag_ptr(a);
46502 CHECK_ACCESS(a_ptr);
46503 LDKDecodeError a_conv = *(LDKDecodeError*)(a_ptr);
46504 a_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(a));
46505 LDKGraphSyncError *ret_copy = MALLOC(sizeof(LDKGraphSyncError), "LDKGraphSyncError");
46506 *ret_copy = GraphSyncError_decode_error(a_conv);
46507 uint64_t ret_ref = tag_ptr(ret_copy, true);
46511 uint64_t __attribute__((export_name("TS_GraphSyncError_lightning_error"))) TS_GraphSyncError_lightning_error(uint64_t a) {
46512 LDKLightningError a_conv;
46513 a_conv.inner = untag_ptr(a);
46514 a_conv.is_owned = ptr_is_owned(a);
46515 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
46516 a_conv = LightningError_clone(&a_conv);
46517 LDKGraphSyncError *ret_copy = MALLOC(sizeof(LDKGraphSyncError), "LDKGraphSyncError");
46518 *ret_copy = GraphSyncError_lightning_error(a_conv);
46519 uint64_t ret_ref = tag_ptr(ret_copy, true);
46523 void __attribute__((export_name("TS_ParseError_free"))) TS_ParseError_free(uint64_t this_ptr) {
46524 if (!ptr_is_owned(this_ptr)) return;
46525 void* this_ptr_ptr = untag_ptr(this_ptr);
46526 CHECK_ACCESS(this_ptr_ptr);
46527 LDKParseError this_ptr_conv = *(LDKParseError*)(this_ptr_ptr);
46528 FREE(untag_ptr(this_ptr));
46529 ParseError_free(this_ptr_conv);
46532 static inline uint64_t ParseError_clone_ptr(LDKParseError *NONNULL_PTR arg) {
46533 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
46534 *ret_copy = ParseError_clone(arg);
46535 uint64_t ret_ref = tag_ptr(ret_copy, true);
46538 int64_t __attribute__((export_name("TS_ParseError_clone_ptr"))) TS_ParseError_clone_ptr(uint64_t arg) {
46539 LDKParseError* arg_conv = (LDKParseError*)untag_ptr(arg);
46540 int64_t ret_conv = ParseError_clone_ptr(arg_conv);
46544 uint64_t __attribute__((export_name("TS_ParseError_clone"))) TS_ParseError_clone(uint64_t orig) {
46545 LDKParseError* orig_conv = (LDKParseError*)untag_ptr(orig);
46546 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
46547 *ret_copy = ParseError_clone(orig_conv);
46548 uint64_t ret_ref = tag_ptr(ret_copy, true);
46552 uint64_t __attribute__((export_name("TS_ParseError_bech32_error"))) TS_ParseError_bech32_error(uint64_t a) {
46553 void* a_ptr = untag_ptr(a);
46554 CHECK_ACCESS(a_ptr);
46555 LDKBech32Error a_conv = *(LDKBech32Error*)(a_ptr);
46556 a_conv = Bech32Error_clone((LDKBech32Error*)untag_ptr(a));
46557 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
46558 *ret_copy = ParseError_bech32_error(a_conv);
46559 uint64_t ret_ref = tag_ptr(ret_copy, true);
46563 uint64_t __attribute__((export_name("TS_ParseError_parse_amount_error"))) TS_ParseError_parse_amount_error(int32_t a) {
46565 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
46566 *ret_copy = ParseError_parse_amount_error((LDKError){ ._dummy = 0 });
46567 uint64_t ret_ref = tag_ptr(ret_copy, true);
46571 uint64_t __attribute__((export_name("TS_ParseError_malformed_signature"))) TS_ParseError_malformed_signature(uint32_t a) {
46572 LDKSecp256k1Error a_conv = LDKSecp256k1Error_from_js(a);
46573 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
46574 *ret_copy = ParseError_malformed_signature(a_conv);
46575 uint64_t ret_ref = tag_ptr(ret_copy, true);
46579 uint64_t __attribute__((export_name("TS_ParseError_bad_prefix"))) TS_ParseError_bad_prefix() {
46580 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
46581 *ret_copy = ParseError_bad_prefix();
46582 uint64_t ret_ref = tag_ptr(ret_copy, true);
46586 uint64_t __attribute__((export_name("TS_ParseError_unknown_currency"))) TS_ParseError_unknown_currency() {
46587 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
46588 *ret_copy = ParseError_unknown_currency();
46589 uint64_t ret_ref = tag_ptr(ret_copy, true);
46593 uint64_t __attribute__((export_name("TS_ParseError_unknown_si_prefix"))) TS_ParseError_unknown_si_prefix() {
46594 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
46595 *ret_copy = ParseError_unknown_si_prefix();
46596 uint64_t ret_ref = tag_ptr(ret_copy, true);
46600 uint64_t __attribute__((export_name("TS_ParseError_malformed_hrp"))) TS_ParseError_malformed_hrp() {
46601 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
46602 *ret_copy = ParseError_malformed_hrp();
46603 uint64_t ret_ref = tag_ptr(ret_copy, true);
46607 uint64_t __attribute__((export_name("TS_ParseError_too_short_data_part"))) TS_ParseError_too_short_data_part() {
46608 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
46609 *ret_copy = ParseError_too_short_data_part();
46610 uint64_t ret_ref = tag_ptr(ret_copy, true);
46614 uint64_t __attribute__((export_name("TS_ParseError_unexpected_end_of_tagged_fields"))) TS_ParseError_unexpected_end_of_tagged_fields() {
46615 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
46616 *ret_copy = ParseError_unexpected_end_of_tagged_fields();
46617 uint64_t ret_ref = tag_ptr(ret_copy, true);
46621 uint64_t __attribute__((export_name("TS_ParseError_description_decode_error"))) TS_ParseError_description_decode_error(int32_t a) {
46623 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
46624 *ret_copy = ParseError_description_decode_error((LDKError){ ._dummy = 0 });
46625 uint64_t ret_ref = tag_ptr(ret_copy, true);
46629 uint64_t __attribute__((export_name("TS_ParseError_padding_error"))) TS_ParseError_padding_error() {
46630 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
46631 *ret_copy = ParseError_padding_error();
46632 uint64_t ret_ref = tag_ptr(ret_copy, true);
46636 uint64_t __attribute__((export_name("TS_ParseError_integer_overflow_error"))) TS_ParseError_integer_overflow_error() {
46637 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
46638 *ret_copy = ParseError_integer_overflow_error();
46639 uint64_t ret_ref = tag_ptr(ret_copy, true);
46643 uint64_t __attribute__((export_name("TS_ParseError_invalid_seg_wit_program_length"))) TS_ParseError_invalid_seg_wit_program_length() {
46644 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
46645 *ret_copy = ParseError_invalid_seg_wit_program_length();
46646 uint64_t ret_ref = tag_ptr(ret_copy, true);
46650 uint64_t __attribute__((export_name("TS_ParseError_invalid_pub_key_hash_length"))) TS_ParseError_invalid_pub_key_hash_length() {
46651 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
46652 *ret_copy = ParseError_invalid_pub_key_hash_length();
46653 uint64_t ret_ref = tag_ptr(ret_copy, true);
46657 uint64_t __attribute__((export_name("TS_ParseError_invalid_script_hash_length"))) TS_ParseError_invalid_script_hash_length() {
46658 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
46659 *ret_copy = ParseError_invalid_script_hash_length();
46660 uint64_t ret_ref = tag_ptr(ret_copy, true);
46664 uint64_t __attribute__((export_name("TS_ParseError_invalid_recovery_id"))) TS_ParseError_invalid_recovery_id() {
46665 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
46666 *ret_copy = ParseError_invalid_recovery_id();
46667 uint64_t ret_ref = tag_ptr(ret_copy, true);
46671 uint64_t __attribute__((export_name("TS_ParseError_invalid_slice_length"))) TS_ParseError_invalid_slice_length(jstring a) {
46672 LDKStr a_conv = str_ref_to_owned_c(a);
46673 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
46674 *ret_copy = ParseError_invalid_slice_length(a_conv);
46675 uint64_t ret_ref = tag_ptr(ret_copy, true);
46679 uint64_t __attribute__((export_name("TS_ParseError_skip"))) TS_ParseError_skip() {
46680 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
46681 *ret_copy = ParseError_skip();
46682 uint64_t ret_ref = tag_ptr(ret_copy, true);
46686 jboolean __attribute__((export_name("TS_ParseError_eq"))) TS_ParseError_eq(uint64_t a, uint64_t b) {
46687 LDKParseError* a_conv = (LDKParseError*)untag_ptr(a);
46688 LDKParseError* b_conv = (LDKParseError*)untag_ptr(b);
46689 jboolean ret_conv = ParseError_eq(a_conv, b_conv);
46693 void __attribute__((export_name("TS_ParseOrSemanticError_free"))) TS_ParseOrSemanticError_free(uint64_t this_ptr) {
46694 if (!ptr_is_owned(this_ptr)) return;
46695 void* this_ptr_ptr = untag_ptr(this_ptr);
46696 CHECK_ACCESS(this_ptr_ptr);
46697 LDKParseOrSemanticError this_ptr_conv = *(LDKParseOrSemanticError*)(this_ptr_ptr);
46698 FREE(untag_ptr(this_ptr));
46699 ParseOrSemanticError_free(this_ptr_conv);
46702 static inline uint64_t ParseOrSemanticError_clone_ptr(LDKParseOrSemanticError *NONNULL_PTR arg) {
46703 LDKParseOrSemanticError *ret_copy = MALLOC(sizeof(LDKParseOrSemanticError), "LDKParseOrSemanticError");
46704 *ret_copy = ParseOrSemanticError_clone(arg);
46705 uint64_t ret_ref = tag_ptr(ret_copy, true);
46708 int64_t __attribute__((export_name("TS_ParseOrSemanticError_clone_ptr"))) TS_ParseOrSemanticError_clone_ptr(uint64_t arg) {
46709 LDKParseOrSemanticError* arg_conv = (LDKParseOrSemanticError*)untag_ptr(arg);
46710 int64_t ret_conv = ParseOrSemanticError_clone_ptr(arg_conv);
46714 uint64_t __attribute__((export_name("TS_ParseOrSemanticError_clone"))) TS_ParseOrSemanticError_clone(uint64_t orig) {
46715 LDKParseOrSemanticError* orig_conv = (LDKParseOrSemanticError*)untag_ptr(orig);
46716 LDKParseOrSemanticError *ret_copy = MALLOC(sizeof(LDKParseOrSemanticError), "LDKParseOrSemanticError");
46717 *ret_copy = ParseOrSemanticError_clone(orig_conv);
46718 uint64_t ret_ref = tag_ptr(ret_copy, true);
46722 uint64_t __attribute__((export_name("TS_ParseOrSemanticError_parse_error"))) TS_ParseOrSemanticError_parse_error(uint64_t a) {
46723 void* a_ptr = untag_ptr(a);
46724 CHECK_ACCESS(a_ptr);
46725 LDKParseError a_conv = *(LDKParseError*)(a_ptr);
46726 a_conv = ParseError_clone((LDKParseError*)untag_ptr(a));
46727 LDKParseOrSemanticError *ret_copy = MALLOC(sizeof(LDKParseOrSemanticError), "LDKParseOrSemanticError");
46728 *ret_copy = ParseOrSemanticError_parse_error(a_conv);
46729 uint64_t ret_ref = tag_ptr(ret_copy, true);
46733 uint64_t __attribute__((export_name("TS_ParseOrSemanticError_semantic_error"))) TS_ParseOrSemanticError_semantic_error(uint32_t a) {
46734 LDKSemanticError a_conv = LDKSemanticError_from_js(a);
46735 LDKParseOrSemanticError *ret_copy = MALLOC(sizeof(LDKParseOrSemanticError), "LDKParseOrSemanticError");
46736 *ret_copy = ParseOrSemanticError_semantic_error(a_conv);
46737 uint64_t ret_ref = tag_ptr(ret_copy, true);
46741 jboolean __attribute__((export_name("TS_ParseOrSemanticError_eq"))) TS_ParseOrSemanticError_eq(uint64_t a, uint64_t b) {
46742 LDKParseOrSemanticError* a_conv = (LDKParseOrSemanticError*)untag_ptr(a);
46743 LDKParseOrSemanticError* b_conv = (LDKParseOrSemanticError*)untag_ptr(b);
46744 jboolean ret_conv = ParseOrSemanticError_eq(a_conv, b_conv);
46748 void __attribute__((export_name("TS_Invoice_free"))) TS_Invoice_free(uint64_t this_obj) {
46749 LDKInvoice this_obj_conv;
46750 this_obj_conv.inner = untag_ptr(this_obj);
46751 this_obj_conv.is_owned = ptr_is_owned(this_obj);
46752 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
46753 Invoice_free(this_obj_conv);
46756 jboolean __attribute__((export_name("TS_Invoice_eq"))) TS_Invoice_eq(uint64_t a, uint64_t b) {
46758 a_conv.inner = untag_ptr(a);
46759 a_conv.is_owned = ptr_is_owned(a);
46760 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
46761 a_conv.is_owned = false;
46763 b_conv.inner = untag_ptr(b);
46764 b_conv.is_owned = ptr_is_owned(b);
46765 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
46766 b_conv.is_owned = false;
46767 jboolean ret_conv = Invoice_eq(&a_conv, &b_conv);
46771 static inline uint64_t Invoice_clone_ptr(LDKInvoice *NONNULL_PTR arg) {
46772 LDKInvoice ret_var = Invoice_clone(arg);
46773 uint64_t ret_ref = 0;
46774 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46775 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46778 int64_t __attribute__((export_name("TS_Invoice_clone_ptr"))) TS_Invoice_clone_ptr(uint64_t arg) {
46779 LDKInvoice arg_conv;
46780 arg_conv.inner = untag_ptr(arg);
46781 arg_conv.is_owned = ptr_is_owned(arg);
46782 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
46783 arg_conv.is_owned = false;
46784 int64_t ret_conv = Invoice_clone_ptr(&arg_conv);
46788 uint64_t __attribute__((export_name("TS_Invoice_clone"))) TS_Invoice_clone(uint64_t orig) {
46789 LDKInvoice orig_conv;
46790 orig_conv.inner = untag_ptr(orig);
46791 orig_conv.is_owned = ptr_is_owned(orig);
46792 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
46793 orig_conv.is_owned = false;
46794 LDKInvoice ret_var = Invoice_clone(&orig_conv);
46795 uint64_t ret_ref = 0;
46796 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46797 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46801 int64_t __attribute__((export_name("TS_Invoice_hash"))) TS_Invoice_hash(uint64_t o) {
46803 o_conv.inner = untag_ptr(o);
46804 o_conv.is_owned = ptr_is_owned(o);
46805 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
46806 o_conv.is_owned = false;
46807 int64_t ret_conv = Invoice_hash(&o_conv);
46811 void __attribute__((export_name("TS_SignedRawInvoice_free"))) TS_SignedRawInvoice_free(uint64_t this_obj) {
46812 LDKSignedRawInvoice this_obj_conv;
46813 this_obj_conv.inner = untag_ptr(this_obj);
46814 this_obj_conv.is_owned = ptr_is_owned(this_obj);
46815 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
46816 SignedRawInvoice_free(this_obj_conv);
46819 jboolean __attribute__((export_name("TS_SignedRawInvoice_eq"))) TS_SignedRawInvoice_eq(uint64_t a, uint64_t b) {
46820 LDKSignedRawInvoice a_conv;
46821 a_conv.inner = untag_ptr(a);
46822 a_conv.is_owned = ptr_is_owned(a);
46823 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
46824 a_conv.is_owned = false;
46825 LDKSignedRawInvoice b_conv;
46826 b_conv.inner = untag_ptr(b);
46827 b_conv.is_owned = ptr_is_owned(b);
46828 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
46829 b_conv.is_owned = false;
46830 jboolean ret_conv = SignedRawInvoice_eq(&a_conv, &b_conv);
46834 static inline uint64_t SignedRawInvoice_clone_ptr(LDKSignedRawInvoice *NONNULL_PTR arg) {
46835 LDKSignedRawInvoice ret_var = SignedRawInvoice_clone(arg);
46836 uint64_t ret_ref = 0;
46837 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46838 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46841 int64_t __attribute__((export_name("TS_SignedRawInvoice_clone_ptr"))) TS_SignedRawInvoice_clone_ptr(uint64_t arg) {
46842 LDKSignedRawInvoice arg_conv;
46843 arg_conv.inner = untag_ptr(arg);
46844 arg_conv.is_owned = ptr_is_owned(arg);
46845 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
46846 arg_conv.is_owned = false;
46847 int64_t ret_conv = SignedRawInvoice_clone_ptr(&arg_conv);
46851 uint64_t __attribute__((export_name("TS_SignedRawInvoice_clone"))) TS_SignedRawInvoice_clone(uint64_t orig) {
46852 LDKSignedRawInvoice orig_conv;
46853 orig_conv.inner = untag_ptr(orig);
46854 orig_conv.is_owned = ptr_is_owned(orig);
46855 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
46856 orig_conv.is_owned = false;
46857 LDKSignedRawInvoice ret_var = SignedRawInvoice_clone(&orig_conv);
46858 uint64_t ret_ref = 0;
46859 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46860 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46864 int64_t __attribute__((export_name("TS_SignedRawInvoice_hash"))) TS_SignedRawInvoice_hash(uint64_t o) {
46865 LDKSignedRawInvoice o_conv;
46866 o_conv.inner = untag_ptr(o);
46867 o_conv.is_owned = ptr_is_owned(o);
46868 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
46869 o_conv.is_owned = false;
46870 int64_t ret_conv = SignedRawInvoice_hash(&o_conv);
46874 void __attribute__((export_name("TS_RawInvoice_free"))) TS_RawInvoice_free(uint64_t this_obj) {
46875 LDKRawInvoice this_obj_conv;
46876 this_obj_conv.inner = untag_ptr(this_obj);
46877 this_obj_conv.is_owned = ptr_is_owned(this_obj);
46878 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
46879 RawInvoice_free(this_obj_conv);
46882 uint64_t __attribute__((export_name("TS_RawInvoice_get_data"))) TS_RawInvoice_get_data(uint64_t this_ptr) {
46883 LDKRawInvoice this_ptr_conv;
46884 this_ptr_conv.inner = untag_ptr(this_ptr);
46885 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46886 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46887 this_ptr_conv.is_owned = false;
46888 LDKRawDataPart ret_var = RawInvoice_get_data(&this_ptr_conv);
46889 uint64_t ret_ref = 0;
46890 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46891 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46895 void __attribute__((export_name("TS_RawInvoice_set_data"))) TS_RawInvoice_set_data(uint64_t this_ptr, uint64_t val) {
46896 LDKRawInvoice this_ptr_conv;
46897 this_ptr_conv.inner = untag_ptr(this_ptr);
46898 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46899 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46900 this_ptr_conv.is_owned = false;
46901 LDKRawDataPart val_conv;
46902 val_conv.inner = untag_ptr(val);
46903 val_conv.is_owned = ptr_is_owned(val);
46904 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
46905 val_conv = RawDataPart_clone(&val_conv);
46906 RawInvoice_set_data(&this_ptr_conv, val_conv);
46909 jboolean __attribute__((export_name("TS_RawInvoice_eq"))) TS_RawInvoice_eq(uint64_t a, uint64_t b) {
46910 LDKRawInvoice a_conv;
46911 a_conv.inner = untag_ptr(a);
46912 a_conv.is_owned = ptr_is_owned(a);
46913 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
46914 a_conv.is_owned = false;
46915 LDKRawInvoice b_conv;
46916 b_conv.inner = untag_ptr(b);
46917 b_conv.is_owned = ptr_is_owned(b);
46918 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
46919 b_conv.is_owned = false;
46920 jboolean ret_conv = RawInvoice_eq(&a_conv, &b_conv);
46924 static inline uint64_t RawInvoice_clone_ptr(LDKRawInvoice *NONNULL_PTR arg) {
46925 LDKRawInvoice ret_var = RawInvoice_clone(arg);
46926 uint64_t ret_ref = 0;
46927 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46928 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46931 int64_t __attribute__((export_name("TS_RawInvoice_clone_ptr"))) TS_RawInvoice_clone_ptr(uint64_t arg) {
46932 LDKRawInvoice arg_conv;
46933 arg_conv.inner = untag_ptr(arg);
46934 arg_conv.is_owned = ptr_is_owned(arg);
46935 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
46936 arg_conv.is_owned = false;
46937 int64_t ret_conv = RawInvoice_clone_ptr(&arg_conv);
46941 uint64_t __attribute__((export_name("TS_RawInvoice_clone"))) TS_RawInvoice_clone(uint64_t orig) {
46942 LDKRawInvoice orig_conv;
46943 orig_conv.inner = untag_ptr(orig);
46944 orig_conv.is_owned = ptr_is_owned(orig);
46945 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
46946 orig_conv.is_owned = false;
46947 LDKRawInvoice ret_var = RawInvoice_clone(&orig_conv);
46948 uint64_t ret_ref = 0;
46949 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46950 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46954 int64_t __attribute__((export_name("TS_RawInvoice_hash"))) TS_RawInvoice_hash(uint64_t o) {
46955 LDKRawInvoice o_conv;
46956 o_conv.inner = untag_ptr(o);
46957 o_conv.is_owned = ptr_is_owned(o);
46958 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
46959 o_conv.is_owned = false;
46960 int64_t ret_conv = RawInvoice_hash(&o_conv);
46964 void __attribute__((export_name("TS_RawDataPart_free"))) TS_RawDataPart_free(uint64_t this_obj) {
46965 LDKRawDataPart this_obj_conv;
46966 this_obj_conv.inner = untag_ptr(this_obj);
46967 this_obj_conv.is_owned = ptr_is_owned(this_obj);
46968 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
46969 RawDataPart_free(this_obj_conv);
46972 uint64_t __attribute__((export_name("TS_RawDataPart_get_timestamp"))) TS_RawDataPart_get_timestamp(uint64_t this_ptr) {
46973 LDKRawDataPart this_ptr_conv;
46974 this_ptr_conv.inner = untag_ptr(this_ptr);
46975 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46976 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46977 this_ptr_conv.is_owned = false;
46978 LDKPositiveTimestamp ret_var = RawDataPart_get_timestamp(&this_ptr_conv);
46979 uint64_t ret_ref = 0;
46980 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46981 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46985 void __attribute__((export_name("TS_RawDataPart_set_timestamp"))) TS_RawDataPart_set_timestamp(uint64_t this_ptr, uint64_t val) {
46986 LDKRawDataPart this_ptr_conv;
46987 this_ptr_conv.inner = untag_ptr(this_ptr);
46988 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46989 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46990 this_ptr_conv.is_owned = false;
46991 LDKPositiveTimestamp val_conv;
46992 val_conv.inner = untag_ptr(val);
46993 val_conv.is_owned = ptr_is_owned(val);
46994 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
46995 val_conv = PositiveTimestamp_clone(&val_conv);
46996 RawDataPart_set_timestamp(&this_ptr_conv, val_conv);
46999 jboolean __attribute__((export_name("TS_RawDataPart_eq"))) TS_RawDataPart_eq(uint64_t a, uint64_t b) {
47000 LDKRawDataPart a_conv;
47001 a_conv.inner = untag_ptr(a);
47002 a_conv.is_owned = ptr_is_owned(a);
47003 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
47004 a_conv.is_owned = false;
47005 LDKRawDataPart b_conv;
47006 b_conv.inner = untag_ptr(b);
47007 b_conv.is_owned = ptr_is_owned(b);
47008 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
47009 b_conv.is_owned = false;
47010 jboolean ret_conv = RawDataPart_eq(&a_conv, &b_conv);
47014 static inline uint64_t RawDataPart_clone_ptr(LDKRawDataPart *NONNULL_PTR arg) {
47015 LDKRawDataPart ret_var = RawDataPart_clone(arg);
47016 uint64_t ret_ref = 0;
47017 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47018 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47021 int64_t __attribute__((export_name("TS_RawDataPart_clone_ptr"))) TS_RawDataPart_clone_ptr(uint64_t arg) {
47022 LDKRawDataPart arg_conv;
47023 arg_conv.inner = untag_ptr(arg);
47024 arg_conv.is_owned = ptr_is_owned(arg);
47025 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
47026 arg_conv.is_owned = false;
47027 int64_t ret_conv = RawDataPart_clone_ptr(&arg_conv);
47031 uint64_t __attribute__((export_name("TS_RawDataPart_clone"))) TS_RawDataPart_clone(uint64_t orig) {
47032 LDKRawDataPart orig_conv;
47033 orig_conv.inner = untag_ptr(orig);
47034 orig_conv.is_owned = ptr_is_owned(orig);
47035 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
47036 orig_conv.is_owned = false;
47037 LDKRawDataPart ret_var = RawDataPart_clone(&orig_conv);
47038 uint64_t ret_ref = 0;
47039 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47040 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47044 int64_t __attribute__((export_name("TS_RawDataPart_hash"))) TS_RawDataPart_hash(uint64_t o) {
47045 LDKRawDataPart o_conv;
47046 o_conv.inner = untag_ptr(o);
47047 o_conv.is_owned = ptr_is_owned(o);
47048 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
47049 o_conv.is_owned = false;
47050 int64_t ret_conv = RawDataPart_hash(&o_conv);
47054 void __attribute__((export_name("TS_PositiveTimestamp_free"))) TS_PositiveTimestamp_free(uint64_t this_obj) {
47055 LDKPositiveTimestamp this_obj_conv;
47056 this_obj_conv.inner = untag_ptr(this_obj);
47057 this_obj_conv.is_owned = ptr_is_owned(this_obj);
47058 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
47059 PositiveTimestamp_free(this_obj_conv);
47062 jboolean __attribute__((export_name("TS_PositiveTimestamp_eq"))) TS_PositiveTimestamp_eq(uint64_t a, uint64_t b) {
47063 LDKPositiveTimestamp a_conv;
47064 a_conv.inner = untag_ptr(a);
47065 a_conv.is_owned = ptr_is_owned(a);
47066 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
47067 a_conv.is_owned = false;
47068 LDKPositiveTimestamp b_conv;
47069 b_conv.inner = untag_ptr(b);
47070 b_conv.is_owned = ptr_is_owned(b);
47071 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
47072 b_conv.is_owned = false;
47073 jboolean ret_conv = PositiveTimestamp_eq(&a_conv, &b_conv);
47077 static inline uint64_t PositiveTimestamp_clone_ptr(LDKPositiveTimestamp *NONNULL_PTR arg) {
47078 LDKPositiveTimestamp ret_var = PositiveTimestamp_clone(arg);
47079 uint64_t ret_ref = 0;
47080 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47081 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47084 int64_t __attribute__((export_name("TS_PositiveTimestamp_clone_ptr"))) TS_PositiveTimestamp_clone_ptr(uint64_t arg) {
47085 LDKPositiveTimestamp arg_conv;
47086 arg_conv.inner = untag_ptr(arg);
47087 arg_conv.is_owned = ptr_is_owned(arg);
47088 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
47089 arg_conv.is_owned = false;
47090 int64_t ret_conv = PositiveTimestamp_clone_ptr(&arg_conv);
47094 uint64_t __attribute__((export_name("TS_PositiveTimestamp_clone"))) TS_PositiveTimestamp_clone(uint64_t orig) {
47095 LDKPositiveTimestamp orig_conv;
47096 orig_conv.inner = untag_ptr(orig);
47097 orig_conv.is_owned = ptr_is_owned(orig);
47098 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
47099 orig_conv.is_owned = false;
47100 LDKPositiveTimestamp ret_var = PositiveTimestamp_clone(&orig_conv);
47101 uint64_t ret_ref = 0;
47102 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47103 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47107 int64_t __attribute__((export_name("TS_PositiveTimestamp_hash"))) TS_PositiveTimestamp_hash(uint64_t o) {
47108 LDKPositiveTimestamp o_conv;
47109 o_conv.inner = untag_ptr(o);
47110 o_conv.is_owned = ptr_is_owned(o);
47111 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
47112 o_conv.is_owned = false;
47113 int64_t ret_conv = PositiveTimestamp_hash(&o_conv);
47117 uint32_t __attribute__((export_name("TS_SiPrefix_clone"))) TS_SiPrefix_clone(uint64_t orig) {
47118 LDKSiPrefix* orig_conv = (LDKSiPrefix*)untag_ptr(orig);
47119 uint32_t ret_conv = LDKSiPrefix_to_js(SiPrefix_clone(orig_conv));
47123 uint32_t __attribute__((export_name("TS_SiPrefix_milli"))) TS_SiPrefix_milli() {
47124 uint32_t ret_conv = LDKSiPrefix_to_js(SiPrefix_milli());
47128 uint32_t __attribute__((export_name("TS_SiPrefix_micro"))) TS_SiPrefix_micro() {
47129 uint32_t ret_conv = LDKSiPrefix_to_js(SiPrefix_micro());
47133 uint32_t __attribute__((export_name("TS_SiPrefix_nano"))) TS_SiPrefix_nano() {
47134 uint32_t ret_conv = LDKSiPrefix_to_js(SiPrefix_nano());
47138 uint32_t __attribute__((export_name("TS_SiPrefix_pico"))) TS_SiPrefix_pico() {
47139 uint32_t ret_conv = LDKSiPrefix_to_js(SiPrefix_pico());
47143 jboolean __attribute__((export_name("TS_SiPrefix_eq"))) TS_SiPrefix_eq(uint64_t a, uint64_t b) {
47144 LDKSiPrefix* a_conv = (LDKSiPrefix*)untag_ptr(a);
47145 LDKSiPrefix* b_conv = (LDKSiPrefix*)untag_ptr(b);
47146 jboolean ret_conv = SiPrefix_eq(a_conv, b_conv);
47150 int64_t __attribute__((export_name("TS_SiPrefix_hash"))) TS_SiPrefix_hash(uint64_t o) {
47151 LDKSiPrefix* o_conv = (LDKSiPrefix*)untag_ptr(o);
47152 int64_t ret_conv = SiPrefix_hash(o_conv);
47156 int64_t __attribute__((export_name("TS_SiPrefix_multiplier"))) TS_SiPrefix_multiplier(uint64_t this_arg) {
47157 LDKSiPrefix* this_arg_conv = (LDKSiPrefix*)untag_ptr(this_arg);
47158 int64_t ret_conv = SiPrefix_multiplier(this_arg_conv);
47162 uint32_t __attribute__((export_name("TS_Currency_clone"))) TS_Currency_clone(uint64_t orig) {
47163 LDKCurrency* orig_conv = (LDKCurrency*)untag_ptr(orig);
47164 uint32_t ret_conv = LDKCurrency_to_js(Currency_clone(orig_conv));
47168 uint32_t __attribute__((export_name("TS_Currency_bitcoin"))) TS_Currency_bitcoin() {
47169 uint32_t ret_conv = LDKCurrency_to_js(Currency_bitcoin());
47173 uint32_t __attribute__((export_name("TS_Currency_bitcoin_testnet"))) TS_Currency_bitcoin_testnet() {
47174 uint32_t ret_conv = LDKCurrency_to_js(Currency_bitcoin_testnet());
47178 uint32_t __attribute__((export_name("TS_Currency_regtest"))) TS_Currency_regtest() {
47179 uint32_t ret_conv = LDKCurrency_to_js(Currency_regtest());
47183 uint32_t __attribute__((export_name("TS_Currency_simnet"))) TS_Currency_simnet() {
47184 uint32_t ret_conv = LDKCurrency_to_js(Currency_simnet());
47188 uint32_t __attribute__((export_name("TS_Currency_signet"))) TS_Currency_signet() {
47189 uint32_t ret_conv = LDKCurrency_to_js(Currency_signet());
47193 int64_t __attribute__((export_name("TS_Currency_hash"))) TS_Currency_hash(uint64_t o) {
47194 LDKCurrency* o_conv = (LDKCurrency*)untag_ptr(o);
47195 int64_t ret_conv = Currency_hash(o_conv);
47199 jboolean __attribute__((export_name("TS_Currency_eq"))) TS_Currency_eq(uint64_t a, uint64_t b) {
47200 LDKCurrency* a_conv = (LDKCurrency*)untag_ptr(a);
47201 LDKCurrency* b_conv = (LDKCurrency*)untag_ptr(b);
47202 jboolean ret_conv = Currency_eq(a_conv, b_conv);
47206 void __attribute__((export_name("TS_Sha256_free"))) TS_Sha256_free(uint64_t this_obj) {
47207 LDKSha256 this_obj_conv;
47208 this_obj_conv.inner = untag_ptr(this_obj);
47209 this_obj_conv.is_owned = ptr_is_owned(this_obj);
47210 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
47211 Sha256_free(this_obj_conv);
47214 static inline uint64_t Sha256_clone_ptr(LDKSha256 *NONNULL_PTR arg) {
47215 LDKSha256 ret_var = Sha256_clone(arg);
47216 uint64_t ret_ref = 0;
47217 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47218 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47221 int64_t __attribute__((export_name("TS_Sha256_clone_ptr"))) TS_Sha256_clone_ptr(uint64_t arg) {
47222 LDKSha256 arg_conv;
47223 arg_conv.inner = untag_ptr(arg);
47224 arg_conv.is_owned = ptr_is_owned(arg);
47225 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
47226 arg_conv.is_owned = false;
47227 int64_t ret_conv = Sha256_clone_ptr(&arg_conv);
47231 uint64_t __attribute__((export_name("TS_Sha256_clone"))) TS_Sha256_clone(uint64_t orig) {
47232 LDKSha256 orig_conv;
47233 orig_conv.inner = untag_ptr(orig);
47234 orig_conv.is_owned = ptr_is_owned(orig);
47235 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
47236 orig_conv.is_owned = false;
47237 LDKSha256 ret_var = Sha256_clone(&orig_conv);
47238 uint64_t ret_ref = 0;
47239 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47240 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47244 int64_t __attribute__((export_name("TS_Sha256_hash"))) TS_Sha256_hash(uint64_t o) {
47246 o_conv.inner = untag_ptr(o);
47247 o_conv.is_owned = ptr_is_owned(o);
47248 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
47249 o_conv.is_owned = false;
47250 int64_t ret_conv = Sha256_hash(&o_conv);
47254 jboolean __attribute__((export_name("TS_Sha256_eq"))) TS_Sha256_eq(uint64_t a, uint64_t b) {
47256 a_conv.inner = untag_ptr(a);
47257 a_conv.is_owned = ptr_is_owned(a);
47258 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
47259 a_conv.is_owned = false;
47261 b_conv.inner = untag_ptr(b);
47262 b_conv.is_owned = ptr_is_owned(b);
47263 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
47264 b_conv.is_owned = false;
47265 jboolean ret_conv = Sha256_eq(&a_conv, &b_conv);
47269 void __attribute__((export_name("TS_Description_free"))) TS_Description_free(uint64_t this_obj) {
47270 LDKDescription this_obj_conv;
47271 this_obj_conv.inner = untag_ptr(this_obj);
47272 this_obj_conv.is_owned = ptr_is_owned(this_obj);
47273 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
47274 Description_free(this_obj_conv);
47277 static inline uint64_t Description_clone_ptr(LDKDescription *NONNULL_PTR arg) {
47278 LDKDescription ret_var = Description_clone(arg);
47279 uint64_t ret_ref = 0;
47280 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47281 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47284 int64_t __attribute__((export_name("TS_Description_clone_ptr"))) TS_Description_clone_ptr(uint64_t arg) {
47285 LDKDescription arg_conv;
47286 arg_conv.inner = untag_ptr(arg);
47287 arg_conv.is_owned = ptr_is_owned(arg);
47288 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
47289 arg_conv.is_owned = false;
47290 int64_t ret_conv = Description_clone_ptr(&arg_conv);
47294 uint64_t __attribute__((export_name("TS_Description_clone"))) TS_Description_clone(uint64_t orig) {
47295 LDKDescription orig_conv;
47296 orig_conv.inner = untag_ptr(orig);
47297 orig_conv.is_owned = ptr_is_owned(orig);
47298 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
47299 orig_conv.is_owned = false;
47300 LDKDescription ret_var = Description_clone(&orig_conv);
47301 uint64_t ret_ref = 0;
47302 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47303 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47307 int64_t __attribute__((export_name("TS_Description_hash"))) TS_Description_hash(uint64_t o) {
47308 LDKDescription o_conv;
47309 o_conv.inner = untag_ptr(o);
47310 o_conv.is_owned = ptr_is_owned(o);
47311 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
47312 o_conv.is_owned = false;
47313 int64_t ret_conv = Description_hash(&o_conv);
47317 jboolean __attribute__((export_name("TS_Description_eq"))) TS_Description_eq(uint64_t a, uint64_t b) {
47318 LDKDescription a_conv;
47319 a_conv.inner = untag_ptr(a);
47320 a_conv.is_owned = ptr_is_owned(a);
47321 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
47322 a_conv.is_owned = false;
47323 LDKDescription b_conv;
47324 b_conv.inner = untag_ptr(b);
47325 b_conv.is_owned = ptr_is_owned(b);
47326 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
47327 b_conv.is_owned = false;
47328 jboolean ret_conv = Description_eq(&a_conv, &b_conv);
47332 void __attribute__((export_name("TS_PayeePubKey_free"))) TS_PayeePubKey_free(uint64_t this_obj) {
47333 LDKPayeePubKey this_obj_conv;
47334 this_obj_conv.inner = untag_ptr(this_obj);
47335 this_obj_conv.is_owned = ptr_is_owned(this_obj);
47336 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
47337 PayeePubKey_free(this_obj_conv);
47340 int8_tArray __attribute__((export_name("TS_PayeePubKey_get_a"))) TS_PayeePubKey_get_a(uint64_t this_ptr) {
47341 LDKPayeePubKey this_ptr_conv;
47342 this_ptr_conv.inner = untag_ptr(this_ptr);
47343 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47344 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47345 this_ptr_conv.is_owned = false;
47346 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
47347 memcpy(ret_arr->elems, PayeePubKey_get_a(&this_ptr_conv).compressed_form, 33);
47351 void __attribute__((export_name("TS_PayeePubKey_set_a"))) TS_PayeePubKey_set_a(uint64_t this_ptr, int8_tArray val) {
47352 LDKPayeePubKey this_ptr_conv;
47353 this_ptr_conv.inner = untag_ptr(this_ptr);
47354 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47355 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47356 this_ptr_conv.is_owned = false;
47357 LDKPublicKey val_ref;
47358 CHECK(val->arr_len == 33);
47359 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
47360 PayeePubKey_set_a(&this_ptr_conv, val_ref);
47363 uint64_t __attribute__((export_name("TS_PayeePubKey_new"))) TS_PayeePubKey_new(int8_tArray a_arg) {
47364 LDKPublicKey a_arg_ref;
47365 CHECK(a_arg->arr_len == 33);
47366 memcpy(a_arg_ref.compressed_form, a_arg->elems, 33); FREE(a_arg);
47367 LDKPayeePubKey ret_var = PayeePubKey_new(a_arg_ref);
47368 uint64_t ret_ref = 0;
47369 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47370 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47374 static inline uint64_t PayeePubKey_clone_ptr(LDKPayeePubKey *NONNULL_PTR arg) {
47375 LDKPayeePubKey ret_var = PayeePubKey_clone(arg);
47376 uint64_t ret_ref = 0;
47377 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47378 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47381 int64_t __attribute__((export_name("TS_PayeePubKey_clone_ptr"))) TS_PayeePubKey_clone_ptr(uint64_t arg) {
47382 LDKPayeePubKey arg_conv;
47383 arg_conv.inner = untag_ptr(arg);
47384 arg_conv.is_owned = ptr_is_owned(arg);
47385 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
47386 arg_conv.is_owned = false;
47387 int64_t ret_conv = PayeePubKey_clone_ptr(&arg_conv);
47391 uint64_t __attribute__((export_name("TS_PayeePubKey_clone"))) TS_PayeePubKey_clone(uint64_t orig) {
47392 LDKPayeePubKey orig_conv;
47393 orig_conv.inner = untag_ptr(orig);
47394 orig_conv.is_owned = ptr_is_owned(orig);
47395 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
47396 orig_conv.is_owned = false;
47397 LDKPayeePubKey ret_var = PayeePubKey_clone(&orig_conv);
47398 uint64_t ret_ref = 0;
47399 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47400 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47404 int64_t __attribute__((export_name("TS_PayeePubKey_hash"))) TS_PayeePubKey_hash(uint64_t o) {
47405 LDKPayeePubKey o_conv;
47406 o_conv.inner = untag_ptr(o);
47407 o_conv.is_owned = ptr_is_owned(o);
47408 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
47409 o_conv.is_owned = false;
47410 int64_t ret_conv = PayeePubKey_hash(&o_conv);
47414 jboolean __attribute__((export_name("TS_PayeePubKey_eq"))) TS_PayeePubKey_eq(uint64_t a, uint64_t b) {
47415 LDKPayeePubKey a_conv;
47416 a_conv.inner = untag_ptr(a);
47417 a_conv.is_owned = ptr_is_owned(a);
47418 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
47419 a_conv.is_owned = false;
47420 LDKPayeePubKey b_conv;
47421 b_conv.inner = untag_ptr(b);
47422 b_conv.is_owned = ptr_is_owned(b);
47423 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
47424 b_conv.is_owned = false;
47425 jboolean ret_conv = PayeePubKey_eq(&a_conv, &b_conv);
47429 void __attribute__((export_name("TS_ExpiryTime_free"))) TS_ExpiryTime_free(uint64_t this_obj) {
47430 LDKExpiryTime this_obj_conv;
47431 this_obj_conv.inner = untag_ptr(this_obj);
47432 this_obj_conv.is_owned = ptr_is_owned(this_obj);
47433 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
47434 ExpiryTime_free(this_obj_conv);
47437 static inline uint64_t ExpiryTime_clone_ptr(LDKExpiryTime *NONNULL_PTR arg) {
47438 LDKExpiryTime ret_var = ExpiryTime_clone(arg);
47439 uint64_t ret_ref = 0;
47440 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47441 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47444 int64_t __attribute__((export_name("TS_ExpiryTime_clone_ptr"))) TS_ExpiryTime_clone_ptr(uint64_t arg) {
47445 LDKExpiryTime arg_conv;
47446 arg_conv.inner = untag_ptr(arg);
47447 arg_conv.is_owned = ptr_is_owned(arg);
47448 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
47449 arg_conv.is_owned = false;
47450 int64_t ret_conv = ExpiryTime_clone_ptr(&arg_conv);
47454 uint64_t __attribute__((export_name("TS_ExpiryTime_clone"))) TS_ExpiryTime_clone(uint64_t orig) {
47455 LDKExpiryTime orig_conv;
47456 orig_conv.inner = untag_ptr(orig);
47457 orig_conv.is_owned = ptr_is_owned(orig);
47458 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
47459 orig_conv.is_owned = false;
47460 LDKExpiryTime ret_var = ExpiryTime_clone(&orig_conv);
47461 uint64_t ret_ref = 0;
47462 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47463 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47467 int64_t __attribute__((export_name("TS_ExpiryTime_hash"))) TS_ExpiryTime_hash(uint64_t o) {
47468 LDKExpiryTime o_conv;
47469 o_conv.inner = untag_ptr(o);
47470 o_conv.is_owned = ptr_is_owned(o);
47471 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
47472 o_conv.is_owned = false;
47473 int64_t ret_conv = ExpiryTime_hash(&o_conv);
47477 jboolean __attribute__((export_name("TS_ExpiryTime_eq"))) TS_ExpiryTime_eq(uint64_t a, uint64_t b) {
47478 LDKExpiryTime a_conv;
47479 a_conv.inner = untag_ptr(a);
47480 a_conv.is_owned = ptr_is_owned(a);
47481 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
47482 a_conv.is_owned = false;
47483 LDKExpiryTime b_conv;
47484 b_conv.inner = untag_ptr(b);
47485 b_conv.is_owned = ptr_is_owned(b);
47486 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
47487 b_conv.is_owned = false;
47488 jboolean ret_conv = ExpiryTime_eq(&a_conv, &b_conv);
47492 void __attribute__((export_name("TS_MinFinalCltvExpiry_free"))) TS_MinFinalCltvExpiry_free(uint64_t this_obj) {
47493 LDKMinFinalCltvExpiry this_obj_conv;
47494 this_obj_conv.inner = untag_ptr(this_obj);
47495 this_obj_conv.is_owned = ptr_is_owned(this_obj);
47496 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
47497 MinFinalCltvExpiry_free(this_obj_conv);
47500 int64_t __attribute__((export_name("TS_MinFinalCltvExpiry_get_a"))) TS_MinFinalCltvExpiry_get_a(uint64_t this_ptr) {
47501 LDKMinFinalCltvExpiry this_ptr_conv;
47502 this_ptr_conv.inner = untag_ptr(this_ptr);
47503 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47504 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47505 this_ptr_conv.is_owned = false;
47506 int64_t ret_conv = MinFinalCltvExpiry_get_a(&this_ptr_conv);
47510 void __attribute__((export_name("TS_MinFinalCltvExpiry_set_a"))) TS_MinFinalCltvExpiry_set_a(uint64_t this_ptr, int64_t val) {
47511 LDKMinFinalCltvExpiry this_ptr_conv;
47512 this_ptr_conv.inner = untag_ptr(this_ptr);
47513 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47514 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47515 this_ptr_conv.is_owned = false;
47516 MinFinalCltvExpiry_set_a(&this_ptr_conv, val);
47519 uint64_t __attribute__((export_name("TS_MinFinalCltvExpiry_new"))) TS_MinFinalCltvExpiry_new(int64_t a_arg) {
47520 LDKMinFinalCltvExpiry ret_var = MinFinalCltvExpiry_new(a_arg);
47521 uint64_t ret_ref = 0;
47522 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47523 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47527 static inline uint64_t MinFinalCltvExpiry_clone_ptr(LDKMinFinalCltvExpiry *NONNULL_PTR arg) {
47528 LDKMinFinalCltvExpiry ret_var = MinFinalCltvExpiry_clone(arg);
47529 uint64_t ret_ref = 0;
47530 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47531 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47534 int64_t __attribute__((export_name("TS_MinFinalCltvExpiry_clone_ptr"))) TS_MinFinalCltvExpiry_clone_ptr(uint64_t arg) {
47535 LDKMinFinalCltvExpiry arg_conv;
47536 arg_conv.inner = untag_ptr(arg);
47537 arg_conv.is_owned = ptr_is_owned(arg);
47538 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
47539 arg_conv.is_owned = false;
47540 int64_t ret_conv = MinFinalCltvExpiry_clone_ptr(&arg_conv);
47544 uint64_t __attribute__((export_name("TS_MinFinalCltvExpiry_clone"))) TS_MinFinalCltvExpiry_clone(uint64_t orig) {
47545 LDKMinFinalCltvExpiry orig_conv;
47546 orig_conv.inner = untag_ptr(orig);
47547 orig_conv.is_owned = ptr_is_owned(orig);
47548 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
47549 orig_conv.is_owned = false;
47550 LDKMinFinalCltvExpiry ret_var = MinFinalCltvExpiry_clone(&orig_conv);
47551 uint64_t ret_ref = 0;
47552 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47553 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47557 int64_t __attribute__((export_name("TS_MinFinalCltvExpiry_hash"))) TS_MinFinalCltvExpiry_hash(uint64_t o) {
47558 LDKMinFinalCltvExpiry o_conv;
47559 o_conv.inner = untag_ptr(o);
47560 o_conv.is_owned = ptr_is_owned(o);
47561 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
47562 o_conv.is_owned = false;
47563 int64_t ret_conv = MinFinalCltvExpiry_hash(&o_conv);
47567 jboolean __attribute__((export_name("TS_MinFinalCltvExpiry_eq"))) TS_MinFinalCltvExpiry_eq(uint64_t a, uint64_t b) {
47568 LDKMinFinalCltvExpiry a_conv;
47569 a_conv.inner = untag_ptr(a);
47570 a_conv.is_owned = ptr_is_owned(a);
47571 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
47572 a_conv.is_owned = false;
47573 LDKMinFinalCltvExpiry b_conv;
47574 b_conv.inner = untag_ptr(b);
47575 b_conv.is_owned = ptr_is_owned(b);
47576 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
47577 b_conv.is_owned = false;
47578 jboolean ret_conv = MinFinalCltvExpiry_eq(&a_conv, &b_conv);
47582 void __attribute__((export_name("TS_Fallback_free"))) TS_Fallback_free(uint64_t this_ptr) {
47583 if (!ptr_is_owned(this_ptr)) return;
47584 void* this_ptr_ptr = untag_ptr(this_ptr);
47585 CHECK_ACCESS(this_ptr_ptr);
47586 LDKFallback this_ptr_conv = *(LDKFallback*)(this_ptr_ptr);
47587 FREE(untag_ptr(this_ptr));
47588 Fallback_free(this_ptr_conv);
47591 static inline uint64_t Fallback_clone_ptr(LDKFallback *NONNULL_PTR arg) {
47592 LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
47593 *ret_copy = Fallback_clone(arg);
47594 uint64_t ret_ref = tag_ptr(ret_copy, true);
47597 int64_t __attribute__((export_name("TS_Fallback_clone_ptr"))) TS_Fallback_clone_ptr(uint64_t arg) {
47598 LDKFallback* arg_conv = (LDKFallback*)untag_ptr(arg);
47599 int64_t ret_conv = Fallback_clone_ptr(arg_conv);
47603 uint64_t __attribute__((export_name("TS_Fallback_clone"))) TS_Fallback_clone(uint64_t orig) {
47604 LDKFallback* orig_conv = (LDKFallback*)untag_ptr(orig);
47605 LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
47606 *ret_copy = Fallback_clone(orig_conv);
47607 uint64_t ret_ref = tag_ptr(ret_copy, true);
47611 uint64_t __attribute__((export_name("TS_Fallback_seg_wit_program"))) TS_Fallback_seg_wit_program(int8_t version, int8_tArray program) {
47613 LDKCVec_u8Z program_ref;
47614 program_ref.datalen = program->arr_len;
47615 program_ref.data = MALLOC(program_ref.datalen, "LDKCVec_u8Z Bytes");
47616 memcpy(program_ref.data, program->elems, program_ref.datalen); FREE(program);
47617 LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
47618 *ret_copy = Fallback_seg_wit_program((LDKU5){ ._0 = version }, program_ref);
47619 uint64_t ret_ref = tag_ptr(ret_copy, true);
47623 uint64_t __attribute__((export_name("TS_Fallback_pub_key_hash"))) TS_Fallback_pub_key_hash(int8_tArray a) {
47624 LDKTwentyBytes a_ref;
47625 CHECK(a->arr_len == 20);
47626 memcpy(a_ref.data, a->elems, 20); FREE(a);
47627 LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
47628 *ret_copy = Fallback_pub_key_hash(a_ref);
47629 uint64_t ret_ref = tag_ptr(ret_copy, true);
47633 uint64_t __attribute__((export_name("TS_Fallback_script_hash"))) TS_Fallback_script_hash(int8_tArray a) {
47634 LDKTwentyBytes a_ref;
47635 CHECK(a->arr_len == 20);
47636 memcpy(a_ref.data, a->elems, 20); FREE(a);
47637 LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
47638 *ret_copy = Fallback_script_hash(a_ref);
47639 uint64_t ret_ref = tag_ptr(ret_copy, true);
47643 int64_t __attribute__((export_name("TS_Fallback_hash"))) TS_Fallback_hash(uint64_t o) {
47644 LDKFallback* o_conv = (LDKFallback*)untag_ptr(o);
47645 int64_t ret_conv = Fallback_hash(o_conv);
47649 jboolean __attribute__((export_name("TS_Fallback_eq"))) TS_Fallback_eq(uint64_t a, uint64_t b) {
47650 LDKFallback* a_conv = (LDKFallback*)untag_ptr(a);
47651 LDKFallback* b_conv = (LDKFallback*)untag_ptr(b);
47652 jboolean ret_conv = Fallback_eq(a_conv, b_conv);
47656 void __attribute__((export_name("TS_InvoiceSignature_free"))) TS_InvoiceSignature_free(uint64_t this_obj) {
47657 LDKInvoiceSignature this_obj_conv;
47658 this_obj_conv.inner = untag_ptr(this_obj);
47659 this_obj_conv.is_owned = ptr_is_owned(this_obj);
47660 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
47661 InvoiceSignature_free(this_obj_conv);
47664 static inline uint64_t InvoiceSignature_clone_ptr(LDKInvoiceSignature *NONNULL_PTR arg) {
47665 LDKInvoiceSignature ret_var = InvoiceSignature_clone(arg);
47666 uint64_t ret_ref = 0;
47667 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47668 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47671 int64_t __attribute__((export_name("TS_InvoiceSignature_clone_ptr"))) TS_InvoiceSignature_clone_ptr(uint64_t arg) {
47672 LDKInvoiceSignature arg_conv;
47673 arg_conv.inner = untag_ptr(arg);
47674 arg_conv.is_owned = ptr_is_owned(arg);
47675 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
47676 arg_conv.is_owned = false;
47677 int64_t ret_conv = InvoiceSignature_clone_ptr(&arg_conv);
47681 uint64_t __attribute__((export_name("TS_InvoiceSignature_clone"))) TS_InvoiceSignature_clone(uint64_t orig) {
47682 LDKInvoiceSignature orig_conv;
47683 orig_conv.inner = untag_ptr(orig);
47684 orig_conv.is_owned = ptr_is_owned(orig);
47685 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
47686 orig_conv.is_owned = false;
47687 LDKInvoiceSignature ret_var = InvoiceSignature_clone(&orig_conv);
47688 uint64_t ret_ref = 0;
47689 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47690 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47694 int64_t __attribute__((export_name("TS_InvoiceSignature_hash"))) TS_InvoiceSignature_hash(uint64_t o) {
47695 LDKInvoiceSignature o_conv;
47696 o_conv.inner = untag_ptr(o);
47697 o_conv.is_owned = ptr_is_owned(o);
47698 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
47699 o_conv.is_owned = false;
47700 int64_t ret_conv = InvoiceSignature_hash(&o_conv);
47704 jboolean __attribute__((export_name("TS_InvoiceSignature_eq"))) TS_InvoiceSignature_eq(uint64_t a, uint64_t b) {
47705 LDKInvoiceSignature a_conv;
47706 a_conv.inner = untag_ptr(a);
47707 a_conv.is_owned = ptr_is_owned(a);
47708 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
47709 a_conv.is_owned = false;
47710 LDKInvoiceSignature b_conv;
47711 b_conv.inner = untag_ptr(b);
47712 b_conv.is_owned = ptr_is_owned(b);
47713 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
47714 b_conv.is_owned = false;
47715 jboolean ret_conv = InvoiceSignature_eq(&a_conv, &b_conv);
47719 void __attribute__((export_name("TS_PrivateRoute_free"))) TS_PrivateRoute_free(uint64_t this_obj) {
47720 LDKPrivateRoute this_obj_conv;
47721 this_obj_conv.inner = untag_ptr(this_obj);
47722 this_obj_conv.is_owned = ptr_is_owned(this_obj);
47723 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
47724 PrivateRoute_free(this_obj_conv);
47727 static inline uint64_t PrivateRoute_clone_ptr(LDKPrivateRoute *NONNULL_PTR arg) {
47728 LDKPrivateRoute ret_var = PrivateRoute_clone(arg);
47729 uint64_t ret_ref = 0;
47730 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47731 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47734 int64_t __attribute__((export_name("TS_PrivateRoute_clone_ptr"))) TS_PrivateRoute_clone_ptr(uint64_t arg) {
47735 LDKPrivateRoute arg_conv;
47736 arg_conv.inner = untag_ptr(arg);
47737 arg_conv.is_owned = ptr_is_owned(arg);
47738 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
47739 arg_conv.is_owned = false;
47740 int64_t ret_conv = PrivateRoute_clone_ptr(&arg_conv);
47744 uint64_t __attribute__((export_name("TS_PrivateRoute_clone"))) TS_PrivateRoute_clone(uint64_t orig) {
47745 LDKPrivateRoute orig_conv;
47746 orig_conv.inner = untag_ptr(orig);
47747 orig_conv.is_owned = ptr_is_owned(orig);
47748 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
47749 orig_conv.is_owned = false;
47750 LDKPrivateRoute ret_var = PrivateRoute_clone(&orig_conv);
47751 uint64_t ret_ref = 0;
47752 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47753 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47757 int64_t __attribute__((export_name("TS_PrivateRoute_hash"))) TS_PrivateRoute_hash(uint64_t o) {
47758 LDKPrivateRoute o_conv;
47759 o_conv.inner = untag_ptr(o);
47760 o_conv.is_owned = ptr_is_owned(o);
47761 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
47762 o_conv.is_owned = false;
47763 int64_t ret_conv = PrivateRoute_hash(&o_conv);
47767 jboolean __attribute__((export_name("TS_PrivateRoute_eq"))) TS_PrivateRoute_eq(uint64_t a, uint64_t b) {
47768 LDKPrivateRoute a_conv;
47769 a_conv.inner = untag_ptr(a);
47770 a_conv.is_owned = ptr_is_owned(a);
47771 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
47772 a_conv.is_owned = false;
47773 LDKPrivateRoute b_conv;
47774 b_conv.inner = untag_ptr(b);
47775 b_conv.is_owned = ptr_is_owned(b);
47776 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
47777 b_conv.is_owned = false;
47778 jboolean ret_conv = PrivateRoute_eq(&a_conv, &b_conv);
47782 uint64_t __attribute__((export_name("TS_SignedRawInvoice_into_parts"))) TS_SignedRawInvoice_into_parts(uint64_t this_arg) {
47783 LDKSignedRawInvoice this_arg_conv;
47784 this_arg_conv.inner = untag_ptr(this_arg);
47785 this_arg_conv.is_owned = ptr_is_owned(this_arg);
47786 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
47787 this_arg_conv = SignedRawInvoice_clone(&this_arg_conv);
47788 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
47789 *ret_conv = SignedRawInvoice_into_parts(this_arg_conv);
47790 return tag_ptr(ret_conv, true);
47793 uint64_t __attribute__((export_name("TS_SignedRawInvoice_raw_invoice"))) TS_SignedRawInvoice_raw_invoice(uint64_t this_arg) {
47794 LDKSignedRawInvoice this_arg_conv;
47795 this_arg_conv.inner = untag_ptr(this_arg);
47796 this_arg_conv.is_owned = ptr_is_owned(this_arg);
47797 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
47798 this_arg_conv.is_owned = false;
47799 LDKRawInvoice ret_var = SignedRawInvoice_raw_invoice(&this_arg_conv);
47800 uint64_t ret_ref = 0;
47801 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47802 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47806 int8_tArray __attribute__((export_name("TS_SignedRawInvoice_signable_hash"))) TS_SignedRawInvoice_signable_hash(uint64_t this_arg) {
47807 LDKSignedRawInvoice this_arg_conv;
47808 this_arg_conv.inner = untag_ptr(this_arg);
47809 this_arg_conv.is_owned = ptr_is_owned(this_arg);
47810 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
47811 this_arg_conv.is_owned = false;
47812 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
47813 memcpy(ret_arr->elems, *SignedRawInvoice_signable_hash(&this_arg_conv), 32);
47817 uint64_t __attribute__((export_name("TS_SignedRawInvoice_signature"))) TS_SignedRawInvoice_signature(uint64_t this_arg) {
47818 LDKSignedRawInvoice this_arg_conv;
47819 this_arg_conv.inner = untag_ptr(this_arg);
47820 this_arg_conv.is_owned = ptr_is_owned(this_arg);
47821 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
47822 this_arg_conv.is_owned = false;
47823 LDKInvoiceSignature ret_var = SignedRawInvoice_signature(&this_arg_conv);
47824 uint64_t ret_ref = 0;
47825 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47826 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47830 uint64_t __attribute__((export_name("TS_SignedRawInvoice_recover_payee_pub_key"))) TS_SignedRawInvoice_recover_payee_pub_key(uint64_t this_arg) {
47831 LDKSignedRawInvoice this_arg_conv;
47832 this_arg_conv.inner = untag_ptr(this_arg);
47833 this_arg_conv.is_owned = ptr_is_owned(this_arg);
47834 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
47835 this_arg_conv.is_owned = false;
47836 LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
47837 *ret_conv = SignedRawInvoice_recover_payee_pub_key(&this_arg_conv);
47838 return tag_ptr(ret_conv, true);
47841 jboolean __attribute__((export_name("TS_SignedRawInvoice_check_signature"))) TS_SignedRawInvoice_check_signature(uint64_t this_arg) {
47842 LDKSignedRawInvoice this_arg_conv;
47843 this_arg_conv.inner = untag_ptr(this_arg);
47844 this_arg_conv.is_owned = ptr_is_owned(this_arg);
47845 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
47846 this_arg_conv.is_owned = false;
47847 jboolean ret_conv = SignedRawInvoice_check_signature(&this_arg_conv);
47851 int8_tArray __attribute__((export_name("TS_RawInvoice_signable_hash"))) TS_RawInvoice_signable_hash(uint64_t this_arg) {
47852 LDKRawInvoice this_arg_conv;
47853 this_arg_conv.inner = untag_ptr(this_arg);
47854 this_arg_conv.is_owned = ptr_is_owned(this_arg);
47855 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
47856 this_arg_conv.is_owned = false;
47857 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
47858 memcpy(ret_arr->elems, RawInvoice_signable_hash(&this_arg_conv).data, 32);
47862 uint64_t __attribute__((export_name("TS_RawInvoice_payment_hash"))) TS_RawInvoice_payment_hash(uint64_t this_arg) {
47863 LDKRawInvoice this_arg_conv;
47864 this_arg_conv.inner = untag_ptr(this_arg);
47865 this_arg_conv.is_owned = ptr_is_owned(this_arg);
47866 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
47867 this_arg_conv.is_owned = false;
47868 LDKSha256 ret_var = RawInvoice_payment_hash(&this_arg_conv);
47869 uint64_t ret_ref = 0;
47870 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47871 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47875 uint64_t __attribute__((export_name("TS_RawInvoice_description"))) TS_RawInvoice_description(uint64_t this_arg) {
47876 LDKRawInvoice this_arg_conv;
47877 this_arg_conv.inner = untag_ptr(this_arg);
47878 this_arg_conv.is_owned = ptr_is_owned(this_arg);
47879 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
47880 this_arg_conv.is_owned = false;
47881 LDKDescription ret_var = RawInvoice_description(&this_arg_conv);
47882 uint64_t ret_ref = 0;
47883 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47884 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47888 uint64_t __attribute__((export_name("TS_RawInvoice_payee_pub_key"))) TS_RawInvoice_payee_pub_key(uint64_t this_arg) {
47889 LDKRawInvoice this_arg_conv;
47890 this_arg_conv.inner = untag_ptr(this_arg);
47891 this_arg_conv.is_owned = ptr_is_owned(this_arg);
47892 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
47893 this_arg_conv.is_owned = false;
47894 LDKPayeePubKey ret_var = RawInvoice_payee_pub_key(&this_arg_conv);
47895 uint64_t ret_ref = 0;
47896 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47897 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47901 uint64_t __attribute__((export_name("TS_RawInvoice_description_hash"))) TS_RawInvoice_description_hash(uint64_t this_arg) {
47902 LDKRawInvoice this_arg_conv;
47903 this_arg_conv.inner = untag_ptr(this_arg);
47904 this_arg_conv.is_owned = ptr_is_owned(this_arg);
47905 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
47906 this_arg_conv.is_owned = false;
47907 LDKSha256 ret_var = RawInvoice_description_hash(&this_arg_conv);
47908 uint64_t ret_ref = 0;
47909 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47910 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47914 uint64_t __attribute__((export_name("TS_RawInvoice_expiry_time"))) TS_RawInvoice_expiry_time(uint64_t this_arg) {
47915 LDKRawInvoice this_arg_conv;
47916 this_arg_conv.inner = untag_ptr(this_arg);
47917 this_arg_conv.is_owned = ptr_is_owned(this_arg);
47918 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
47919 this_arg_conv.is_owned = false;
47920 LDKExpiryTime ret_var = RawInvoice_expiry_time(&this_arg_conv);
47921 uint64_t ret_ref = 0;
47922 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47923 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47927 uint64_t __attribute__((export_name("TS_RawInvoice_min_final_cltv_expiry"))) TS_RawInvoice_min_final_cltv_expiry(uint64_t this_arg) {
47928 LDKRawInvoice this_arg_conv;
47929 this_arg_conv.inner = untag_ptr(this_arg);
47930 this_arg_conv.is_owned = ptr_is_owned(this_arg);
47931 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
47932 this_arg_conv.is_owned = false;
47933 LDKMinFinalCltvExpiry ret_var = RawInvoice_min_final_cltv_expiry(&this_arg_conv);
47934 uint64_t ret_ref = 0;
47935 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47936 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47940 int8_tArray __attribute__((export_name("TS_RawInvoice_payment_secret"))) TS_RawInvoice_payment_secret(uint64_t this_arg) {
47941 LDKRawInvoice this_arg_conv;
47942 this_arg_conv.inner = untag_ptr(this_arg);
47943 this_arg_conv.is_owned = ptr_is_owned(this_arg);
47944 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
47945 this_arg_conv.is_owned = false;
47946 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
47947 memcpy(ret_arr->elems, RawInvoice_payment_secret(&this_arg_conv).data, 32);
47951 uint64_t __attribute__((export_name("TS_RawInvoice_features"))) TS_RawInvoice_features(uint64_t this_arg) {
47952 LDKRawInvoice this_arg_conv;
47953 this_arg_conv.inner = untag_ptr(this_arg);
47954 this_arg_conv.is_owned = ptr_is_owned(this_arg);
47955 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
47956 this_arg_conv.is_owned = false;
47957 LDKInvoiceFeatures ret_var = RawInvoice_features(&this_arg_conv);
47958 uint64_t ret_ref = 0;
47959 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47960 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47964 uint64_tArray __attribute__((export_name("TS_RawInvoice_private_routes"))) TS_RawInvoice_private_routes(uint64_t this_arg) {
47965 LDKRawInvoice this_arg_conv;
47966 this_arg_conv.inner = untag_ptr(this_arg);
47967 this_arg_conv.is_owned = ptr_is_owned(this_arg);
47968 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
47969 this_arg_conv.is_owned = false;
47970 LDKCVec_PrivateRouteZ ret_var = RawInvoice_private_routes(&this_arg_conv);
47971 uint64_tArray ret_arr = NULL;
47972 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
47973 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
47974 for (size_t o = 0; o < ret_var.datalen; o++) {
47975 LDKPrivateRoute ret_conv_14_var = ret_var.data[o];
47976 uint64_t ret_conv_14_ref = 0;
47977 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_14_var);
47978 ret_conv_14_ref = tag_ptr(ret_conv_14_var.inner, ret_conv_14_var.is_owned);
47979 ret_arr_ptr[o] = ret_conv_14_ref;
47982 FREE(ret_var.data);
47986 uint64_t __attribute__((export_name("TS_RawInvoice_amount_pico_btc"))) TS_RawInvoice_amount_pico_btc(uint64_t this_arg) {
47987 LDKRawInvoice this_arg_conv;
47988 this_arg_conv.inner = untag_ptr(this_arg);
47989 this_arg_conv.is_owned = ptr_is_owned(this_arg);
47990 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
47991 this_arg_conv.is_owned = false;
47992 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
47993 *ret_copy = RawInvoice_amount_pico_btc(&this_arg_conv);
47994 uint64_t ret_ref = tag_ptr(ret_copy, true);
47998 uint32_t __attribute__((export_name("TS_RawInvoice_currency"))) TS_RawInvoice_currency(uint64_t this_arg) {
47999 LDKRawInvoice this_arg_conv;
48000 this_arg_conv.inner = untag_ptr(this_arg);
48001 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48002 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48003 this_arg_conv.is_owned = false;
48004 uint32_t ret_conv = LDKCurrency_to_js(RawInvoice_currency(&this_arg_conv));
48008 uint64_t __attribute__((export_name("TS_PositiveTimestamp_from_unix_timestamp"))) TS_PositiveTimestamp_from_unix_timestamp(int64_t unix_seconds) {
48009 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
48010 *ret_conv = PositiveTimestamp_from_unix_timestamp(unix_seconds);
48011 return tag_ptr(ret_conv, true);
48014 uint64_t __attribute__((export_name("TS_PositiveTimestamp_from_duration_since_epoch"))) TS_PositiveTimestamp_from_duration_since_epoch(int64_t duration) {
48015 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
48016 *ret_conv = PositiveTimestamp_from_duration_since_epoch(duration);
48017 return tag_ptr(ret_conv, true);
48020 int64_t __attribute__((export_name("TS_PositiveTimestamp_as_unix_timestamp"))) TS_PositiveTimestamp_as_unix_timestamp(uint64_t this_arg) {
48021 LDKPositiveTimestamp this_arg_conv;
48022 this_arg_conv.inner = untag_ptr(this_arg);
48023 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48024 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48025 this_arg_conv.is_owned = false;
48026 int64_t ret_conv = PositiveTimestamp_as_unix_timestamp(&this_arg_conv);
48030 int64_t __attribute__((export_name("TS_PositiveTimestamp_as_duration_since_epoch"))) TS_PositiveTimestamp_as_duration_since_epoch(uint64_t this_arg) {
48031 LDKPositiveTimestamp this_arg_conv;
48032 this_arg_conv.inner = untag_ptr(this_arg);
48033 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48034 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48035 this_arg_conv.is_owned = false;
48036 int64_t ret_conv = PositiveTimestamp_as_duration_since_epoch(&this_arg_conv);
48040 uint64_t __attribute__((export_name("TS_Invoice_into_signed_raw"))) TS_Invoice_into_signed_raw(uint64_t this_arg) {
48041 LDKInvoice this_arg_conv;
48042 this_arg_conv.inner = untag_ptr(this_arg);
48043 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48044 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48045 this_arg_conv = Invoice_clone(&this_arg_conv);
48046 LDKSignedRawInvoice ret_var = Invoice_into_signed_raw(this_arg_conv);
48047 uint64_t ret_ref = 0;
48048 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48049 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48053 uint64_t __attribute__((export_name("TS_Invoice_check_signature"))) TS_Invoice_check_signature(uint64_t this_arg) {
48054 LDKInvoice this_arg_conv;
48055 this_arg_conv.inner = untag_ptr(this_arg);
48056 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48057 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48058 this_arg_conv.is_owned = false;
48059 LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
48060 *ret_conv = Invoice_check_signature(&this_arg_conv);
48061 return tag_ptr(ret_conv, true);
48064 uint64_t __attribute__((export_name("TS_Invoice_from_signed"))) TS_Invoice_from_signed(uint64_t signed_invoice) {
48065 LDKSignedRawInvoice signed_invoice_conv;
48066 signed_invoice_conv.inner = untag_ptr(signed_invoice);
48067 signed_invoice_conv.is_owned = ptr_is_owned(signed_invoice);
48068 CHECK_INNER_FIELD_ACCESS_OR_NULL(signed_invoice_conv);
48069 signed_invoice_conv = SignedRawInvoice_clone(&signed_invoice_conv);
48070 LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
48071 *ret_conv = Invoice_from_signed(signed_invoice_conv);
48072 return tag_ptr(ret_conv, true);
48075 int64_t __attribute__((export_name("TS_Invoice_duration_since_epoch"))) TS_Invoice_duration_since_epoch(uint64_t this_arg) {
48076 LDKInvoice this_arg_conv;
48077 this_arg_conv.inner = untag_ptr(this_arg);
48078 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48079 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48080 this_arg_conv.is_owned = false;
48081 int64_t ret_conv = Invoice_duration_since_epoch(&this_arg_conv);
48085 int8_tArray __attribute__((export_name("TS_Invoice_payment_hash"))) TS_Invoice_payment_hash(uint64_t this_arg) {
48086 LDKInvoice this_arg_conv;
48087 this_arg_conv.inner = untag_ptr(this_arg);
48088 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48089 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48090 this_arg_conv.is_owned = false;
48091 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
48092 memcpy(ret_arr->elems, *Invoice_payment_hash(&this_arg_conv), 32);
48096 int8_tArray __attribute__((export_name("TS_Invoice_payee_pub_key"))) TS_Invoice_payee_pub_key(uint64_t this_arg) {
48097 LDKInvoice this_arg_conv;
48098 this_arg_conv.inner = untag_ptr(this_arg);
48099 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48100 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48101 this_arg_conv.is_owned = false;
48102 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
48103 memcpy(ret_arr->elems, Invoice_payee_pub_key(&this_arg_conv).compressed_form, 33);
48107 int8_tArray __attribute__((export_name("TS_Invoice_payment_secret"))) TS_Invoice_payment_secret(uint64_t this_arg) {
48108 LDKInvoice this_arg_conv;
48109 this_arg_conv.inner = untag_ptr(this_arg);
48110 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48111 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48112 this_arg_conv.is_owned = false;
48113 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
48114 memcpy(ret_arr->elems, *Invoice_payment_secret(&this_arg_conv), 32);
48118 uint64_t __attribute__((export_name("TS_Invoice_features"))) TS_Invoice_features(uint64_t this_arg) {
48119 LDKInvoice this_arg_conv;
48120 this_arg_conv.inner = untag_ptr(this_arg);
48121 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48122 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48123 this_arg_conv.is_owned = false;
48124 LDKInvoiceFeatures ret_var = Invoice_features(&this_arg_conv);
48125 uint64_t ret_ref = 0;
48126 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48127 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48131 int8_tArray __attribute__((export_name("TS_Invoice_recover_payee_pub_key"))) TS_Invoice_recover_payee_pub_key(uint64_t this_arg) {
48132 LDKInvoice this_arg_conv;
48133 this_arg_conv.inner = untag_ptr(this_arg);
48134 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48135 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48136 this_arg_conv.is_owned = false;
48137 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
48138 memcpy(ret_arr->elems, Invoice_recover_payee_pub_key(&this_arg_conv).compressed_form, 33);
48142 int64_t __attribute__((export_name("TS_Invoice_expiry_time"))) TS_Invoice_expiry_time(uint64_t this_arg) {
48143 LDKInvoice this_arg_conv;
48144 this_arg_conv.inner = untag_ptr(this_arg);
48145 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48146 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48147 this_arg_conv.is_owned = false;
48148 int64_t ret_conv = Invoice_expiry_time(&this_arg_conv);
48152 jboolean __attribute__((export_name("TS_Invoice_would_expire"))) TS_Invoice_would_expire(uint64_t this_arg, int64_t at_time) {
48153 LDKInvoice this_arg_conv;
48154 this_arg_conv.inner = untag_ptr(this_arg);
48155 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48156 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48157 this_arg_conv.is_owned = false;
48158 jboolean ret_conv = Invoice_would_expire(&this_arg_conv, at_time);
48162 int64_t __attribute__((export_name("TS_Invoice_min_final_cltv_expiry"))) TS_Invoice_min_final_cltv_expiry(uint64_t this_arg) {
48163 LDKInvoice this_arg_conv;
48164 this_arg_conv.inner = untag_ptr(this_arg);
48165 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48166 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48167 this_arg_conv.is_owned = false;
48168 int64_t ret_conv = Invoice_min_final_cltv_expiry(&this_arg_conv);
48172 uint64_tArray __attribute__((export_name("TS_Invoice_private_routes"))) TS_Invoice_private_routes(uint64_t this_arg) {
48173 LDKInvoice this_arg_conv;
48174 this_arg_conv.inner = untag_ptr(this_arg);
48175 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48176 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48177 this_arg_conv.is_owned = false;
48178 LDKCVec_PrivateRouteZ ret_var = Invoice_private_routes(&this_arg_conv);
48179 uint64_tArray ret_arr = NULL;
48180 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
48181 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
48182 for (size_t o = 0; o < ret_var.datalen; o++) {
48183 LDKPrivateRoute ret_conv_14_var = ret_var.data[o];
48184 uint64_t ret_conv_14_ref = 0;
48185 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_14_var);
48186 ret_conv_14_ref = tag_ptr(ret_conv_14_var.inner, ret_conv_14_var.is_owned);
48187 ret_arr_ptr[o] = ret_conv_14_ref;
48190 FREE(ret_var.data);
48194 uint64_tArray __attribute__((export_name("TS_Invoice_route_hints"))) TS_Invoice_route_hints(uint64_t this_arg) {
48195 LDKInvoice this_arg_conv;
48196 this_arg_conv.inner = untag_ptr(this_arg);
48197 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48198 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48199 this_arg_conv.is_owned = false;
48200 LDKCVec_RouteHintZ ret_var = Invoice_route_hints(&this_arg_conv);
48201 uint64_tArray ret_arr = NULL;
48202 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
48203 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
48204 for (size_t l = 0; l < ret_var.datalen; l++) {
48205 LDKRouteHint ret_conv_11_var = ret_var.data[l];
48206 uint64_t ret_conv_11_ref = 0;
48207 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_11_var);
48208 ret_conv_11_ref = tag_ptr(ret_conv_11_var.inner, ret_conv_11_var.is_owned);
48209 ret_arr_ptr[l] = ret_conv_11_ref;
48212 FREE(ret_var.data);
48216 uint32_t __attribute__((export_name("TS_Invoice_currency"))) TS_Invoice_currency(uint64_t this_arg) {
48217 LDKInvoice this_arg_conv;
48218 this_arg_conv.inner = untag_ptr(this_arg);
48219 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48220 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48221 this_arg_conv.is_owned = false;
48222 uint32_t ret_conv = LDKCurrency_to_js(Invoice_currency(&this_arg_conv));
48226 uint64_t __attribute__((export_name("TS_Invoice_amount_milli_satoshis"))) TS_Invoice_amount_milli_satoshis(uint64_t this_arg) {
48227 LDKInvoice this_arg_conv;
48228 this_arg_conv.inner = untag_ptr(this_arg);
48229 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48230 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48231 this_arg_conv.is_owned = false;
48232 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
48233 *ret_copy = Invoice_amount_milli_satoshis(&this_arg_conv);
48234 uint64_t ret_ref = tag_ptr(ret_copy, true);
48238 uint64_t __attribute__((export_name("TS_Description_new"))) TS_Description_new(jstring description) {
48239 LDKStr description_conv = str_ref_to_owned_c(description);
48240 LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
48241 *ret_conv = Description_new(description_conv);
48242 return tag_ptr(ret_conv, true);
48245 jstring __attribute__((export_name("TS_Description_into_inner"))) TS_Description_into_inner(uint64_t this_arg) {
48246 LDKDescription this_arg_conv;
48247 this_arg_conv.inner = untag_ptr(this_arg);
48248 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48249 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48250 this_arg_conv = Description_clone(&this_arg_conv);
48251 LDKStr ret_str = Description_into_inner(this_arg_conv);
48252 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
48257 uint64_t __attribute__((export_name("TS_ExpiryTime_from_seconds"))) TS_ExpiryTime_from_seconds(int64_t seconds) {
48258 LDKExpiryTime ret_var = ExpiryTime_from_seconds(seconds);
48259 uint64_t ret_ref = 0;
48260 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48261 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48265 uint64_t __attribute__((export_name("TS_ExpiryTime_from_duration"))) TS_ExpiryTime_from_duration(int64_t duration) {
48266 LDKExpiryTime ret_var = ExpiryTime_from_duration(duration);
48267 uint64_t ret_ref = 0;
48268 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48269 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48273 int64_t __attribute__((export_name("TS_ExpiryTime_as_seconds"))) TS_ExpiryTime_as_seconds(uint64_t this_arg) {
48274 LDKExpiryTime this_arg_conv;
48275 this_arg_conv.inner = untag_ptr(this_arg);
48276 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48277 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48278 this_arg_conv.is_owned = false;
48279 int64_t ret_conv = ExpiryTime_as_seconds(&this_arg_conv);
48283 int64_t __attribute__((export_name("TS_ExpiryTime_as_duration"))) TS_ExpiryTime_as_duration(uint64_t this_arg) {
48284 LDKExpiryTime this_arg_conv;
48285 this_arg_conv.inner = untag_ptr(this_arg);
48286 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48287 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48288 this_arg_conv.is_owned = false;
48289 int64_t ret_conv = ExpiryTime_as_duration(&this_arg_conv);
48293 uint64_t __attribute__((export_name("TS_PrivateRoute_new"))) TS_PrivateRoute_new(uint64_t hops) {
48294 LDKRouteHint hops_conv;
48295 hops_conv.inner = untag_ptr(hops);
48296 hops_conv.is_owned = ptr_is_owned(hops);
48297 CHECK_INNER_FIELD_ACCESS_OR_NULL(hops_conv);
48298 hops_conv = RouteHint_clone(&hops_conv);
48299 LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
48300 *ret_conv = PrivateRoute_new(hops_conv);
48301 return tag_ptr(ret_conv, true);
48304 uint64_t __attribute__((export_name("TS_PrivateRoute_into_inner"))) TS_PrivateRoute_into_inner(uint64_t this_arg) {
48305 LDKPrivateRoute this_arg_conv;
48306 this_arg_conv.inner = untag_ptr(this_arg);
48307 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48308 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48309 this_arg_conv = PrivateRoute_clone(&this_arg_conv);
48310 LDKRouteHint ret_var = PrivateRoute_into_inner(this_arg_conv);
48311 uint64_t ret_ref = 0;
48312 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48313 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48317 uint32_t __attribute__((export_name("TS_CreationError_clone"))) TS_CreationError_clone(uint64_t orig) {
48318 LDKCreationError* orig_conv = (LDKCreationError*)untag_ptr(orig);
48319 uint32_t ret_conv = LDKCreationError_to_js(CreationError_clone(orig_conv));
48323 uint32_t __attribute__((export_name("TS_CreationError_description_too_long"))) TS_CreationError_description_too_long() {
48324 uint32_t ret_conv = LDKCreationError_to_js(CreationError_description_too_long());
48328 uint32_t __attribute__((export_name("TS_CreationError_route_too_long"))) TS_CreationError_route_too_long() {
48329 uint32_t ret_conv = LDKCreationError_to_js(CreationError_route_too_long());
48333 uint32_t __attribute__((export_name("TS_CreationError_timestamp_out_of_bounds"))) TS_CreationError_timestamp_out_of_bounds() {
48334 uint32_t ret_conv = LDKCreationError_to_js(CreationError_timestamp_out_of_bounds());
48338 uint32_t __attribute__((export_name("TS_CreationError_invalid_amount"))) TS_CreationError_invalid_amount() {
48339 uint32_t ret_conv = LDKCreationError_to_js(CreationError_invalid_amount());
48343 uint32_t __attribute__((export_name("TS_CreationError_missing_route_hints"))) TS_CreationError_missing_route_hints() {
48344 uint32_t ret_conv = LDKCreationError_to_js(CreationError_missing_route_hints());
48348 jboolean __attribute__((export_name("TS_CreationError_eq"))) TS_CreationError_eq(uint64_t a, uint64_t b) {
48349 LDKCreationError* a_conv = (LDKCreationError*)untag_ptr(a);
48350 LDKCreationError* b_conv = (LDKCreationError*)untag_ptr(b);
48351 jboolean ret_conv = CreationError_eq(a_conv, b_conv);
48355 jstring __attribute__((export_name("TS_CreationError_to_str"))) TS_CreationError_to_str(uint64_t o) {
48356 LDKCreationError* o_conv = (LDKCreationError*)untag_ptr(o);
48357 LDKStr ret_str = CreationError_to_str(o_conv);
48358 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
48363 uint32_t __attribute__((export_name("TS_SemanticError_clone"))) TS_SemanticError_clone(uint64_t orig) {
48364 LDKSemanticError* orig_conv = (LDKSemanticError*)untag_ptr(orig);
48365 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_clone(orig_conv));
48369 uint32_t __attribute__((export_name("TS_SemanticError_no_payment_hash"))) TS_SemanticError_no_payment_hash() {
48370 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_no_payment_hash());
48374 uint32_t __attribute__((export_name("TS_SemanticError_multiple_payment_hashes"))) TS_SemanticError_multiple_payment_hashes() {
48375 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_multiple_payment_hashes());
48379 uint32_t __attribute__((export_name("TS_SemanticError_no_description"))) TS_SemanticError_no_description() {
48380 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_no_description());
48384 uint32_t __attribute__((export_name("TS_SemanticError_multiple_descriptions"))) TS_SemanticError_multiple_descriptions() {
48385 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_multiple_descriptions());
48389 uint32_t __attribute__((export_name("TS_SemanticError_no_payment_secret"))) TS_SemanticError_no_payment_secret() {
48390 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_no_payment_secret());
48394 uint32_t __attribute__((export_name("TS_SemanticError_multiple_payment_secrets"))) TS_SemanticError_multiple_payment_secrets() {
48395 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_multiple_payment_secrets());
48399 uint32_t __attribute__((export_name("TS_SemanticError_invalid_features"))) TS_SemanticError_invalid_features() {
48400 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_invalid_features());
48404 uint32_t __attribute__((export_name("TS_SemanticError_invalid_recovery_id"))) TS_SemanticError_invalid_recovery_id() {
48405 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_invalid_recovery_id());
48409 uint32_t __attribute__((export_name("TS_SemanticError_invalid_signature"))) TS_SemanticError_invalid_signature() {
48410 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_invalid_signature());
48414 uint32_t __attribute__((export_name("TS_SemanticError_imprecise_amount"))) TS_SemanticError_imprecise_amount() {
48415 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_imprecise_amount());
48419 jboolean __attribute__((export_name("TS_SemanticError_eq"))) TS_SemanticError_eq(uint64_t a, uint64_t b) {
48420 LDKSemanticError* a_conv = (LDKSemanticError*)untag_ptr(a);
48421 LDKSemanticError* b_conv = (LDKSemanticError*)untag_ptr(b);
48422 jboolean ret_conv = SemanticError_eq(a_conv, b_conv);
48426 jstring __attribute__((export_name("TS_SemanticError_to_str"))) TS_SemanticError_to_str(uint64_t o) {
48427 LDKSemanticError* o_conv = (LDKSemanticError*)untag_ptr(o);
48428 LDKStr ret_str = SemanticError_to_str(o_conv);
48429 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
48434 void __attribute__((export_name("TS_SignOrCreationError_free"))) TS_SignOrCreationError_free(uint64_t this_ptr) {
48435 if (!ptr_is_owned(this_ptr)) return;
48436 void* this_ptr_ptr = untag_ptr(this_ptr);
48437 CHECK_ACCESS(this_ptr_ptr);
48438 LDKSignOrCreationError this_ptr_conv = *(LDKSignOrCreationError*)(this_ptr_ptr);
48439 FREE(untag_ptr(this_ptr));
48440 SignOrCreationError_free(this_ptr_conv);
48443 static inline uint64_t SignOrCreationError_clone_ptr(LDKSignOrCreationError *NONNULL_PTR arg) {
48444 LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
48445 *ret_copy = SignOrCreationError_clone(arg);
48446 uint64_t ret_ref = tag_ptr(ret_copy, true);
48449 int64_t __attribute__((export_name("TS_SignOrCreationError_clone_ptr"))) TS_SignOrCreationError_clone_ptr(uint64_t arg) {
48450 LDKSignOrCreationError* arg_conv = (LDKSignOrCreationError*)untag_ptr(arg);
48451 int64_t ret_conv = SignOrCreationError_clone_ptr(arg_conv);
48455 uint64_t __attribute__((export_name("TS_SignOrCreationError_clone"))) TS_SignOrCreationError_clone(uint64_t orig) {
48456 LDKSignOrCreationError* orig_conv = (LDKSignOrCreationError*)untag_ptr(orig);
48457 LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
48458 *ret_copy = SignOrCreationError_clone(orig_conv);
48459 uint64_t ret_ref = tag_ptr(ret_copy, true);
48463 uint64_t __attribute__((export_name("TS_SignOrCreationError_sign_error"))) TS_SignOrCreationError_sign_error() {
48464 LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
48465 *ret_copy = SignOrCreationError_sign_error();
48466 uint64_t ret_ref = tag_ptr(ret_copy, true);
48470 uint64_t __attribute__((export_name("TS_SignOrCreationError_creation_error"))) TS_SignOrCreationError_creation_error(uint32_t a) {
48471 LDKCreationError a_conv = LDKCreationError_from_js(a);
48472 LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
48473 *ret_copy = SignOrCreationError_creation_error(a_conv);
48474 uint64_t ret_ref = tag_ptr(ret_copy, true);
48478 jboolean __attribute__((export_name("TS_SignOrCreationError_eq"))) TS_SignOrCreationError_eq(uint64_t a, uint64_t b) {
48479 LDKSignOrCreationError* a_conv = (LDKSignOrCreationError*)untag_ptr(a);
48480 LDKSignOrCreationError* b_conv = (LDKSignOrCreationError*)untag_ptr(b);
48481 jboolean ret_conv = SignOrCreationError_eq(a_conv, b_conv);
48485 jstring __attribute__((export_name("TS_SignOrCreationError_to_str"))) TS_SignOrCreationError_to_str(uint64_t o) {
48486 LDKSignOrCreationError* o_conv = (LDKSignOrCreationError*)untag_ptr(o);
48487 LDKStr ret_str = SignOrCreationError_to_str(o_conv);
48488 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
48493 void __attribute__((export_name("TS_InvoicePayer_free"))) TS_InvoicePayer_free(uint64_t this_obj) {
48494 LDKInvoicePayer this_obj_conv;
48495 this_obj_conv.inner = untag_ptr(this_obj);
48496 this_obj_conv.is_owned = ptr_is_owned(this_obj);
48497 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
48498 InvoicePayer_free(this_obj_conv);
48501 void __attribute__((export_name("TS_Payer_free"))) TS_Payer_free(uint64_t this_ptr) {
48502 if (!ptr_is_owned(this_ptr)) return;
48503 void* this_ptr_ptr = untag_ptr(this_ptr);
48504 CHECK_ACCESS(this_ptr_ptr);
48505 LDKPayer this_ptr_conv = *(LDKPayer*)(this_ptr_ptr);
48506 FREE(untag_ptr(this_ptr));
48507 Payer_free(this_ptr_conv);
48510 void __attribute__((export_name("TS_Retry_free"))) TS_Retry_free(uint64_t this_ptr) {
48511 if (!ptr_is_owned(this_ptr)) return;
48512 void* this_ptr_ptr = untag_ptr(this_ptr);
48513 CHECK_ACCESS(this_ptr_ptr);
48514 LDKRetry this_ptr_conv = *(LDKRetry*)(this_ptr_ptr);
48515 FREE(untag_ptr(this_ptr));
48516 Retry_free(this_ptr_conv);
48519 static inline uint64_t Retry_clone_ptr(LDKRetry *NONNULL_PTR arg) {
48520 LDKRetry *ret_copy = MALLOC(sizeof(LDKRetry), "LDKRetry");
48521 *ret_copy = Retry_clone(arg);
48522 uint64_t ret_ref = tag_ptr(ret_copy, true);
48525 int64_t __attribute__((export_name("TS_Retry_clone_ptr"))) TS_Retry_clone_ptr(uint64_t arg) {
48526 LDKRetry* arg_conv = (LDKRetry*)untag_ptr(arg);
48527 int64_t ret_conv = Retry_clone_ptr(arg_conv);
48531 uint64_t __attribute__((export_name("TS_Retry_clone"))) TS_Retry_clone(uint64_t orig) {
48532 LDKRetry* orig_conv = (LDKRetry*)untag_ptr(orig);
48533 LDKRetry *ret_copy = MALLOC(sizeof(LDKRetry), "LDKRetry");
48534 *ret_copy = Retry_clone(orig_conv);
48535 uint64_t ret_ref = tag_ptr(ret_copy, true);
48539 uint64_t __attribute__((export_name("TS_Retry_attempts"))) TS_Retry_attempts(uint32_t a) {
48540 LDKRetry *ret_copy = MALLOC(sizeof(LDKRetry), "LDKRetry");
48541 *ret_copy = Retry_attempts(a);
48542 uint64_t ret_ref = tag_ptr(ret_copy, true);
48546 jboolean __attribute__((export_name("TS_Retry_eq"))) TS_Retry_eq(uint64_t a, uint64_t b) {
48547 LDKRetry* a_conv = (LDKRetry*)untag_ptr(a);
48548 LDKRetry* b_conv = (LDKRetry*)untag_ptr(b);
48549 jboolean ret_conv = Retry_eq(a_conv, b_conv);
48553 int64_t __attribute__((export_name("TS_Retry_hash"))) TS_Retry_hash(uint64_t o) {
48554 LDKRetry* o_conv = (LDKRetry*)untag_ptr(o);
48555 int64_t ret_conv = Retry_hash(o_conv);
48559 void __attribute__((export_name("TS_PaymentError_free"))) TS_PaymentError_free(uint64_t this_ptr) {
48560 if (!ptr_is_owned(this_ptr)) return;
48561 void* this_ptr_ptr = untag_ptr(this_ptr);
48562 CHECK_ACCESS(this_ptr_ptr);
48563 LDKPaymentError this_ptr_conv = *(LDKPaymentError*)(this_ptr_ptr);
48564 FREE(untag_ptr(this_ptr));
48565 PaymentError_free(this_ptr_conv);
48568 static inline uint64_t PaymentError_clone_ptr(LDKPaymentError *NONNULL_PTR arg) {
48569 LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
48570 *ret_copy = PaymentError_clone(arg);
48571 uint64_t ret_ref = tag_ptr(ret_copy, true);
48574 int64_t __attribute__((export_name("TS_PaymentError_clone_ptr"))) TS_PaymentError_clone_ptr(uint64_t arg) {
48575 LDKPaymentError* arg_conv = (LDKPaymentError*)untag_ptr(arg);
48576 int64_t ret_conv = PaymentError_clone_ptr(arg_conv);
48580 uint64_t __attribute__((export_name("TS_PaymentError_clone"))) TS_PaymentError_clone(uint64_t orig) {
48581 LDKPaymentError* orig_conv = (LDKPaymentError*)untag_ptr(orig);
48582 LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
48583 *ret_copy = PaymentError_clone(orig_conv);
48584 uint64_t ret_ref = tag_ptr(ret_copy, true);
48588 uint64_t __attribute__((export_name("TS_PaymentError_invoice"))) TS_PaymentError_invoice(jstring a) {
48589 LDKStr a_conv = str_ref_to_owned_c(a);
48590 LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
48591 *ret_copy = PaymentError_invoice(a_conv);
48592 uint64_t ret_ref = tag_ptr(ret_copy, true);
48596 uint64_t __attribute__((export_name("TS_PaymentError_routing"))) TS_PaymentError_routing(uint64_t a) {
48597 LDKLightningError a_conv;
48598 a_conv.inner = untag_ptr(a);
48599 a_conv.is_owned = ptr_is_owned(a);
48600 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
48601 a_conv = LightningError_clone(&a_conv);
48602 LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
48603 *ret_copy = PaymentError_routing(a_conv);
48604 uint64_t ret_ref = tag_ptr(ret_copy, true);
48608 uint64_t __attribute__((export_name("TS_PaymentError_sending"))) TS_PaymentError_sending(uint64_t a) {
48609 void* a_ptr = untag_ptr(a);
48610 CHECK_ACCESS(a_ptr);
48611 LDKPaymentSendFailure a_conv = *(LDKPaymentSendFailure*)(a_ptr);
48612 a_conv = PaymentSendFailure_clone((LDKPaymentSendFailure*)untag_ptr(a));
48613 LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
48614 *ret_copy = PaymentError_sending(a_conv);
48615 uint64_t ret_ref = tag_ptr(ret_copy, true);
48619 uint64_t __attribute__((export_name("TS_InvoicePayer_new"))) TS_InvoicePayer_new(uint64_t payer, uint64_t router, uint64_t logger, uint64_t event_handler, uint64_t retry) {
48620 void* payer_ptr = untag_ptr(payer);
48621 CHECK_ACCESS(payer_ptr);
48622 LDKPayer payer_conv = *(LDKPayer*)(payer_ptr);
48623 if (payer_conv.free == LDKPayer_JCalls_free) {
48624 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
48625 LDKPayer_JCalls_cloned(&payer_conv);
48627 void* router_ptr = untag_ptr(router);
48628 CHECK_ACCESS(router_ptr);
48629 LDKRouter router_conv = *(LDKRouter*)(router_ptr);
48630 if (router_conv.free == LDKRouter_JCalls_free) {
48631 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
48632 LDKRouter_JCalls_cloned(&router_conv);
48634 void* logger_ptr = untag_ptr(logger);
48635 CHECK_ACCESS(logger_ptr);
48636 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
48637 if (logger_conv.free == LDKLogger_JCalls_free) {
48638 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
48639 LDKLogger_JCalls_cloned(&logger_conv);
48641 void* event_handler_ptr = untag_ptr(event_handler);
48642 CHECK_ACCESS(event_handler_ptr);
48643 LDKEventHandler event_handler_conv = *(LDKEventHandler*)(event_handler_ptr);
48644 if (event_handler_conv.free == LDKEventHandler_JCalls_free) {
48645 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
48646 LDKEventHandler_JCalls_cloned(&event_handler_conv);
48648 void* retry_ptr = untag_ptr(retry);
48649 CHECK_ACCESS(retry_ptr);
48650 LDKRetry retry_conv = *(LDKRetry*)(retry_ptr);
48651 retry_conv = Retry_clone((LDKRetry*)untag_ptr(retry));
48652 LDKInvoicePayer ret_var = InvoicePayer_new(payer_conv, router_conv, logger_conv, event_handler_conv, retry_conv);
48653 uint64_t ret_ref = 0;
48654 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48655 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48659 uint64_t __attribute__((export_name("TS_InvoicePayer_pay_invoice"))) TS_InvoicePayer_pay_invoice(uint64_t this_arg, uint64_t invoice) {
48660 LDKInvoicePayer this_arg_conv;
48661 this_arg_conv.inner = untag_ptr(this_arg);
48662 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48663 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48664 this_arg_conv.is_owned = false;
48665 LDKInvoice invoice_conv;
48666 invoice_conv.inner = untag_ptr(invoice);
48667 invoice_conv.is_owned = ptr_is_owned(invoice);
48668 CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_conv);
48669 invoice_conv.is_owned = false;
48670 LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
48671 *ret_conv = InvoicePayer_pay_invoice(&this_arg_conv, &invoice_conv);
48672 return tag_ptr(ret_conv, true);
48675 uint64_t __attribute__((export_name("TS_InvoicePayer_pay_invoice_with_id"))) TS_InvoicePayer_pay_invoice_with_id(uint64_t this_arg, uint64_t invoice, int8_tArray payment_id) {
48676 LDKInvoicePayer this_arg_conv;
48677 this_arg_conv.inner = untag_ptr(this_arg);
48678 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48679 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48680 this_arg_conv.is_owned = false;
48681 LDKInvoice invoice_conv;
48682 invoice_conv.inner = untag_ptr(invoice);
48683 invoice_conv.is_owned = ptr_is_owned(invoice);
48684 CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_conv);
48685 invoice_conv.is_owned = false;
48686 LDKThirtyTwoBytes payment_id_ref;
48687 CHECK(payment_id->arr_len == 32);
48688 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
48689 LDKCResult_NonePaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentErrorZ), "LDKCResult_NonePaymentErrorZ");
48690 *ret_conv = InvoicePayer_pay_invoice_with_id(&this_arg_conv, &invoice_conv, payment_id_ref);
48691 return tag_ptr(ret_conv, true);
48694 uint64_t __attribute__((export_name("TS_InvoicePayer_pay_zero_value_invoice"))) TS_InvoicePayer_pay_zero_value_invoice(uint64_t this_arg, uint64_t invoice, int64_t amount_msats) {
48695 LDKInvoicePayer this_arg_conv;
48696 this_arg_conv.inner = untag_ptr(this_arg);
48697 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48698 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48699 this_arg_conv.is_owned = false;
48700 LDKInvoice invoice_conv;
48701 invoice_conv.inner = untag_ptr(invoice);
48702 invoice_conv.is_owned = ptr_is_owned(invoice);
48703 CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_conv);
48704 invoice_conv.is_owned = false;
48705 LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
48706 *ret_conv = InvoicePayer_pay_zero_value_invoice(&this_arg_conv, &invoice_conv, amount_msats);
48707 return tag_ptr(ret_conv, true);
48710 uint64_t __attribute__((export_name("TS_InvoicePayer_pay_zero_value_invoice_with_id"))) TS_InvoicePayer_pay_zero_value_invoice_with_id(uint64_t this_arg, uint64_t invoice, int64_t amount_msats, int8_tArray payment_id) {
48711 LDKInvoicePayer this_arg_conv;
48712 this_arg_conv.inner = untag_ptr(this_arg);
48713 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48714 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48715 this_arg_conv.is_owned = false;
48716 LDKInvoice invoice_conv;
48717 invoice_conv.inner = untag_ptr(invoice);
48718 invoice_conv.is_owned = ptr_is_owned(invoice);
48719 CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_conv);
48720 invoice_conv.is_owned = false;
48721 LDKThirtyTwoBytes payment_id_ref;
48722 CHECK(payment_id->arr_len == 32);
48723 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
48724 LDKCResult_NonePaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentErrorZ), "LDKCResult_NonePaymentErrorZ");
48725 *ret_conv = InvoicePayer_pay_zero_value_invoice_with_id(&this_arg_conv, &invoice_conv, amount_msats, payment_id_ref);
48726 return tag_ptr(ret_conv, true);
48729 uint64_t __attribute__((export_name("TS_InvoicePayer_pay_pubkey"))) TS_InvoicePayer_pay_pubkey(uint64_t this_arg, int8_tArray pubkey, int8_tArray payment_preimage, int64_t amount_msats, int32_t final_cltv_expiry_delta) {
48730 LDKInvoicePayer this_arg_conv;
48731 this_arg_conv.inner = untag_ptr(this_arg);
48732 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48733 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48734 this_arg_conv.is_owned = false;
48735 LDKPublicKey pubkey_ref;
48736 CHECK(pubkey->arr_len == 33);
48737 memcpy(pubkey_ref.compressed_form, pubkey->elems, 33); FREE(pubkey);
48738 LDKThirtyTwoBytes payment_preimage_ref;
48739 CHECK(payment_preimage->arr_len == 32);
48740 memcpy(payment_preimage_ref.data, payment_preimage->elems, 32); FREE(payment_preimage);
48741 LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
48742 *ret_conv = InvoicePayer_pay_pubkey(&this_arg_conv, pubkey_ref, payment_preimage_ref, amount_msats, final_cltv_expiry_delta);
48743 return tag_ptr(ret_conv, true);
48746 uint64_t __attribute__((export_name("TS_InvoicePayer_pay_pubkey_with_id"))) TS_InvoicePayer_pay_pubkey_with_id(uint64_t this_arg, int8_tArray pubkey, int8_tArray payment_preimage, int8_tArray payment_id, int64_t amount_msats, int32_t final_cltv_expiry_delta) {
48747 LDKInvoicePayer this_arg_conv;
48748 this_arg_conv.inner = untag_ptr(this_arg);
48749 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48750 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48751 this_arg_conv.is_owned = false;
48752 LDKPublicKey pubkey_ref;
48753 CHECK(pubkey->arr_len == 33);
48754 memcpy(pubkey_ref.compressed_form, pubkey->elems, 33); FREE(pubkey);
48755 LDKThirtyTwoBytes payment_preimage_ref;
48756 CHECK(payment_preimage->arr_len == 32);
48757 memcpy(payment_preimage_ref.data, payment_preimage->elems, 32); FREE(payment_preimage);
48758 LDKThirtyTwoBytes payment_id_ref;
48759 CHECK(payment_id->arr_len == 32);
48760 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
48761 LDKCResult_NonePaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentErrorZ), "LDKCResult_NonePaymentErrorZ");
48762 *ret_conv = InvoicePayer_pay_pubkey_with_id(&this_arg_conv, pubkey_ref, payment_preimage_ref, payment_id_ref, amount_msats, final_cltv_expiry_delta);
48763 return tag_ptr(ret_conv, true);
48766 void __attribute__((export_name("TS_InvoicePayer_remove_cached_payment"))) TS_InvoicePayer_remove_cached_payment(uint64_t this_arg, int8_tArray payment_hash) {
48767 LDKInvoicePayer this_arg_conv;
48768 this_arg_conv.inner = untag_ptr(this_arg);
48769 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48770 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48771 this_arg_conv.is_owned = false;
48772 unsigned char payment_hash_arr[32];
48773 CHECK(payment_hash->arr_len == 32);
48774 memcpy(payment_hash_arr, payment_hash->elems, 32); FREE(payment_hash);
48775 unsigned char (*payment_hash_ref)[32] = &payment_hash_arr;
48776 InvoicePayer_remove_cached_payment(&this_arg_conv, payment_hash_ref);
48779 uint64_t __attribute__((export_name("TS_InvoicePayer_as_EventHandler"))) TS_InvoicePayer_as_EventHandler(uint64_t this_arg) {
48780 LDKInvoicePayer this_arg_conv;
48781 this_arg_conv.inner = untag_ptr(this_arg);
48782 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48783 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48784 this_arg_conv.is_owned = false;
48785 LDKEventHandler* ret_ret = MALLOC(sizeof(LDKEventHandler), "LDKEventHandler");
48786 *ret_ret = InvoicePayer_as_EventHandler(&this_arg_conv);
48787 return tag_ptr(ret_ret, true);
48790 uint64_t __attribute__((export_name("TS_create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch"))) TS_create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch(uint64_t channelmanager, uint64_t keys_manager, uint64_t logger, uint32_t network, uint64_t amt_msat, uint64_t description_hash, int64_t duration_since_epoch, int32_t invoice_expiry_delta_secs) {
48791 LDKChannelManager channelmanager_conv;
48792 channelmanager_conv.inner = untag_ptr(channelmanager);
48793 channelmanager_conv.is_owned = ptr_is_owned(channelmanager);
48794 CHECK_INNER_FIELD_ACCESS_OR_NULL(channelmanager_conv);
48795 channelmanager_conv.is_owned = false;
48796 void* keys_manager_ptr = untag_ptr(keys_manager);
48797 CHECK_ACCESS(keys_manager_ptr);
48798 LDKKeysInterface keys_manager_conv = *(LDKKeysInterface*)(keys_manager_ptr);
48799 if (keys_manager_conv.free == LDKKeysInterface_JCalls_free) {
48800 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
48801 LDKKeysInterface_JCalls_cloned(&keys_manager_conv);
48803 void* logger_ptr = untag_ptr(logger);
48804 CHECK_ACCESS(logger_ptr);
48805 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
48806 if (logger_conv.free == LDKLogger_JCalls_free) {
48807 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
48808 LDKLogger_JCalls_cloned(&logger_conv);
48810 LDKCurrency network_conv = LDKCurrency_from_js(network);
48811 void* amt_msat_ptr = untag_ptr(amt_msat);
48812 CHECK_ACCESS(amt_msat_ptr);
48813 LDKCOption_u64Z amt_msat_conv = *(LDKCOption_u64Z*)(amt_msat_ptr);
48814 amt_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(amt_msat));
48815 LDKSha256 description_hash_conv;
48816 description_hash_conv.inner = untag_ptr(description_hash);
48817 description_hash_conv.is_owned = ptr_is_owned(description_hash);
48818 CHECK_INNER_FIELD_ACCESS_OR_NULL(description_hash_conv);
48819 description_hash_conv = Sha256_clone(&description_hash_conv);
48820 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
48821 *ret_conv = create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch(&channelmanager_conv, keys_manager_conv, logger_conv, network_conv, amt_msat_conv, description_hash_conv, duration_since_epoch, invoice_expiry_delta_secs);
48822 return tag_ptr(ret_conv, true);
48825 uint64_t __attribute__((export_name("TS_create_invoice_from_channelmanager_and_duration_since_epoch"))) TS_create_invoice_from_channelmanager_and_duration_since_epoch(uint64_t channelmanager, uint64_t keys_manager, uint64_t logger, uint32_t network, uint64_t amt_msat, jstring description, int64_t duration_since_epoch, int32_t invoice_expiry_delta_secs) {
48826 LDKChannelManager channelmanager_conv;
48827 channelmanager_conv.inner = untag_ptr(channelmanager);
48828 channelmanager_conv.is_owned = ptr_is_owned(channelmanager);
48829 CHECK_INNER_FIELD_ACCESS_OR_NULL(channelmanager_conv);
48830 channelmanager_conv.is_owned = false;
48831 void* keys_manager_ptr = untag_ptr(keys_manager);
48832 CHECK_ACCESS(keys_manager_ptr);
48833 LDKKeysInterface keys_manager_conv = *(LDKKeysInterface*)(keys_manager_ptr);
48834 if (keys_manager_conv.free == LDKKeysInterface_JCalls_free) {
48835 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
48836 LDKKeysInterface_JCalls_cloned(&keys_manager_conv);
48838 void* logger_ptr = untag_ptr(logger);
48839 CHECK_ACCESS(logger_ptr);
48840 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
48841 if (logger_conv.free == LDKLogger_JCalls_free) {
48842 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
48843 LDKLogger_JCalls_cloned(&logger_conv);
48845 LDKCurrency network_conv = LDKCurrency_from_js(network);
48846 void* amt_msat_ptr = untag_ptr(amt_msat);
48847 CHECK_ACCESS(amt_msat_ptr);
48848 LDKCOption_u64Z amt_msat_conv = *(LDKCOption_u64Z*)(amt_msat_ptr);
48849 amt_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(amt_msat));
48850 LDKStr description_conv = str_ref_to_owned_c(description);
48851 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
48852 *ret_conv = create_invoice_from_channelmanager_and_duration_since_epoch(&channelmanager_conv, keys_manager_conv, logger_conv, network_conv, amt_msat_conv, description_conv, duration_since_epoch, invoice_expiry_delta_secs);
48853 return tag_ptr(ret_conv, true);
48856 uint64_t __attribute__((export_name("TS_create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_hash"))) TS_create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_hash(uint64_t channelmanager, uint64_t keys_manager, uint64_t logger, uint32_t network, uint64_t amt_msat, jstring description, int64_t duration_since_epoch, int32_t invoice_expiry_delta_secs, int8_tArray payment_hash) {
48857 LDKChannelManager channelmanager_conv;
48858 channelmanager_conv.inner = untag_ptr(channelmanager);
48859 channelmanager_conv.is_owned = ptr_is_owned(channelmanager);
48860 CHECK_INNER_FIELD_ACCESS_OR_NULL(channelmanager_conv);
48861 channelmanager_conv.is_owned = false;
48862 void* keys_manager_ptr = untag_ptr(keys_manager);
48863 CHECK_ACCESS(keys_manager_ptr);
48864 LDKKeysInterface keys_manager_conv = *(LDKKeysInterface*)(keys_manager_ptr);
48865 if (keys_manager_conv.free == LDKKeysInterface_JCalls_free) {
48866 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
48867 LDKKeysInterface_JCalls_cloned(&keys_manager_conv);
48869 void* logger_ptr = untag_ptr(logger);
48870 CHECK_ACCESS(logger_ptr);
48871 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
48872 if (logger_conv.free == LDKLogger_JCalls_free) {
48873 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
48874 LDKLogger_JCalls_cloned(&logger_conv);
48876 LDKCurrency network_conv = LDKCurrency_from_js(network);
48877 void* amt_msat_ptr = untag_ptr(amt_msat);
48878 CHECK_ACCESS(amt_msat_ptr);
48879 LDKCOption_u64Z amt_msat_conv = *(LDKCOption_u64Z*)(amt_msat_ptr);
48880 amt_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(amt_msat));
48881 LDKStr description_conv = str_ref_to_owned_c(description);
48882 LDKThirtyTwoBytes payment_hash_ref;
48883 CHECK(payment_hash->arr_len == 32);
48884 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
48885 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
48886 *ret_conv = create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_hash(&channelmanager_conv, keys_manager_conv, logger_conv, network_conv, amt_msat_conv, description_conv, duration_since_epoch, invoice_expiry_delta_secs, payment_hash_ref);
48887 return tag_ptr(ret_conv, true);
48890 uint64_t __attribute__((export_name("TS_ChannelManager_as_Payer"))) TS_ChannelManager_as_Payer(uint64_t this_arg) {
48891 LDKChannelManager this_arg_conv;
48892 this_arg_conv.inner = untag_ptr(this_arg);
48893 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48894 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48895 this_arg_conv.is_owned = false;
48896 LDKPayer* ret_ret = MALLOC(sizeof(LDKPayer), "LDKPayer");
48897 *ret_ret = ChannelManager_as_Payer(&this_arg_conv);
48898 return tag_ptr(ret_ret, true);
48901 uint64_t __attribute__((export_name("TS_SiPrefix_from_str"))) TS_SiPrefix_from_str(jstring s) {
48902 LDKStr s_conv = str_ref_to_owned_c(s);
48903 LDKCResult_SiPrefixParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixParseErrorZ), "LDKCResult_SiPrefixParseErrorZ");
48904 *ret_conv = SiPrefix_from_str(s_conv);
48905 return tag_ptr(ret_conv, true);
48908 uint64_t __attribute__((export_name("TS_Invoice_from_str"))) TS_Invoice_from_str(jstring s) {
48909 LDKStr s_conv = str_ref_to_owned_c(s);
48910 LDKCResult_InvoiceParseOrSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceParseOrSemanticErrorZ), "LDKCResult_InvoiceParseOrSemanticErrorZ");
48911 *ret_conv = Invoice_from_str(s_conv);
48912 return tag_ptr(ret_conv, true);
48915 uint64_t __attribute__((export_name("TS_SignedRawInvoice_from_str"))) TS_SignedRawInvoice_from_str(jstring s) {
48916 LDKStr s_conv = str_ref_to_owned_c(s);
48917 LDKCResult_SignedRawInvoiceParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceParseErrorZ), "LDKCResult_SignedRawInvoiceParseErrorZ");
48918 *ret_conv = SignedRawInvoice_from_str(s_conv);
48919 return tag_ptr(ret_conv, true);
48922 jstring __attribute__((export_name("TS_ParseError_to_str"))) TS_ParseError_to_str(uint64_t o) {
48923 LDKParseError* o_conv = (LDKParseError*)untag_ptr(o);
48924 LDKStr ret_str = ParseError_to_str(o_conv);
48925 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
48930 jstring __attribute__((export_name("TS_ParseOrSemanticError_to_str"))) TS_ParseOrSemanticError_to_str(uint64_t o) {
48931 LDKParseOrSemanticError* o_conv = (LDKParseOrSemanticError*)untag_ptr(o);
48932 LDKStr ret_str = ParseOrSemanticError_to_str(o_conv);
48933 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
48938 jstring __attribute__((export_name("TS_Invoice_to_str"))) TS_Invoice_to_str(uint64_t o) {
48940 o_conv.inner = untag_ptr(o);
48941 o_conv.is_owned = ptr_is_owned(o);
48942 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
48943 o_conv.is_owned = false;
48944 LDKStr ret_str = Invoice_to_str(&o_conv);
48945 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
48950 jstring __attribute__((export_name("TS_SignedRawInvoice_to_str"))) TS_SignedRawInvoice_to_str(uint64_t o) {
48951 LDKSignedRawInvoice o_conv;
48952 o_conv.inner = untag_ptr(o);
48953 o_conv.is_owned = ptr_is_owned(o);
48954 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
48955 o_conv.is_owned = false;
48956 LDKStr ret_str = SignedRawInvoice_to_str(&o_conv);
48957 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
48962 jstring __attribute__((export_name("TS_Currency_to_str"))) TS_Currency_to_str(uint64_t o) {
48963 LDKCurrency* o_conv = (LDKCurrency*)untag_ptr(o);
48964 LDKStr ret_str = Currency_to_str(o_conv);
48965 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
48970 jstring __attribute__((export_name("TS_SiPrefix_to_str"))) TS_SiPrefix_to_str(uint64_t o) {
48971 LDKSiPrefix* o_conv = (LDKSiPrefix*)untag_ptr(o);
48972 LDKStr ret_str = SiPrefix_to_str(o_conv);
48973 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);